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