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