前面使用了首选项的存储方式，因此将其他的两种存储方式（键值型数据库和关系型数据库）也学习一下，简单记录一下，并进行封装，方便后续使用。
1、效果预览
2、使用条件
2.1 键值型数据库
- 设备协同数据库，针对每条记录，Key的长度≤896 Byte，Value的长度<4 MB。
-
单版本数据库，针对每条记录，Key的长度≤1 KB，Value的长度<4 MB。
-
每个应用程序最多支持同时打开16个键值型分布式数据库。
-
键值型数据库事件回调方法中不允许进行阻塞操作，例如修改UI组件。
2.2 关系型数据库
- 系统默认日志方式是WAL（Write Ahead Log）模式，系统默认落盘方式是FULL模式。
-
数据库中连接池的最大数量是4个，用以管理用户的读操作。
-
为保证数据的准确性，数据库同一时间只能支持一个写操作。
-
当应用被卸载完成后，设备上的相关数据库文件及临时文件会被自动清除。
-
ArkTS侧支持的基本数据类型：number、string、二进制类型数据、boolean。
-
为保证插入并读取数据成功，建议一条数据不要超过2M。超出该大小，插入成功，读取失败。
3、核心API
3.1 键值型数据库
-
createKVManager（创建一个KVManager对象实例）
-
getKVStore（指定Options和storeId，创建并得到指定类型的KVStore数据库）
-
put（添加指定类型的键值对到数据库）
-
get（获取指定键的值）
-
delete（从数据库中删除指定键值的数据）
3.2 关系型数据库
-
getRdbStore（获得一个相关的RdbStore，操作关系型数据库）
-
executeSql（执行包含指定参数但不返回值的SQL语句）
-
deleteRdbStore（删除数据库）
-
insert（插入一行数据）
-
delete（从数据库中删除数据）
-
update（更新数据库中的数据）
-
query（根据指定条件查询数据库中的数据）
4、封装与调用
4.1 键值型数据库
4.1.1 封装
import distributedKVStore from '@ohos.data.distributedKVStore';
const BUNDLE_NAME = "dbName_tengyu"
let context = getContext(this)
// 数据库对象
let kvManager: distributedKVStore.KVManager | undefined = undefined;
// KVStore数据库
let kvStore: distributedKVStore.SingleKVStore | undefined = undefined;
class DistributedUtil {
constructor() {
this.createKeyValueDB();
}
async getKvManager(bundleName?: string) {
const kvStoreConfig: distributedKVStore.KVManagerConfig = {
context: context,bundleName: bundleName || BUNDLE_NAME
};
try {
kvManager = distributedKVStore.createKVManager(kvStoreConfig);
}
catch (err) {
console.error(`error:${err}`)
}
}
// 创建并得到指定类型的KVStore数据库
async createKeyValueDB(op?: distributedKVStore.Options) {
if (kvManager === undefined) {
this.getKvManager();
}
try {
const options: distributedKVStore.Options = {
// 当数据库文件不存在时是否创建数据库，默认为true
createIfMissing: true,// 设置数据库文件是否加密，默认为false，即不加密
encrypt: false,// 设置数据库文件是否备份，默认为true，即备份
backup: false,// 设置数据库文件是否自动同步。默认为false，即手动同步
autoSync: true,// kvStoreType不填时，默认创建多设备协同数据库
kvStoreType: distributedKVStore.KVStoreType.SINGLE_VERSION,// 多设备协同数据库：kvStoreType: distributedKVStore.KVStoreType.DEVICE_COLLABORATION,securityLevel: distributedKVStore.SecurityLevel.S1
};
kvManager.getKVStore<distributedKVStore.SingleKVStore>('storeId',op || options,(err,store: distributedKVStore.SingleKVStore) => {
if (err) {
console.error(`Failed to get KVStore: Code:${err.code},message:${err.message}`);
return;
}
console.info('Succeeded in getting KVStore.');
kvStore = store;
});
} catch (e) {
console.error(`An unexpected error occurred. Code:${e.code},message:${e.message}`);
}
return kvStore;
}
// 删除指定键值的数据
async deleteStoreData(key: string) {
if (!kvStore) {
return;
}
try {
kvStore.delete(key,(err) => {
if (err !== undefined) {
console.error(`Failed to delete data. Code:${err.code},message:${err.message}`);
return;
}
console.info('Succeeded in deleting data.');
});
} catch (e) {
console.error(`An unexpected error occurred. Code:${e.code},message:${e.message}`);
}
}
// 向键值数据库中插入数据
async putStoreData(key: string,value: any) {
if (!key || !value) {
return
}
if(!kvStore) {
kvStore = await this.createKeyValueDB();
}
try {
kvStore.put(key,value,(err) => {
if (err !== undefined) {
console.error(`Failed to put data. Code:${err.code},message:${err.message}`);
return;
}
console.info('Succeeded in putting data.');
});
} catch (e) {
console.error(`An unexpected error occurred. Code:${e.code},message:${e.message}`);
}
}
// 获取指定键的值
async getStoreData(key: string) {
if (!key) {
return
}
if(!kvStore) {
kvStore = await this.createKeyValueDB();
}
return new Promise((resolve,reject) => {
try {
kvStore.get(key,data) => {
if (err != undefined) {
console.error(`Failed to get data. Code:${err.code},message:${err.message}`);
reject(err)
return;
}
resolve(data)
});
} catch (err) {
reject(err)
console.error('TAG',`Failed to get value,Cause: ${err}`)
}
});
}
}
export default new DistributedUtil();
4.1.2 调用
import distributedUtil from '../../utils/distributedStrong'
// 向数据库新增数据
distributedUtil.putStoreData('test0011',JSON.stringify({
name: 666,age: 32,date: '2023.06.26'
}))
// 获取数据库中的数据
distributedUtil.getStoreData('test0011').then(res => {
console.log('===获取数据库中的数据====',JSON.stringify(res))
})
4.2 关系型数据库
关系型数据库运作机制
4.2.1 封装
import relationalStore from '@ohos.data.relationalStore';
const DB_NAME = "RelationStoreDB.db"
let context = getContext(this)
let store: relationalStore.RdbStore | undefined = undefined;
class RelationalUtil {
async getRdbStoreConfig(dbName?: string,config?: relationalStore.StoreConfig) {
const STORE_CONFIG: relationalStore.StoreConfig = config || {
// 数据库文件名
name: dbName || DB_NAME,// 数据库安全级别
securityLevel: relationalStore.SecurityLevel.S1,// 可选参数，指定数据库是否加密，默认不加密
encrypt: false,};
return STORE_CONFIG;
}
// 创建并得到指定类型的KVStore数据库
async createDatabaseTable(sqlCreateTable: string) {
const STORE_CONFIG = await this.getRdbStoreConfig();
relationalStore.getRdbStore(context,STORE_CONFIG,rdbStore: relationalStore.RdbStore) => {
if (err) {
console.error(`Failed to get RdbStore. Code:${err.code},message:${err.message}`);
return;
}
console.info('Succeeded in getting RdbStore.');
// 当数据库创建时，数据库默认版本为0
store = rdbStore;
store.executeSql(sqlCreateTable); // 创建数据表
})
}
// 删除数据库
async deleteDB(dbName: string = DB_NAME) {
relationalStore.deleteRdbStore(context,dbName,(err) => {
if (err) {
console.error(`Failed to delete RdbStore. Code:${err.code},message:${err.message}`);
return;
}
console.info('Succeeded in deleting RdbStore.');
});
}
// 向数据库中插入数据
async insertDatas(tableName: string,valueBucket) {
if (store != undefined) {
(store as relationalStore.RdbStore).insert(tableName,valueBucket,rowId: number) => {
if (err) {
console.error(`Failed to insert data. Code:${err.code},message:${err.message}`);
return;
}
console.info(`Succeeded in inserting data. rowId:${rowId}`);
})
}
}
// 对数据进行修改
async updateDatas(tableName: string,key,val) {
let predicates = new relationalStore.RdbPredicates(tableName); // 创建表tableName的predicates
predicates.equalTo(key,val); // 匹配表tableName中key为val的字段
if (store != undefined) {
(store as relationalStore.RdbStore).update(valueBucket,predicates,message:${err.message}`);
return;
}
console.info(`Succeeded in inserting data. rowId:${rowId}`);
})
}
}
//根据谓词指定的查询条件查找数据
async getDatas(tableName: string,atomArr: Array<string>,key: string,val: string | number) {
let predicates = new relationalStore.RdbPredicates(tableName);
predicates.equalTo(key,val);
if (store != undefined) {
return new Promise((resolve,reject) => {
(store as relationalStore.RdbStore).query(predicates,atomArr,resultSet) => {
if (err) {
console.error(`Failed to query data. Code:${err.code},message:${err.message}`);
reject(err);
return;
}
resolve(resultSet);
console.info(`ResultSet column names: ${resultSet.columnNames},column count: ${resultSet.columnCount}`);
})
})
}
}
}
export default new RelationalUtil();
4.2.2 调用
import relationalUtil from '../../utils/relationalStrong';
import { ValuesBucket } from '@ohos.data.ValuesBucket';
const DB_NAME = 'testDB'
const TABLE_NAME = 'table1'
// 建库建表
const SQL_CREATE_TABLE = 'CREATE TABLE IF NOT EXISTS EMPLOYEE (ID INTEGER PRIMARY KEY AUTOINCREMENT,NAME TEXT NOT NULL,AGE INTEGER,SALARY REAL,CODES BLOB)';
relationalUtil.createDatabaseTable(SQL_CREATE_TABLE,DB_NAME);
// 删除数据库
relationalUtil.deleteDB(DB_NAME);
// 新增数据
const valBucket: ValuesBucket = {
'NAME': 111,'AGE': 222,'SALARY': 333,'CODES': 444,};
relationalUtil.insertDatas(TABLE_NAME,valBucket);
// 修改数据
relationalUtil.updateDatas(TABLE_NAME,valBucket,'NAME','Test001Val');
// 获取数据
relationalUtil.getDatas(TABLE_NAME,['NAME','AGE','SALARY'],'Test001Val');原文地址：https://blog.csdn.net/qq_23334071/article/details/135104854
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。