鸿蒙next中简单实用relationalStore封装数据库

文档来自于: developer.huawei.com/consumer/cn…

在APP中使用数据库很常见, 下面我将简单的使用数据库封装

1. 定义RdbUtils

export default class RdbUtils {
  private static rdbStore: relationalStore.RdbStore;

  static initDb(context: Context) {
    const config: relationalStore.StoreConfig = {
      name: 'voice.db',
      securityLevel: relationalStore.SecurityLevel.S1
    };

    relationalStore.getRdbStore(context, config, (err, store) => {
      if (err) {
        console.error(`Failed to get RdbStore. Code:${err.code}, message:${err.message}`);
        return;
      }
      console.info(`Succeeded in getting RdbStore.`);

      //创建各种表
      RdbUtils.setStore(store)
      VoicePackDao.createTable()
      VoiceItemDao.createTable()
    });
  }

  static setStore(store: relationalStore.RdbStore) {
    RdbUtils.rdbStore = store;
  }

  static getStore(): relationalStore.RdbStore {
    return RdbUtils.rdbStore;
  }

  static executeSql(sql: string): Promise<void> {
    return RdbUtils.getStore().executeSql(sql);
  }

  static insert(tableName: string, data: ValuesBucket): Promise<number> {
    return RdbUtils.getStore().insert(tableName, data, relationalStore.ConflictResolution.ON_CONFLICT_REPLACE);
  }

  static insertAll(tableName: string, data: Array<ValuesBucket>): Promise<number> {
    return RdbUtils.getStore().batchInsert(tableName, data);
  }

  static find(predicates: relationalStore.RdbPredicates) {
    return RdbUtils.getStore().query(predicates)
  }

  static delete(predicates: relationalStore.RdbPredicates) {
    return RdbUtils.getStore().delete(predicates)
  }
}

2. 初始化

在EntryAbility的onCreate中调用

//初始化数据库
RdbUtils.initDb(this.context)

简单的贴出其中一个类VoicePack.ets

import { ValuesBucket } from '@kit.ArkData'

export interface VoicePack extends ValuesBucket {
  objectId: string
  title: string
  size: number
  createdAt: number
}

继续VoicePackDao.ets

import RdbUtils from './RdbUtils';
import { VoicePack } from './VoicePack';
import { relationalStore } from '@kit.ArkData';

export class VoicePackDao {
  private static tableName = "voice_pack";
  private static createTableQuery =
    `CREATE TABLE IF NOT EXISTS ${VoicePackDao.tableName}(objectId TEXT PRIMARY KEY, title TEXT, size INTEGER, createdAt INTEGER)`;

  static createTable() {
    return RdbUtils.executeSql(VoicePackDao.createTableQuery);
  }

  static async getPackListByPage(currentPageIndex: number, pageSize: number): Promise<Array<VoicePack>> {
    let query = new relationalStore.RdbPredicates(VoicePackDao.tableName)
    query.orderByDesc("createdAt")
    query.limitAs(pageSize)
    query.offsetAs(currentPageIndex * pageSize)
    let result = await RdbUtils.find(query)

    const list: Array<VoicePack> = []
    while (result.goToNextRow()) {
      list.push(result.getRow() as VoicePack)
    }

    return list
  }

  static async getAll(): Promise<Array<VoicePack>> {
    let query = new relationalStore.RdbPredicates(VoicePackDao.tableName)
    query.orderByDesc("createdAt")
    let result = await RdbUtils.find(query)

    const list: Array<VoicePack> = []
    while (result.goToNextRow()) {
      list.push(result.getRow() as VoicePack)
    }

    return list
  }

  static async deleteByObjectId(objectId: string): Promise<number> {
    let query = new relationalStore.RdbPredicates(VoicePackDao.tableName)
    query.equalTo("objectId", objectId)
    return RdbUtils.delete(query)
  }

  static async insertAll(packages: Array<VoicePack>): Promise<number> {
    return RdbUtils.insertAll(VoicePackDao.tableName, packages)
  }

  static async insert(voicePack: VoicePack): Promise<number> {
    return RdbUtils.insert(VoicePackDao.tableName, voicePack)
  }

  static async deleteAll(): Promise<number> {
    let query = new relationalStore.RdbPredicates(VoicePackDao.tableName)
    return RdbUtils.delete(query)
  }
}

其中需要自己写sql语句建表, 感觉挺麻烦的, 我是用ai帮忙生成的, 很快. 但是希望能用bean直接动态生成表?

3. 使用

使用就很简单了

import { Pack } from '../bean/PackDetail';
import { VoicePack } from './VoicePack';
import { VoicePackDao } from './VoicePackDao';

export class VoicePackUtils {
  static deletePack(pack: Pack) {
    return VoicePackDao.deleteByObjectId(pack.objectId)
  }

  static savePack(pack: Pack): Promise<number> {
    let voicePack: VoicePack = {
      objectId: pack.objectId,
      title: pack.name,
      size: pack.size,
      createdAt: new Date().getTime()
    }

    return VoicePackDao.insert(voicePack)
  }

  static getAllPack(): Promise<Array<VoicePack>> {
    return VoicePackDao.getAll()
  }
}

4. 总结

由于是简单使用, 没有涉及到任何的实务, 数据库的升级之类的, 有兴趣的可以自行研究一下