1# @ohos.data.rdb (关系型数据库) 2 3关系型数据库（Relational Database，RDB）是一种基于关系模型来管理数据的数据库。关系型数据库基于SQLite组件提供了一套完整的对本地数据库进行管理的机制，对外提供了一系列的增、删、改、查等接口，也可以直接运行用户输入的SQL语句来满足复杂的场景需要。不支持Worker线程。 4 5该模块提供以下关系型数据库相关的常用功能： 6 7- [RdbPredicates](#rdbpredicates)： 数据库中用来代表数据实体的性质、特征或者数据实体之间关系的词项，主要用来定义数据库的操作条件。 8- [RdbStore](#rdbstore)：提供管理关系数据库(RDB)方法的接口。 9 10> **说明：** 11> 12> 本模块首批接口从API version 7开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。 13> 14> 从API Version 9开始，该接口不再维护，推荐使用新接口[@ohos.data.relationalStore](js-apis-data-relationalStore.md)。 15 16 17## 导入模块 18 19```ts 20import data_rdb from '@ohos.data.rdb'; 21``` 22## data_rdb.getRdbStore 23 24getRdbStore(context: Context, config: StoreConfig, version: number, callback: AsyncCallback<RdbStore>): void 25 26获得一个相关的RdbStore，操作关系型数据库，用户可以根据自己的需求配置RdbStore的参数，然后通过RdbStore调用相关接口可以执行相关的数据操作，使用callback异步回调。 27 28**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 29 30**参数：** 31 32| 参数名 | 类型 | 必填 | 说明 | 33| -------- | ------------------------------------------ | ---- | ------------------------------------------------------------ | 34| context | Context | 是 | 应用的上下文。 <br>FA模型的应用Context定义见[Context](js-apis-inner-app-context.md)。<br>Stage模型的应用Context定义见[Context](js-apis-inner-app-context.md)。 | 35| config | [StoreConfig](#storeconfig) | 是 | 与此RDB存储相关的数据库配置。 | 36| version | number | 是 | 数据库版本。<br>目前暂不支持通过version自动识别数据库升级降级操作，只能由开发者自行维护。 | 37| callback | AsyncCallback<[RdbStore](#rdbstore)> | 是 | 指定callback回调函数，返回RdbStore对象。 | 38 39**示例：** 40 41FA模型示例： 42 43```js 44import featureAbility from '@ohos.ability.featureAbility'; 45import relationalStore from '@ohos.data.relationalStore'; 46import window from '@ohos.window'; 47import { BusinessError } from '@ohos.base'; 48 49data_rdb.getRdbStore(this.context, "RdbTest.db", 1, (err, rdbStore) => { 50 if (err) { 51 console.info("Get RdbStore failed, err: " + err) 52 return 53 } 54 console.log("Get RdbStore successfully.") 55}) 56``` 57 58Stage模型示例： 59 60```ts 61import UIAbility from '@ohos.app.ability.UIAbility'; 62import { BusinessError } from "@ohos.base"; 63import window from '@ohos.window'; 64 65class EntryAbility extends UIAbility { 66 onWindowStageCreate(windowStage: window.WindowStage){ 67 data_rdb.getRdbStore(this.context, "RdbTest.db", 1, (err: BusinessError, rdbStore: data_rdb.RdbStore) => { 68 if (err) { 69 console.info("Get RdbStore failed, err: " + err) 70 return 71 } 72 console.log("Get RdbStore successfully.") 73 }) 74 } 75} 76``` 77 78## data_rdb.getRdbStore 79 80getRdbStore(context: Context, config: StoreConfig, version: number): Promise<RdbStore> 81 82获得一个相关的RdbStore，操作关系型数据库，用户可以根据自己的需求配置RdbStore的参数，然后通过RdbStore调用相关接口可以执行相关的数据操作，使用Promise异步回调。 83 84**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 85 86**参数：** 87 88| 参数名 | 类型 | 必填 | 说明 | 89| ------- | --------------------------- | ---- | ------------------------------------------------------------ | 90| context | Context | 是 | 应用的上下文。 <br>FA模型的应用Context定义见[Context](js-apis-inner-app-context.md)。<br>Stage模型的应用Context定义见[Context](js-apis-inner-app-context.md)。 | 91| config | [StoreConfig](#storeconfig) | 是 | 与此RDB存储相关的数据库配置。 | 92| version | number | 是 | 数据库版本。<br>目前暂不支持通过version自动识别数据库升级降级操作，只能由开发者自行维护。 | 93 94**返回值**： 95 96| 类型 | 说明 | 97| ------------------------------------ | ------------------------------- | 98| Promise<[RdbStore](#rdbstore)> | Promise对象。返回RdbStore对象。 | 99 100**示例：** 101 102FA模型示例： 103 104```js 105import featureAbility from '@ohos.ability.featureAbility'; 106 107let promise = data_rdb.getRdbStore(this.context, "RdbTest.db", 1); 108promise.then(async (rdbStore) => { 109 console.log("Get RdbStore successfully.") 110}).catch((err: BusinessError) => { 111 console.log("Get RdbStore failed, err: " + err) 112}) 113``` 114 115Stage模型示例： 116 117```ts 118import UIAbility from '@ohos.app.ability.UIAbility'; 119import { BusinessError } from "@ohos.base"; 120import window from '@ohos.window'; 121 122class EntryAbility extends UIAbility { 123 onWindowStageCreate(windowStage: window.WindowStage){ 124 context = this.context 125 } 126} 127 128// 获取context后调用getRdbStore 129let promise = data_rdb.getRdbStore(this.context, "RdbTest.db", 1); 130promise.then(async (rdbStore: data_rdb.RdbStore) => { 131 console.log("Get RdbStore successfully.") 132}).catch((err: BusinessError) => { 133 console.log("Get RdbStore failed, err: " + err) 134}) 135``` 136 137## data_rdb.deleteRdbStore 138 139deleteRdbStore(context: Context, name: string, callback: AsyncCallback<void>): void 140 141删除数据库，使用callback异步回调。 142 143**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 144 145**参数：** 146 147| 参数名 | 类型 | 必填 | 说明 | 148| -------- | ------------------------- | ---- | ------------------------------------------------------------ | 149| context | Context | 是 | 应用的上下文。 <br>FA模型的应用Context定义见[Context](js-apis-inner-app-context.md)。<br>Stage模型的应用Context定义见[Context](js-apis-inner-app-context.md)。 | 150| name | string | 是 | 数据库名称。 | 151| callback | AsyncCallback<void> | 是 | 指定callback回调函数。 | 152 153**示例：** 154 155FA模型示例： 156 157```js 158import featureAbility from '@ohos.ability.featureAbility'; 159 160data_rdb.deleteRdbStore(this.context, "RdbTest.db", (err) => { 161 if (err) { 162 console.info("Delete RdbStore failed, err: " + err) 163 return 164 } 165 console.log("Delete RdbStore successfully.") 166}) 167``` 168 169Stage模型示例： 170 171```ts 172import UIAbility from '@ohos.app.ability.UIAbility'; 173import window from '@ohos.window'; 174 175class EntryAbility extends UIAbility { 176 onWindowStageCreate(windowStage: window.WindowStage){ 177 context = this.context 178 } 179} 180 181// 获取context后调用deleteRdbStore 182data_rdb.deleteRdbStore(this.context, "RdbTest.db", (err) => { 183 if (err) { 184 console.info("Delete RdbStore failed, err: " + err) 185 return 186 } 187 console.log("Delete RdbStore successfully.") 188}) 189``` 190 191## data_rdb.deleteRdbStore 192 193deleteRdbStore(context: Context, name: string): Promise<void> 194 195使用指定的数据库文件配置删除数据库，使用Promise异步回调。 196 197**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 198 199**参数** 200 201| 参数名 | 类型 | 必填 | 说明 | 202| ------- | ------- | ---- | ------------------------------------------------------------ | 203| context | Context | 是 | 应用的上下文。 <br>FA模型的应用Context定义见[Context](js-apis-inner-app-context.md)。<br>Stage模型的应用Context定义见[Context](js-apis-inner-app-context.md)。 | 204| name | string | 是 | 数据库名称。 | 205 206**返回值**： 207 208| 类型 | 说明 | 209| ------------------- | ------------------------- | 210| Promise<void> | 无返回结果的Promise对象。 | 211 212**示例：** 213 214FA模型示例： 215 216```js 217import featureAbility from '@ohos.ability.featureAbility'; 218 219let promise = data_rdb.deleteRdbStore(this.context, "RdbTest.db") 220promise.then(() => { 221 console.log("Delete RdbStore successfully.") 222}).catch((err: BusinessError) => { 223 console.info("Delete RdbStore failed, err: " + err) 224}) 225``` 226 227Stage模型示例： 228 229```ts 230import UIAbility from '@ohos.app.ability.UIAbility'; 231import { BusinessError } from "@ohos.base"; 232import window from '@ohos.window'; 233 234class EntryAbility extends UIAbility { 235 onWindowStageCreate(windowStage: window.WindowStage){ 236 context = this.context 237 } 238} 239 240// 获取context后调用deleteRdbStore 241let promise = data_rdb.deleteRdbStore(this.context, "RdbTest.db") 242promise.then(()=>{ 243 console.log("Delete RdbStore successfully.") 244}).catch((err: BusinessError) => { 245 console.info("Delete RdbStore failed, err: " + err) 246}) 247``` 248 249## ValueType 250 251用于表示允许的数据字段类型。 252 253**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 254 255| 类型 | 说明 | 256| ------- | -------------------- | 257| number | 表示值类型为数字。 | 258| string | 表示值类型为字符。 | 259| boolean | 表示值类型为布尔值。 | 260 261 262## ValuesBucket 263 264用于存储键值对的类型。 265 266**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 267 268| 键类型 | 值类型 | 269| ------ | ----------------------------------------------------------- | 270| string | [ValueType](#valuetype)\| Uint8Array \| null | 271 272## SyncMode<sup>8+</sup> 273 274指数据库同步模式。 275 276**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 277 278| 名称 | 值 | 说明 | 279| -------------- | ---- | ---------------------------------- | 280| SYNC_MODE_PUSH | 0 | 表示数据从本地设备推送到远程设备。 | 281| SYNC_MODE_PULL | 1 | 表示数据从远程设备拉至本地设备。 | 282 283## SubscribeType<sup>8+</sup> 284 285描述订阅类型。 286 287**需要权限：** ohos.permission.DISTRIBUTED_DATASYNC 288 289**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 290 291| 名称 | 值 | 说明 | 292| --------------------- | ---- | ------------------ | 293| SUBSCRIBE_TYPE_REMOTE | 0 | 订阅远程数据更改。 | 294 295## StoreConfig 296 297管理关系数据库配置。 298 299**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 300 301| 名称 | 类型 | 必填 | 说明 | 302| -------- | -------- | -------- | -------- | 303| name | string | 是 | 数据库文件名。 | 304 305## RdbPredicates 306 307表示关系型数据库（RDB）的谓词。该类确定RDB中条件表达式的值是true还是false。 308 309### constructor 310 311constructor(name: string) 312 313构造函数。 314 315**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 316 317**参数：** 318 319| 参数名 | 类型 | 必填 | 说明 | 320| -------- | -------- | -------- | -------- | 321| name | string | 是 | 数据库表名。 | 322 323**示例：** 324 325```ts 326let predicates = new data_rdb.RdbPredicates("EMPLOYEE") 327``` 328 329### inDevices<sup>8+</sup> 330 331inDevices(devices: Array<string>): RdbPredicates 332 333同步分布式数据库时连接到组网内指定的远程设备。 334 335> **说明：** 336> 337> 其中devices通过调用[deviceManager.getTrustedDeviceListSync](js-apis-device-manager.md#gettrusteddevicelistsync)方法得到。deviceManager模块的接口均为系统接口，仅系统应用可用。 338 339**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 340 341**参数：** 342 343| 参数名 | 类型 | 必填 | 说明 | 344| -------- | -------- | -------- | -------- | 345| devices | Array<string> | 是 | 指定的组网内的远程设备ID。 | 346 347**返回值**： 348 349| 类型 | 说明 | 350| -------- | -------- | 351| [RdbPredicates](#rdbpredicates) | 返回与指定字段匹配的谓词。 | 352 353**示例：** 354 355```ts 356import deviceManager from '@ohos.distributedHardware.deviceManager'; 357 358let dmInstance: deviceManager.DeviceManager; 359let deviceIds: Array<string> = []; 360let devices: Array<string> = []; 361 362deviceManager.createDeviceManager("com.example.appdatamgrverify", (err: BusinessError, manager: void) => { 363 if (err) { 364 console.log("create device manager failed, err=" + err); 365 return; 366 } 367 dmInstance = manager; 368 devices = dmInstance.getTrustedDeviceListSync(); 369 for (let i = 0; i < devices.length; i++) { 370 deviceIds[i] = devices[i].deviceId; 371 } 372}) 373 374let predicates = new data_rdb.RdbPredicates("EMPLOYEE"); 375predicates.inDevices(deviceIds); 376 377let predicates = new data_rdb.RdbPredicates("EMPLOYEE"); 378predicates.inDevices(deviceIds); 379``` 380 381### inAllDevices<sup>8+</sup> 382 383inAllDevices(): RdbPredicates 384 385同步分布式数据库时连接到组网内所有的远程设备。 386 387**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 388 389**返回值**： 390 391| 类型 | 说明 | 392| -------- | -------- | 393| [RdbPredicates](#rdbpredicates) | 返回与指定字段匹配的谓词。 | 394 395**示例：** 396 397```ts 398let predicates = new data_rdb.RdbPredicates("EMPLOYEE") 399predicates.inAllDevices() 400``` 401 402### equalTo 403 404equalTo(field: string, value: ValueType): RdbPredicates 405 406配置谓词以匹配数据字段为ValueType且值等于指定值的字段。 407 408**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 409 410**参数：** 411 412| 参数名 | 类型 | 必填 | 说明 | 413| -------- | -------- | -------- | -------- | 414| field | string | 是 | 数据库表中的列名。 | 415| value | [ValueType](#valuetype) | 是 | 指示要与谓词匹配的值。 | 416 417**返回值**： 418 419| 类型 | 说明 | 420| -------- | -------- | 421| [RdbPredicates](#rdbpredicates) | 返回与指定字段匹配的谓词。 | 422 423**示例：** 424 425```ts 426let predicates = new data_rdb.RdbPredicates("EMPLOYEE") 427predicates.equalTo("NAME", "lisi") 428``` 429 430 431### notEqualTo 432 433notEqualTo(field: string, value: ValueType): RdbPredicates 434 435配置谓词以匹配数据字段为ValueType且值不等于指定值的字段。 436 437**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 438 439**参数：** 440 441| 参数名 | 类型 | 必填 | 说明 | 442| -------- | -------- | -------- | -------- | 443| field | string | 是 | 数据库表中的列名。 | 444| value | [ValueType](#valuetype) | 是 | 指示要与谓词匹配的值。 | 445 446**返回值**： 447 448| 类型 | 说明 | 449| -------- | -------- | 450| [RdbPredicates](#rdbpredicates) | 返回与指定字段匹配的谓词。 | 451 452**示例：** 453 454```ts 455let predicates = new data_rdb.RdbPredicates("EMPLOYEE") 456predicates.notEqualTo("NAME", "lisi") 457``` 458 459 460### beginWrap 461 462beginWrap(): RdbPredicates 463 464向谓词添加左括号。 465 466**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 467 468**返回值**： 469 470| 类型 | 说明 | 471| -------- | -------- | 472| [RdbPredicates](#rdbpredicates) | 返回带有左括号的Rdb谓词。 | 473 474**示例：** 475 476```ts 477let predicates = new data_rdb.RdbPredicates("EMPLOYEE") 478predicates.equalTo("NAME", "lisi") 479 .beginWrap() 480 .equalTo("AGE", 18) 481 .or() 482 .equalTo("SALARY", 200.5) 483 .endWrap() 484``` 485 486### endWrap 487 488endWrap(): RdbPredicates 489 490向谓词添加右括号。 491 492**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 493 494**返回值**： 495 496| 类型 | 说明 | 497| -------- | -------- | 498| [RdbPredicates](#rdbpredicates) | 返回带有右括号的Rdb谓词。 | 499 500**示例：** 501 502```ts 503let predicates = new data_rdb.RdbPredicates("EMPLOYEE") 504predicates.equalTo("NAME", "lisi") 505 .beginWrap() 506 .equalTo("AGE", 18) 507 .or() 508 .equalTo("SALARY", 200.5) 509 .endWrap() 510``` 511 512### or 513 514or(): RdbPredicates 515 516将或条件添加到谓词中。 517 518**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 519 520**返回值**： 521 522| 类型 | 说明 | 523| -------- | -------- | 524| [RdbPredicates](#rdbpredicates) | 返回带有或条件的Rdb谓词。 | 525 526**示例：** 527 528```ts 529let predicates = new data_rdb.RdbPredicates("EMPLOYEE") 530predicates.equalTo("NAME", "Lisa") 531 .or() 532 .equalTo("NAME", "Rose") 533``` 534 535### and 536 537and(): RdbPredicates 538 539向谓词添加和条件。 540 541**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 542 543**返回值**： 544 545| 类型 | 说明 | 546| -------- | -------- | 547| [RdbPredicates](#rdbpredicates) | 返回带有和条件的Rdb谓词。 | 548 549**示例：** 550 551```ts 552let predicates = new data_rdb.RdbPredicates("EMPLOYEE") 553predicates.equalTo("NAME", "Lisa") 554 .and() 555 .equalTo("SALARY", 200.5) 556``` 557 558### contains 559 560contains(field: string, value: string): RdbPredicates 561 562配置谓词以匹配数据字段为string且value包含指定值的字段。 563 564**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 565 566**参数：** 567 568| 参数名 | 类型 | 必填 | 说明 | 569| -------- | -------- | -------- | -------- | 570| field | string | 是 | 数据库表中的列名。 | 571| value | string | 是 | 指示要与谓词匹配的值。 | 572 573**返回值**： 574 575| 类型 | 说明 | 576| -------- | -------- | 577| [RdbPredicates](#rdbpredicates) | 返回与指定字段匹配的谓词。 | 578 579**示例：** 580 581```ts 582let predicates = new data_rdb.RdbPredicates("EMPLOYEE") 583predicates.contains("NAME", "os") 584``` 585 586### beginsWith 587 588beginsWith(field: string, value: string): RdbPredicates 589 590配置谓词以匹配数据字段为string且值以指定字符串开头的字段。 591 592**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 593 594**参数：** 595 596| 参数名 | 类型 | 必填 | 说明 | 597| -------- | -------- | -------- | -------- | 598| field | string | 是 | 数据库表中的列名。 | 599| value | string | 是 | 指示要与谓词匹配的值。 | 600 601**返回值**： 602 603| 类型 | 说明 | 604| -------- | -------- | 605| [RdbPredicates](#rdbpredicates) | 返回与指定字段匹配的谓词。 | 606 607**示例：** 608 609```ts 610let predicates = new data_rdb.RdbPredicates("EMPLOYEE") 611predicates.beginsWith("NAME", "os") 612``` 613 614### endsWith 615 616endsWith(field: string, value: string): RdbPredicates 617 618配置谓词以匹配数据字段为string且值以指定字符串结尾的字段。 619 620**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 621 622**参数：** 623 624| 参数名 | 类型 | 必填 | 说明 | 625| -------- | -------- | -------- | -------- | 626| field | string | 是 | 数据库表中的列名。 | 627| value | string | 是 | 指示要与谓词匹配的值。 | 628 629**返回值**： 630 631| 类型 | 说明 | 632| -------- | -------- | 633| [RdbPredicates](#rdbpredicates) | 返回与指定字段匹配的谓词。 | 634 635**示例：** 636 637```ts 638let predicates = new data_rdb.RdbPredicates("EMPLOYEE") 639predicates.endsWith("NAME", "se") 640``` 641 642### isNull 643 644isNull(field: string): RdbPredicates 645 646配置谓词以匹配值为null的字段。 647 648**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 649 650**参数：** 651 652| 参数名 | 类型 | 必填 | 说明 | 653| -------- | -------- | -------- | -------- | 654| field | string | 是 | 数据库表中的列名。 | 655 656**返回值**： 657 658| 类型 | 说明 | 659| -------- | -------- | 660| [RdbPredicates](#rdbpredicates) | 返回与指定字段匹配的谓词。 | 661 662**示例**： 663```ts 664let predicates = new data_rdb.RdbPredicates("EMPLOYEE") 665predicates.isNull("NAME") 666``` 667 668### isNotNull 669 670isNotNull(field: string): RdbPredicates 671 672配置谓词以匹配值不为null的指定字段。 673 674**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 675 676**参数：** 677 678| 参数名 | 类型 | 必填 | 说明 | 679| -------- | -------- | -------- | -------- | 680| field | string | 是 | 数据库表中的列名。 | 681 682**返回值**： 683 684| 类型 | 说明 | 685| -------- | -------- | 686| [RdbPredicates](#rdbpredicates) | 返回与指定字段匹配的谓词。 | 687 688**示例：** 689 690```ts 691let predicates = new data_rdb.RdbPredicates("EMPLOYEE") 692predicates.isNotNull("NAME") 693``` 694 695### like 696 697like(field: string, value: string): RdbPredicates 698 699配置谓词以匹配数据字段为string且值类似于指定字符串的字段。 700 701**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 702 703**参数：** 704 705| 参数名 | 类型 | 必填 | 说明 | 706| -------- | -------- | -------- | -------- | 707| field | string | 是 | 数据库表中的列名。 | 708| value | string | 是 | 指示要与谓词匹配的值。 | 709 710**返回值**： 711 712| 类型 | 说明 | 713| -------- | -------- | 714| [RdbPredicates](#rdbpredicates) | 返回与指定字段匹配的谓词。 | 715 716**示例：** 717 718```ts 719let predicates = new data_rdb.RdbPredicates("EMPLOYEE") 720predicates.like("NAME", "%os%") 721``` 722 723### glob 724 725glob(field: string, value: string): RdbPredicates 726 727配置RdbPredicates匹配数据字段为string的指定字段。 728 729**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 730 731**参数：** 732 733| 参数名 | 类型 | 必填 | 说明 | 734| -------- | -------- | -------- | -------- | 735| field | string | 是 | 数据库表中的列名。 | 736| value | string | 是 | 指示要与谓词匹配的值。<br>支持通配符，*表示0个、1个或多个数字或字符，?表示1个数字或字符。 | 737 738**返回值**： 739 740| 类型 | 说明 | 741| -------- | -------- | 742| [RdbPredicates](#rdbpredicates) | 返回与指定字段匹配的谓词。 | 743 744**示例：** 745 746```ts 747let predicates = new data_rdb.RdbPredicates("EMPLOYEE") 748predicates.glob("NAME", "?h*g") 749``` 750 751### between 752 753between(field: string, low: ValueType, high: ValueType): RdbPredicates 754 755将谓词配置为匹配数据字段为ValueType且value在给定范围内的指定字段。 756 757**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 758 759**参数：** 760 761| 参数名 | 类型 | 必填 | 说明 | 762| -------- | -------- | -------- | -------- | 763| field | string | 是 | 数据库表中的列名。 | 764| low | [ValueType](#valuetype) | 是 | 指示与谓词匹配的最小值。 | 765| high | [ValueType](#valuetype) | 是 | 指示要与谓词匹配的最大值。 | 766 767**返回值**： 768 769| 类型 | 说明 | 770| -------- | -------- | 771| [RdbPredicates](#rdbpredicates) | 返回与指定字段匹配的谓词。 | 772 773**示例：** 774 775```ts 776let predicates = new data_rdb.RdbPredicates("EMPLOYEE") 777predicates.between("AGE", 10, 50) 778``` 779 780### notBetween 781 782notBetween(field: string, low: ValueType, high: ValueType): RdbPredicates 783 784配置RdbPredicates以匹配数据字段为ValueType且value超出给定范围的指定字段。 785 786**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 787 788**参数：** 789 790| 参数名 | 类型 | 必填 | 说明 | 791| -------- | -------- | -------- | -------- | 792| field | string | 是 | 数据库表中的列名。 | 793| low | [ValueType](#valuetype) | 是 | 指示与谓词匹配的最小值。 | 794| high | [ValueType](#valuetype) | 是 | 指示要与谓词匹配的最大值。 | 795 796**返回值**： 797 798| 类型 | 说明 | 799| -------- | -------- | 800| [RdbPredicates](#rdbpredicates) | 返回与指定字段匹配的谓词。 | 801 802**示例：** 803 804```ts 805let predicates = new data_rdb.RdbPredicates("EMPLOYEE") 806predicates.notBetween("AGE", 10, 50) 807``` 808 809### greaterThan 810 811greaterThan(field: string, value: ValueType): RdbPredicates 812 813配置谓词以匹配数据字段为ValueType且值大于指定值的字段。 814 815**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 816 817**参数：** 818 819| 参数名 | 类型 | 必填 | 说明 | 820| -------- | -------- | -------- | -------- | 821| field | string | 是 | 数据库表中的列名。 | 822| value | [ValueType](#valuetype) | 是 | 指示要与谓词匹配的值。 | 823 824**返回值**： 825 826| 类型 | 说明 | 827| -------- | -------- | 828| [RdbPredicates](#rdbpredicates) | 返回与指定字段匹配的谓词。 | 829 830**示例：** 831 832```ts 833let predicates = new data_rdb.RdbPredicates("EMPLOYEE") 834predicates.greaterThan("AGE", 18) 835``` 836 837### lessThan 838 839lessThan(field: string, value: ValueType): RdbPredicates 840 841配置谓词以匹配数据字段为valueType且value小于指定值的字段。 842 843**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 844 845**参数：** 846 847| 参数名 | 类型 | 必填 | 说明 | 848| -------- | -------- | -------- | -------- | 849| field | string | 是 | 数据库表中的列名。 | 850| value | [ValueType](#valuetype) | 是 | 指示要与谓词匹配的值。 | 851 852**返回值**： 853 854| 类型 | 说明 | 855| -------- | -------- | 856| [RdbPredicates](#rdbpredicates) | 返回与指定字段匹配的谓词。 | 857 858**示例：** 859 860```ts 861let predicates = new data_rdb.RdbPredicates("EMPLOYEE") 862predicates.lessThan("AGE", 20) 863``` 864 865### greaterThanOrEqualTo 866 867greaterThanOrEqualTo(field: string, value: ValueType): RdbPredicates 868 869配置谓词以匹配数据字段为ValueType且value大于或等于指定值的字段。 870 871**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 872 873**参数：** 874 875| 参数名 | 类型 | 必填 | 说明 | 876| -------- | -------- | -------- | -------- | 877| field | string | 是 | 数据库表中的列名。 | 878| value | [ValueType](#valuetype) | 是 | 指示要与谓词匹配的值。 | 879 880**返回值**： 881 882| 类型 | 说明 | 883| -------- | -------- | 884| [RdbPredicates](#rdbpredicates) | 返回与指定字段匹配的谓词。 | 885 886**示例：** 887 888```ts 889let predicates = new data_rdb.RdbPredicates("EMPLOYEE") 890predicates.greaterThanOrEqualTo("AGE", 18) 891``` 892 893### lessThanOrEqualTo 894 895lessThanOrEqualTo(field: string, value: ValueType): RdbPredicates 896 897配置谓词以匹配数据字段为ValueType且value小于或等于指定值的字段。 898 899**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 900 901**参数：** 902 903| 参数名 | 类型 | 必填 | 说明 | 904| -------- | -------- | -------- | -------- | 905| field | string | 是 | 数据库表中的列名。 | 906| value | [ValueType](#valuetype) | 是 | 指示要与谓词匹配的值。 | 907 908**返回值**： 909 910| 类型 | 说明 | 911| -------- | -------- | 912| [RdbPredicates](#rdbpredicates) | 返回与指定字段匹配的谓词。 | 913 914**示例：** 915 916```ts 917let predicates = new data_rdb.RdbPredicates("EMPLOYEE") 918predicates.lessThanOrEqualTo("AGE", 20) 919``` 920 921### orderByAsc 922 923orderByAsc(field: string): RdbPredicates 924 925配置谓词以匹配其值按升序排序的列。 926 927**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 928 929**参数：** 930 931| 参数名 | 类型 | 必填 | 说明 | 932| -------- | -------- | -------- | -------- | 933| field | string | 是 | 数据库表中的列名。 | 934 935**返回值**： 936 937| 类型 | 说明 | 938| -------- | -------- | 939| [RdbPredicates](#rdbpredicates) | 返回与指定字段匹配的谓词。 | 940 941**示例：** 942 943```ts 944let predicates = new data_rdb.RdbPredicates("EMPLOYEE") 945predicates.orderByAsc("NAME") 946``` 947 948### orderByDesc 949 950orderByDesc(field: string): RdbPredicates 951 952配置谓词以匹配其值按降序排序的列。 953 954**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 955 956**参数：** 957 958| 参数名 | 类型 | 必填 | 说明 | 959| -------- | -------- | -------- | -------- | 960| field | string | 是 | 数据库表中的列名。 | 961 962**返回值**： 963 964| 类型 | 说明 | 965| -------- | -------- | 966| [RdbPredicates](#rdbpredicates) | 返回与指定字段匹配的谓词。 | 967 968**示例：** 969 970```ts 971let predicates = new data_rdb.RdbPredicates("EMPLOYEE") 972predicates.orderByDesc("AGE") 973``` 974 975### distinct 976 977distinct(): RdbPredicates 978 979配置谓词以过滤重复记录并仅保留其中一个。 980 981**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 982 983**返回值**： 984 985| 类型 | 说明 | 986| -------- | -------- | 987| [RdbPredicates](#rdbpredicates) | 返回可用于过滤重复记录的谓词。 | 988 989**示例：** 990 991```ts 992let predicates = new data_rdb.RdbPredicates("EMPLOYEE") 993predicates.equalTo("NAME", "Rose").distinct() 994``` 995 996### limitAs 997 998limitAs(value: number): RdbPredicates 999 1000设置最大数据记录数的谓词。 1001 1002**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 1003 1004**参数：** 1005 1006| 参数名 | 类型 | 必填 | 说明 | 1007| -------- | -------- | -------- | -------- | 1008| value | number | 是 | 最大数据记录数。 | 1009 1010**返回值**： 1011 1012| 类型 | 说明 | 1013| -------- | -------- | 1014| [RdbPredicates](#rdbpredicates) | 返回可用于设置最大数据记录数的谓词。 | 1015 1016**示例：** 1017 1018```ts 1019let predicates = new data_rdb.RdbPredicates("EMPLOYEE") 1020predicates.equalTo("NAME", "Rose").limitAs(3) 1021``` 1022 1023### offsetAs 1024 1025offsetAs(rowOffset: number): RdbPredicates 1026 1027配置RdbPredicates以指定返回结果的起始位置。 1028 1029**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 1030 1031**参数：** 1032 1033| 参数名 | 类型 | 必填 | 说明 | 1034| -------- | -------- | -------- | -------- | 1035| rowOffset | number | 是 | 返回结果的起始位置，取值为正整数。 | 1036 1037**返回值**： 1038 1039| 类型 | 说明 | 1040| -------- | -------- | 1041| [RdbPredicates](#rdbpredicates) | 返回具有指定返回结果起始位置的谓词。 | 1042 1043**示例：** 1044 1045```ts 1046let predicates = new data_rdb.RdbPredicates("EMPLOYEE") 1047predicates.equalTo("NAME", "Rose").offsetAs(3) 1048``` 1049 1050### groupBy 1051 1052groupBy(fields: Array<string>): RdbPredicates 1053 1054配置RdbPredicates按指定列分组查询结果。 1055 1056**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 1057 1058**参数：** 1059 1060| 参数名 | 类型 | 必填 | 说明 | 1061| -------- | -------- | -------- | -------- | 1062| fields | Array<string> | 是 | 指定分组依赖的列名。 | 1063 1064**返回值**： 1065 1066| 类型 | 说明 | 1067| -------- | -------- | 1068| [RdbPredicates](#rdbpredicates) | 返回分组查询列的谓词。 | 1069 1070**示例：** 1071 1072```ts 1073let predicates = new data_rdb.RdbPredicates("EMPLOYEE") 1074predicates.groupBy(["AGE", "NAME"]) 1075``` 1076 1077### indexedBy 1078 1079indexedBy(field: string): RdbPredicates 1080 1081配置RdbPredicates以指定索引列。 1082 1083**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 1084 1085**参数：** 1086 1087| 参数名 | 类型 | 必填 | 说明 | 1088| -------- | -------- | -------- | -------- | 1089| field | string | 是 | 索引列的名称。 | 1090 1091**返回值**： 1092 1093 1094| 类型 | 说明 | 1095| -------- | -------- | 1096| [RdbPredicates](#rdbpredicates) | 返回具有指定索引列的RdbPredicates。 | 1097 1098**示例：** 1099 1100```ts 1101let predicates = new data_rdb.RdbPredicates("EMPLOYEE") 1102predicates.indexedBy("SALARY_INDEX") 1103``` 1104 1105### in 1106 1107in(field: string, value: Array<ValueType>): RdbPredicates 1108 1109配置RdbPredicates以匹配数据字段为ValueType数组且值在给定范围内的指定字段。 1110 1111**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 1112 1113**参数：** 1114 1115| 参数名 | 类型 | 必填 | 说明 | 1116| -------- | -------- | -------- | -------- | 1117| field | string | 是 | 数据库表中的列名。 | 1118| value | Array<[ValueType](#valuetype)> | 是 | 以ValueType型数组形式指定的要匹配的值。 | 1119 1120**返回值**： 1121 1122| 类型 | 说明 | 1123| -------- | -------- | 1124| [RdbPredicates](#rdbpredicates) | 返回与指定字段匹配的谓词。 | 1125 1126**示例：** 1127 1128```ts 1129let predicates = new data_rdb.RdbPredicates("EMPLOYEE") 1130predicates.in("AGE", [18, 20]) 1131``` 1132 1133### notIn 1134 1135notIn(field: string, value: Array<ValueType>): RdbPredicates 1136 1137将RdbPredicates配置为匹配数据字段为ValueType且值超出给定范围的指定字段。 1138 1139**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 1140 1141**参数：** 1142 1143| 参数名 | 类型 | 必填 | 说明 | 1144| -------- | -------- | -------- | -------- | 1145| field | string | 是 | 数据库表中的列名。 | 1146| value | Array<[ValueType](#valuetype)> | 是 | 以ValueType数组形式指定的要匹配的值。 | 1147 1148**返回值**： 1149 1150| 类型 | 说明 | 1151| -------- | -------- | 1152| [RdbPredicates](#rdbpredicates) | 返回与指定字段匹配的谓词。 | 1153 1154**示例：** 1155 1156```ts 1157let predicates = new data_rdb.RdbPredicates("EMPLOYEE") 1158predicates.notIn("NAME", ["Lisa", "Rose"]) 1159``` 1160 1161## RdbStore 1162 1163提供管理关系数据库(RDB)方法的接口。 1164 1165在使用以下相关接口前，请使用[executeSql](#executesql8)接口初始化数据库表结构和相关数据。 1166 1167### insert 1168 1169insert(table: string, values: ValuesBucket, callback: AsyncCallback<number>):void 1170 1171向目标表中插入一行数据，使用callback异步回调。 1172 1173**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 1174 1175**参数：** 1176 1177| 参数名 | 类型 | 必填 | 说明 | 1178| -------- | -------- | -------- | -------- | 1179| table | string | 是 | 指定的目标表名。 | 1180| values | [ValuesBucket](#valuesbucket) | 是 | 表示要插入到表中的数据行。 | 1181| callback | AsyncCallback<number> | 是 | 指定callback回调函数。如果操作成功，返回行ID；否则返回-1。 | 1182 1183**示例：** 1184 1185```ts 1186import { ValuesBucket } from '@ohos.data.ValuesBucket'; 1187 1188let key1 = "NAME"; 1189let key2 = "AGE"; 1190let key3 = "SALARY"; 1191let key4 = "CODES"; 1192let value1 = "Lisi"; 1193let value2 = 18; 1194let value3 = 100.5; 1195let value4 = new Uint8Array([1, 2, 3, 4, 5]); 1196const valueBucket: ValuesBucket = { 1197 key1: value1, 1198 key2: value2, 1199 key3: value3, 1200 key4: value4, 1201}; 1202 1203rdbStore.insert("EMPLOYEE", valueBucket, (status: number, rowId: number) => { 1204 if (status) { 1205 console.log("Insert is failed"); 1206 return; 1207 } 1208 console.log("Insert is successful, rowId = " + rowId); 1209}) 1210``` 1211 1212### insert 1213 1214insert(table: string, values: ValuesBucket):Promise<number> 1215 1216向目标表中插入一行数据，使用Promise异步回调。 1217 1218**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 1219 1220**参数：** 1221 1222| 参数名 | 类型 | 必填 | 说明 | 1223| -------- | -------- | -------- | -------- | 1224| table | string | 是 | 指定的目标表名。 | 1225| values | [ValuesBucket](#valuesbucket) | 是 | 表示要插入到表中的数据行。 | 1226 1227**返回值**： 1228 1229| 类型 | 说明 | 1230| -------- | -------- | 1231| Promise<number> | Promise对象。如果操作成功，返回行ID；否则返回-1。 | 1232 1233**示例：** 1234 1235```ts 1236import { ValuesBucket } from '@ohos.data.ValuesBucket'; 1237 1238let key1 = "NAME"; 1239let key2 = "AGE"; 1240let key3 = "SALARY"; 1241let key4 = "CODES"; 1242let value1 = "Lisi"; 1243let value2 = 18; 1244let value3 = 100.5; 1245let value4 = new Uint8Array([1, 2, 3, 4, 5]); 1246const valueBucket: ValuesBucket = { 1247 key1: value1, 1248 key2: value2, 1249 key3: value3, 1250 key4: value4, 1251}; 1252 1253let promise: void = rdbStore.insert("EMPLOYEE", valueBucket) 1254promise.then((rowId: BusinessError) => { 1255 console.log("Insert is successful, rowId = " + rowId); 1256}).catch((status: number) => { 1257 console.log("Insert is failed"); 1258}) 1259``` 1260 1261### batchInsert 1262 1263batchInsert(table: string, values: Array<ValuesBucket>, callback: AsyncCallback<number>):void 1264 1265向目标表中插入一组数据，使用callback异步回调。 1266 1267**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 1268 1269**参数：** 1270 1271| 参数名 | 类型 | 必填 | 说明 | 1272| -------- | -------- | -------- | -------- | 1273| table | string | 是 | 指定的目标表名。 | 1274| values | Array<[ValuesBucket](#valuesbucket)> | 是 | 表示要插入到表中的一组数据。 | 1275| callback | AsyncCallback<number> | 是 | 指定callback回调函数。如果操作成功，返回插入的数据个数，否则返回-1。 | 1276 1277**示例：** 1278 1279```ts 1280import { ValuesBucket } from '@ohos.data.ValuesBucket'; 1281 1282let key1 = "NAME"; 1283let key2 = "AGE"; 1284let key3 = "SALARY"; 1285let key4 = "CODES"; 1286let value1 = "Lisa"; 1287let value2 = 18; 1288let value3 = 100.5; 1289let value4 = new Uint8Array([1, 2, 3, 4, 5]); 1290let value5 = "Jack"; 1291let value6 = 19; 1292let value7 = 101.5; 1293let value8 = new Uint8Array([6, 7, 8, 9, 10]); 1294let value9 = "Tom"; 1295let value10 = 20; 1296let value11 = 102.5; 1297let value12 = new Uint8Array([11, 12, 13, 14, 15]); 1298const valueBucket1: ValuesBucket = { 1299 key1: value1, 1300 key2: value2, 1301 key3: value3, 1302 key4: value4, 1303}; 1304const valueBucket2: ValuesBucket = { 1305 key1: value5, 1306 key2: value6, 1307 key3: value7, 1308 key4: value8, 1309}; 1310const valueBucket3: ValuesBucket = { 1311 key1: value9, 1312 key2: value10, 1313 key3: value11, 1314 key4: value12, 1315}; 1316 1317let valueBuckets = new Array(valueBucket1, valueBucket2, valueBucket3); 1318rdbStore.batchInsert("EMPLOYEE", valueBuckets, (status: number, insertNum: number) => { 1319 if (status) { 1320 console.log("batchInsert is failed, status = " + status); 1321 return; 1322 } 1323 console.log("batchInsert is successful, the number of values that were inserted = " + insertNum); 1324}) 1325``` 1326 1327### batchInsert 1328 1329batchInsert(table: string, values: Array<ValuesBucket>):Promise<number> 1330 1331向目标表中插入一组数据，使用Promise异步回调。 1332 1333**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 1334 1335**参数：** 1336 1337| 参数名 | 类型 | 必填 | 说明 | 1338| -------- | -------- | -------- | -------- | 1339| table | string | 是 | 指定的目标表名。 | 1340| values | Array<[ValuesBucket](#valuesbucket)> | 是 | 表示要插入到表中的一组数据。 | 1341 1342**返回值**： 1343 1344| 类型 | 说明 | 1345| -------- | -------- | 1346| Promise<number> | Promise对象。如果操作成功，返回插入的数据个数，否则返回-1。 | 1347 1348**示例：** 1349 1350```ts 1351import { ValuesBucket } from '@ohos.data.ValuesBucket'; 1352 1353let key1 = "NAME"; 1354let key2 = "AGE"; 1355let key3 = "SALARY"; 1356let key4 = "CODES"; 1357let value1 = "Lisa"; 1358let value2 = 18; 1359let value3 = 100.5; 1360let value4 = new Uint8Array([1, 2, 3, 4, 5]); 1361let value5 = "Jack"; 1362let value6 = 19; 1363let value7 = 101.5; 1364let value8 = new Uint8Array([6, 7, 8, 9, 10]); 1365let value9 = "Tom"; 1366let value10 = 20; 1367let value11 = 102.5; 1368let value12 = new Uint8Array([11, 12, 13, 14, 15]); 1369const valueBucket1: ValuesBucket = { 1370 key1: value1, 1371 key2: value2, 1372 key3: value3, 1373 key4: value4, 1374}; 1375const valueBucket2: ValuesBucket = { 1376 key1: value5, 1377 key2: value6, 1378 key3: value7, 1379 key4: value8, 1380}; 1381const valueBucket3: ValuesBucket = { 1382 key1: value9, 1383 key2: value10, 1384 key3: value11, 1385 key4: value12, 1386}; 1387 1388let valueBuckets = new Array(valueBucket1, valueBucket2, valueBucket3); 1389let promise: void = rdbStore.batchInsert("EMPLOYEE", valueBuckets); 1390promise.then((insertNum: number) => { 1391 console.log("batchInsert is successful, the number of values that were inserted = " + insertNum); 1392}).catch((status: number) => { 1393 console.log("batchInsert is failed, status = " + status); 1394}) 1395``` 1396 1397### update 1398 1399update(values: ValuesBucket, predicates: RdbPredicates, callback: AsyncCallback<number>):void 1400 1401根据RdbPredicates的指定实例对象更新数据库中的数据，使用callback异步回调。 1402 1403**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 1404 1405**参数：** 1406 1407| 参数名 | 类型 | 必填 | 说明 | 1408| -------- | -------- | -------- | -------- | 1409| values | [ValuesBucket](#valuesbucket) | 是 | values指示数据库中要更新的数据行。键值对与数据库表的列名相关联。 | 1410| predicates | [RdbPredicates](#rdbpredicates) | 是 | RdbPredicates的实例对象指定的更新条件。 | 1411| callback | AsyncCallback<number> | 是 | 指定的callback回调方法。返回受影响的行数。 | 1412 1413**示例：** 1414 1415```ts 1416import { ValuesBucket } from '@ohos.data.ValuesBucket'; 1417 1418let key1 = "NAME"; 1419let key2 = "AGE"; 1420let key3 = "SALARY"; 1421let key4 = "CODES"; 1422let value1 = "Lisa"; 1423let value2 = 18; 1424let value3 = 100.5; 1425let value4 = new Uint8Array([1, 2, 3, 4, 5]); 1426 1427const valueBucket: ValuesBucket = { 1428 key1: value1, 1429 key2: value2, 1430 key3: value3, 1431 key4: value4, 1432}; 1433let predicates = new data_rdb.RdbPredicates("EMPLOYEE") 1434predicates.equalTo("NAME", "Lisa") 1435rdbStore.update(valueBucket, predicates, (err: BusinessError, rows: number) => { 1436 if (err) { 1437 console.info("Updated failed, err: " + err) 1438 return 1439 } 1440 console.log("Updated row count: " + rows) 1441}) 1442``` 1443 1444### update 1445 1446update(values: ValuesBucket, predicates: RdbPredicates):Promise<number> 1447 1448根据RdbPredicates的指定实例对象更新数据库中的数据，使用Promise异步回调。 1449 1450**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 1451 1452**参数：** 1453 1454| 参数名 | 类型 | 必填 | 说明 | 1455| -------- | -------- | -------- | -------- | 1456| values | [ValuesBucket](#valuesbucket) | 是 | values指示数据库中要更新的数据行。键值对与数据库表的列名相关联。 | 1457| predicates | [RdbPredicates](#rdbpredicates) | 是 | RdbPredicates的实例对象指定的更新条件。 | 1458 1459**返回值**： 1460 1461| 类型 | 说明 | 1462| -------- | -------- | 1463| Promise<number> | 指定的Promise回调方法。返回受影响的行数。 | 1464 1465**示例：** 1466 1467```ts 1468import { ValuesBucket } from '@ohos.data.ValuesBucket'; 1469 1470let key1 = "NAME"; 1471let key2 = "AGE"; 1472let key3 = "SALARY"; 1473let key4 = "CODES"; 1474let value1 = "Lisa"; 1475let value2 = 18; 1476let value3 = 100.5; 1477let value4 = new Uint8Array([1, 2, 3, 4, 5]); 1478 1479const valueBucket: ValuesBucket = { 1480 key1: value1, 1481 key2: value2, 1482 key3: value3, 1483 key4: value4, 1484}; 1485let predicates = new data_rdb.RdbPredicates("EMPLOYEE") 1486predicates.equalTo("NAME", "Lisa") 1487let promise: void = rdbStore.update(valueBucket, predicates) 1488promise.then(async (rows: number) => { 1489 console.log("Updated row count: " + rows) 1490}).catch((err: BusinessError) => { 1491 console.info("Updated failed, err: " + err) 1492}) 1493``` 1494 1495### delete 1496 1497delete(predicates: RdbPredicates, callback: AsyncCallback<number>):void 1498 1499根据RdbPredicates的指定实例对象从数据库中删除数据，使用callback异步回调。 1500 1501**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 1502 1503**参数：** 1504 1505| 参数名 | 类型 | 必填 | 说明 | 1506| -------- | -------- | -------- | -------- | 1507| predicates | [RdbPredicates](#rdbpredicates) | 是 | RdbPredicates的实例对象指定的删除条件。 | 1508| callback | AsyncCallback<number> | 是 | 指定callback回调函数。返回受影响的行数。 | 1509 1510**示例：** 1511 1512```ts 1513let predicates = new data_rdb.RdbPredicates("EMPLOYEE") 1514predicates.equalTo("NAME", "Lisa") 1515rdbStore.delete(predicates, (err: BusinessError, rows: number) => { 1516 if (err) { 1517 console.info("Delete failed, err: " + err) 1518 return 1519 } 1520 console.log("Delete rows: " + rows) 1521}) 1522``` 1523 1524### delete 1525 1526delete(predicates: RdbPredicates):Promise<number> 1527 1528根据RdbPredicates的指定实例对象从数据库中删除数据，使用Promise异步回调。 1529 1530**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 1531 1532**参数：** 1533 1534| 参数名 | 类型 | 必填 | 说明 | 1535| -------- | -------- | -------- | -------- | 1536| predicates | [RdbPredicates](#rdbpredicates) | 是 | RdbPredicates的实例对象指定的删除条件。 | 1537 1538**返回值**： 1539 1540| 类型 | 说明 | 1541| -------- | -------- | 1542| Promise<number> | Promise对象。返回受影响的行数。 | 1543 1544**示例：** 1545 1546```ts 1547let predicates = new data_rdb.RdbPredicates("EMPLOYEE") 1548predicates.equalTo("NAME", "Lisa") 1549let promise: void = rdbStore.delete(predicates) 1550promise.then((rows: number) => { 1551 console.log("Delete rows: " + rows) 1552}).catch((err: BusinessError) => { 1553 console.info("Delete failed, err: " + err) 1554}) 1555``` 1556 1557### query 1558 1559query(predicates: RdbPredicates, columns: Array<string>, callback: AsyncCallback<ResultSet>):void 1560 1561根据指定条件查询数据库中的数据，使用callback异步回调。 1562 1563**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 1564 1565**参数：** 1566 1567| 参数名 | 类型 | 必填 | 说明 | 1568| -------- | -------- | -------- | -------- | 1569| predicates | [RdbPredicates](#rdbpredicates) | 是 | RdbPredicates的实例对象指定的查询条件。 | 1570| columns | Array<string> | 是 | 表示要查询的列。如果值为空，则查询应用于所有列。 | 1571| callback | AsyncCallback<[ResultSet](js-apis-data-resultset.md)> | 是 | 指定callback回调函数。如果操作成功，则返回ResultSet对象。 | 1572 1573**示例：** 1574 1575```ts 1576let predicates = new data_rdb.RdbPredicates("EMPLOYEE") 1577predicates.equalTo("NAME", "Rose") 1578rdbStore.query(predicates, ["ID", "NAME", "AGE", "SALARY", "CODES"], (err: BusinessError, resultSet: void) => { 1579 if (err) { 1580 console.info("Query failed, err: " + err) 1581 return 1582 } 1583 console.log("ResultSet column names: " + resultSet.columnNames) 1584 console.log("ResultSet column count: " + resultSet.columnCount) 1585}) 1586``` 1587 1588### query 1589 1590query(predicates: RdbPredicates, columns?: Array<string>):Promise<ResultSet> 1591 1592根据指定条件查询数据库中的数据，使用Promise异步回调。 1593 1594**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 1595 1596**参数：** 1597 1598| 参数名 | 类型 | 必填 | 说明 | 1599| -------- | -------- | -------- | -------- | 1600| predicates | [RdbPredicates](#rdbpredicates) | 是 | RdbPredicates的实例对象指定的查询条件。 | 1601| columns | Array<string> | 否 | 表示要查询的列。如果值为空，则查询应用于所有列。 | 1602 1603**返回值**： 1604 1605| 类型 | 说明 | 1606| -------- | -------- | 1607| Promise<[ResultSet](js-apis-data-resultset.md)> | Promise对象。如果操作成功，则返回ResultSet对象。 | 1608 1609**示例：** 1610 1611```ts 1612let predicates = new data_rdb.RdbPredicates("EMPLOYEE") 1613predicates.equalTo("NAME", "Rose") 1614let promise: void = rdbStore.query(predicates, ["ID", "NAME", "AGE", "SALARY", "CODES"]) 1615promise.then((resultSet: void) => { 1616 console.log("ResultSet column names: " + resultSet.columnNames) 1617 console.log("ResultSet column count: " + resultSet.columnCount) 1618}).catch((err: BusinessError) => { 1619 console.info("Query failed, err: " + err) 1620}) 1621``` 1622 1623### querySql<sup>8+</sup> 1624 1625querySql(sql: string, bindArgs: Array<ValueType>, callback: AsyncCallback<ResultSet>):void 1626 1627根据指定SQL语句查询数据库中的数据，使用callback异步回调。 1628 1629**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 1630 1631**参数：** 1632 1633| 参数名 | 类型 | 必填 | 说明 | 1634| -------- | -------- | -------- | -------- | 1635| sql | string | 是 | 指定要执行的SQL语句。 | 1636| bindArgs | Array<[ValueType](#valuetype)> | 是 | SQL语句中参数的值。该值与sql参数语句中的占位符相对应。当sql参数语句完整时，该参数需为空数组。 | 1637| callback | AsyncCallback<[ResultSet](js-apis-data-resultset.md)> | 是 | 指定callback回调函数。如果操作成功，则返回ResultSet对象。 | 1638 1639**示例：** 1640 1641```ts 1642rdbStore.querySql("SELECT * FROM EMPLOYEE CROSS JOIN BOOK WHERE BOOK.NAME = ?", ['sanguo'], (err: BusinessError, resultSet: void) => { 1643 if (err) { 1644 console.info("Query failed, err: " + err) 1645 return 1646 } 1647 console.log("ResultSet column names: " + resultSet.columnNames) 1648 console.log("ResultSet column count: " + resultSet.columnCount) 1649}) 1650``` 1651 1652### querySql<sup>8+</sup> 1653 1654querySql(sql: string, bindArgs?: Array<ValueType>):Promise<ResultSet> 1655 1656根据指定SQL语句查询数据库中的数据，使用Promise异步回调。 1657 1658**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 1659 1660**参数：** 1661 1662| 参数名 | 类型 | 必填 | 说明 | 1663| -------- | -------- | -------- | -------- | 1664| sql | string | 是 | 指定要执行的SQL语句。 | 1665| bindArgs | Array<[ValueType](#valuetype)> | 否 | SQL语句中参数的值。该值与sql参数语句中的占位符相对应。当sql参数语句完整时，该参数不填。 | 1666 1667**返回值**： 1668 1669| 类型 | 说明 | 1670| -------- | -------- | 1671| Promise<[ResultSet](js-apis-data-resultset.md)> | Promise对象。如果操作成功，则返回ResultSet对象。 | 1672 1673**示例：** 1674 1675```ts 1676let promise: void = rdbStore.querySql("SELECT * FROM EMPLOYEE CROSS JOIN BOOK WHERE BOOK.NAME = 'sanguo'") 1677promise.then((resultSet: void) => { 1678 console.log("ResultSet column names: " + resultSet.columnNames) 1679 console.log("ResultSet column count: " + resultSet.columnCount) 1680}).catch((err: BusinessError) => { 1681 console.info("Query failed, err: " + err) 1682}) 1683``` 1684 1685### executeSql<sup>8+</sup> 1686 1687executeSql(sql: string, bindArgs: Array<ValueType>, callback: AsyncCallback<void>):void 1688 1689执行包含指定参数但不返回值的SQL语句，使用callback异步回调。 1690 1691**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 1692 1693**参数：** 1694 1695| 参数名 | 类型 | 必填 | 说明 | 1696| -------- | -------- | -------- | -------- | 1697| sql | string | 是 | 指定要执行的SQL语句。 | 1698| bindArgs | Array<[ValueType](#valuetype)> | 是 | SQL语句中参数的值。该值与sql参数语句中的占位符相对应。当sql参数语句完整时，该参数需为空数组。 | 1699| callback | AsyncCallback<void> | 是 | 指定callback回调函数。 | 1700 1701**示例：** 1702 1703```ts 1704const SQL_DELETE_TABLE = "DELETE FROM test WHERE name = ?" 1705rdbStore.executeSql(SQL_DELETE_TABLE, ['zhangsan'], (err: BusinessError) => { 1706 if (err) { 1707 console.info("ExecuteSql failed, err: " + err) 1708 return 1709 } 1710 console.info('Delete table done.') 1711}) 1712``` 1713 1714### executeSql<sup>8+</sup> 1715 1716executeSql(sql: string, bindArgs?: Array<ValueType>):Promise<void> 1717 1718执行包含指定参数但不返回值的SQL语句，使用Promise异步回调。 1719 1720**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 1721 1722**参数：** 1723 1724| 参数名 | 类型 | 必填 | 说明 | 1725| -------- | -------- | -------- | -------- | 1726| sql | string | 是 | 指定要执行的SQL语句。 | 1727| bindArgs | Array<[ValueType](#valuetype)> | 否 | SQL语句中参数的值。该值与sql参数语句中的占位符相对应。当sql参数语句完整时，该参数不填。 | 1728 1729**返回值**： 1730 1731| 类型 | 说明 | 1732| -------- | -------- | 1733| Promise<void> | 无返回结果的Promise对象。 | 1734 1735**示例：** 1736 1737```ts 1738const SQL_DELETE_TABLE = "DELETE FROM test WHERE name = 'zhangsan'" 1739let promise: void = rdbStore.executeSql(SQL_DELETE_TABLE) 1740promise.then(() => { 1741 console.info('Delete table done.') 1742}).catch((err: BusinessError) => { 1743 console.info("ExecuteSql failed, err: " + err) 1744}) 1745``` 1746 1747### beginTransaction<sup>8+</sup> 1748 1749beginTransaction():void 1750 1751在开始执行SQL语句之前，开始事务。 1752 1753**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 1754 1755**示例：** 1756 1757```ts 1758import featureAbility from '@ohos.ability.featureAbility'; 1759import { ValuesBucket } from '@ohos.data.ValuesBucket'; 1760 1761let key1 = "NAME"; 1762let key2 = "AGE"; 1763let key3 = "SALARY"; 1764let key4 = "blobType"; 1765let value1 = "Lisa"; 1766let value2 = 18; 1767let value3 = 100.5; 1768let value4 = new Uint8Array([1, 2, 3]); 1769 1770const valueBucket: ValuesBucket = { 1771 key1: value1, 1772 key2: value2, 1773 key3: value3, 1774 key4: value4, 1775}; 1776 1777data_rdb.getRdbStore(this.context, "RdbTest.db", 1, async (err: BusinessError, rdbStore) => { 1778 rdbStore.beginTransaction() 1779 await rdbStore.insert("test", valueBucket) 1780 rdbStore.commit() 1781}) 1782``` 1783 1784### commit<sup>8+</sup> 1785 1786commit():void 1787 1788提交已执行的SQL语句。 1789 1790**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 1791 1792**示例：** 1793 1794```ts 1795import { ValuesBucket } from '@ohos.data.ValuesBucket'; 1796import featureAbility from '@ohos.ability.featureAbility'; 1797 1798let key1 = "NAME"; 1799let key2 = "AGE"; 1800let key3 = "SALARY"; 1801let key4 = "blobType"; 1802let value1 = "Lisa"; 1803let value2 = 18; 1804let value3 = 100.5; 1805let value4 = new Uint8Array([1, 2, 3]); 1806 1807const valueBucket: ValuesBucket = { 1808 key1: value1, 1809 key2: value2, 1810 key3: value3, 1811 key4: value4, 1812}; 1813 1814data_rdb.getRdbStore(this.context, "RdbTest.db", 1, async (err: BusinessError, rdbStore) => { 1815 rdbStore.beginTransaction() 1816 await rdbStore.insert("test", valueBucket) 1817 rdbStore.commit() 1818}) 1819``` 1820 1821### rollBack<sup>8+</sup> 1822 1823rollBack():void 1824 1825回滚已经执行的SQL语句。 1826 1827**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 1828 1829**示例：** 1830 1831```ts 1832import { ValuesBucket } from '@ohos.data.ValuesBucket'; 1833import featureAbility from '@ohos.ability.featureAbility'; 1834 1835let key1 = "NAME"; 1836let key2 = "AGE"; 1837let key3 = "SALARY"; 1838let key4 = "blobType"; 1839let value1 = "Lisa"; 1840let value2 = 18; 1841let value3 = 100.5; 1842let value4 = new Uint8Array([1, 2, 3]); 1843 1844const valueBucket: ValuesBucket = { 1845 key1: value1, 1846 key2: value2, 1847 key3: value3, 1848 key4: value4, 1849}; 1850 1851const STORE_CONFIG = { name: "RdbTest.db"} 1852data_rdb.getRdbStore(this,context, "RdbTest.db", 1, async (err: BusinessError, rdbStore) => { 1853 try { 1854 rdbStore.beginTransaction() 1855 await rdbStore.insert("test", valueBucket) 1856 rdbStore.commit() 1857 } catch (e) { 1858 rdbStore.rollBack() 1859 } 1860}) 1861``` 1862 1863### setDistributedTables<sup>8+</sup> 1864 1865setDistributedTables(tables: Array<string>, callback: AsyncCallback<void>): void 1866 1867设置分布式列表，使用callback异步回调。 1868 1869**需要权限：** ohos.permission.DISTRIBUTED_DATASYNC 1870 1871**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 1872 1873**参数：** 1874 1875| 参数名 | 类型 | 必填 | 说明 | 1876| -------- | -------- | -------- | -------- | 1877| tables | Array<string> | 是 | 要设置的分布式列表表名 | 1878| callback | AsyncCallback<void> | 是 | 指定callback回调函数。 | 1879 1880**示例：** 1881 1882```ts 1883rdbStore.setDistributedTables(["EMPLOYEE"], (err: BusinessError) => { 1884 if (err) { 1885 console.info('SetDistributedTables failed, err: ' + err) 1886 return 1887 } 1888 console.info('SetDistributedTables successfully.') 1889}) 1890``` 1891 1892### setDistributedTables<sup>8+</sup> 1893 1894 setDistributedTables(tables: Array<string>): Promise<void> 1895 1896设置分布式列表，使用Promise异步回调。 1897 1898**需要权限：** ohos.permission.DISTRIBUTED_DATASYNC 1899 1900**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 1901 1902**参数：** 1903 1904| 参数名 | 类型 | 必填 | 说明 | 1905| -------- | -------- | -------- | -------- | 1906| tables | Array<string> | 是 | 要设置的分布式列表表名。 | 1907 1908**返回值**： 1909 1910| 类型 | 说明 | 1911| -------- | -------- | 1912| Promise<void> | 无返回结果的Promise对象。 | 1913 1914**示例：** 1915 1916```ts 1917let promise: void = rdbStore.setDistributedTables(["EMPLOYEE"]) 1918promise.then(() => { 1919 console.info("SetDistributedTables successfully.") 1920}).catch((err: BusinessError) => { 1921 console.info("SetDistributedTables failed, err: " + err) 1922}) 1923``` 1924 1925### obtainDistributedTableName<sup>8+</sup> 1926 1927obtainDistributedTableName(device: string, table: string, callback: AsyncCallback<string>): void 1928 1929根据远程设备的本地表名获取指定远程设备的分布式表名。在查询远程设备数据库时，需要使用分布式表名, 使用callback异步回调。 1930 1931> **说明：** 1932> 1933> 其中device通过调用[deviceManager.getTrustedDeviceListSync](js-apis-device-manager.md#gettrusteddevicelistsync)方法得到。deviceManager模块的接口均为系统接口，仅系统应用可用。 1934 1935**需要权限：** ohos.permission.DISTRIBUTED_DATASYNC 1936 1937**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 1938 1939**参数：** 1940 1941| 参数名 | 类型 | 必填 | 说明 | 1942| -------- | -------- | -------- | -------- | 1943| device | string | 是 | 远程设备ID 。 | 1944| table | string | 是 | 远程设备的本地表名 | 1945| callback | AsyncCallback<string> | 是 | 指定的callback回调函数。如果操作成功，返回远程设备的分布式表名。 | 1946 1947**示例：** 1948 1949```ts 1950import deviceManager from '@ohos.distributedHardware.deviceManager'; 1951 1952let dmInstance: Array<string>; 1953 1954deviceManager.createDeviceManager("com.example.appdatamgrverify", (err: BusinessError, manager: void) => { 1955 if (err) { 1956 console.log("create device manager failed, err=" + err); 1957 return; 1958 } 1959 dmInstance = manager; 1960 let devices: Array<string> = dmInstance.getTrustedDeviceListSync(); 1961 let deviceId: Array<string> = devices[0].deviceId; 1962}) 1963 1964rdbStore.obtainDistributedTableName(deviceId, "EMPLOYEE", (err: BusinessError, tableName: String) { 1965 if (err) { 1966 console.info('ObtainDistributedTableName failed, err: ' + err) 1967 return 1968 } 1969 console.info('ObtainDistributedTableName successfully, tableName=.' + tableName) 1970}) 1971``` 1972 1973### obtainDistributedTableName<sup>8+</sup> 1974 1975 obtainDistributedTableName(device: string, table: string): Promise<string> 1976 1977根据远程设备的本地表名获取指定远程设备的分布式表名。在查询远程设备数据库时，需要使用分布式表名，使用Promise异步回调。 1978 1979> **说明：** 1980> 1981> 其中device通过调用[deviceManager.getTrustedDeviceListSync](js-apis-device-manager.md#gettrusteddevicelistsync)方法得到。deviceManager模块的接口均为系统接口，仅系统应用可用。 1982 1983**需要权限：** ohos.permission.DISTRIBUTED_DATASYNC 1984 1985**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 1986 1987**参数：** 1988 1989| 参数名 | 类型 | 必填 | 说明 | 1990| -------- | -------- | -------- | -------- | 1991| device | string | 是 | 远程设备ID。 | 1992| table | string | 是 | 远程设备的本地表名。 | 1993 1994**返回值**： 1995 1996| 类型 | 说明 | 1997| -------- | -------- | 1998| Promise<string> | Promise对象。如果操作成功，返回远程设备的分布式表名。 | 1999 2000**示例：** 2001 2002```ts 2003import deviceManager from '@ohos.distributedHardware.deviceManager'; 2004 2005let dmInstance: Array<string>; 2006 2007deviceManager.createDeviceManager("com.example.appdatamgrverify", (err: BusinessError, manager: void) => { 2008 if (err) { 2009 console.log("create device manager failed, err=" + err); 2010 return; 2011 } 2012 dmInstance = manager; 2013 let devices: Array<string> = dmInstance.getTrustedDeviceListSync(); 2014 let deviceId: Array<string> = devices[0].deviceId; 2015}) 2016 2017let promise: void = rdbStore.obtainDistributedTableName(deviceId, "EMPLOYEE") 2018promise.then((tableName: String) => { 2019 console.info('ObtainDistributedTableName successfully, tableName= ' + tableName) 2020}).catch((err: BusinessError) => { 2021 console.info('ObtainDistributedTableName failed, err: ' + err) 2022}) 2023``` 2024 2025### sync<sup>8+</sup> 2026 2027sync(mode: SyncMode, predicates: RdbPredicates, callback: AsyncCallback<Array<[string, number]>>): void 2028 2029在设备之间同步数据, 使用callback异步回调。 2030 2031**需要权限：** ohos.permission.DISTRIBUTED_DATASYNC 2032 2033**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 2034 2035**参数：** 2036 2037| 参数名 | 类型 | 必填 | 说明 | 2038| -------- | -------- | -------- | -------- | 2039| mode | [SyncMode](#syncmode8) | 是 | 指同步模式。该值可以是推、拉。 | 2040| predicates | [RdbPredicates](#rdbpredicates) | 是 | 约束同步数据和设备。 | 2041| callback | AsyncCallback<Array<[string, number]>> | 是 | 指定的callback回调函数，用于向调用者发送同步结果。string：设备ID；number：每个设备同步状态，0表示成功，其他值表示失败。| 2042 2043**示例：** 2044 2045```ts 2046import deviceManager from '@ohos.distributedHardware.deviceManager'; 2047 2048let dmInstance: Array<string>; 2049 2050deviceManager.createDeviceManager("com.example.appdatamgrverify", (err: BusinessError, manager: void) => { 2051 if (err) { 2052 console.log("create device manager failed, err=" + err); 2053 return; 2054 } 2055 dmInstance = manager; 2056 let devices: Array<string> = dmInstance.getTrustedDeviceListSync(); 2057 for (let i = 0; i < devices.length; i++) { 2058 let deviceIds: Array<string> = devices[i].deviceId; 2059 } 2060}) 2061 2062let predicates = new data_rdb.RdbPredicates('EMPLOYEE') 2063predicates.inDevices(deviceIds) 2064rdbStore.sync(data_rdb.SyncMode.SYNC_MODE_PUSH, predicates, (err: BusinessError, result: void) { 2065 if (err) { 2066 console.log('Sync failed, err: ' + err) 2067 return 2068 } 2069 console.log('Sync done.') 2070 for (let i = 0; i < result.length; i++) { 2071 console.log('device=' + result[i][0] + ' status=' + result[i][1]) 2072 } 2073}) 2074``` 2075 2076### sync<sup>8+</sup> 2077 2078 sync(mode: SyncMode, predicates: RdbPredicates): Promise<Array<[string, number]>> 2079 2080在设备之间同步数据，使用Promise异步回调。 2081 2082**需要权限：** ohos.permission.DISTRIBUTED_DATASYNC 2083 2084**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 2085 2086**参数：** 2087 2088| 参数名 | 类型 | 必填 | 说明 | 2089| -------- | -------- | -------- | -------- | 2090| mode | [SyncMode](#syncmode8) | 是 | 指同步模式。该值可以是推、拉。 | 2091| predicates | [RdbPredicates](#rdbpredicates) | 是 | 约束同步数据和设备。 | 2092 2093**返回值**： 2094 2095| 类型 | 说明 | 2096| -------- | -------- | 2097| Promise<Array<[string, number]>> | Promise对象，用于向调用者发送同步结果。string：设备ID；number：每个设备同步状态，0表示成功，其他值表示失败。 | 2098 2099**示例：** 2100 2101```ts 2102import deviceManager from '@ohos.distributedHardware.deviceManager'; 2103 2104let dmInstance: Array<string>; 2105 2106deviceManager.createDeviceManager("com.example.appdatamgrverify", (err: BusinessError, manager: void) => { 2107 if (err) { 2108 console.log("create device manager failed, err=" + err); 2109 return; 2110 } 2111 dmInstance = manager; 2112 let devices: Array<string> = dmInstance.getTrustedDeviceListSync(); 2113 for (let i = 0; i < devices.length; i++) { 2114 let deviceIds: Array<string> = devices[i].deviceId; 2115 } 2116}) 2117 2118let predicates = new data_rdb.RdbPredicates('EMPLOYEE') 2119predicates.inDevices(deviceIds) 2120let promise: void = rdbStore.sync(data_rdb.SyncMode.SYNC_MODE_PUSH, predicates) 2121promise.then((result: void) =>{ 2122 console.log('Sync done.') 2123 for (let i = 0; i < result.length; i++) { 2124 console.log('device=' + result[i][0] + ' status=' + result[i][1]) 2125 } 2126}).catch((err: BusinessError) => { 2127 console.log('Sync failed') 2128}) 2129``` 2130 2131### on('dataChange')<sup>8+</sup> 2132 2133on(event: 'dataChange', type: SubscribeType, observer: Callback<Array<string>>): void 2134 2135注册数据库的观察者。当分布式数据库中的数据发生更改时，将调用回调。 2136 2137**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 2138 2139**参数：** 2140 2141| 参数名 | 类型 | 必填 | 说明 | 2142| -------- | -------- | -------- | -------- | 2143| event | string | 是 | 取值为'dataChange'，表示数据更改。 | 2144| type | [SubscribeType](#subscribetype8) | 是 | 订阅类型。 | 2145| observer | Callback<Array<string>> | 是 | 指分布式数据库中数据更改事件的观察者。Array<string>为数据库中的数据发生改变的对端设备ID。 | 2146 2147**示例：** 2148 2149```ts 2150let devices: Array<string>; 2151 2152try { 2153 rdbStore.on('dataChange', data_rdb.SubscribeType.SUBSCRIBE_TYPE_REMOTE, (storeObserver: Array<string>) => { 2154 for (let i = 0; i < devices.length; i++) { 2155 console.log('device=' + devices[i] + ' data changed') 2156 } 2157 }) 2158} catch (err) { 2159 console.log('Register observer failed') 2160} 2161``` 2162 2163### off('dataChange')<sup>8+</sup> 2164 2165off(event:'dataChange', type: SubscribeType, observer: Callback<Array<string>>): void 2166 2167从数据库中删除指定类型的指定观察者, 使用callback异步回调。 2168 2169**系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core 2170 2171**参数：** 2172 2173| 参数名 | 类型 | 必填 | 说明 | 2174| -------- | -------- | -------- | -------- | 2175| event | string | 是 | 取值为'dataChange'，表示数据更改。 | 2176| type | [SubscribeType](#subscribetype8) | 是 | 订阅类型。 | 2177| observer | Callback<Array<string>> | 是 | 指已注册的数据更改观察者。Array<string>为数据库中的数据发生改变的对端设备ID。 | 2178 2179**示例：** 2180 2181```ts 2182let devices: Array<string>; 2183 2184try { 2185 rdbStore.off('dataChange', data_rdb.SubscribeType.SUBSCRIBE_TYPE_REMOTE, (storeObserver: Array<string>) => { 2186 for (let i = 0; i < devices.length; i++) { 2187 console.log('device=' + devices[i] + ' data changed') 2188 } 2189 }) 2190} catch (err) { 2191 console.log('Unregister observer failed') 2192} 2193``` 2194