HarmonyOS期末项目——作业清单（三）搭建关系型数据库-CSDN博客

数据模型（Bean）：通过定义数据模型类（如DDLDetailClass、PreferenceData、TaskCategoryData、TaskListItemData），结构化地管理和存储应用数据。
数据库（Database）：使用HarmonyOS的数据存储方案，创建和管理数据库表（如CategoryTable、PreferenceDB、TaskDB、TaskTable），实现数据的增删改查操作。

二、交互示意图

三、创建数据库

3.1PreferenceDB.ets (偏好数据库)

管理用户偏好设置的数据库操作。

3.1.1 功能

获取偏好设置存储对象：getPreferenceStorage() 方法用于获取偏好设置存储对象。该对象是通过 dataPreferences.getPreferences(context, 'Pref.db') 获取的。如果获取失败，将会记录错误信息到日志中。
设置偏好设置：putPreference(key: string, value: string) 方法用于向偏好设置中存储键值对。它会将给定的键值对存储到偏好设置中，并通过 preference.flush() 立即将更改刷新到存储中。如果存储操作失败，将会记录错误信息到日志中。
获取偏好设置：getPreference(key: string): Promise<string> 方法用于根据键获取对应的偏好设置值。它会首先检查是否已经获取了偏好设置存储对象，如果没有则会先获取。然后尝试从偏好设置中获取指定键的值，并返回获取的值。如果获取失败，将会记录错误信息到日志中。

3.1.2 代码文件



let context = getContext(this)
let preference: dataPreferences.Preferences
let preferenceTemp: dataPreferences.Preferences

class PreferenceDB {
  async getPreferenceStorage() {
    try {
      preference = await dataPreferences.getPreferences(context, 'Pref.db')
    } catch(err){
      Logger.error(`PrefDB: failed to get storage: ${err}`)
    }
  }
  async putPreference(key: string, value: string) {
    try {
      await preference.put(key, value)
    } catch(err) {
      Logger.error(`PrefDB: failed to put pref: ${err}`)
    }
    await preference.flush()
  }
  async getPreference(key: string): Promise<string> {
    let res: string = ''
    if (!preference) preference = await dataPreferences.getPreferences(context, 'Pref.db')
    try {
      res = (await preference.get(key, '')).toString()
    } catch(err) {
      Logger.error(`PrefDB: failed to get pref: ${err}`)
    }
    return res
  }
}

export default new PreferenceDB()

3.2 TaskDB.ets (任务数据库)

管理任务的数据库操作。

3.2.1 功能简介

TaskDB 类用于执行与任务相关的数据库操作，包括插入、删除、更新和查询数据等功能。
通过 getRdbStore 方法获取数据库存储实例，确保数据库操作的准备就绪。
提供了 insertData 方法，用于向数据库中插入数据，支持传入数据对象和回调函数。
deleteData 方法用于删除数据库中的数据，可以传入条件谓词以指定删除条件。
updateData 方法用于更新数据库中的数据，支持传入更新数据和条件谓词。
query 方法用于执行查询操作，支持传入条件谓词以指定查询条件，并通过回调函数返回查询结果。
类构造函数接受表名、创建表的 SQL 语句、表的列信息和数据库配置参数作为参数，确保了 TaskDB 实例与指定的数据库表进行交互。
通过日志记录器 Logger 对数据库操作过程进行日志记录，方便调试和错误追踪。

3.2.2 代码文件



export default class TaskDB {
  private rdbStore: relationalStore.RdbStore | null = null
  private tableName: string
  private sqlCreateTable: string
  private columns: Array<string>
  private RDB_TAG: string = '[DEBUG_RDB]'
  private StoreConfig: relationalStore.StoreConfig


  constructor(tableName: string, sqlCreateTable: string, columns: Array<string>, Config: relationalStore.StoreConfig = CommonConstants.STORE_CONFIG) {
    this.tableName = tableName
    this.sqlCreateTable = sqlCreateTable
    this.columns = columns
    this.StoreConfig = Config
  }

  getRdbStore(callback: Function = () => {}) {
    if (!callback || typeof callback === 'undefined' || callback === undefined) {
      Logger.info(this.RDB_TAG, 'getRdbStore() has no callback!');
      return;
    }
    if (this.rdbStore !== null) {
      callback();
      return;
    }
    let context: Context = getContext(this) as Context
    relationalStore.getRdbStore(context, this.StoreConfig, (err, rdb) => {
      if (err) {
        Logger.error(this.RDB_TAG, `gerRdbStore() failed, err: ${err}`);
        return;
      }
      this.rdbStore = rdb
      this.rdbStore.executeSql(this.sqlCreateTable)
      // 假定这里 execute 之后不会出事
      callback();
    })
  }

  updateColumns(newColumn: string, newColumnData: string) {
    this.rdbStore.executeSql(`ALTER TABLE ${this.tableName} ADD COLUMN ${newColumn} ${newColumnData}`)
  }


  insertData(data: relationalStore.ValuesBucket, callback: Function = () => {}) {
    if (!callback || typeof callback === 'undefined' || callback === undefined) {
      Logger.info(this.RDB_TAG, 'insertData() has no callback!');
      return;
    }
    const valueBucket: relationalStore.ValuesBucket = data
    if (this.rdbStore) {
      Logger.debug(this.RDB_TAG, this.tableName)
      this.rdbStore.insert(this.tableName, valueBucket, (err, ret) => {
        if (err) {
          Logger.error(this.RDB_TAG, `insertData() failed, err: ${err.code}, ${err.name}, ${err.message}, valueB = ${JSON.stringify(valueBucket)}, ret = ${ret}`);
          callback(false)
          return
        }
        Logger.debug(this.RDB_TAG, `insert finished: ${ret}`)
        callback(ret)
      })
    }
  }
  deleteData(predicates:  relationalStore.RdbPredicates, callback: Function = () => {}) {
    if (!callback || typeof callback === 'undefined' || callback === undefined) {
      Logger.info(this.RDB_TAG, 'deleteData() has no callback!');
      return;
    }
    if (this.rdbStore) {
      this.rdbStore.delete(predicates, (err, ret) => {
        if (err) {
          Logger.error(this.RDB_TAG, `deleteData() failed, err: ${err}`);
          callback(false);
          return;
        }
        Logger.info(this.RDB_TAG, `deleteData() finished: ${ret}`);
        callback(true);
      })
    }
  }
  updateData(predicates: relationalStore.RdbPredicates, data: relationalStore.ValuesBucket, callback: Function = () => {}) {
    if (!callback || typeof callback === 'undefined' || callback === undefined) {
      Logger.info(this.RDB_TAG, 'updateDate() has no callback!');
      return;
    }
    const valueBucket: relationalStore.ValuesBucket = data
    if (this.rdbStore) {
      this.rdbStore.update(valueBucket, predicates, (err, ret) => {
        if (err) {
          Logger.error(this.RDB_TAG, `updateData() failed, err: ${err}`);
          callback(false);
          return;
        }
        Logger.info(this.RDB_TAG, `updateData() finished: ${ret}`);
        callback(true);
      })
    }
  }
  query(predicates: relationalStore.RdbPredicates, callback: Function = () => {}) {
    if (!callback || typeof callback === 'undefined' || callback === undefined) {
      Logger.info(this.RDB_TAG, 'queryTaskName() has no callback!');
      return;
    }
    if (this.rdbStore) {
      this.rdbStore.query(predicates).then((resultSet) => {
        Logger.debug(this.RDB_TAG, `query finished.`)
        callback(resultSet)
        resultSet.close()
      }).catch((err) => {
        if (err) {
          Logger.error(this.RDB_TAG, `query() failed, err:  ${err}`);
          return;
        }
      })
    }
  }

}

四、数据表定义

定义数据表的结构和字段。

4.1 CategoryTable.ets (类别表)

定义了任务类别的数据库表结构和操作。

4.1.1 功能简介

CategoryTable 类用于对任务类别数据进行数据库操作，包括插入、删除、更新和查询数据等功能。
通过构造函数初始化 TaskDB 实例，确保CategoryTable 与指定的数据库表进行交互。
提供了 insertData 方法，用于向数据库中插入任务类别数据，支持传入任务类别对象和回调函数。
deleteData 方法用于根据任务类别对象删除数据库中的数据。
updateData 方法用于根据任务类别对象更新数据库中的数据。
query 方法用于执行查询操作，支持根据任务类别的不同属性进行查询，并通过回调函数返回查询结果。
提供了基础查询方法 basic_query，用于处理查询操作的基础逻辑，支持查询所有任务类别或根据特定属性进行条件查询。
通过日志记录器 Logger 对数据库操作过程进行日志记录，方便调试和错误追踪。
提供了 generateBucket 方法，用于生成 relationalStore.ValuesBucket 对象，方便进行数据操作。

4.1.2 代码文件


export default class CategoryTable {
  private cateTable = new TaskDB(CommonConstants.CATEGORY_TABLE_INIT.tableName, CommonConstants.CATEGORY_TABLE_INIT.sqlCreate,
    CommonConstants.CATEGORY_TABLE_INIT.columns, CommonConstants.CATEGORY_STORE_CONFIG)

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

  getRdbStore(callback: Function = () => {}) {
    this.cateTable.getRdbStore(callback)
  }

  insertData(prefData: TaskCategoryData, callback: Function) {
    const valueBucket: relationalStore.ValuesBucket = generateBucket(prefData)
    this.cateTable.insertData(valueBucket, callback)
  }

  deleteData(prefData: TaskCategoryData, callback: Function) {
    let predicates = new relationalStore.RdbPredicates(CommonConstants.CATEGORY_TABLE_INIT.tableName)
    predicates.equalTo('id', prefData.id)
    this.cateTable.deleteData(predicates, callback)
  }

  updateData(prefData: TaskCategoryData, callback: Function) {
    const valueBucket: relationalStore.ValuesBucket = generateBucket(prefData)
    let predicates = new relationalStore.RdbPredicates(CommonConstants.CATEGORY_TABLE_INIT.tableName)
    predicates.equalTo('id', prefData.id)
    this.cateTable.updateData(predicates, valueBucket, callback)
  }

  query(queryID: number, callback: Function){
    let tmp = new TaskCategoryData(); tmp.id = queryID;
    this.basic_query('id', tmp, callback, (queryID == 0))
  }
  private basic_query(query_type: string, queryData: TaskCategoryData, callback: Function, isAll: boolean = true) {
    Logger.debug(`TaskTable query_type: ${query_type}, query_data: ${JSON.stringify(queryData)}, visit: ${queryData[query_type]}`)
    let predicates = new relationalStore.RdbPredicates(CommonConstants.CATEGORY_TABLE_INIT.tableName)
    if (!isAll) predicates.like(query_type, queryData[query_type])
    this.cateTable.query(predicates, (resultSet: relationalStore.ResultSet) => {
      let count: number = resultSet.rowCount
      Logger.debug(`Category Table number: ${count}`)
      if (count === 0 || typeof count === 'string') {
        // empty
        callback([])
      } else {
        resultSet.goToFirstRow()
        // get results
        const result: TaskCategoryData[] = []
        for (let i = 0; i < count; ++i) {
          let tmp: TaskCategoryData = new TaskCategoryData()
          for (let t = 0; t < CommonConstants.CATEGORY_TABLE_INIT.columns.length; ++t) {
            let nowColumn = CommonConstants.CATEGORY_TABLE_INIT.columns[t]
            let nowIndex = resultSet.getColumnIndex(nowColumn)

            switch (nowColumn) {
              case 'id':
                tmp[nowColumn] = resultSet.getDouble(nowIndex)
                break
              case 'name':
                tmp[nowColumn] = resultSet.getString(nowIndex)
                break
              case 'color':
                tmp[nowColumn] = resultSet.getString(nowIndex)
            }

            Logger.debug(`CateTable READING: nowC = ${nowColumn}, data = ${tmp[nowColumn]}`)
          }
          result[i] = tmp
          Logger.debug(`CateTable Reading DATA: ${JSON.stringify(tmp)}`)
          resultSet.goToNextRow()
        }
        callback(result)
      }
    })
  }
}

function generateBucket(data: TaskCategoryData): relationalStore.ValuesBucket {
  let obj: relationalStore.ValuesBucket = {}
  CommonConstants.CATEGORY_TABLE_INIT.columns.forEach((value) => {
    if (value == 'id') return;
    obj[value] = data[value];
  })
  return obj
}

4.2 PreferenceData.ets (偏好数据类)

管理用户的偏好设置。

4.2.1功能简介

PreferenceData 类实现了 PreferenceInterface 接口，用于表示用户偏好设置的数据对象。
通过实现 PreferenceInterface 接口，确保了PreferenceData 类包含了必要的属性，使其符合用户偏好设置的数据结构要求。

4.2.2 代码文件


export interface PreferenceInterface {
  id: number
}
export default class PreferenceData implements PreferenceInterface {
  id: number = 1
}

4.3 TaskCategoryData.ets (任务类别数据类)

定义了任务类别的结构。

4.3.1 功能简介

包含 color、name 和 id 属性，分别表示任务类别的颜色、名称和唯一标识符。
通过实现 TaskCategoryDataInterface 接口，确保了 TaskCategoryData 类包含了必要的属性，使其符合任务类别的数据结构要求。

4.3.2 代码文件

export interface TaskCategoryDataInterface {
  color: string
  name: string
  id: number
}

export default class TaskCategoryData implements TaskCategoryDataInterface {
  color: string = '#000000'
  name: string = '默认清单'
  id: number = 0
}

4.4 TaskListItemData.ets (任务列表项数据类)

定义了任务列表项的结构。

4.4.1 功能简介

TaskListItemData 类实现了 ItemDataInterface 接口，用于表示任务列表项的数据对象。
属性 ddl_state 包含了任务的DDL状态的阈值，根据任务的剩余时间与总时间的比例确定任务状态。
setAll 方法用于根据传入的任务类别列表更新任务项的DDL状态和类别名称。
setCategoryName 方法根据传入的任务类别列表设置任务项的类别名称。
getDDLState 方法根据任务的剩余时间与总时间的比例，以及DDL状态的阈值，确定任务的DDL状态。
getDDLPer 方法计算任务剩余时间与总时间的比例，用于展示任务完成百分比。
通过实现 ItemDataInterface 接口，确保了 TaskListItemData 类包含了必要的属性，使其符合任务列表项的数据结构要求。

4.4.2 代码文件



export interface ItemDataInterface {
  id: number
  detail: string
  task_name: string
  start_date_stamp: number
  due_date_stamp: number
  is_completed: boolean
  ddl_detail: string
  category: number
  topped: boolean
}

@Observed
export class TaskListItemData implements ItemDataInterface {
  id: number = -1
  start_date_stamp: number = 0
  due_date_stamp: number = 0
  detail: string = ''
  subject: number = 0
  task_name: string = ''
  is_completed: boolean = false
  ddl_detail: string = '0.3-0.5-0.8'
  ddl_state = {
    critical: 0.3,
    hard: 0.5,
    medium: 0.8
  }
  category: number = 1
  categoryName: string = ''
  topped: boolean = false

  setAll(categoryList: TaskCategoryData[]) {
    let ddl_arr = this.ddl_detail.split('-')
    Logger.debug(`TaskDDL Info: arr = ${JSON.stringify(ddl_arr)}, det = ${this.ddl_detail}`)
    this.ddl_state.critical = Number(ddl_arr[0])
    this.ddl_state.hard = Number(ddl_arr[1])
    this.ddl_state.medium = Number(ddl_arr[2])
    this.setCategoryName(categoryList)
  }
  setCategoryName(categoryList: TaskCategoryData[]) {
    for (let i = 0; i < categoryList.length; ++i) {
      if (categoryList[i].id == this.category) {
        this.categoryName = categoryList[i].name
        break;
      }
    }
  }
  getDDLState(): string {
    let taskFullTime = this.due_date_stamp - this.start_date_stamp
    let nowTime = new Date()
    let remainingTime = this.due_date_stamp - nowTime.getTime()
    let resultPercentage = remainingTime / taskFullTime
    Logger.debug(`TaskDDL State: full = ${taskFullTime}, remaining = ${remainingTime}, per = ${resultPercentage}`)
    Logger.debug(`TaskDDL ------ due: ${new Date(this.due_date_stamp).toString()}, now: ${new Date().toString()}, start: ${new Date(this.start_date_stamp).toString()}`)
    Logger.debug(`TaskDDL ------: arr = ${JSON.stringify(this.ddl_state)}`)

    if (remainingTime < 0) return 'critical'
    if (resultPercentage < this.ddl_state.critical) return 'critical'
    else if (resultPercentage < this.ddl_state.hard) return 'hard'
    else if (resultPercentage < this.ddl_state.medium) return 'medium'
    else return 'easy'
  }
  getDDLPer(): number {
    let taskFullTime = this.due_date_stamp - this.start_date_stamp
    let nowTime = new Date()
    let remainingTime = this.due_date_stamp - nowTime.getTime()
    if (remainingTime <= 0) return 0
    let resultPercentage = remainingTime / taskFullTime
    return resultPercentage * 100
  }
}

五、创建数据表

通过SQL语句在数据库中创建所需的数据表。

TaskTable.ets

5.1 功能简介

TaskTable 类用于将任务数据转换为数据库中的存储形式，并提供了从数据库中检索任务数据的功能。
通过实例化 TaskDB 类实现对任务数据表的操作，包括插入、删除、更新和查询等。
构造函数初始化了 TaskDB 实例，获取了数据库存储。
updateColumns 方法用于更新任务数据表的列信息。
insertData 方法用于向任务数据表中插入新的任务数据。
deleteData 方法用于从任务数据表中删除指定的任务数据。
updateData 方法用于更新任务数据表中指定任务数据的信息。
queryTaskName 方法用于根据任务名称查询任务数据。
basic_query 方法是一个通用的查询方法，支持根据不同的查询类型和查询数据进行查询，从数据库中检索符合条件的任务数据，并将结果返回给回调函数。
generateBucket 方法用于生成 relationalStore.ValuesBucket 对象，将任务数据转换为数据库存储所需的格式。

5.2 代码文件


export default class TaskTable {
  private taskTable = new TaskDB(CommonConstants.TASK_TABLE_INIT.tableName, CommonConstants.TASK_TABLE_INIT.sqlCreate,
    CommonConstants.TASK_TABLE_INIT.columns)

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

  // test() { this.cateTable.test() }
  getRdbStore(callback: Function = () => {}) {
    this.taskTable.getRdbStore(callback)
  }

  updateColumns(newColumn: string, newColumnType: string) {
    let newColumnData: string = ''
    switch (newColumnType) {
      case 'double':
        newColumnData = 'INTEGER'
        break;
      case 'string':
        newColumnData = 'TEXT'
        break;
      case 'boolean':
        newColumnData = 'BOOLEAN'
      default:
        newColumnData = 'INTEGER'
    }
    Logger.debug(`UpdateColumns: ${newColumn} ${newColumnData}`)
    this.taskTable.updateColumns(newColumn, newColumnData)
  }

  insertData(taskData: TaskListItemData, callback: Function) {
    const valueBucket: relationalStore.ValuesBucket = generateBucket(taskData)
    this.taskTable.insertData(valueBucket, callback)
  }

  deleteData(taskData: TaskListItemData, callback: Function) {
    let predicates = new relationalStore.RdbPredicates(CommonConstants.TASK_TABLE_INIT.tableName)
    predicates.equalTo('id', taskData.id)
    this.taskTable.deleteData(predicates, callback)
  }

  updateData(taskData: TaskListItemData, callback: Function) {
    const valueBucket: relationalStore.ValuesBucket = generateBucket(taskData)
    let predicates = new relationalStore.RdbPredicates(CommonConstants.TASK_TABLE_INIT.tableName)
    predicates.equalTo('id', taskData.id)
    this.taskTable.updateData(predicates, valueBucket, callback)
  }
 
  queryTaskName(task_name: string, callback: Function, isAll: boolean = true) {
    let submit: TaskListItemData = new TaskListItemData(); submit.task_name = task_name
    this.basic_query("task_name", submit, callback, isAll)
    
  }
 
  basic_query(query_type: string, queryData: TaskListItemData, callback: Function, isAll: boolean = true) {
    Logger.debug(`TaskTable query_type: ${query_type}, query_data: ${JSON.stringify(queryData)}, visit: ${queryData[query_type]}`)
    let predicates = new relationalStore.RdbPredicates(CommonConstants.TASK_TABLE_INIT.tableName)
    if (!isAll) {
      if (CommonConstants.COLUMN_TYPE[query_type] == 'string') predicates.like(query_type, queryData[query_type])
      else predicates.equalTo(query_type, queryData[query_type])
    }
    this.taskTable.query(predicates, (resultSet: relationalStore.ResultSet) => {
      let count: number = resultSet.rowCount
      Logger.debug(`TaskTable number: ${count}`)
      if (count === 0 || typeof count === 'string') {
        
        callback([])
      } else {
        resultSet.goToFirstRow()
        
        const result: TaskListItemData[] = []
        for (let i = 0; i < count; ++i) {
          let tmp: TaskListItemData = new TaskListItemData()
          for (let t = 0; t < CommonConstants.TASK_TABLE_INIT.columns.length; ++t) {
            let nowColumn = CommonConstants.TASK_TABLE_INIT.columns[t]
            let nowIndex = resultSet.getColumnIndex(nowColumn)

            switch (CommonConstants.COLUMN_TYPE[nowColumn]) {
              case 'double':
                tmp[nowColumn] = resultSet.getDouble(nowIndex)
                break
              case 'string':
                tmp[nowColumn] = resultSet.getString(nowIndex)
                break
              case 'boolean':
                tmp[nowColumn] = Boolean(resultSet.getDouble(nowIndex))
            }

            Logger.debug(`TaskTable READING: nowC = ${nowColumn}, data = ${tmp[nowColumn]}`)
          }
          result[i] = tmp
          Logger.debug(`TaskTable Reading DATA: ${JSON.stringify(tmp)}`)
          resultSet.goToNextRow()
        }
        callback(result)
      }
    })
  }
}

function generateBucket(taskData: TaskListItemData): relationalStore.ValuesBucket {
  let obj: relationalStore.ValuesBucket = {}
  for (let i = 1; i < CommonConstants.TASK_TABLE_INIT.columns.length; ++i) {
    let nowCol = CommonConstants.TASK_TABLE_INIT.columns[i]
    obj[nowCol] = taskData[nowCol]
  }
  return obj
}

六、数据库初始化

DDLDetailClass.ets
类 DDLDetailClass 提供了一个简单的数据结构，用于存储任务DDL（Deadline）的提示和详细信息。

6.1 功能简介

hint 属性存储了DDL的提示信息，例如“临近DDL”、“已过期”等。
detail 属性存储了DDL的详细信息，例如DDL的具体日期和时间等。
构造函数接受两个参数，分别为 hint 和 detail，并将它们分别赋值给对象的对应属性。

6.2 代码文件

export default class DDLDetailClass {
  hint: string
  detail: string

  constructor(hint: string, detail: string) {
    this.hint = hint
    this.detail = detail
  }
}