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

news/2024/7/21 9:44:11 标签: harmonyos

图片

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

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 封装

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');


http://www.niftyadmin.cn/n/5276441.html

相关文章

华纳云：ServiceComb如何实现zipkin分布式调用链追踪

华纳云：ServiceComb如何实现zipkin分布式调用链追踪

Apache ServiceComb是一个开源的微服务框架&#xff0c;它提供了分布式系统开发所需的一系列工具和服务。在ServiceComb中&#xff0c;实现分布式调用链追踪可以通过整合Zipkin来实现。Zipkin是一个开源的分布式追踪系统&#xff0c;它可以帮助你跟踪微服务架构中的请求流&…
阅读更多...
大数据HCIE成神之路之数据预处理（3）——数值离散化

大数据HCIE成神之路之数据预处理（3）——数值离散化

数值离散化 1.1 无监督连续变量的离散化 – 聚类划分1.1.1 实验任务1.1.1.1 实验背景1.1.1.2 实验目标1.1.1.3 实验数据解析 1.1.2 实验思路1.1.3 实验操作步骤1.1.4 结果验证 1.2 无监督连续变量的离散化 – 等宽划分1.2.1 实验任务1.2.1.1 实验背景1.2.1.2 实验目标1.2.1.3 实…
阅读更多...
MFC 消息映射机制

MFC 消息映射机制

目录 消息映射机制概述 宏展开 宏展开的作用 消息映射机制的执行流程 消息处理 消息映射机制概述 MFC的消息映射映射机制是可以在不重写WindowProc虚函数的大前提下&#xff0c;仍然可以处理消息。 类必须具备的要件 类内必须添加声明宏 DECLARE_MESSAGE_MAP() 类外…
阅读更多...
云原生消息流系统 Apache Pulsar 在腾讯云的大规模生产实践

云原生消息流系统 Apache Pulsar 在腾讯云的大规模生产实践

导语 由 InfoQ 主办的 Qcon 全球软件开发者大会北京站上周已精彩落幕&#xff0c;腾讯云中间件团队的冉小龙参与了《云原生机构设计与音视频技术应用》专题&#xff0c;带来了以《云原生消息流系统 Apache Pulsar 在腾讯云的大规模生产实践》为主题的精彩演讲&#xff0c;在本…
阅读更多...
《opencv实用探索·二十一》人脸识别

《opencv实用探索·二十一》人脸识别

Haar级联分类器 在OpenCV中主要使用了两种特征&#xff08;即两种方法&#xff09;进行人脸检测&#xff0c;Haar特征和LBP特征。用的最多的是Haar特征人脸检测。 Haar级联分类器是一种用于目标检测的机器学习方法&#xff0c;它是一种基于机器学习的特征选择方法&#xff0c;…
阅读更多...
最新ChatGPT网站系统源码+AI绘画系统+支持GPT语音对话+详细图文搭建教程/支持GPT4.0/H5端系统/文档知识库

最新ChatGPT网站系统源码+AI绘画系统+支持GPT语音对话+详细图文搭建教程/支持GPT4.0/H5端系统/文档知识库

一、前言 SparkAi创作系统是基于ChatGPT进行开发的Ai智能问答系统和Midjourney绘画系统&#xff0c;支持OpenAI-GPT全模型国内AI全模型。本期针对源码系统整体测试下来非常完美&#xff0c;可以说SparkAi是目前国内一款的ChatGPT对接OpenAI软件系统。那么如何搭建部署AI创作Ch…
阅读更多...
做一个家政预约小程序需要了解哪些功能？

做一个家政预约小程序需要了解哪些功能？

随着科技的发展&#xff0c;人们的生活方式发生改变&#xff0c;家政服务在快节奏的时代成为家庭必备。为了满足人们对家政服务的需求&#xff0c;许多家政公司开始寻求线上发展机会。小程序作为轻量级应用&#xff0c;逐渐成为家政行业的重要载体。本文将详细介绍家政小程序的…
阅读更多...
Azure Machine Learning - 提示工程高级技术

Azure Machine Learning - 提示工程高级技术

本指南将指导你提示设计和提示工程方面的一些高级技术。 关注TechLead&#xff0c;分享AI全维度知识。作者拥有10年互联网服务架构、AI产品研发经验、团队管理经验&#xff0c;同济本复旦硕&#xff0c;复旦机器人智能实验室成员&#xff0c;阿里云认证的资深架构师&#xff0c…
阅读更多...
最新文章

Copyright @ 2022~2023