野外泛在线考核系统（十）

已于 2023-12-17 20:46:30 修改
阅读量84 收藏 1
点赞数
文章标签： typescript harmonyos
于 2023-12-10 22:23:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43160566/article/details/134915029
版权

野外泛在线考核系统（十）

三、平板端

接着（九）捋一捋这几天遇到的问题。

（一）平板新建数据表

问题： 新建数据表，插入数据而后再显示出来？
这个问题，本来不是问题，因为有成熟的例子关系型数据库（ArkTS），有源代码，但是源代码过于复杂，是通过自定义弹窗输入数据，而后插入到数据表中的，我就模仿着自己弄了个数据表。然后进行插入，查询，更新，删除等操作。

  1. 首先要新建数据库的功能文件Rdb.ets。如下图：
    在这里插入图片描述
    其代码如下：
/*
 * Copyright (c) 2023 Huawei Device Co., Ltd.
 * Licensed under the Apache License,Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import relationalStore from '@ohos.data.relationalStore';
import CommonConstants from '../constants/CommonConstants';
import Logger from '../utils/Logger';
import call from '@ohos.telephony.call';

export default class Rdb {
  private rdbStore:relationalStore.RdbStore|null =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:Function=()=>{}){
    if (!callback || typeof callback === 'undefined' || callback === undefined){
      Logger.info(CommonConstants.RDB_TAG,'getRdbStore() has no callback!');
      return;
    }
    if (this.rdbStore !== null){
      Logger.info(CommonConstants.RDB_TAG,'The rdbStore exists.');
      callback();
      return
    }
    let context:Context = getContext(this) as Context;
    relationalStore.getRdbStore(context,CommonConstants.STORE_CONFIG,(err,rdb)=>{
      if(err){
        Logger.error(CommonConstants.RDB_TAG,`getRdbStore() failed,err:${err}`);
        return;
      }
      this.rdbStore = rdb;
      this.rdbStore.executeSql(this.sqlCreateTable);
      Logger.info(CommonConstants.RDB_TAG,'getRdbStore() finished.');
      callback();
    });
  }

  insertData(data: relationalStore.ValuesBucket, callback: Function = () => {
  }) {
    if (!callback || typeof callback === 'undefined' || callback === undefined) {
      Logger.info(CommonConstants.RDB_TAG, 'insertData() has no callback!');
      return;
    }
    let resFlag: boolean = false;
    const valueBucket: relationalStore.ValuesBucket = data;
   // Logger.info(CommonConstants.RDB_TAG, `insertData() insert--start: ${data[0]}`);
    if (this.rdbStore) {
      this.rdbStore.insert(this.tableName, valueBucket, (err, ret) => {
        if (err) {
          Logger.error(CommonConstants.RDB_TAG, `insertData() failed, err: ${err}`);
          callback(resFlag);
          return;
        }
        Logger.info(CommonConstants.RDB_TAG, `insertData() finished: ${ret}`);
        callback(ret);
      });
    }
  }

  deleteData(predicates: relationalStore.RdbPredicates, callback: Function = () => {
  }) {
    if (!callback || typeof callback === 'undefined' || callback === undefined) {
      Logger.info(CommonConstants.RDB_TAG, 'deleteData() has no callback!');
      return;
    }
    let resFlag: boolean = false;
    if (this.rdbStore) {
      this.rdbStore.delete(predicates, (err, ret) => {
        if (err) {
          Logger.error(CommonConstants.RDB_TAG, `deleteData() failed, err: ${err}`);
          callback(resFlag);
          return;
        }
        Logger.info(CommonConstants.RDB_TAG, `deleteData() finished: ${ret}`);
        callback(!resFlag);
      });
    }
  }

  updateData(predicates: relationalStore.RdbPredicates, data: relationalStore.ValuesBucket, callback: Function = () => {
  }) {
    if (!callback || typeof callback === 'undefined' || callback === undefined) {
      Logger.info(CommonConstants.RDB_TAG, 'updateDate() has no callback!');
      return;
    }
    let resFlag: boolean = false;
    const valueBucket: relationalStore.ValuesBucket = data;
    if (this.rdbStore) {
      this.rdbStore.update(valueBucket, predicates, (err, ret) => {
        if (err) {
          Logger.error(CommonConstants.RDB_TAG, `updateData() failed, err: ${err}`);
          callback(resFlag);
          return;
        }
        Logger.info(CommonConstants.RDB_TAG, `updateData() finished: ${ret}`);
        callback(!resFlag);
      });
    }
  }

  query(predicates: relationalStore.RdbPredicates, callback: Function = () => {
  }) {
    if (!callback || typeof callback === 'undefined' || callback === undefined) {
      Logger.info(CommonConstants.RDB_TAG, 'query() has no callback!');
      return;
    }
    if (this.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();
      });
    }
  }
}
  1. 接着先创建接口文件ConstantsInterface.ets，构建接口：CreateTable 用于创建数据表，如下图：
    在这里插入图片描述
export interface CreateTable{
  tableName:string;
  sqlCreate:string;
  columns:string[];
}
  1. 接着创建表，在此之前，先要新建一个文件ScoreData.ets，并在其中构建一个类ContentScoreData，如下图：
    在这里插入图片描述

该类和即将创建的数据表对应，字段和字段类型必须一致。

export class ContentScoreData{
  id:number = -1;
  content:string = '';
  item:string = '';
  team:string = '';
  teacher:string = '';
  contentScore:number = 78;
  contentDate:string = '2023-12-10';
}
  1. 接着要在CommonConstants.ets文件中，利用CreateTable 接口创建表的语句。如下图：
    在这里插入图片描述
    **注意：**sqlCreate 的结尾一定是 ) ，我就是因为少了这个 ) ，运行不会错，但是数据死活插入不进表，找了一天终于找到这个错误。
import relationalStore from '@ohos.data.relationalStore';
import {CreateTable} from '../../viewmodel/ConstantsInterface';

export class CommonConstants{
  static readonly STORE_CONFIG:relationalStore.StoreConfig ={
    name:"database.db",
    securityLevel:relationalStore.SecurityLevel.S1
  };
  /*
  数据表设置
   */
  //ContentScore 表
  static readonly CONTENTSCORE_TABLE:CreateTable = {
    tableName:'contentScoreTable',
    sqlCreate:'CREATE TABLE IF NOT EXISTS contentScoreTable(id INTEGER PRIMARY KEY,content TEXT,'+
              'item TEXT, team TEXT, teacher TEXT, '+'contentScore INTEGER,'+'contentDate TEXT)',
    columns:['id','content','item','team','teacher','contentScore','contentDate']

  };
  1. 接着创建表文件ContentScoreTable.ets，用于对表进行操作。
    在这里插入图片描述
import relationalStore from '@ohos.data.relationalStore';
import { ContentScoreData } from '../../bean/ScoreData';
import {CommonConstants} from '../../constants/CommonConstants';
import Rdb from '../Rdb';

export default class ContentScoreTable{
  private ContentScoreTable = new Rdb(CommonConstants.CONTENTSCORE_TABLE.tableName,CommonConstants.CONTENTSCORE_TABLE.sqlCreate,
    CommonConstants.CONTENTSCORE_TABLE.columns);

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

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

  insertData(score:ContentScoreData,callback:Function){
    const valueBucket: relationalStore.ValuesBucket = generateBucket(score);
    this.ContentScoreTable.insertData(valueBucket,callback);
  }

  deleteData(score:ContentScoreData,callback:Function){
    let predicates = new relationalStore.RdbPredicates(CommonConstants.CONTENTSCORE_TABLE.tableName);
    predicates.equalTo('id',score.id);
    this.ContentScoreTable.deleteData(predicates,callback);
  }

  updateData(score:ContentScoreData,callback:Function){
    const valueBucket:relationalStore.ValuesBucket = generateBucket(score);
    let predicates = new relationalStore.RdbPredicates(CommonConstants.CONTENTSCORE_TABLE.tableName);
    predicates.equalTo('id',score.id);
    this.ContentScoreTable.updateData(predicates,valueBucket,callback);
  }
 query(teacher:string,callback:Function,isALL:boolean =true){
 // query(id:number,teacher:string,callback:Function,isALL:boolean =true){
    let predicates = new relationalStore.RdbPredicates(CommonConstants.CONTENTSCORE_TABLE.tableName);
    if(!isALL){
      predicates.equalTo('teacher',teacher);
      //predicates.equalTo('id',id).equalTo('teacher',teacher);
    }
    this.ContentScoreTable.query(predicates,(resultSet:relationalStore.ResultSet)=>{
      let count:number = resultSet.rowCount;
      console.log(`${CommonConstants.CONTENTSCORE_TABLE}`+'Query get results --'+count.toString());
      if(count === 0 || typeof count === 'string'){
        console.log(`${CommonConstants.CONTENTSCORE_TABLE}`+'Query no results!');
        callback([]);
      }else{
        resultSet.goToFirstRow();
        const result:ContentScoreData[] = [];
        console.log(`${CommonConstants.CONTENTSCORE_TABLE}`+'Query get results --start!');
        for (let i=0;i<count;i++){
          let tmp:ContentScoreData = {
          //  id:0, content:'', item:'', team:'', teacher:'', contentScore:0, contentDate:null
            id:0, content:'', item:'', team:'', teacher:'', contentScore:85, contentDate:'2023-12-01'
          };
        //  let today = new Date();
          tmp.id = resultSet.getDouble(resultSet.getColumnIndex('id'));
          tmp.content = resultSet.getString(resultSet.getColumnIndex('content'));
          tmp.item = resultSet.getString(resultSet.getColumnIndex('item'));
          tmp.team = resultSet.getString(resultSet.getColumnIndex('team'));
          tmp.teacher = resultSet.getString(resultSet.getColumnIndex('teacher'));
          tmp.contentScore = resultSet.getDouble(resultSet.getColumnIndex('contentScore'));
          tmp.contentDate = resultSet.getString(resultSet.getColumnIndex('contentDate'));

          result[i] = tmp;
          console.log(`${CommonConstants.CONTENTSCORE_TABLE}`+'Query get results --end!');
          resultSet.goToNextRow();
        }
        callback(result);
      }
    });
  }

}

function generateBucket(score:ContentScoreData):relationalStore.ValuesBucket{
  let obj:relationalStore.ValuesBucket={};
  obj.content = score.content;
  obj.item = score.item;
  obj.team = score.team;
  obj.teacher = score.teacher;
  obj.contentScore = score.contentScore;
  obj.contentDate = score.contentDate;
  return obj;
}
  1. 至此，算是完成了表的创建，具体要插入数据和显示数据看执行如下操作：
import promptAction from '@ohos.promptAction';
import {CommonConstants} from '../common/constants/CommonConstants';
import {ContentScoreData } from '../common/bean/ScoreData';
import ContentScoreTable from '../common/database/tables/ContentScoreTable';
import DataViewModel from '../viewmodel/DataViewModel';
import Logger from '../common/utils/Logger';

@Component
export default struct ManageData {
  @State message: string = '插入数据的试验'
  @State scores:Array<ContentScoreData>=[];

  @State index: number = -1;
  @State newScore1: ContentScoreData =  {id:0, content:'', item:'', team:'', teacher:'', contentScore:0 , contentDate:'2023-01-01'};
 
  private ContentScoreTable = new ContentScoreTable(()=>{});
  private deleteList: Array<ContentScoreData> = [];
  //从服务器获取数据相关设置
  @State path:string = 'search_itemScore'
  @State teacherID:string = 'qp001'
  @State contentScores:Array<ContentScoreData> = []

  changeCategory() {
    DataViewModel.getDataList(this.path, this.teacherID).then((data: ContentScoreData[]) => {
      this.contentScores = data;
    }).catch((err: string | Resource) => {
      promptAction.showToast({
        message: err,
        duration: CommonConstants.ANIMATION_DURATION
      });
    });
  }

  insertDataToTable0():void{
    this.newScore1.id = 1;
    this.newScore1.content = '准备';
    this.newScore1.item = '坦克大战'
    this.newScore1.team = '坦克大战1组';
    this.newScore1.teacher = '王老师';
    this.newScore1.contentScore = 98;
  //  this.newScore1.contentDate = '2023-12-16';
    this.ContentScoreTable.insertData(this.newScore1, (id: number) => {
    });
  }

  insertDataToTable1():void{
    this.newScore1.id = 2;
    this.newScore1.content = '准备';
    this.newScore1.item = '坦克大战'
    this.newScore1.team = '坦克大战1组';
    this.newScore1.teacher = '张老师';
    this.newScore1.contentScore = 98;
    this.newScore1.contentDate = new Date().toLocaleDateString();
    this.ContentScoreTable.insertData(this.newScore1, (id: number) => {
    });
  }

  insertDataToTable2():void{
    this.newScore1.id = 3;
    this.newScore1.content = '进攻';
    this.newScore1.item = '坦克大战'
    this.newScore1.team = '坦克大战1组';
    this.newScore1.teacher = '张老师';
    this.newScore1.contentScore = 98;
    this.newScore1.contentDate = new Date().toLocaleDateString()
    this.ContentScoreTable.insertData(this.newScore1, (id: number) => {
    });
  }

  insertDataToTable3():void{
    this.newScore1.id = 4;
    this.newScore1.content = '撤离';
    this.newScore1.item = '坦克大战'
    this.newScore1.team = '坦克大战1组';
    this.newScore1.teacher = '张老师';
    this.newScore1.contentScore = 98;
    this.newScore1.contentDate = new Date().toDateString();
    this.ContentScoreTable.insertData(this.newScore1, (id: number) => {
    });
  }

  showData():void{
    this.ContentScoreTable.getRdbStore(() => {
      this.ContentScoreTable.query('0', (result: ContentScoreData[]) => {
        this.scores = result;
      }, true);
    });
  }



  selectListItem(item: ContentScoreData) {
    //this.isInsert = false;
    this.index = this.scores.indexOf(item);
    this.newScore1 = {
      id: item.id,
      content:item.content,
      item:item.item,
      team:item.team,
      teacher:item.teacher,
      contentScore:item.contentScore,
      contentDate:item.contentDate
    };
  }

  deleteListItem() {
    for (let i = 0; i < this.deleteList.length; i++) {
      let index = this.scores.indexOf(this.deleteList[i]);
      this.scores.splice(index, 1);
      this.ContentScoreTable.deleteData(this.deleteList[i], () => {
      });
    }
    this.deleteList = [];
   
  }

  aboutToAppear() {

    this.ContentScoreTable.getRdbStore(() => {
      this.ContentScoreTable.query('0', (result: ContentScoreData[]) => {
        this.scores = result;
      }, true);
    });
  }



  build() {
    Stack(){
      Column() {
        Text(this.message)
          .fontSize(50)
          .fontWeight(FontWeight.Bold)
        Row(){
          Button('插入王数据')
            .fontSize(30)
            .fontWeight(FontWeight.Bold)
            .onClick(() => {
              this.insertDataToTable0()
            })
          Button('插入数据1')
            .fontSize(30)
            .fontWeight(FontWeight.Bold)
            .onClick(() => {
              this.insertDataToTable1()
            })
          Button('插入数据2')
            .fontSize(30)
            .fontWeight(FontWeight.Bold)
            .onClick(() => {
              this.insertDataToTable2()
            })
        }
        Button('插入数据3')
          .fontSize(30)
          .fontWeight(FontWeight.Bold)
          .onClick(() => {
            this.insertDataToTable3()
          })
        Button('显示数据')
          .fontSize(30)
          .fontWeight(FontWeight.Bold)
          .onClick(() => {
            this.showData()
          })


        Text('----------------------------------------------')
        Row(){
          List({space:CommonConstants.FULL_SIZE}){
            ForEach(this.scores,(item:ContentScoreData)=>{
              ListItem(){
                Row(){
                  Text(item.id.toString())
                    .fontSize(20)
                    .fontWeight(FontWeight.Bold)
                    .width('5%')
                  Text(item.content)
                    .fontSize(20)
                    .fontWeight(FontWeight.Bold)
                    .width('10%')
                  Text(item.item)
                    .fontSize(20)
                    .fontWeight(FontWeight.Bold)
                    .width('15%')
                  Text(item.team)
                    .fontSize(20)
                    .fontWeight(FontWeight.Bold)
                    .width('20%')
                  Text(item.teacher)
                    .fontSize(20)
                    .fontWeight(FontWeight.Bold)
                    .width('10%')
                  Text(item.contentScore.toString())
                    .fontSize(20)
                    .fontWeight(FontWeight.Bold)
                    .width('5%')
                  Text(item.contentDate)
                    .fontSize(20)
                    .fontWeight(FontWeight.Bold)
                    .width('35%')
                  Toggle({ type: ToggleType.Checkbox })
                    .onChange((isOn) => {
                      if (isOn) {
                        this.deleteList.push(item);
                      } else {
                        let index = this.deleteList.indexOf(item);
                        this.deleteList.splice(index, 1);
                      }
                    })                 

                }.border({ width: 1 }).width('80%').alignItems(VerticalAlign.Bottom)
              }
              .onClick(() => {
                this.selectListItem(item);               
              })
            })
          }
        }.border({ width: 2 }).width('60%')
        .alignItems(VerticalAlign.Bottom)
        Text('----------------------------------------------')


      }
      .width('100%')
      .alignItems(HorizontalAlign.Center)
      Button() {
        Image($rawfile('delete.png'))
      }
      .width($r('app.float.component_size_MP'))
      .height($r('app.float.component_size_MP'))
      .backgroundColor($r('app.color.background_color'))
      .markAnchor({ x: $r('app.float.mark_anchor'), y: CommonConstants.MINIMUM_SIZE })
      .position({ x: CommonConstants.DELETE_POSITION_X, y: CommonConstants.DELETE_POSITION_Y })
      .onClick(() => {
        this.deleteListItem();
      })
    }
  }
}

至此，基本搞懂关系数据库创建表，插入数据显示数据了，下一步研究显示单条数据。

彩云之南雪域之巅
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
野外智能导航系统.pdf
09-12
"野外智能导航系统" 本文总体描述了野外智能导航系统的设计和实现，该系统能够实时监测使用者的身体状况、环境温度和位置信息，并提供精准的导航和路线记忆功能。此外，该系统还具有组队功能，能够实现位置共享和...
鸿蒙-关系型数据库(@ohos.data.relationalStore)
zhujian82637的博客
07-02 3715
update函数需要传入两个参数，第一个是需要更新的列值，是一个对象，key为列名，value是对应的值，第二个参数是一个条件对象，上面代码表示更新userInfo表中name='lisi'的age更新为66。batchInsert函数第一个参数是表名称，第二个参数是一个ValuesBucket数组对象，ValuesBucket表示key-value的对象，key表示表的列名称，value是对应的值。2、RdbPredicates 用来定义数据库的操作条件，可用于查询，修改，删除的条件语句。
基于OpenHarmony开发的健康生活应用（ArkTS）
2301_76484015的博客
05-04 1634
用户点击悬浮按钮进入任务列表页，点击任务列表可进入对应任务编辑的页面中，对任务进行详细的设置，之后点击完成按钮编辑任务后将返回首页。成就页面展示用户可以获取的所有勋章，当用户满足一定的条件时，将点亮本页面对应的勋章，没有得到的成就勋章处于熄灭状态。共有六种勋章，当用户连续完成任务打卡3天、7天、30天、50天、73天、99天时，可以获得对应的 "连续xx天达成" 勋章。根据健康生活APP的使用场景和业务逻辑，定义了三个数据对象，并使用三张数据表来存储，分别是健康任务信息表、每日信息表和全局信息表。
HarmonyOS实战开发-如何在鸿蒙开发中使用数据库
m0_70749039的博客
04-26 2108
鸿蒙中的数据库基于SQLite组件，用来处理关系比较复杂的数据，本文将以WORKER表为例，为大家演示在鸿蒙开发中对数据库的增删改查操作。
HarmonyOS开发(九)：数据管理
advent86的专栏
12-03 1358
应用数据持久化，是指应用将内存中的数据通过文件或数据库的形式保存到设备上。内存中的数据形态通常是任意的数据结构或数据对象，存储介质上的数据形态可能是文本、数据库、二进制文件等。HarmonyOS标准系统支持典型的存储数据形态有：用户首选项、键值型数据库、关系型数据库键值型数据库存储键值对形式的数据，一般用来存储的数据没有复杂的关系模型。
OpenHarmony关系型数据库[1]
zl392321162的博客
03-24 587
关系型数据库(Relational Database, 以下简称RDB)是一种基于关系模型来管理数据的数据库，是在SQLite基础上提供一套完整的对本地数据库进行管理的机制，为开发者提供无需编写原生SQL语句即可实现数据增、删、改、查等接口，同时开发者也可以直接运行原生SQL语句来满足复杂的场景需要。关系型数据库在应用卸载之后，才会被自动清除。
基于鸿蒙应用开发：任务列表
qq_55764099的博客
12-29 722
任务列表应用，基于OpenHarmony 4.0开发，主要功能：任务列表增删改查，任务进度显示，后台通知提醒ListItem组件实现复选框勾选完成，展开详细信息功能获取父组件传入的进度，在环形进度条实时显示在 CustomDialog 中获取当前数组，并通过 RdbUtil 在数据库内插入、修改数据，实现数据持久化。同时调起 TaskReminderService 实现后台代理提醒。
基于单片机的野外信息检测记录系统的设计
03-19
从而使得整个 系统实现了基于单片机的野外信息检测记录系统的设计。 由于 GPRS 具有传输速率高、 接入时间短、 提供实时在线功能、 按流量多少来计费等性能特点。 综合 PIC 单片机的功能特性以及采集模块的低功耗性...
基于World Wind移动端的地质数据野外采集系统
05-06
针对传统的野外地质数据采集与数字化工作步骤繁琐、效率低、工作周期长等问题，研发了一种基于World Wind移动端的地质数据野外采集系统，系统集成了World Wind地图技术、网络通信技术、多线程技术和数据存储技术....
野外测试仪可充电电池管理系统硬件设计-论文
05-10
野外测试仪可充电电池管理系统硬件设计
高精度野外烟雾检测识别系统实现
06-19
基于深度学习的野外烟雾检测识别系统可用于日常生活中检测与定位野外烟雾目标，利用深度学习算法可实现图片、视频、摄像头等方式的目标检测识别，另外支持结果可视化与图片或视频检测结果的导出。本系统采用YOLOv5...
【Harmony OS - 应用数据持久化】
weixin_44273311的博客
12-28 1176
鸿蒙系统支持数据持久化的三种方式的基本流程和使用：用户首选项、键值型数据库、关系型数据库
HarmonyOS 数据管理与应用数据持久化（二）
HarmonyOSDev的博客
11-03 1088
关系型数据库基于 SQLite 组件，适用于存储包含复杂关系数据的场景，比如一个班级的学生信息，需要包括姓名、学号、各科成绩等，又或者公司的雇员信息，需要包括姓名、工号、职位等，由于数据之间有较强的对应关系，复杂程度比键值型数据更高，此时需要使用关系型数据库来持久化保存数据。
openharmony开发最新4.0版本---数据库连接（二）(基于api10,devstudio4.0) 中relationalStore的使用
m0_55673121的博客
01-04 1335
rdb的使用
Harmony鸿蒙应用开发——关系型数据库（RelationalStore）
Creat_List的博客
01-10 3415
基本概念 关系型数据库基于SQLite组件，适用于存储包含复杂关系数据的场景，比如一个班级的学生信息，需要包括姓名、学号、各科成绩等，又或者公司的雇员信息，需要包括姓名、工号、职位等，由于数据之间有较强的对应关系，复杂程度比键值型数据更高，此时需要使用关系型数据库来持久化保存数据。 接口说明 以下是关系型数据库持久化功能的相关接口，大部分为异步接口。异步接口均有callback和Promise两种返回形式，下表均以callback形式为例，更多接口及使用方式请见关系型数据库。 接口名称
玩转HarmonyOS NEXT之组件导航与路由跳转一
最新发布
断线的风筝
07-10 526
Navigation通过事件提供自定义转场动画的能力，通过如下三步可以定义一个自定义的转场动画。构建一个自定义转场动画工具类，通过一个Map管理各个页面自定义动画对象CustomTransition，页面在创建的时候将自己的自定义转场动画对象注册进去，销毁的时候解注册。实现一个转场协议对象。
鸿蒙NEXT
2301_81771576的博客
06-29 1891
据了解，除了已经公开亮相华为开发者大会的腾讯视频、腾讯新闻、QQ 浏览器、搜狗输入法、腾讯自选股、QQ音乐、酷狗音乐、酷我音乐、全民K歌、懒人听书、起点读书外，腾讯旗下多款产品已在进行鸿蒙系统的开发适配工作，希望尽快保障用户平滑、安全、稳定地过渡到新系统。其次就是，鸿蒙NEXT针对一些基础、高频、创新的场景， 通过 API、控件等方式向第三方应用开放如实时朗读、智能荐图、自动填写、图文翻译、OCR 服务识别推荐、主体抠图、人脸检测、卡证识别等能力，和开发者共同打造生态级的鸿蒙原生智能。
分布式磁带资源管理系统的研究与实现.pdf
06-21
在野外地震勘探领域，磁带作为一种关键的存储和传输媒介，扮演着至关重要的角色。随着石油天然气勘探工作的深入，对于磁带资源的有效管理和高效利用变得尤为重要。本文主要研究和实现了分布式磁带资源管理系统，旨在...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值