ArkTS，关系类数据库的封装

最新推荐文章于 2024-06-27 14:05:30 发布
最新推荐文章于 2024-06-27 14:05:30 发布
阅读量689 收藏 28
点赞数 22
文章标签： 数据库 程序人生 harmonyos
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_55064824/article/details/139317955
版权

前言

这个类的封装是我在做一个手机助手的项目时遇到的一个封装，在这个项目里有需要创建三个表去存储数据，达到数据持久化的效果（因为存储的数据大于8k所以使用数据库的方法进行存储）

封装方法讲解

在封装这个类的时候，一共是有两个方法，一个是用枚举值的形式去判断表名来达到建立不同的表（枚举值判断），一个是先封装一个基础的类然后将不同的地方提取出来，用继承类的方法去封装这个类（泛型类方法）。
两个方法都可以实现我所需要的效果，但是第一种方法对于使用的局限性是比较大，在调用这个方法时需要至少传入一个枚举值，从而起到判断的作用，而且因为是三个表，每个表所对应的数据类型是不一样的，当我们要传入或者返回一个相应的值的时候，往往需要用断言的方式去进行。而第二个方法就没有这方面的困扰，你不需要用所谓的枚举去进行判断，也不需要对返回值进行断言，泛型类的方法主要是通过一个通用的不需要更改的部分先进行封装，然后用继承的方式去封装不同的地方。

数据持久化及数据库API分析

应用数据持久化

应用数据持久化，是指应用将内存中的数据通过文件或数据库的形式保存到设备上。
HarmonyOS 标准系统支持典型的存储数据形态，包括用户首选项、键值型数据库、关系型数据库。

数据库级别概念

关系型数据库（Relational Database，RDB）是一种基于关系模型来管理数据的数据库。关系型数据库基于SQLite组件提供了一套完整的对本地数据库进行管理的机制，对外提供了一系列的增、删、改、查等接口，也可以直接运行用户输入的SQL语句来满足复杂的场景需要。不支持Worker线程。
ArkTS侧支持的基本数据类型：number、string、二进制类型数据、boolean。为保证插入并读取数据成功，建议一条数据不要超过2M。超出该大小，插入成功，读取失败。
该模块提供以下关系型数据库相关的常用功能：

  • RdbPredicates： 数据库中用来代表数据实体的性质、特征或者数据实体之间关系的词项，主要用来定义数据库的操作条件。
  • RdbStore：提供管理关系数据库(RDB)方法的接口。
  • ResultSet：提供用户调用关系型数据库查询接口之后返回的结果集合

接口说明

以下是关系型数据库持久化功能的相关接口，大部分为异步接口。

异步接口均有 callback 和 Promise 两种返回形式，更多接口及使用方式请见关系型数据库

接口名称描述
getRdbStore获得一个相关的RdbStore，操作关系型数据库，用户可以根据自己的需求配置RdbStore的参数，然后通过RdbStore调用相关接口可以执行相关的数据操作。
executeSql执行包含指定参数但不返回值的SQL语句。
insert向目标表中插入一行数据。
update根据RdbPredicates的指定实例对象更新数据库中的数据。
delete根据RdbPredicates的指定实例对象从数据库中删除数据。
query根据指定条件查询数据库中的数据。
deleteRdbStore删除数据库。

开始封装

枚举值判断法

准备封装

封装前的准备工作，定义一些在封装中需要用到的常量、变量等

import { relationalStore, ValuesBucket } from '@kit.ArkData'

//笔记文件关键信息
export interface PrivacyNoteDBInfo extends ValuesBucket {
  id: number | null,
  title: string,
  content: string,
  date_added: number,
}

// 隐私录音的字段
export interface PrivacyRecorderDBInfo extends ValuesBucket {
  id: number | null // 新增时 id 为 null ，自动生成自增 id
  filePath: string
  title: string
  date_added: number
  duration: number
}

// 图片和视频文件关键信息。(PhotoKeys)
export interface PrivacyPhotoDBInfo extends ValuesBucket {
  id: number | null // 新增时 id 为 null ，自动生成自增 id
  mediaUri: string // 文件uri
  privacyUri: string // 沙箱文件uri
  media_type: number // 媒体文件类型
  date_added: number // 添加日期
}

//隐私类型枚举
export enum secret {
  NOTE,
  RECORDER,
  PHOTO
}

class PrivacyDB {
  // SQL 语法：（SQL语法的数据类型关键词不一样，可通过AI生成SQL语句）
  // 解释说明：
  //   CREATE TABLE IF NOT EXISTS     如果表不存在才创建新的表
  //   INTEGER -> number              INTEGER 整数型   FLOAT 浮点数
  //   PRIMARY KEY                    主键(唯一标识)
  //   AUTOINCREMENT                  自增
  //   TEXT -> string                 字符串型
  //   NOT NULL                       不允许空
  private privacy: string = ''//表名
  //隐私笔记初始化数据库
  private noteContent: string = `CREATE TABLE IF NOT EXISTS PRIVACY_NOTE (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        title TEXT NOT NULL,
        content TEXT NOT NULL,
        date_added INTEGER NOT NULL
      )`
  //隐私录音初始化数据库
  private recorderContent: string = `CREATE TABLE IF NOT EXISTS PRIVACY_RECORDER (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        filePath TEXT,
        title TEXT,
        date_added INTEGER,
        duration INTEGER
      )`
  //隐私相册初始化数据库
  private photoContent: string = `CREATE TABLE IF NOT EXISTS PRIVACY_PHOTO (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        mediaUri TEXT,
        privacyUri TEXT,
        media_type INTEGER,
        date_added INTEGER
      )`
  // 操作数据库的管理对象
  private store: relationalStore.RdbStore | null = null
  }
判断表名方法封装
// 判断表名
 getPrivacy(ilk: secret) {
  let privacy: string = ''
  if (ilk === secret.NOTE) {
    privacy = 'PRIVACY_NOTE'
  }
  if (ilk === secret.RECORDER) {
    privacy = 'PRIVACY_RECORDER'
  }
  if (ilk === secret.PHOTO) {
    privacy = 'PRIVACY_PHOTO'
  }
  return privacy
}
初始化数据库
//初始化数据库
async getStoreInstance(ilk: secret) {
  try {
    //当 store 有值时，直接返回 store 的值
    if (this.store) {
      return this.store
    }
    // 获取操作数据库的管理对象(如果数据库文件不存在，会自动创建数据库文件)
    this.store = await relationalStore.getRdbStore(getContext(), {
      name: 'aaa.db',
      securityLevel: relationalStore.SecurityLevel.S1
    })
    // 执行创建表的语句 execute 执行
    this.store.executeSql(this.noteContent)
    this.store.executeSql(this.photoContent)
    this.store.executeSql(this.recorderContent)
    //返回 store 的值
    return this.store
  } catch (err) {
    return Promise.reject('initDB error')
  }
}
新增数据

新增数据不需要传入id，当你传入的id为 null 时，数据库的API会自动根据上一个id进行自增（如果没有上一个，则为1）

// 新增数据库
async insert(item: PrivacyNoteDBInfo | PrivacyRecorderDBInfo | PrivacyPhotoDBInfo, ilk: secret) {
  //判断是哪个表
  this.privacy = await this.getPrivacy(ilk)
  // 获取相应的表
  const store = await this.getStoreInstance(ilk)
  // 将数据添加入表，并赋值给 rowId
  const rowId = await store.insert(this.privacy, item)
  // 返回 rowId
  return rowId > -1 ? Promise.resolve(rowId) : Promise.reject('insert error')
}

这里补充一个批量新增数据，这个方法其实与新增是一样的，只是传入值有所不同

// 批量新增数据库
async batchInsert(items: PrivacyNoteDBInfo[] | PrivacyRecorderDBInfo[] | PrivacyPhotoDBInfo[], ilk: secret) {
  this.privacy = await this.getPrivacy(ilk)
  const store = await this.getStoreInstance(ilk)
  const rowId = await store.batchInsert(this.privacy, items)
  return rowId ? Promise.resolve(rowId) : Promise.reject('insert error')
}
查询
查询表内数据总数
//查询数据库总数
async queryCount(ilk: secret) {
  //判断是哪个表
  this.privacy = await this.getPrivacy(ilk)
  // 获取相应的表
  const store = await this.getStoreInstance(ilk)
  const predicates = new relationalStore.RdbPredicates(this.privacy)
  const resultSet = await store.query(predicates)
  return resultSet.rowCount > 0 ? resultSet.rowCount : 0
}
查询数据
//查询数据
async query(ilk: secret, id?: number) {
  this.privacy = await this.getPrivacy(ilk)
  const store = await this.getStoreInstance(ilk)
  const predicates = new relationalStore.RdbPredicates(this.privacy)
  // 倒序排列
  predicates.orderByDesc('id')
  // 如果有 id，添加 id 作为查询条件
  if (id) {
    predicates.equalTo('id', id)
  }
  const resultSet = await store.query(predicates)
  const note: PrivacyNoteDBInfo[] = []
  const recorder: PrivacyRecorderDBInfo[] = []
  const photo: PrivacyPhotoDBInfo[] = []
  while (resultSet.goToNextRow()) {
    // 移动指针的时候提取数据，按列下标提取数据
    if (ilk === secret.NOTE) {
      note.push(
        {
          id: resultSet.getLong(0),
          title: resultSet.getString(1),
          content: resultSet.getString(2),
          date_added: resultSet.getLong(3),
        }
      )
    }
    if (ilk === secret.RECORDER) {
      recorder.push(
        {
          id: resultSet.getLong(0),
          filePath: resultSet.getString(1),
          title: resultSet.getString(2),
          date_added: resultSet.getLong(3),
          duration: resultSet.getLong(4),
        }
      )
    }
    if (ilk === secret.PHOTO) {
      photo.push(
        {
          id: resultSet.getLong(0),
          mediaUri: resultSet.getString(1),
          privacyUri: resultSet.getString(2),
          media_type: resultSet.getLong(3),
          date_added: resultSet.getLong(4),
        }
      )
    }
  }
  // 循环结束，释放结果集的内存空间（性能优化）
  resultSet.close()
  // 循环结束后，返回结果
  if (ilk === secret.NOTE) {
    return note
  } else
    if (ilk === secret.RECORDER) {
      return recorder
    } else
    if (ilk === secret.PHOTO) {
      return photo
    } else {
    return 
  }
}
知识补充 谓词
RdbPredicates

表示关系型数据库（RDB）的谓词，主要用来定义数据库的操作条件。

使用说明

RdbPredicates 为构造函数类，需要通过 new 关键词创建类的实例，参数为 数据库表名。

参数：

参数名类型必填说明
namestring是数据库表名。
知识补充 结果集
ResultSet

提供通过查询数据库生成的数据库结果集的访问方法。结果集是指用户调用关系型数据库查询接口之后返回的结果集合，提供了多种灵活的数据访问方式，以便用户获取各项数据。

属性

名称类型必填说明
columnNamesArray是获取结果集中所有列的名称。
columnCountnumber是获取结果集中的列数。
rowCountnumber是获取结果集中的行数。
删除数据
//删除数据
async delete(id: number, ilk: secret) {
 this.privacy = await this.getPrivacy(ilk)
 const store = await this.getStoreInstance(ilk)
 const predicates = new relationalStore.RdbPredicates(this.privacy)
 predicates.equalTo('id', id)
 // 删除完成，返回受影响的行数
 const rowCount = await store.delete(predicates)
 return rowCount ? Promise.resolve(rowCount) : Promise.reject('delete error')

}

补充批量删除

//批量删除数据
async batchDelete(ids: number[], ilk: secret) {
  this.privacy = await this.getPrivacy(ilk)
  const store = await this.getStoreInstance(ilk)
  const predicates = new relationalStore.RdbPredicates(this.privacy)
  predicates.in('id', ids)
  // 删除完成，返回受影响的行数
  const rowCount = await store.delete(predicates)
  return rowCount ? Promise.resolve(rowCount) : Promise.reject('delete error')

}
更新数据
//更新数据
  async update(item: PrivacyNoteDBInfo | PrivacyRecorderDBInfo | PrivacyPhotoDBInfo, ilk: secret) {
    // 如果没有 id 直接退出
    if (!item.id) {
      return Promise.reject('id error')
    }
    this.privacy = await this.getPrivacy(ilk)
    const store = await this.getStoreInstance(ilk)
    const predicates = new relationalStore.RdbPredicates(this.privacy)
    predicates.equalTo('id', item.id)
    // 更新完成，返回受影响的行数
    const rowCount = await store.update(item, predicates)
    return rowCount ? Promise.resolve(rowCount) : Promise.reject('delete error')
  }
}
最后通过 new 实例的方法导出
export const privacyNoteDB = new PrivacyNoteDB()
完整封装代码
import { relationalStore, ValuesBucket } from '@kit.ArkData'

//笔记文件关键信息
export interface PrivacyNoteDBInfo extends ValuesBucket {
  id: number | null,
  title: string,
  content: string,
  date_added: number,
}

// 隐私录音的字段
export interface PrivacyRecorderDBInfo extends ValuesBucket {
  id: number | null // 新增时 id 为 null ，自动生成自增 id
  filePath: string
  title: string
  date_added: number
  duration: number
}

// 图片和视频文件关键信息。(PhotoKeys)
export interface PrivacyPhotoDBInfo extends ValuesBucket {
  id: number | null // 新增时 id 为 null ，自动生成自增 id
  mediaUri: string // 文件uri
  privacyUri: string // 沙箱文件uri
  media_type: number // 媒体文件类型
  date_added: number // 添加日期
}

//隐私类型枚举
export enum secret {
  NOTE,
  RECORDER,
  PHOTO
}

class PrivacyDB {
  // SQL 语法：（SQL语法的数据类型关键词不一样，可通过AI生成SQL语句）
  // 解释说明：
  //   CREATE TABLE IF NOT EXISTS     如果表不存在才创建新的表
  //   INTEGER -> number              INTEGER 整数型   FLOAT 浮点数
  //   PRIMARY KEY                    主键(唯一标识)
  //   AUTOINCREMENT                  自增
  //   TEXT -> string                 字符串型
  //   NOT NULL                       不允许空
  //表名
  private privacy: string = ''
  //隐私笔记初始化数据库
  private noteContent: string = `CREATE TABLE IF NOT EXISTS PRIVACY_NOTE (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        title TEXT NOT NULL,
        content TEXT NOT NULL,
        date_added INTEGER NOT NULL
      )`
  //隐私录音初始化数据库
  private recorderContent: string = `CREATE TABLE IF NOT EXISTS PRIVACY_RECORDER (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        filePath TEXT,
        title TEXT,
        date_added INTEGER,
        duration INTEGER
      )`
  //隐私相册初始化数据库
  private photoContent: string = `CREATE TABLE IF NOT EXISTS PRIVACY_PHOTO (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        mediaUri TEXT,
        privacyUri TEXT,
        media_type INTEGER,
        date_added INTEGER
      )`
  // 操作数据库的管理对象
  private store: relationalStore.RdbStore | null = null

  // 判断表名
  getPrivacy(ilk: secret) {
    let privacy: string = ''
    if (ilk === secret.NOTE) {
      privacy = 'PRIVACY_NOTE'
    }
    if (ilk === secret.RECORDER) {
      privacy = 'PRIVACY_RECORDER'
    }
    if (ilk === secret.PHOTO) {
      privacy = 'PRIVACY_PHOTO'
    }
    return privacy
  }

  //初始化数据库
  async getStoreInstance(ilk: secret) {
    try {
      //当 store 有值时，直接返回 store 的值
      if (this.store) {
        return this.store
      }
      // 获取操作数据库的管理对象(如果数据库文件不存在，会自动创建数据库文件)
      this.store = await relationalStore.getRdbStore(getContext(), {
        name: 'aaa.db',
        securityLevel: relationalStore.SecurityLevel.S1
      })
      // 执行创建表的语句 execute 执行
      this.store.executeSql(this.noteContent)
      this.store.executeSql(this.photoContent)
      this.store.executeSql(this.recorderContent)
      //返回 store 的值
      return this.store
    } catch (err) {
      return Promise.reject('initDB error')
    }
  }

  // 新增数据库
  async insert(item: PrivacyNoteDBInfo | PrivacyRecorderDBInfo | PrivacyPhotoDBInfo, ilk: secret) {
    //判断是哪个表
    this.privacy = await this.getPrivacy(ilk)
    // 获取相应的表
    const store = await this.getStoreInstance(ilk)
    // 将数据添加入表，并赋值给 rowId
    const rowId = await store.insert(this.privacy, item)
    // 返回 rowId
    return rowId > -1 ? Promise.resolve(rowId) : Promise.reject('insert error')
  }

  // 批量新增数据库
  async batchInsert(items: PrivacyNoteDBInfo[] | PrivacyRecorderDBInfo[] | PrivacyPhotoDBInfo[], ilk: secret) {
    this.privacy = await this.getPrivacy(ilk)
    const store = await this.getStoreInstance(ilk)
    const rowId = await store.batchInsert(this.privacy, items)
    return rowId ? Promise.resolve(rowId) : Promise.reject('insert error')
  }

  //查询数据库总数
  async queryCount(ilk: secret) {
    //判断是哪个表
    this.privacy = await this.getPrivacy(ilk)
    // 获取相应的表
    const store = await this.getStoreInstance(ilk)
    const predicates = new relationalStore.RdbPredicates(this.privacy)
    const resultSet = await store.query(predicates)
    return resultSet.rowCount > 0 ? resultSet.rowCount : 0
  }

  //查询数据
  async query(ilk: secret, id?: number) {
    this.privacy = await this.getPrivacy(ilk)
    const store = await this.getStoreInstance(ilk)
    const predicates = new relationalStore.RdbPredicates(this.privacy)
    // 倒序排列
    predicates.orderByDesc('id')
    // 如果有 id，添加 id 作为查询条件
    if (id) {
      predicates.equalTo('id', id)
    }
    const resultSet = await store.query(predicates)
    const note: PrivacyNoteDBInfo[] = []
    const recorder: PrivacyRecorderDBInfo[] = []
    const photo: PrivacyPhotoDBInfo[] = []
    while (resultSet.goToNextRow()) {
      // 移动指针的时候提取数据，按列下标提取数据
      if (ilk === secret.NOTE) {
        note.push(
          {
            id: resultSet.getLong(0),
            title: resultSet.getString(1),
            content: resultSet.getString(2),
            date_added: resultSet.getLong(3),
          }
        )
      }
      if (ilk === secret.RECORDER) {
        recorder.push(
          {
            id: resultSet.getLong(0),
            filePath: resultSet.getString(1),
            title: resultSet.getString(2),
            date_added: resultSet.getLong(3),
            duration: resultSet.getLong(4),
          }
        )
      }
      if (ilk === secret.PHOTO) {
        photo.push(
          {
            id: resultSet.getLong(0),
            mediaUri: resultSet.getString(1),
            privacyUri: resultSet.getString(2),
            media_type: resultSet.getLong(3),
            date_added: resultSet.getLong(4),
          }
        )
      }
    }
    // 循环结束，释放结果集的内存空间（性能优化）
    resultSet.close()
    // 循环结束后，返回结果
    if (ilk === secret.NOTE) {
      return note
    } else
      if (ilk === secret.RECORDER) {
        return recorder
      } else
      if (ilk === secret.PHOTO) {
        return photo
      } else {
      return
    }
  }

  //删除数据
  async delete(id: number, ilk: secret) {
    this.privacy = await this.getPrivacy(ilk)
    const store = await this.getStoreInstance(ilk)
    const predicates = new relationalStore.RdbPredicates(this.privacy)
    predicates.equalTo('id', id)
    // 删除完成，返回受影响的行数
    const rowCount = await store.delete(predicates)
    return rowCount ? Promise.resolve(rowCount) : Promise.reject('delete error')

  }

  //批量删除数据
  async batchDelete(ids: number[], ilk: secret) {
    this.privacy = await this.getPrivacy(ilk)
    const store = await this.getStoreInstance(ilk)
    const predicates = new relationalStore.RdbPredicates(this.privacy)
    predicates.in('id', ids)
    // 删除完成，返回受影响的行数
    const rowCount = await store.delete(predicates)
    return rowCount ? Promise.resolve(rowCount) : Promise.reject('delete error')

  }

  //更新数据
  async update(item: PrivacyNoteDBInfo | PrivacyRecorderDBInfo | PrivacyPhotoDBInfo, ilk: secret) {
    // 如果没有 id 直接退出
    if (!item.id) {
      return Promise.reject('id error')
    }
    this.privacy = await this.getPrivacy(ilk)
    const store = await this.getStoreInstance(ilk)
    const predicates = new relationalStore.RdbPredicates(this.privacy)
    predicates.equalTo('id', item.id)
    // 更新完成，返回受影响的行数
    const rowCount = await store.update(item, predicates)
    return rowCount ? Promise.resolve(rowCount) : Promise.reject('delete error')
  }
}

export const privacyNoteDB = new PrivacyNoteDB()

继承法

准备封装
import { relationalStore, ValuesBucket } from '@kit.ArkData'

// 数据库名和表名
const tableName = 'privacy_note'

// 创建数据库的语句
const sqlCreate = `CREATE TABLE IF NOT EXISTS qwe (

        id INTEGER PRIMARY KEY AUTOINCREMENT,

        title TEXT NOT NULL,

        content TEXT NOT NULL,

        date_added INTEGER NOT NULL

      )`
    
// RdbModule类用于封装对关系型数据库的操作
class RdbModule {

  // 操作数据库的实例
  private store: relationalStore.RdbStore | null = null;
  private tableName: string; // 数据库表的名称
  private sqlCreate: string; // 创建数据库表的SQL语句
  private securityLevel: relationalStore.SecurityLevel; // 数据库的安全等级

  // 构造函数，初始化表名、创建语句和安全等级
  constructor(tableName: string, sqlCreate: string, securityLevel: relationalStore.SecurityLevel) {
    if (sqlCreate.includes(tableName)) {
      this.tableName = tableName;
      this.sqlCreate = sqlCreate;
      this.securityLevel = securityLevel;
    } else {
      // 如果表名和建表语句内的表名不匹配,则抛出错误
      console.error("The table name does not match the statement that created the table")
      throw new Error("The table name does not match the statement that created the table");
    }
  }
}
初始化数据库
// 获取数据库操作实例，如果已存在则直接返回，否则创建新的实例
  async getStoreInstance() {
    if (this.store) {
      return this.store;
    }
    const store = await relationalStore.getRdbStore(getContext(), {
      name: this.tableName + '.db', // 数据库名称
      securityLevel: this.securityLevel // 安全等级
    });
    store.executeSql(this.sqlCreate); // 执行创建表的SQL语句
    this.store = store; // 存储实例以便后续使用
    return this.store; // 返回数据库操作实例
  }
新增数据
// 插入一条数据到数据库
  async setData<T extends ValuesBucket>(value: T) {
    const store = await this.getStoreInstance();
    return store.insert(this.tableName, value);
  }
查询
查询表内总数
 // 查询数据库中的数据量
  async getTotal() {
    const store = await this.getStoreInstance();
    const predicates = new relationalStore.RdbPredicates(this.tableName);
    const results = await store.query(predicates);
    return results.rowCount <= 0 ? 0 : results.rowCount;
  }
查询数据（可批量查询）
// 查询数据库列表，可以指定单个或多个ID，返回一个数组
  async getTheList<T>(id?: number | number[]) {
    const store = await this.getStoreInstance();
    const predicates = new relationalStore.RdbPredicates(this.tableName);
    if (typeof id === 'number') {
      id = [id];
    }
    id !== undefined ? predicates.in("id", id) : predicates.orderByDesc("id");
    const results = await store.query(predicates);
    const list: T[] = [];
    while (results.goToNextRow()) {
      list.push(results.getRow() as T);
    }
    return list;
  }
删除数据
// 删除数据库中的数据
  async delData(id: number) {
    const store = await this.getStoreInstance();
    const predicates = new relationalStore.RdbPredicates(this.tableName);
    predicates.equalTo("id", id);
    return store.delete(predicates);
  }
更新数据
// 更新数据库中的数据
 async upData<T extends ValuesBucket>(id: number, val: T) {
   const store = await this.getStoreInstance();
   const predicates = new relationalStore.RdbPredicates(this.tableName);
   predicates.equalTo("id", id);
   return store.update(val, predicates);
 }
完整封装代码
import { relationalStore, ValuesBucket } from '@kit.ArkData'



// 数据库名和表名

const tableName = 'privacy_note'

// 创建数据库的语句

const sqlCreate = `CREATE TABLE IF NOT EXISTS qwe (

        id INTEGER PRIMARY KEY AUTOINCREMENT,

        title TEXT NOT NULL,

        content TEXT NOT NULL,

        date_added INTEGER NOT NULL

      )`





// RdbModule类用于封装对关系型数据库的操作

class RdbModule {

  // 操作数据库的实例

  private store: relationalStore.RdbStore | null = null;

  private tableName: string; // 数据库表的名称

  private sqlCreate: string; // 创建数据库表的SQL语句

  private securityLevel: relationalStore.SecurityLevel; // 数据库的安全等级



  // 构造函数，初始化表名、创建语句和安全等级

  constructor(tableName: string, sqlCreate: string, securityLevel: relationalStore.SecurityLevel) {

    if (sqlCreate.includes(tableName)) {

      this.tableName = tableName;

      this.sqlCreate = sqlCreate;

      this.securityLevel = securityLevel;

    } else {

      // 如果表名和建表语句内的表名不匹配,则抛出错误

      console.error("The table name does not match the statement that created the table")

      throw new Error("The table name does not match the statement that created the table");

    }

  }



  // 获取数据库操作实例，如果已存在则直接返回，否则创建新的实例

  async getStoreInstance() {

    if (this.store) {

      return this.store;

    }

    const store = await relationalStore.getRdbStore(getContext(), {

      name: this.tableName + '.db', // 数据库名称

      securityLevel: this.securityLevel // 安全等级

    });

    store.executeSql(this.sqlCreate); // 执行创建表的SQL语句

    this.store = store; // 存储实例以便后续使用

    return this.store; // 返回数据库操作实例

  }



  // 插入一条数据到数据库

  async setData<T extends ValuesBucket>(value: T) {

    const store = await this.getStoreInstance();

    return store.insert(this.tableName, value);

  }



  // 查询数据库中的数据量

  async getTotal() {

    const store = await this.getStoreInstance();

    const predicates = new relationalStore.RdbPredicates(this.tableName);

    const results = await store.query(predicates);

    return results.rowCount <= 0 ? 0 : results.rowCount;

  }



  // 查询数据库列表，可以指定单个或多个ID，返回一个数组

  async getTheList<T>(id?: number | number[]) {

    const store = await this.getStoreInstance();

    const predicates = new relationalStore.RdbPredicates(this.tableName);

    if (typeof id === 'number') {

      id = [id];

    }

    id !== undefined ? predicates.in("id", id) : predicates.orderByDesc("id");

    const results = await store.query(predicates);



    const list: T[] = [];

    while (results.goToNextRow()) {

      list.push(results.getRow() as T);

    }

    return list;

  }



  // 更新数据库中的数据

  async upData<T extends ValuesBucket>(id: number, val: T) {

    const store = await this.getStoreInstance();

    const predicates = new relationalStore.RdbPredicates(this.tableName);

    predicates.equalTo("id", id);

    return store.update(val, predicates);

  }



  // 删除数据库中的数据

  async delData(id: number) {

    const store = await this.getStoreInstance();

    const predicates = new relationalStore.RdbPredicates(this.tableName);

    predicates.equalTo("id", id);

    return store.delete(predicates);

  }

}



// 创建RdbModule实例，并传入表名、创建语句和安全等级

// 如果需要多个数据库，可以导出多个实例

export const rdbModule = new RdbModule(tableName, sqlCreate, relationalStore.SecurityLevel.S1);
silent-阳
关注
  • 22
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
鸿蒙开发实战项目(五十四):关系型数据库（ArkTS）
sybh的博客
01-28 1457
本Codelab以记账为例，使用关系型数据库的相关接口实现了对账单的增、删、改、查操作。
Python3实现的Mysql数据库操作封装类
09-09
在Python3中，为了提高代码的可重用性和模块化，我们常常会将数据库操作封装成一个类。这个类通常包含了连接数据库、执行SQL查询、更新数据以及关闭连接等基本功能。以下是一个关于Python3实现的Mysql数据库操作封装...
HarmonyOS 应用开发之通过关系型数据库实现数据持久化
maniuT的博客
04-01 1167
关系型数据库基于SQLite组件，适用于存储包含复杂关系数据的场景，比如一个班级的学生信息，需要包括姓名、学号、各科成绩等，又或者公司的雇员信息，需要包括姓名、工号、职位等，由于数据之间有较强的对应关系，复杂程度比键值型数据更高，此时需要使用关系型数据库来持久化保存数据。
HarmonyOS ArkTS 保存应用数据（十）
Chen_xiaobao的博客
11-23 2484
在移动互联网蓬勃发展的今天，移动应用给我们生活带来了极大的便利，这些便利的本质在于数据的互联互通。因此在应用的开发中数据存储占据了非常重要的位置，HarmonyOS应用开发也不例外。首选项为应用提供Key-Value键值型的数据存储能力，支持应用持久化轻量级数据，并对其进行增删除改查等。该存储对象中的数据会被缓存在内存中，因此它可以获得更快的存取速度，下面详细介绍下首选项的开发过程。
Harmony鸿蒙应用开发——关系型数据库（RelationalStore）
Creat_List的博客
01-10 3543
基本概念 关系型数据库基于SQLite组件，适用于存储包含复杂关系数据的场景，比如一个班级的学生信息，需要包括姓名、学号、各科成绩等，又或者公司的雇员信息，需要包括姓名、工号、职位等，由于数据之间有较强的对应关系，复杂程度比键值型数据更高，此时需要使用关系型数据库来持久化保存数据。 接口说明 以下是关系型数据库持久化功能的相关接口，大部分为异步接口。异步接口均有callback和Promise两种返回形式，下表均以callback形式为例，更多接口及使用方式请见关系型数据库。 接口名称
HarmonyOs开发：关系型数据库封装之增删改查
知足常乐
06-05 805
数据量较少的持久化存储，我们可以选择用户首选项或者是分布式键值数据库进行操作，如果前两种无法满足，在鸿蒙当中，也给我们提供了关系型数据库进行数据之间的操作
1、鸿蒙数组实现增删改查
cjd_d_的博客
05-17 1290
js模拟增删 html 首先是一个大的容器container 然后分成上部和下部分 上部放着增加和全部删除按钮 下面是for循环遍历数组 <div class="container"> <div class="topview"> <div class="btnview" onclick="add"> <text>增加</text> </div> <di
鸿蒙、如何使用@ohos.contact 接口，实现对联系人的增删查改功能
m0_70749039的博客
04-09 1135
本示例使用@ohos.contact 接口，实现了对联系人的增删查改功能。
【HarmonyOS开发】ArkTs关系型和非关系型数据库的存储封装
qq_23334071的博客
12-20 3498
前面使用了首选项的存储方式，因此将其他的两种存储方式（）也学习一下，简单记录一下，并进行封装，方便后续使用。
鸿蒙开发之如何使用关系型数据库进行关联查询
qq_14863717的博客
06-27 1134
通过使用RdbPredicates设置查询条件和RdbStore执行查询，你可以在HarmonyOS的关系型数据库中实现复杂的关联查询，类似于传统SQL中的JOIN操作。这种方法虽然不同于直接编写SQL语句，但提供了灵活性和对查询条件的精细控制。
PHP数据库处理封装类实例
10-20
在PHP开发中，数据库操作是常见的任务，而封装数据库处理类是一种良好的编程实践，可以提高代码的可维护性和复用性。本篇文章将深入探讨PHP中的数据库处理封装类，特别是基于mysqli扩展的封装，以及如何进行数据库...
数据库封装类CPingDatabase.rar_C++封装数据库_数据库封装类_类库
09-21
本压缩包"数据库封装类CPingDatabase.rar"包含了一个名为"CPingDatabase"的C++类库，专门用于封装数据库操作。 "CPingDatabase"类的设计通常会包括以下关键功能： 1. **连接管理**：类中会有一个初始化方法，用于...
php简单数据库操作类的封装
08-30
PHP简单数据库操作类的封装 PHP简单数据库操作类的封装是指将数据库操作封装成一个类，提供了一个简洁高效的方式来与数据库交互。这个类可以实例化，提供了连接数据库、执行SQL语句、返回查询结果等功能。 ConnDB...
PHP访问MYSQL数据库封装类(附函数说明)
10-28
本文将详细解析一个基于 `mysql_` 函数封装的 PHP 数据库访问类，以便更高效、安全地与 MySQL 数据库进行交互。 首先，我们来看一下这个 `db_mysql` 类的主要组成部分： 1. **属性**： - `$querynum`：用于记录...
鸿蒙HarmonyOS 数据库结果集ResultSet介绍
abckingaa的博客
06-16 490
鸿蒙HarmonyOS 数据库结果集ResultSet介绍查询结果集的使用关系型数据库提供了查询返回的结果集ResultSet，其指向查询结果中的一行数据，供用户对查询结果进行遍历和访问。ResultSet对外API如下所示。类名接口名描述ResultSetboolean goTo(int offset)从结果集当前位置移动指定偏移量。ResultSetboolean goToRow(int position)将结果集移动到指定位置。ResultSetboolean goToNextRow()将结果集向后移
【鸿蒙开发实战】鸿蒙中如何通过关系型数据库实现数据持久化
最新发布
HarmonyOS_001的博客
06-27 621
有很多小伙伴不知道该从哪里开始学习鸿蒙开发技术？也不知道鸿蒙开发的知识点重点掌握的又有哪些？自学时频繁踩坑，导致浪费大量时间。结果还是一知半解。所以有一份实用的鸿蒙（HarmonyOS NEXT）全栈开发资料用来跟着学习是非常有必要的。获取完整版高清学习资料，请点击→鸿蒙全栈开发学习资料（安全链接，请放心点击）
鸿蒙数据库
m0_74351542的博客
05-19 175
-创建表的时候设置约束条件。
鸿蒙-关系型数据库(@ohos.data.relationalStore)
zhujian82637的博客
07-02 3821
update函数需要传入两个参数，第一个是需要更新的列值，是一个对象，key为列名，value是对应的值，第二个参数是一个条件对象，上面代码表示更新userInfo表中name='lisi'的age更新为66。batchInsert函数第一个参数是表名称，第二个参数是一个ValuesBucket数组对象，ValuesBucket表示key-value的对象，key表示表的列名称，value是对应的值。2、RdbPredicates 用来定义数据库的操作条件，可用于查询，修改，删除的条件语句。
qt 数据库工具类封装
07-30
Qt是一种广泛应用的C++跨平台开发框架，它为开发人员提供了丰富的工具和类库来简化软件开发过程。Qt还提供了对数据库的支持，允许开发者使用数据库进行数据的存储和管理。为了进一步简化开发过程，我们可以封装一个数据库工具类。 数据库工具类的主要目的是封装对数据库的操作，使其易于使用、可重用，并提供错误处理和异常处理机制。以下是一个可能的Qt数据库工具类的实现示例。 首先，我们需要一个类来代表数据库连接。我们可以创建一个名为Database的类，其中包含连接数据库、断开数据库、执行查询等功能的成员函数。 其次，我们可以创建一个Table类，用于代表数据库中的表。Table类可以提供一些功能，如创建表、插入数据、更新数据、删除数据等。 我们还可以为每个表创建对应的模型类，用于与Qt的模型视图框架进行交互。模型类可以继承自Qt的QAbstractTableModel类，并实现一些必要的函数，如rowCount、columnCount、data等。这样，我们可以方便地将表中的数据展示在Qt的ListView或TableView等控件上。 在封装数据库工具类时，我们还可以考虑使用单例模式，确保整个应用程序中只有一个数据库实例存在。这样做可以避免重复创建数据库连接和占用过多资源。 总的来说，Qt数据库工具类的封装可以大大简化数据库操作的编写过程，提高代码的可读性和可维护性。通过对数据库连接的封装，我们可以更方便地进行数据库操作，同时减少错误和异常处理的工作量。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值