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

2023-12-20 18:32:32

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

1、效果预览

2、使用条件

2.1?键值型数据库

????????键值型数据库实现数据持久化width=device-width,initial-scale=1.0http://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.0http://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 封装

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, (err, 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, (err, 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, (err, 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, valueBucket, 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, (err, 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 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, (err, 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'], 'NAME', 'Test001Val');

文章来源:https://blog.csdn.net/qq_23334071/article/details/135104854
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若内容造成侵权/违法违规/事实不符，请联系我的编程经验分享网邮箱：veading@qq.com进行投诉反馈，一经查实，立即删除！