鸿蒙 —— 关系型数据库

建库建表

// entry/src/main/ets/database/AccountTagTable.ets
import { relationalStore } from '@kit.ArkData';

export interface TableData {
  id: number,
  tagName: string,
  tagImage: string,
  tagNumber: number,
  accountType: number
}

function bucket(data: TableData): relationalStore.ValuesBucket {
  let obj: relationalStore.ValuesBucket = {
    tagName: data.tagName,
    tagImage: data.tagImage,
    tagNumber: data.tagNumber,
    accountType: data.accountType
  }
  return obj
}

export default class AccountTagTable {
  private tableName: string = 'tagTable'
  // 表结构：tagTable (id, tagName, tagImage, tagNumber, accountType)
  private createTable = 'CREATE TABLE IF NOT EXISTS tagTable (id INTEGER PRIMARY KEY AUTOINCREMENT' +
    ', tagName Text, tagImage Text, tagNumber INTEGER, accountType INTEGER)';
  private rdbStore: relationalStore.RdbStore | undefined = undefined;

  // 建库建表
  getRdbStore(callback: Function) {
    const STORE_CONFIG :relationalStore.StoreConfig= { // 关系数据库配置
      name: 'Rdb.db', // 数据库文件名
      securityLevel: relationalStore.SecurityLevel.S3, // 数据库安全级别,
      allowRebuild: true // 指定数据库是否支持异常时自动删除，并重建一个空库空表
    };

    let context: Context = getContext(this) as Context
    relationalStore.getRdbStore(context, STORE_CONFIG, (err, store) => { // 建库：Rdb.db
      if (err) {
        console.error(`Failed to get RdbStore. Code:${err.code}, message:${err.message}`);
        return;
      }
      this.rdbStore = store

      // 当数据库创建时，数据库默认版本为0
      if (store.version === 0) {
        store.executeSql(this.createTable); // 建表
        // 设置数据库的版本，入参为大于0的整数
        store.version = 1;
      }

      callback()
    });
  }

  // 增
  insert(data: TableData, callback: Function) {
    const valuesBucket: relationalStore.ValuesBucket = bucket(data)
    if (this.rdbStore !== undefined) {
      this.rdbStore.insert(this.tableName, valuesBucket, (err) => {
        if (err) {
          console.error(`Insert failed, code is ${err.code}, message is ${err.message}`);
          return;
        }
        callback()
      })
    }
  }

  // 删
  delete(data: TableData, callback: Function) {
    let predicates = new relationalStore.RdbPredicates(this.tableName);
    predicates.equalTo('id', data.id);
    if (this.rdbStore !== undefined) {
      this.rdbStore.delete(predicates, (err) => {
        if (err) {
          console.error(`Delete failed, code is ${err.code}, message is ${err.message}`);
          return;
        }
        callback()
      })
    }
  }

  // 改
  update(data: TableData, callback: Function) {
    const valuesBucket: relationalStore.ValuesBucket = bucket(data)
    let predicates = new relationalStore.RdbPredicates(this.tableName);
    predicates.equalTo('id', data.id);
    if (this.rdbStore !== undefined) {
      this.rdbStore.update(valuesBucket, predicates, (err) => {
        if (err) {
          console.error(`Updated failed, code is ${err.code}, message is ${err.message}`);
          return;
        }
        callback()
      })
    }
  }

  // 查
  querySql(callback: Function) {
    if (this.rdbStore !== undefined) {
      this.rdbStore.querySql('SELECT * FROM tagTable ORDER BY tagNumber ASC', (err, resultSet) => {
        if (err) {
          console.error(`Query failed, code is ${err.code}, message is ${err.message}`);
          return;
        }
        const result: TableData[] = []
        // resultSet是一个数据集合的游标，默认指向第-1个记录，有效的数据从0开始。
        while (resultSet.goToNextRow()) {
          let tmp: TableData = {
            id: resultSet.getLong(resultSet.getColumnIndex("id")),
            tagName: resultSet.getString(resultSet.getColumnIndex("tagName")),
            tagImage: resultSet.getString(resultSet.getColumnIndex("tagImage")),
            tagNumber: resultSet.getLong(resultSet.getColumnIndex("tagNumber")),
            accountType: resultSet.getLong(resultSet.getColumnIndex("accountType"))
          }
          result.push(tmp)
        }
        callback(result)
        // 释放数据集的内存，若不释放可能会引起fd泄露与内存泄露
        resultSet.close();
      })
    }
  }

  // 从指定的数据库备份文件恢复数据库
  backup(callback: Function) {
    if (this.rdbStore != undefined) {
      this.rdbStore.backup("Backup.db", (err) => {
        if (err) {
          console.error(`Backup failed, code is ${err.code}, message is ${err.message}`);
          return;
        }
        callback()
      })
    }
  }

  // 从指定的数据库备份文件恢复数据库
  restore(callback: Function) {
    if (this.rdbStore != undefined) {
      this.rdbStore.restore('Backup.db', (err) => {
        console.log('112244')
        if (err) {
          console.error(`Restore failed, code is ${err.code}, message is ${err.message}`);
          return;
        }
        callback()
      })
    }
  }
}

使用

import AccountTagTable, { TableData } from '../database/AccountTagTable'

@Entry
@Component
struct Index {
  private rdb = new AccountTagTable()
  @State tableData: TableData = {
    id: -1,
    tagName: '',
    tagImage: '',
    tagNumber: 1,
    accountType: 0
  }

  aboutToAppear(): void {
    this.rdb.getRdbStore(() => {
      this.rdb.querySql((result: TableData[]) => {
        // 查询数据
      })
    })
  }
  
  build() {
  
  }
}

// 增
this.rdb.insert(this.tableData, () => {
   
})
// 删
this.rdb.delete(this.tableData, () => {
   
})
// 改
this.rdb.update(this.tableData, () => {
   
})