devbox
知新_RL
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【HarmonyOS开发】ArkTs关系型和非关系型数据库的存储封装_distributedkvstore

作者：知新_RL | 2024-03-23 11:22:08

赞

踩

distributedkvstore

图片

前面使用了首选项的存储方式，因此将其他的两种存储方式（键值型数据库和关系型数据库）也学习一下，简单记录一下，并进行封装，方便后续使用。

1、效果预览

2、使用条件

2.1 键值型数据库

        键值型数据库实现数据持久化width=device-width,initial-scale=1.0icon-default.png?t=N7T8http://test.openharmony.cn:7780/pages/v4.0/zh-cn/application-dev/database/data-persistence-by-kv-store.md/

  • 设备协同数据库，针对每条记录，Key的长度≤896 Byte，Value的长度<4 MB。

  • 单版本数据库，针对每条记录，Key的长度≤1 KB，Value的长度<4 MB。

  • 每个应用程序最多支持同时打开16个键值型分布式数据库。

  • 键值型数据库事件回调方法中不允许进行阻塞操作，例如修改UI组件。

2.2 关系型数据库

关系型数据库实现数据持久化width=device-width,initial-scale=1.0icon-default.png?t=N7T8http://test.openharmony.cn:7780/pages/v4.0/zh-cn/application-dev/database/data-persistence-by-rdb-store.md/

  • 系统默认日志方式是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 封装

  1. import distributedKVStore from '@ohos.data.distributedKVStore';
  2.  
  3. const BUNDLE_NAME = "dbName_tengyu"
  4.  
  5. let context = getContext(this)
  6. // 数据库对象
  7. let kvManager: distributedKVStore.KVManager | undefined = undefined;
  8. // KVStore数据库
  9. let kvStore: distributedKVStore.SingleKVStore | undefined = undefined;
  10.  
  11. class DistributedUtil {
  12.   constructor() {
  13.     this.createKeyValueDB();
  14.   }
  15.   async getKvManager(bundleName?: string) {
  16.     const kvStoreConfig: distributedKVStore.KVManagerConfig = {
  17.       context: context,
  18.       bundleName: bundleName || BUNDLE_NAME
  19.     };
  20.     try {
  21.       kvManager = distributedKVStore.createKVManager(kvStoreConfig);
  22.     }
  23.     catch (err) {
  24.       console.error(`error:${err}`)
  25.     }
  26.   }
  27.  
  28.   // 创建并得到指定类型的KVStore数据库
  29.   async createKeyValueDB(op?: distributedKVStore.Options) {
  30.     if (kvManager === undefined) {
  31.       this.getKvManager();
  32.     }
  33.     try {
  34.       const options: distributedKVStore.Options = {
  35.         // 当数据库文件不存在时是否创建数据库，默认为true
  36.         createIfMissing: true,
  37.         // 设置数据库文件是否加密，默认为false，即不加密
  38.         encrypt: false,
  39.         // 设置数据库文件是否备份，默认为true，即备份
  40.         backup: false,
  41.         // 设置数据库文件是否自动同步。默认为false，即手动同步
  42.         autoSync: true,
  43.         // kvStoreType不填时，默认创建多设备协同数据库
  44.         kvStoreType: distributedKVStore.KVStoreType.SINGLE_VERSION,
  45.         // 多设备协同数据库：kvStoreType: distributedKVStore.KVStoreType.DEVICE_COLLABORATION,
  46.         securityLevel: distributedKVStore.SecurityLevel.S1
  47.       };
  48.       kvManager.getKVStore<distributedKVStore.SingleKVStore>('storeId', op || options, (err, store: distributedKVStore.SingleKVStore) => {
  49.         if (err) {
  50.           console.error(`Failed to get KVStore: Code:${err.code},message:${err.message}`);
  51.           return;
  52.         }
  53.         console.info('Succeeded in getting KVStore.');
  54.         kvStore = store;
  55.       });
  56.     } catch (e) {
  57.       console.error(`An unexpected error occurred. Code:${e.code},message:${e.message}`);
  58.     }
  59.     return kvStore;
  60.   }
  61.  
  62.   // 删除指定键值的数据
  63.   async deleteStoreData(key: string) {
  64.     if (!kvStore) {
  65.       return;
  66.     }
  67.  
  68.     try {
  69.       kvStore.delete(key, (err) => {
  70.         if (err !== undefined) {
  71.           console.error(`Failed to delete data. Code:${err.code},message:${err.message}`);
  72.           return;
  73.         }
  74.         console.info('Succeeded in deleting data.');
  75.       });
  76.     } catch (e) {
  77.       console.error(`An unexpected error occurred. Code:${e.code},message:${e.message}`);
  78.     }
  79.   }
  80.  
  81.   // 向键值数据库中插入数据
  82.   async putStoreData(key: string, value: any) {
  83.     if (!key || !value) {
  84.       return
  85.     }
  86.  
  87.     if(!kvStore) {
  88.       kvStore = await this.createKeyValueDB();
  89.     }
  90.  
  91.     try {
  92.       kvStore.put(key, value, (err) => {
  93.         if (err !== undefined) {
  94.           console.error(`Failed to put data. Code:${err.code},message:${err.message}`);
  95.           return;
  96.         }
  97.         console.info('Succeeded in putting data.');
  98.       });
  99.     } catch (e) {
  100.       console.error(`An unexpected error occurred. Code:${e.code},message:${e.message}`);
  101.     }
  102.   }
  103.  
  104.   // 获取指定键的值
  105.   async getStoreData(key: string) {
  106.     if (!key) {
  107.       return
  108.     }
  109.  
  110.     if(!kvStore) {
  111.       kvStore = await this.createKeyValueDB();
  112.     }
  113.  
  114.     return new Promise((resolve, reject) => {
  115.       try {
  116.         kvStore.get(key, (err, data) => {
  117.           if (err != undefined) {
  118.             console.error(`Failed to get data. Code:${err.code},message:${err.message}`);
  119.             reject(err)
  120.             return;
  121.           }
  122.           resolve(data)
  123.         });
  124.       } catch (err) {
  125.         reject(err)
  126.         console.error('TAG', `Failed to get value, Cause: ${err}`)
  127.       }
  128.     });
  129.   }
  130. }
  131.  
  132. export default new DistributedUtil();

4.1.2 调用

  1. import distributedUtil from '../../utils/distributedStrong'
  2.  
  3. // 向数据库新增数据
  4. distributedUtil.putStoreData('test0011', JSON.stringify({
  5.   name: 666,
  6.   age: 32,
  7.   date: '2023.06.26'
  8. }))
  9.  
  10. // 获取数据库中的数据
  11. distributedUtil.getStoreData('test0011').then(res => {
  12.   console.log('===获取数据库中的数据====', JSON.stringify(res))
  13. })

4.2 关系型数据库

关系型数据库运作机制 

4.2.1 封装

  1. import relationalStore from '@ohos.data.relationalStore';
  2.  
  3. const DB_NAME = "RelationStoreDB.db"
  4.  
  5. let context = getContext(this)
  6. let store: relationalStore.RdbStore | undefined = undefined;
  7.  
  8. class RelationalUtil {
  9.   async getRdbStoreConfig(dbName?: string, config?: relationalStore.StoreConfig) {
  10.     const STORE_CONFIG: relationalStore.StoreConfig = config || {
  11.       // 数据库文件名
  12.       name: dbName || DB_NAME,
  13.       // 数据库安全级别
  14.       securityLevel: relationalStore.SecurityLevel.S1,
  15.       // 可选参数，指定数据库是否加密，默认不加密
  16.       encrypt: false,
  17.     };
  18.  
  19.     return STORE_CONFIG;
  20.   }
  21.  
  22.   // 创建并得到指定类型的KVStore数据库
  23.   async createDatabaseTable(sqlCreateTable: string) {
  24.     const STORE_CONFIG = await this.getRdbStoreConfig();
  25.     relationalStore.getRdbStore(context, STORE_CONFIG, (err, rdbStore: relationalStore.RdbStore) => {
  26.       if (err) {
  27.         console.error(`Failed to get RdbStore. Code:${err.code}, message:${err.message}`);
  28.         return;
  29.       }
  30.       console.info('Succeeded in getting RdbStore.');
  31.  
  32.       // 当数据库创建时，数据库默认版本为0
  33.       store = rdbStore;
  34.       store.executeSql(sqlCreateTable); // 创建数据表
  35.     })
  36.   }
  37.  
  38.   // 删除数据库
  39.   async deleteDB(dbName: string = DB_NAME) {
  40.     relationalStore.deleteRdbStore(context, dbName, (err) => {
  41.       if (err) {
  42.         console.error(`Failed to delete RdbStore. Code:${err.code}, message:${err.message}`);
  43.         return;
  44.       }
  45.       console.info('Succeeded in deleting RdbStore.');
  46.     });
  47.   }
  48.  
  49.   // 向数据库中插入数据
  50.   async insertDatas(tableName: string, valueBucket) {
  51.     if (store != undefined) {
  52.       (store as relationalStore.RdbStore).insert(tableName, valueBucket, (err, rowId: number) => {
  53.         if (err) {
  54.           console.error(`Failed to insert data. Code:${err.code}, message:${err.message}`);
  55.           return;
  56.         }
  57.         console.info(`Succeeded in inserting data. rowId:${rowId}`);
  58.       })
  59.     }
  60.   }
  61.  
  62.   // 对数据进行修改
  63.   async updateDatas(tableName: string, valueBucket, key, val) {
  64.     let predicates = new relationalStore.RdbPredicates(tableName); // 创建表tableName的predicates
  65.     predicates.equalTo(key, val); // 匹配表tableName中key为val的字段
  66.     if (store != undefined) {
  67.       (store as relationalStore.RdbStore).update(valueBucket, predicates, (err, rowId: number) => {
  68.         if (err) {
  69.           console.error(`Failed to insert data. Code:${err.code}, message:${err.message}`);
  70.           return;
  71.         }
  72.         console.info(`Succeeded in inserting data. rowId:${rowId}`);
  73.       })
  74.     }
  75.   }
  76.  
  77.   //根据谓词指定的查询条件查找数据
  78.   async getDatas(tableName: string, atomArr: Array<string>, key: string, val: string | number) {
  79.     let predicates = new relationalStore.RdbPredicates(tableName);
  80.     predicates.equalTo(key, val);
  81.     if (store != undefined) {
  82.       return new Promise((resolve, reject) => {
  83.         (store as relationalStore.RdbStore).query(predicates, atomArr, (err, resultSet) => {
  84.           if (err) {
  85.             console.error(`Failed to query data. Code:${err.code}, message:${err.message}`);
  86.             reject(err);
  87.             return;
  88.           }
  89.           resolve(resultSet);
  90.           console.info(`ResultSet column names: ${resultSet.columnNames}, column count: ${resultSet.columnCount}`);
  91.         })
  92.       })
  93.     }
  94.   }
  95. }
  96.  
  97. export default new RelationalUtil();

4.2.2 调用

  1. import relationalUtil from '../../utils/relationalStrong';
  2. import { ValuesBucket } from '@ohos.data.ValuesBucket';
  3.  
  4. const DB_NAME = 'testDB'
  5. const TABLE_NAME = 'table1'
  6. // 建库建表
  7. 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)'; 
  8. relationalUtil.createDatabaseTable(SQL_CREATE_TABLE, DB_NAME);
  9.  
  10. // 删除数据库
  11. relationalUtil.deleteDB(DB_NAME);
  12.  
  13. // 新增数据
  14. const valBucket: ValuesBucket = {
  15.   'NAME': 111,
  16.   'AGE': 222,
  17.   'SALARY': 333,
  18.   'CODES': 444,
  19. };
  20. relationalUtil.insertDatas(TABLE_NAME, valBucket);
  21.  
  22. // 修改数据
  23. relationalUtil.updateDatas(TABLE_NAME, valBucket, 'NAME', 'Test001Val');
  24.  
  25. // 获取数据
  26. relationalUtil.getDatas(TABLE_NAME, ['NAME', 'AGE', 'SALARY'], 'NAME', 'Test001Val');

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/知新_RL/article/detail/294899
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号