基于鸿蒙OS4的关系数据库使用学习——以浅易版备忘录为例 - ToB企服应用市场:ToB评测及商务社交产业平台

../scr/main目录下文件树结构展示
.
|-- constants
| `-- CommonConstants.ets
|-- database
| |-- MemoTable.ets
| `-- Rdb.ets
|-- ets
| |-- component
| | `-- MemoItem.ets
| |-- entryability
| | `-- EntryAbility.ts
| `-- pages
| `-- Index.ets
|-- model
| |-- MemoModel.ets
| `-- TableInterface.ets
|-- module.json5
|-- resources
| |-- base
| | |-- element
| | | |-- color.json
| | | `-- string.json
| | |-- media
| | | `-- icon.png
| | `-- profile
| | `-- main_pages.json
| |-- en_US
| | `-- element
| | `-- string.json
| |-- rawfile
| `-- zh_CN
| `-- element
| `-- string.json
`-- utils
`-- Logger.ets

复制代码

import relationalStore from '@ohos.data.relationalStore'
import { MemoTable } from '../model/TableInterface'
export default class CommonConstants {
// Rdb 数据库配置
static readonly STORE_CONFIG:relationalStore.StoreConfig = {
name:'database.db',
securityLevel:relationalStore.SecurityLevel.S1
}
static readonly MEMO_TABLE:MemoTable = {
tableName:'memoTable',
sqlCreate:'CREATE TABLE IF NOT EXISTS memoTable(id INTEGER PRIMARY KEY AUTOINCREMENT, updateTime INTEGER, content TEXT)',
columns:['id','updateTime','content']
}
// 一些日志控制参数
static readonly RDB_TAG = '[Debug.Rdb]';
static readonly TABLE_TAG = '[Debug.memoTable]';
static readonly INDEX_TAG = '[Debug.Index]';
}

复制代码

```typescript
export interface MemoTable {
tableName: string
sqlCreate: string
columns: string[]
}

复制代码

interface 接口名{
接口代码：一般定义规则、方法等
方法名(形参：形参类型)：方法返回值
}

复制代码

import relationalStore from '@ohos.data.relationalStore';
import CommonConstants from '../constants/CommonConstants';
import Logger from '../utils/Logger';
// 抽象的Rdb类，没有业务属性，可以基于这个类创建带有业务属性的一张或多张表
export default class Rdb {
// 管理关系数据库(RDB)方法属性类型是RdbStore 或 null
private rdbStore: relationalStore.RdbStore | null = null;
// 数据库表名称
private tableName: string;
// 创建SQLite表的语句字符串
private sqlCreateTable: string;
// 列名字段的数组
private columns: Array<string>;
// 实例化 Rdb 对象时，初始化表名、创建表的语句、列名字段的数组
constructor(tableName: string, sqlCreateTable: string, columns: Array<string>) {
this.tableName = tableName;
this.sqlCreateTable = sqlCreateTable;
this.columns = columns;
}
// 获取操作数据库RdbStore对象的方法，接收一个回调函数
getRdbStore(callback: Function = () => {
}) {
// 如果回调函数为空、或undefined 打印错误日志，退出方法
if (!callback || typeof callback === 'undefined' || callback === undefined) {
Logger.info(CommonConstants.RDB_TAG, 'getRdbStore() has no callback!');
return;
}
// 如果属性rdbStore 不为空，说明操作对象已经初始化，打印日志，执行回调函数，退出方法
if (this.rdbStore !== null) {
Logger.info(CommonConstants.RDB_TAG, 'The rdbStore exists.');
callback();
return
}
// 执行到此处，说明回调函数不为空，且rdbStore尚未初始化
// 获取上下文
let context: Context = getContext(this) as Context;
/*
获取RdbStore接口的方法，接收三个参数
context ：应用上下文
config ：数据库配置
callback ：回调函数，异步返回rdb对象
*/
relationalStore.getRdbStore(context, CommonConstants.STORE_CONFIG, (err, rdb) => {
// 如果发生错误，打印日志，退出方法
if (err) {
Logger.error(CommonConstants.RDB_TAG, `gerRdbStore() failed, err: ${err}`);
return;
}
// 如果没有错误，为rdbStore属性赋值为rdb
this.rdbStore = rdb;
// 执行Sql语句，使用创建表的字符串
this.rdbStore.executeSql(this.sqlCreateTable);
// 打印日志
Logger.info(CommonConstants.RDB_TAG, 'getRdbStore() finished.');
// 执行方法入参的回调函数
callback();
});
}
// 插入数据的方法，入参为表格的存储键值对，和回调函数
insertData(data: relationalStore.ValuesBucket, callback: Function = () => {
}) {
// 如果回调函数为空、或undefined 打印错误日志，退出方法
if (!callback || typeof callback === 'undefined' || callback === undefined) {
Logger.info(CommonConstants.RDB_TAG, 'insertData() has no callback!');
return;
}
// 创建结果标识局部变量，默认为false
let resFlag: boolean = false;
// 创建存储键值对局部变量，默认为入参data
const valueBucket: relationalStore.ValuesBucket = data;
// 如果rdbStore存在则执行
if (this.rdbStore) {
// 执行rdbStore的插入数据方法，入参为表名、存储键值对、异步回调函数
this.rdbStore.insert(this.tableName, valueBucket, (err, ret) => {
if (err) {
// 如果发生错误，打印日志，执行入参的回调函数，并传入结果标识 false
Logger.error(CommonConstants.RDB_TAG, `insertData() failed, err: ${err}`);
callback(resFlag);
return;
}
// 如果操作成功，打印日志，执行回调函数，并传入返回ret（行ID）
Logger.info(CommonConstants.RDB_TAG, `insertData() finished: ${ret}`);
callback(ret);
});
}
}
// 删除数据的方法，接收谓词和回调函数两个参数
deleteData(predicates: relationalStore.RdbPredicates, callback: Function = () => {
}) {
// 如果回调函数为空、或undefined 打印错误日志，退出方法
if (!callback || typeof callback === 'undefined' || callback === undefined) {
Logger.info(CommonConstants.RDB_TAG, 'deleteData() has no callback!');
return;
}
// 创建结果标识局部变量，默认为false
let resFlag: boolean = false;
// 如果rdbStore存在则执行
if (this.rdbStore) {
// rdbStore的删除方法，入参为谓词、异步回调函数
this.rdbStore.delete(predicates, (err, ret) => {
// 如果发生错误，打印日志，执行入参的回调函数，并传入结果标识 false
if (err) {
Logger.error(CommonConstants.RDB_TAG, `deleteData() failed, err: ${err}`);
callback(resFlag);
return;
}
// 如果删除成功，打印日志，执行回调函数，并传入返回ret（行ID）
Logger.info(CommonConstants.RDB_TAG, `deleteData() finished: ${ret}`);
callback(!resFlag);
});
}
}
// 更新数据的方法，接收三个参数：谓词、存储键值对、回调函数
updateData(predicates: relationalStore.RdbPredicates, data: relationalStore.ValuesBucket, callback: Function = () => {
}) {
// 如果回调函数为空、或undefined 打印错误日志，退出方法
if (!callback || typeof callback === 'undefined' || callback === undefined) {
Logger.info(CommonConstants.RDB_TAG, 'updateDate() has no callback!');
return;
}
// 创建结果标识局部变量，默认为false
let resFlag: boolean = false;
// 创建存储键值对局部变量，默认为入参data
const valueBucket: relationalStore.ValuesBucket = data;
// 如果rdbStore存在则执行
if (this.rdbStore) {
// rdbStore的更新方法，接收三个参数，存储键值对、谓词、回调函数
this.rdbStore.update(valueBucket, predicates, (err, ret) => {
if (err) {
// 如果发生错误，打印日志，执行入参的回调函数，并传入结果标识 false
Logger.error(CommonConstants.RDB_TAG, `updateData() failed, err: ${err}`);
callback(resFlag);
return;
}
// 如果更新成功，打印日志，执行回调函数，并传入返回成功的标识 true
Logger.info(CommonConstants.RDB_TAG, `updateData() finished: ${ret}`);
callback(!resFlag);
});
}
}
// 查询数据的方法，接收两个参数，谓词、回调函数
query(predicates: relationalStore.RdbPredicates, callback: Function = () => {
}) {
// 如果回调函数为空、或undefined 打印错误日志，退出方法
if (!callback || typeof callback === 'undefined' || callback === undefined) {
Logger.info(CommonConstants.RDB_TAG, 'query() has no callback!');
return;
}
// 如果rdbStore存在则执行
if (this.rdbStore) {
// rdbStore的查询方法，接收三个参数，谓词，数据库列名的数组，异步回调函数
this.rdbStore.query(predicates, this.columns, (err, resultSet) => {
// 如果发生错误，打印日志，退出方法
if (err) {
Logger.error(CommonConstants.RDB_TAG, `query() failed, err: ${err}`);
return;
}
// 如果没有错误，打印日志
Logger.info(CommonConstants.RDB_TAG, 'query() finished.');
// 执行入参的回调函数，传入查询结果
callback(resultSet);
// 关闭结果集
resultSet.close();
});
}
}
}

复制代码

class MemoModel {
id: number
updateTime: number
content: string
constructor(id: number, updateTime: number, content: string) {
this.id = id
this.updateTime = updateTime
this.content = content
}
}
export default MemoModel

复制代码

import relationalStore from '@ohos.data.relationalStore';
import MemoModel from '../model/MemoModel'
import CommonConstants from '../constants/CommonConstants';
import Rdb from './Rdb';
// 笔记的数据库类，基于Rdb类，有业务属性
export default class MemoTable {
// 通过Rdb类实例化memoTable对象，使用常量文件“CommonConstants”中配置的参数
private memoTable = new Rdb(CommonConstants.MEMO_TABLE.tableName, CommonConstants.MEMO_TABLE.sqlCreate,
CommonConstants.MEMO_TABLE.columns);
// 构造函数，执行getRdbStore方法
constructor(callback: Function = () => {
}) {
this.memoTable.getRdbStore(callback);
}
// 通过memoTable对象，执行原Rdb类中的getRdbStore方法，为memoTable对象获取rdbStore操作对象
getRdbStore(callback: Function = () => {
}) {
// 透传回调函数
this.memoTable.getRdbStore(callback);
}
// 插入数据的方法，接收单条memo笔记对象，和回调函数
insertData(memo: MemoModel, callback: Function) {
// 通过工具函数，将单条memo笔记，转化为存储健值对
const valueBucket: relationalStore.ValuesBucket = generateBucket(memo);
// 执行memoTable的插入数据方法，透传回调函数
this.memoTable.insertData(valueBucket, callback);
}
// 删除数据的方法，接收单条memo笔记对象，和回调函数
deleteData(memo: MemoModel, callback: Function) {
// 初始化操作数据库的谓词对象
let predicates = new relationalStore.RdbPredicates(CommonConstants.MEMO_TABLE.tableName);
// 配置谓词以匹配数据表的id列中值的字段，为笔记对象的id
predicates.equalTo('id', memo.id);
// 使用谓词执行memoTable的删除方法，透传回调函数
this.memoTable.deleteData(predicates, callback);
}
// 更新数据的方法，接收单条memo笔记对象，和回调函数
updateData(memo: MemoModel, callback: Function) {
// 通过工具函数，将单条memo笔记，转化为存储健值对
const valueBucket: relationalStore.ValuesBucket = generateBucket(memo);
// 初始化操作数据库的谓词对象
let predicates = new relationalStore.RdbPredicates(CommonConstants.MEMO_TABLE.tableName);
// 配置谓词以匹配数据表的id列中值的字段，为笔记对象的id
predicates.equalTo('id', memo.id);
// 使用谓词执行memoTable的更新方法，透传回调函数
this.memoTable.updateData(predicates, valueBucket, callback);
}
// 查询全部笔记的方法
query(callback: Function) {
// 初始化操作数据库的谓词对象
let predicates = new relationalStore.RdbPredicates(CommonConstants.MEMO_TABLE.tableName);
// 使用谓词执行memoTable的查询方法，此时谓词匹配未指定（equalTo），所以将查询全部
this.memoTable.query(predicates, (resultSet: relationalStore.ResultSet) => {
// 创建局部变量，存储结果的行数
let count: number = resultSet.rowCount;
// 如果查询的结果为0，执行回调函数，传入空数组
if (count === 0 || typeof count === 'string') {
console.log(`${CommonConstants.TABLE_TAG}` + 'Query no results!');
callback([]);
} else {
// 如果有结果，将结果集指向第一行
resultSet.goToFirstRow();
// 创建局部变量，存储最后将返回的结果数组
const result: MemoModel[] = [];
// 使用循环为结果添加内容
for (let i = 0; i < count; i++) {
let tmp: MemoModel = {
id: 0, updateTime: 0, content: ''
};
tmp.id = resultSet.getDouble(resultSet.getColumnIndex('id'));
tmp.updateTime = resultSet.getDouble(resultSet.getColumnIndex('updateTime'));
tmp.content = resultSet.getString(resultSet.getColumnIndex('content'));
result[i] = tmp;
// 转至下一行
resultSet.goToNextRow();
}
// 执行回调函数，把所有的查询结果传入
callback(result);
}
});
}
}
// 工具函数，将memo笔记的数据结构，转化为存储键值对
function generateBucket(memo: MemoModel): relationalStore.ValuesBucket {
let obj: relationalStore.ValuesBucket = {};
obj.updateTime = memo.updateTime
obj.content = memo.content
return obj;
}

复制代码

@Entry
@Component
struct Index {
// 缓存的原始数组
originMemoList: MemoModel[] = []
// 页面中展示的memo列表
@State memoList: MemoModel[] = []
// 新建暂存内容
@State addContent: string = ''
@State number: number = 1
// 当前编辑的memo索引
editingMemoIndex: number = -1
build() {
Stack() {
// 主体页面
Column() {
Row() {
Text("MeMo")
.fontSize(20)
.fontColor(Color.White)
.margin({ left:20})
Blank()
Button() {
Text("我是按钮")
.fontSize(20)
.fontColor(Color.White)
}
.height(40)
.width(150)
.onClick(() => {
this.number = this.number + 1
})
}
.width('100%')
.height(60)
.linearGradient({
direction:GradientDirection.Bottom,
colors:[[Color.Black, 0.5], [Color.Gray, 1]]
})
.shadow({
radius:10
})
Divider()
.color('#604637')
// 笔记列表
Scroll() {
Column() {
Text(String(this.number))
.fontSize(40)
List({space: 10}) {
ForEach(this.memoList, (item: MemoModel, index) => {
ListItem() {
Row() {
Text(item.content)
Text(String(item.updateTime))
}
}.card()
})
}
}
}
}
.width('100%')
.height('100%')
}
}
}

复制代码