鸿蒙关系型数据库开发（课本版)

学不会编程的大学生

已于 2024-06-25 22:46:46 修改

阅读量128

点赞数 3

文章标签： harmonyos 数据库开发华为

于 2024-06-25 22:45:11 首次发布

本文链接：https://blog.csdn.net/weixin_70464416/article/details/139971947

版权

1.在src/main/ets目录下创建名为common的目录，创建类RdbUtil

//导入rdb模块
import data_rdb from '@ohos.data.rdb'
//导入context模块
// @ts-ignore
import context from '@ohos.application.context';

type Context = context.Context;
const STORE_CONFIG = { name: "rdbstore.db" }

export default class RdbUtil {
  private rdbStore: any = null;
  private tableName: string;
  private sqlCreateTable: string;
  private columns: Array<string>;

  constructor(tableName: string, sqlCreateTable: string, columns: Array<string>) {
    this.tableName = tableName;
    this.sqlCreateTable = sqlCreateTable;
    this.columns = columns;
  }

  getRdbStore(callback) {
    //如果已经获取到RdbStore，则不进行操作
    if (this.rdbStore != null) {
      console.info('The rdbStore exists.');
      callback();
      return;
    }
    //应用上下文，本例是使用API9 Stage模型的Context
    let context: Context = getContext(this) as Context;
    data_rdb.getRdbStore(context, STORE_CONFIG, 1, (err, rdb) => {
      if (err) {
        console.error('gerRdbStore() failed, err: ' + err);
        return;
      }
      this.rdbStore = rdb;

      //获取到RdbStore后，需要使用executeSql接口初始化数据库表结构和相关数据
      this.rdbStore.executeSql(this.sqlCreateTable);
      console.info('getRdbStore() finished.');
      callback();
    });
  }

  //插入数据
  insertData(data, callback) {
    let resFlag: boolean = false;  	//用于记录插入是否成功的flag
    const valueBucket = data;  		//存储键－值对的类型，表示要插入表中的数据行
    this.rdbStore.insert(this.tableName, valueBucket, function (err, ret) {
      if (err) {
        console.error('Rdb', 'insertData() failed, err: ' + err);
        callback(resFlag);
        return;
      }
      callback(!resFlag);
    });
  }
  //删除数据
  deleteData(predicates, callback) {
    let resFlag: boolean = false;

    //predicates表示待删除数据的操作条件
    this.rdbStore.delete(predicates, function (err, ret) {
      if (err) {
        console.error('Rdb', 'deleteData() failed, err: ' + err);
        callback(resFlag);
        return;
      }
      callback(!resFlag);
    });
  }
  //更新数据
  updateData(predicates, data, callback) {
    let resFlag: boolean = false;
    const valueBucket = data;
    this.rdbStore.update(valueBucket, predicates, function (err, ret) {
      if (err) {
        console.error('Rdb', 'updateData() failed, err: ' + err);
        callback(resFlag);
        return;
      }
      callback(!resFlag);
    });
  }
  //查找数据
  query(predicates, callback){
    //columns表示要查询的列，如果为空，则表示查询所有列
    this.rdbStore.query(predicates, this.columns, function (err, resultSet) {
      if (err) {
        console.error('Rdb', 'query() failed, err: ' + err);
        return;
      }
      callback(resultSet);  	//如果查找成功，则返回resultSet结果集
      resultSet.close();  	//操作完成后关闭结果集
    });
  }
}

2.在ets目录下创建名为database的目录，并在database目录下创建脚本类AccountData

export default interface AccountData {
  id: number;
  accountType: number;
  typeText: string;
  amount: number;
}

3.在database目录下创建针对账目信息操作类AccountTable

import data_rdb from '@ohos.data.rdb';
import RdbUtil from '../common/RdbUtil';
import AccountData from './AccountData';

const ACCOUNT_TABLE = {
  tableName: 'accountTable',
  sqlCreate: 'CREATE TABLE IF NOT EXISTS accountTable(' +
  'id INTEGER PRIMARY KEY AUTOINCREMENT, accountType INTEGER, ' +
  'typeText TEXT, amount INTEGER)',
  columns: ['id', 'accountType', 'typeText', 'amount']
};

export default class AccountTable {

  private accountTable = new RdbUtil(ACCOUNT_TABLE.tableName, ACCOUNT_TABLE.sqlCreate,
    ACCOUNT_TABLE.columns);

  constructor(callback: Function = () => {}) {
    this.accountTable.getRdbStore(callback);
  }

  getRdbStore(callback: Function = () => {}) {
    this.accountTable.getRdbStore(callback);
  }
  //插入数据
  insertData(account: AccountData, callback) {
    //根据输入数据创建待插入的数据行
    const valueBucket = generateBucket(account);
    this.accountTable.insertData(valueBucket, callback);
  }

  //删除数据
  deleteData(account: AccountData, callback) {
    let predicates = new data_rdb.RdbPredicates(ACCOUNT_TABLE.tableName);

    //根据id匹配待删除的数据行
    predicates.equalTo('id', account.id);
    this.accountTable.deleteData(predicates, callback);
  }

  //修改数据
  updateData(account: AccountData, callback) {
    const valueBucket = generateBucket(account);
    let predicates = new data_rdb.RdbPredicates(ACCOUNT_TABLE.tableName);

    //根据id匹配待修改的数据行
    predicates.equalTo('id', account.id);
    this.accountTable.updateData(predicates, valueBucket, callback);
  }

  //查找数据
  query(amount: number, callback, isAll: boolean = true){
    let predicates = new data_rdb.RdbPredicates(ACCOUNT_TABLE.tableName);
    //是否查找全部数据
    if (!isAll) {
      predicates.equalTo('amount', amount);  //根据金额匹配要查找的数据行
    }
    this.accountTable.query(predicates, function(resultSet) {
      let count = resultSet.rowCount;

      //若查找结果为空，则返回空数组，否则返回查找结果数组
      if (count === 0 || typeof count === 'string') {
        console.log('Query no results!');
        callback([]);
      } else {
        resultSet.goToFirstRow();
        const result = [];
        for (let i = 0; i < count; i++) {
          let tmp: AccountData = { id: 0, accountType: 0, typeText: '', amount: 0 };
          tmp.id = resultSet.getDouble(resultSet.getColumnIndex('id'));
          tmp.accountType = resultSet.getDouble(resultSet.getColumnIndex
          ('accountType'));
          tmp.typeText = resultSet.getString(resultSet.getColumnIndex
          ('typeText'));
          tmp.amount = resultSet.getDouble(resultSet.getColumnIndex
          ('amount'));
          result[i] = tmp;
          resultSet.goToNextRow();
        }
        callback(result);
      }
    });
  }
}

function generateBucket(account: AccountData) {
  let obj = {};
  ACCOUNT_TABLE.columns.forEach((item) => {
    if (item != 'id') {
      obj[item] = account[item];
    }
  });
  return obj;
}

4.修改Index代码

import AccountData from '../database/AccountData';
import AccountTable from '../database/AccountTable';

@Entry
@Component
struct Index {
  @State message: string = 'HelloWorld'
  private accountTable = new AccountTable();

  aboutToAppear() {
    //初始化数据库
    this.accountTable.getRdbStore(() => {
      this.accountTable.query(0, (result) => {
        this.message = result;
      }, true);
    });
  }

  build() {
   Row() {
      Column() {
        Text(this.message)
          .fontSize(70)
          .fontWeight(FontWeight.Bold)

        //增加
        Button(('增加'), { type: ButtonType.Capsule })
          .width(140)
          .fontSize(40)
          .fontWeight(FontWeight.Medium)
          .margin({ top: 10, bottom: 10 })
          .onClick(() => {
            let newAccount: AccountData = { id: 0, accountType: 0, typeText: '苹果', amount: 0 };
            this.accountTable.insertData(newAccount, () => {
            })
          })

        //查询
        Button(('查询'), { type: ButtonType.Capsule })
          .width(140)
          .fontSize(40)
          .fontWeight(FontWeight.Medium)
          .margin({ top: 10, bottom: 10 })
          .onClick(() => {
            this.accountTable.query(0, (result) => {
              this.message = JSON.stringify(result);
            }, true);
          })
        //修改
        Button(('修改'), { type: ButtonType.Capsule })
          .width(140)
          .fontSize(40)
          .fontWeight(FontWeight.Medium)
          .margin({ top: 10, bottom: 10 })
          .onClick(() => {
            let newAccount: AccountData = { id: 1, accountType: 1, typeText: '栗子', amount: 1 };
            this.accountTable.updateData(newAccount, () => {
            })
          })

        //删除
        Button(('删除'), { type: ButtonType.Capsule })
          .width(140)
          .fontSize(40)
          .fontWeight(FontWeight.Medium)
          .margin({ top: 10, bottom: 10 })
          .onClick(() => {
            let newAccount: AccountData = { id: 2, accountType: 1, typeText: '栗子', amount: 1 };
            this.accountTable.deleteData(newAccount, () => {
            })
          })
      }
      .width('100%')
   }
    .height('100%')
  }
}