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