1# 分布式数据管理 2 3分布式数据管理为应用程序提供不同设备间数据库的分布式协同能力。通过调用分布式数据各个接口，应用程序可将数据保存到分布式数据库中，并可对分布式数据库中的数据进行增加、删除、修改、查询、同步等操作。 4 5该模块提供以下分布式数据管理相关的常用功能： 6 7- [KVManager](#kvmanager)：数据管理实例，用于获取KVStore的相关信息。 8- [KvStoreResultSet<sup>8+</sup>](#kvstoreresultset8)：提供获取KVStore数据库结果集的相关方法，包括查询和移动数据读取位置等。 9- [Query<sup>8+</sup>](#query8)：使用谓词表示数据库查询，提供创建Query实例、查询数据库中的数据和添加谓词的方法。 10- [KVStore](#kvstore)：KVStore数据库实例，提供增加数据、删除数据和订阅数据变更、订阅数据同步完成的方法。 11- [SingleKVStore](#singlekvstore)：单版本分布式数据库，继承自[KVStore](#kvstore)，不对数据所属设备进行区分，提供查询数据和同步数据的方法。 12- [DeviceKVStore<sup>8+</sup>](#devicekvstore8)：设备协同数据库，继承自[KVStore](#kvstore)，以设备维度对数据进行区分，提供查询数据和同步数据的方法。 13 14>**说明：** 15> 16>本模块首批接口从API version 7开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。 17 18 19## 导入模块 20 21```js 22import distributedData from '@ohos.data.distributedData'; 23``` 24 25 26## distributedData.createKVManager 27 28createKVManager(config: KVManagerConfig, callback: AsyncCallback<KVManager>): void 29 30创建一个KVManager对象实例，用于管理数据库对象，使用callback异步回调。 31 32**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 33 34**参数：** 35 36| 参数名 | 参数类型 | 必填 | 说明 | 37| ----- | ------ | ------ | ------ | 38| config | [KVManagerConfig](#kvmanagerconfig) | 是 | 提供KVManager实例的配置信息，包括调用方的包名和用户信息。 | 39| callback | AsyncCallback<[KVManager](#kvmanager)> | 是 | 回调函数。返回创建的KVManager对象实例。 | 40 41**示例：** 42```js 43let kvManager; 44try { 45 const kvManagerConfig = { 46 bundleName : 'com.example.datamanagertest', 47 userInfo : { 48 userId : '0', 49 userType : distributedData.UserType.SAME_USER_ID 50 } 51 } 52 distributedData.createKVManager(kvManagerConfig, function (err, manager) { 53 if (err) { 54 console.log("createKVManager err: " + JSON.stringify(err)); 55 return; 56 } 57 console.log("createKVManager success"); 58 kvManager = manager; 59 }); 60} catch (e) { 61 console.log("An unexpected error occurred. Error:" + e); 62} 63``` 64 65## distributedData.createKVManager 66 67createKVManager(config: KVManagerConfig): Promise<KVManager> 68 69创建一个KVManager对象实例，用于管理数据库对象，使用Promise异步回调。 70 71**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 72 73**参数：** 74 75| 参数名 | 参数类型 | 必填 | 说明 | 76| ----- | ------ | ------ | ------ | 77| config |[KVManagerConfig](#kvmanager) | 是 | 提供KVManager实例的配置信息，包括调用方的包名和用户信息。 | 78 79**返回值：** 80 81| 类型 | 说明 | 82| -------- | -------- | 83| Promise<[KVManager](#kvmanager)> | Promise对象。返回创建的KVManager对象实例。 | 84 85**示例：** 86 87```js 88let kvManager; 89try { 90 const kvManagerConfig = { 91 bundleName : 'com.example.datamanagertest', 92 userInfo : { 93 userId : '0', 94 userType : distributedData.UserType.SAME_USER_ID 95 } 96 } 97 distributedData.createKVManager(kvManagerConfig).then((manager) => { 98 console.log("createKVManager success"); 99 kvManager = manager; 100 }).catch((err) => { 101 console.log("createKVManager err: " + JSON.stringify(err)); 102 }); 103} catch (e) { 104 console.log("An unexpected error occurred. Error:" + e); 105} 106``` 107 108## KVManagerConfig 109 110提供KVManager实例的配置信息，包括调用方的包名和用户信息。 111 112**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 113 114| 参数名 | 参数类型 | 必填 | 说明 | 115| ----- | ------ | ------ | ------ | 116| userInfo | [UserInfo](#userinfo) | 是 | 调用方的用户信息。 | 117| bundleName | string | 是 | 调用方的包名。 | 118 119## UserInfo 120 121用户信息。 122 123**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 124 125| 名称 | 参数类型 | 必填 | 说明 | 126| ----- | ------ | ------ | ------ | 127| userId | string | 是 | 指示要设置的用户ID。 | 128| userType | [UserType](#usertype) | 是 | 指示要设置的用户类型。 | 129 130 131## UserType 132 133用户类型枚举。 134 135**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 136 137| 名称 | 值 | 说明 | 138| ----- | ------ | ------ | 139| SAME_USER_ID | 0 | 使用同一帐户登录不同设备的用户。 | 140 141 142## KVManager 143 144数据管理实例，用于获取KVStore的相关信息。在调用KVManager的方法前，需要先通过[createKVManager](#distributeddatacreatekvmanager)构建一个KVManager实例。 145 146### getKVStore 147 148getKVStore<T extends KVStore>(storeId: string, options: Options, callback: AsyncCallback<T>): void 149 150通过指定Options和storeId，创建并获取KVStore数据库，使用callback异步回调。 151 152**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 153 154**参数：** 155 156| 参数名 | 参数类型 | 必填 | 说明 | 157| ----- | ------ | ------ | ------ | 158| storeId | string | 是 | 数据库唯一标识符，长度不大于[MAX_STORE_ID_LENGTH](#constants)。 | 159| options | [Options](#options) | 是 | 创建KVStore实例的配置信息。 | 160| callback | AsyncCallback<T>，<T extends [KVStore](#kvstore)> | 是 | 回调函数。返回创建的KVStore数据库实例。 | 161 162**示例：** 163 164```js 165let kvStore; 166let kvManager; 167try { 168 const options = { 169 createIfMissing : true, 170 encrypt : false, 171 backup : false, 172 autoSync : true, 173 kvStoreType : distributedData.KVStoreType.SINGLE_VERSION, 174 securityLevel : distributedData.SecurityLevel.S2, 175 }; 176 kvManager.getKVStore('storeId', options, function (err, store) { 177 if (err) { 178 console.log("getKVStore err: " + JSON.stringify(err)); 179 return; 180 } 181 console.log("getKVStore success"); 182 kvStore = store; 183 }); 184} catch (e) { 185 console.log("An unexpected error occurred. Error:" + e); 186} 187``` 188 189 190### getKVStore 191 192getKVStore<T extends KVStore>(storeId: string, options: Options): Promise<T> 193 194通过指定Options和storeId，创建并获取KVStore数据库，使用Promise异步回调。 195 196**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 197 198**参数：** 199 200| 参数名 | 参数类型 | 必填 | 说明 | 201| ------- | ---------------------- | ---- | -------------------- | 202| storeId | string | 是 | 数据库唯一标识符，长度不大于[MAX_STORE_ID_LENGTH](#constants)。 | 203| options | [Options](#options) | 是 | 创建KVStore实例的配置信息。| 204 205 206**返回值：** 207 208| 类型 | 说明 | 209| -------------------------------------- | ------------------------ | 210| Promise<T> ，<T extends [KVStore](#kvstore)> | Promise对象。返回创建的KVStore数据库实例。 | 211 212**示例：** 213 214```js 215let kvStore; 216let kvManager; 217try { 218 const options = { 219 createIfMissing : true, 220 encrypt : false, 221 backup : false, 222 autoSync : true, 223 kvStoreType : distributedData.KVStoreType.SINGLE_VERSION, 224 securityLevel : distributedData.SecurityLevel.S2, 225 }; 226 kvManager.getKVStore('storeId', options).then((store) => { 227 console.log("getKVStore success"); 228 kvStore = store; 229 }).catch((err) => { 230 console.log("getKVStore err: " + JSON.stringify(err)); 231 }); 232} catch (e) { 233 console.log("An unexpected error occurred. Error:" + e); 234} 235``` 236 237### closeKVStore<sup>8+</sup> ### 238 239closeKVStore(appId: string, storeId: string, kvStore: KVStore, callback: AsyncCallback<void>): void 240 241通过storeId的值关闭指定的KVStore数据库，使用callback异步回调。 242 243**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 244 245**参数：** 246 247 248| 参数名 | 参数类型 | 必填 | 说明 | 249| ------- | ----------------- | ---- | --------------------------- | 250| appId | string | 是 | 所调用数据库方的包名。 | 251| storeId | string | 是 | 要关闭的数据库唯一标识符，长度不大于[MAX_STORE_ID_LENGTH](#constants)。 | 252| kvStore | [KVStore](#kvstore) | 是 | 要关闭的KVStore数据库。 | 253| callback | AsyncCallback<void> | 是 | 回调函数。 | 254 255**示例：** 256 257```js 258let kvStore; 259let kvManager; 260const options = { 261 createIfMissing : true, 262 encrypt : false, 263 backup : false, 264 autoSync : true, 265 kvStoreType : distributedData.KVStoreType.SINGLE_VERSION, 266 schema : '', 267 securityLevel : distributedData.SecurityLevel.S2, 268 } 269 try { 270 kvManager.getKVStore('storeId', options, async function (err, store) { 271 console.log('getKVStore success'); 272 kvStore = store; 273 kvManager.closeKVStore('appId', 'storeId', kvStore, function (err, data) { 274 console.log('closeKVStore success'); 275 }); 276 }); 277} catch (e) { 278 console.log('closeKVStore e ' + e); 279} 280``` 281 282 283### closeKVStore<sup>8+</sup> ### 284 285closeKVStore(appId: string, storeId: string, kvStore: KVStore): Promise<void> 286 287通过storeId的值关闭指定的KVStore数据库，使用Promise异步回调。 288 289**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 290 291**参数：** 292 293| 参数名 | 参数类型 | 必填 | 说明 | 294| ----- | ------ | ---- | ----------------------------- | 295| appId | string | 是 | 所调用数据库方的包名。 | 296| storeId | string | 是 | 要关闭的数据库唯一标识符，长度不大于[MAX_STORE_ID_LENGTH](#constants)。 | 297| kvStore | [KVStore](#kvstore) | 是 | 要关闭的KVStore数据库。 | 298 299**返回值：** 300 301| 类型 | 说明 | 302| ------------- | -------------- | 303| Promise\<void> | 无返回结果的Promise对象。 | 304 305**示例：** 306 307```js 308let kvManager; 309let kvStore; 310const options = { 311 createIfMissing : true, 312 encrypt : false, 313 backup : false, 314 autoSync : true, 315 kvStoreType : distributedData.KVStoreType.SINGLE_VERSION, 316 schema : '', 317 securityLevel : distributedData.SecurityLevel.S2, 318} 319 try { 320 kvManager.getKVStore('storeId', options).then(async (store) => { 321 console.log('getKVStore success'); 322 kvStore = store; 323 kvManager.closeKVStore('appId', 'storeId', kvStore).then(() => { 324 console.log('closeKVStore success'); 325 }).catch((err) => { 326 console.log('closeKVStore err ' + JSON.stringify(err)); 327 }); 328 }).catch((err) => { 329 console.log('CloseKVStore getKVStore err ' + JSON.stringify(err)); 330 }); 331 } catch (e) { 332 console.log('closeKVStore e ' + e); 333} 334``` 335 336 337### deleteKVStore<sup>8+</sup> ### 338 339deleteKVStore(appId: string, storeId: string, callback: AsyncCallback<void>): void 340 341通过storeId的值删除指定的KVStore数据库，使用callback异步回调。 342 343**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 344 345**参数：** 346 347| 参数名 | 参数类型 | 必填 | 说明 | 348| ----- | ------ | ---- | ----------------------- | 349| appId | string | 是 | 所调用数据库方的包名。 | 350| storeId | string | 是 | 要删除的数据库唯一标识符，长度不大于[MAX_STORE_ID_LENGTH](#constants)。 | 351| callback | AsyncCallback<void> | 是 | 回调函数。 | 352 353**示例：** 354 355```js 356let kvManager; 357let kvStore; 358const options = { 359 createIfMissing : true, 360 encrypt : false, 361 backup : false, 362 autoSync : true, 363 kvStoreType : distributedData.KVStoreType.SINGLE_VERSION, 364 schema : '', 365 securityLevel : distributedData.SecurityLevel.S2, 366} 367try { 368 kvManager.getKVStore('store', options, async function (err, store) { 369 console.log('getKVStore success'); 370 kvStore = store; 371 kvManager.deleteKVStore('appId', 'storeId', function (err, data) { 372 console.log('deleteKVStore success'); 373 }); 374 }); 375} catch (e) { 376 console.log('DeleteKVStore e ' + e); 377} 378``` 379 380### deleteKVStore<sup>8+</sup> ### 381 382deleteKVStore(appId: string, storeId: string): Promise<void> 383 384通过storeId的值删除指定的KVStore数据库，使用Promise异步回调。 385 386**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 387 388**参数：** 389 390| 参数名 | 参数类型 | 必填 | 说明 | 391| ----- | ------ | ---- | ----------------------- | 392| appId | string | 是 | 所调用数据库方的包名。 | 393| storeId | string | 是 | 要删除的数据库唯一标识符，长度不大于[MAX_STORE_ID_LENGTH](#constants)。 | 394 395 396**返回值：** 397 398| 类型 | 说明 | 399| ------------- | -------------- | 400| Promise<void> | 无返回结果的Promise对象。 | 401 402**示例：** 403 404```js 405let kvManager; 406let kvStore; 407const options = { 408 createIfMissing : true, 409 encrypt : false, 410 backup : false, 411 autoSync : true, 412 kvStoreType : distributedData.KVStoreType.SINGLE_VERSION, 413 schema : '', 414 securityLevel : distributedData.SecurityLevel.S2, 415} 416try { 417 kvManager.getKVStore('storeId', options).then(async (store) => { 418 console.log('getKVStore success'); 419 kvStore = store; 420 kvManager.deleteKVStore('appId', 'storeId').then(() => { 421 console.log('deleteKVStore success'); 422 }).catch((err) => { 423 console.log('deleteKVStore err ' + JSON.stringify(err)); 424 }); 425 }).catch((err) => { 426 console.log('getKVStore err ' + JSON.stringify(err)); 427 }); 428} catch (e) { 429 console.log('deleteKVStore e ' + e); 430} 431``` 432 433 434### getAllKVStoreId<sup>8+</sup> ### 435 436getAllKVStoreId(appId: string, callback: AsyncCallback<string[]>): void 437 438获取所有通过[getKVStore](#getkvstore)方法创建的且没有调用[deleteKVStore](#deletekvstore8)方法删除的KVStore数据库的storeId，使用callback异步回调。 439 440**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 441 442**参数：** 443 444| 参数名 | 参数类型 | 必填 | 说明 | 445| ----- | ------ | ---- | ----------------------- | 446| appId | string | 是 | 所调用数据库方的包名。 | 447| callback | AsyncCallback<string[]> | 是 |回调函数。返回所有创建的KvStore数据库的storeId。 | 448 449**示例：** 450 451```js 452let kvManager; 453try { 454 kvManager.getAllKVStoreId('appId', function (err, data) { 455 console.log('GetAllKVStoreId success'); 456 console.log('GetAllKVStoreId size = ' + data.length); 457 }); 458} catch (e) { 459 console.log('GetAllKVStoreId e ' + e); 460} 461``` 462 463 464### getAllKVStoreId<sup>8+</sup> ### 465 466getAllKVStoreId(appId: string): Promise<string[]> 467 468获取所有通过[getKVStore](#getkvstore)方法创建的且没有调用[deleteKVStore](#deletekvstore8)方法删除的KVStore数据库的storeId，使用Promise异步回调。 469 470**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 471 472**参数：** 473 474| 参数名 | 参数类型 | 必填 | 说明 | 475| ----- | ------ | ---- | ----------------------- | 476| appId | string | 是 | 所调用数据库方的包名。 | 477 478 479**返回值：** 480 481| 类型 | 说明 | 482| ------------- | -------------- | 483| Promise<string[]>| Promise对象。返回所有创建的KvStore数据库的storeId。 | 484 485**示例：** 486 487```js 488let kvManager; 489try { 490 console.log('GetAllKVStoreId'); 491 kvManager.getAllKVStoreId('appId').then((data) => { 492 console.log('getAllKVStoreId success'); 493 console.log('size = ' + data.length); 494 }).catch((err) => { 495 console.log('getAllKVStoreId err ' + JSON.stringify(err)); 496 }); 497} catch(e) { 498 console.log('getAllKVStoreId e ' + e); 499} 500``` 501 502 503### on('distributedDataServiceDie')<sup>8+</sup> ### 504 505on(event: 'distributedDataServiceDie', deathCallback: Callback<void>): void 506 507订阅服务状态变更通知。 508 509**系统能力：** SystemCapability.DistributedDataManager.KVStore.DistributedKVStore。 510 511**参数：** 512 513| 参数名 | 参数类型 | 必填 | 说明 | 514| ----- | ------ | ---- | ----------------------- | 515| event | string | 是 | 订阅的事件名，固定为'distributedDataServiceDie'，即服务状态变更事件。 | 516| deathCallback | Callback<void> | 是 | 回调函数。 | 517 518**示例：** 519 520```js 521let kvManager; 522try { 523 524 console.log('KVManagerOn'); 525 const deathCallback = function () { 526 console.log('death callback call'); 527 } 528 kvManager.on('distributedDataServiceDie', deathCallback); 529} catch (e) { 530 console.log("An unexpected error occurred. Error:" + e); 531} 532``` 533 534 535### off('distributedDataServiceDie')<sup>8+</sup> ### 536 537off(event: 'distributedDataServiceDie', deathCallback?: Callback<void>): void 538 539取消订阅服务状态变更通知。 540 541**系统能力：** SystemCapability.DistributedDataManager.KVStore.DistributedKVStore。 542 543**参数：** 544 545| 参数名 | 参数类型 | 必填 | 说明 | 546| ----- | ------ | ---- | ----------------------- | 547| event | string | 是 | 取消订阅的事件名，固定为'distributedDataServiceDie'，即服务状态变更事件。 | 548| deathCallback | Callback<void> | 否 | 回调函数。 | 549 550 551**示例：** 552 553```js 554let kvManager; 555try { 556 console.log('KVManagerOff'); 557 const deathCallback = function () { 558 console.log('death callback call'); 559 } 560 kvManager.off('distributedDataServiceDie', deathCallback); 561} catch (e) { 562 console.log("An unexpected error occurred. Error:" + e); 563} 564 565``` 566 567## Options 568 569用于提供创建数据库的配置信息。 570 571 572| 参数名 | 参数类型 | 必填 | 说明 | 573| ----- | ------ | ---- | ----------------------- | 574| createIfMissing | boolean | 否 | 当数据库文件不存在时是否创建数据库，默认创建。 <br>**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core | 575| encrypt | boolean | 否 |设置数据库文件是否加密，默认不加密。<br>**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core | 576| backup | boolean | 否 |设置数据库文件是否备份，默认备份。<br>**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core | 577| autoSync | boolean | 否 |设置数据库文件是否自动同步，默认不自动同步。<br>**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core<br>**需要权限**： ohos.permission.DISTRIBUTED_DATASYNC | 578| kvStoreType | [KVStoreType](#kvstoretype) | 否 |设置要创建的数据库类型，默认为多设备协同数据库。<br>**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core | 579| securityLevel | [SecurityLevel](#securitylevel) | 否 |设置数据库安全级别，默认不设置安全级别。<br>**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core | 580| schema<sup>8+</sup> | [Schema](#schema8) | 否 | 设置定义存储在数据库中的值。<br>**系统能力：** SystemCapability.DistributedDataManager.KVStore.DistributedKVStore | 581 582 583## KVStoreType 584 585KVStore数据库类型枚举。 586 587 588| 名称 | 值 | 说明 | 589| --- | ---- | ----------------------- | 590| DEVICE_COLLABORATION | 0 | 表示多设备协同数据库。<br>**系统能力：** SystemCapability.DistributedDataManager.KVStore.DistributedKVStore | 591| SINGLE_VERSION | 1 | 表示单版本数据库。 <br>**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core | 592| MULTI_VERSION | 2 | 表示多版本数据库。此类型当前不允许使用。 <br>**系统能力：** SystemCapability.DistributedDataManager.KVStore.DistributedKVStore | 593 594 595## SecurityLevel 596 597数据库的安全级别枚举。 598 599 600| 名称 | 值 | 说明 | 601| --- | ---- | ----------------------- | 602| NO_LEVEL | 0 | 表示数据库不设置安全级别。<br>**系统能力：** SystemCapability.DistributedDataManager.KVStore.DistributedKVStore | 603| S0 | 1 | 表示数据库的安全级别为公共级别。<br>**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core | 604| S1 | 2 | 表示数据库的安全级别为低级别，当数据泄露时会产生较低影响。例如，包含壁纸等系统数据的数据库。<br>**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core | 605| S2 | 3 | 表示数据库的安全级别为中级别，当数据泄露时会产生较大影响。例如，包含录音、视频等用户生成数据或通话记录等信息的数据库。<br>**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core | 606| S3 | 5 | 表示数据库的安全级别为高级别，当数据泄露时会产生重大影响。例如，包含用户运动、健康、位置等信息的数据库。<br>**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core | 607| S4 | 6 | 表示数据库的安全级别为关键级别，当数据泄露时会产生严重影响。例如，包含认证凭据、财务数据等信息的数据库。<br>**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core | 608 609 610## Constants 611 612KVStore常量。 613 614**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 615 616| 名称 | 值 | 说明 | 617| --- | ---- | ----------------------- | 618| MAX_KEY_LENGTH | 1024 | 数据库中Key允许的最大长度，单位字节。 | 619| MAX_VALUE_LENGTH | 4194303 | 数据库中Value允许的最大长度，单位字节。 | 620| MAX_KEY_LENGTH_DEVICE | 896 | 最大设备密钥长度，单位字节。 | 621| MAX_STORE_ID_LENGTH | 128 | 数据库标识符允许的最大长度，单位字节。 | 622| MAX_QUERY_LENGTH | 512000 | 最大查询长度，单位字节。 | 623| MAX_BATCH_SIZE | 128 | 最大批处理操作数量。 | 624 625## Schema<sup>8+</sup> ## 626 627表示数据库模式，可以在创建或打开数据库时创建Schema对象并将它们放入[Options](#options)中。 628 629**系统能力：** SystemCapability.DistributedDataManager.KVStore.DistributedKVStore。 630 631| 名称 | 类型 | 说明 | 632| --- | ---- | ----------------------- | 633| root<sup>8+</sup> | [FieldNode](#fieldnode8) | 表示json根对象。 | 634| indexes<sup>8+</sup> | Array\<string> | 表示json类型的字符串数组。 | 635| mode<sup>8+</sup> | number | 表示Schema的模式。 | 636| skip<sup>8+</sup> | number | Schema的跳跃大小。 | 637 638### constructor<sup>8+</sup> ### 639 640constructor() 641 642用于创建Schema实例的构造函数。 643 644**系统能力：** SystemCapability.DistributedDataManager.KVStore.DistributedKVStore。 645 646## FieldNode<sup>8+</sup> ## 647 648表示 Schema 实例的节点，提供定义存储在数据库中的值的方法。 649 650**系统能力：** SystemCapability.DistributedDataManager.KVStore.DistributedKVStore。 651 652| 名称 | 类型 | 说明 | 653| --- | ---- | ----------------------- | 654| nullable<sup>8+</sup> | boolean | 表示数据库字段是否可以为空。 | 655| default<sup>8+</sup> | string | 表示Fieldnode的默认值。 | 656| type<sup>8+</sup> | number | 表示指定节点对应数据类型的值。 | 657 658### constructor<sup>8+</sup> ### 659 660constructor(name: string) 661 662用于创建带有string字段FieldNode实例的构造函数。 663 664**系统能力：** SystemCapability.DistributedDataManager.KVStore.DistributedKVStore。 665 666**参数：** 667 668| 参数名 | 参数类型 | 必填 | 说明 | 669| ------ | -------- | ---- | --------------- | 670| name | string | 是 | FieldNode的值。 | 671 672### appendChild<sup>8+</sup> ### 673 674appendChild(child: FieldNode): boolean 675 676在当前 FieldNode 中添加一个子节点。 677 678**系统能力：** SystemCapability.DistributedDataManager.KVStore.DistributedKVStore。 679 680**参数：** 681 682| 参数名 | 参数类型 | 必填 | 说明 | 683| ----- | ------ | ---- | ----------------------- | 684| child | [FieldNode](#fieldnode8) | 是 | 要附加的域节点。 | 685 686**返回值：** 687 688| 类型 | 说明 | 689| ------------- | -------------- | 690| boolean |返回true表示子节点成功添加到FieldNode；返回false则表示操作失败。 | 691 692**示例：** 693 694```js 695import ddm from '@ohos.data.distributedData'; 696try { 697 let node = new ddm.FieldNode("root"); 698 let child1 = new ddm.FieldNode("child1"); 699 let child2 = new ddm.FieldNode("child2"); 700 let child3 = new ddm.FieldNode("child3"); 701 node.appendChild(child1); 702 node.appendChild(child2); 703 node.appendChild(child3); 704 console.log("appendNode " + JSON.stringify(node)); 705 child1 = null; 706 child2 = null; 707 child3 = null; 708 node = null; 709} catch (e) { 710 console.log("AppendChild " + e); 711} 712``` 713 714 715## KvStoreResultSet<sup>8+</sup> ## 716 717提供获取KVStore数据库结果集的相关方法，包括查询和移动数据读取位置等。 718 719在调用KvStoreResultSet的方法前，需要先通过[getKVStore](#getkvstore)构建一个KVStore实例。 720 721 722### getCount<sup>8+</sup> ### 723 724getCount(): number 725 726获取结果集中的总行数。 727 728**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 729 730**返回值：** 731 732| 类型 | 说明 | 733| ------ | -------------- | 734| number |返回数据的总行数。 | 735 736**示例：** 737 738```js 739let kvStore; 740try { 741 let resultSet; 742 kvStore.getResultSet('batch_test_string_key').then((result) => { 743 console.log('getResultSet succeed.'); 744 resultSet = result; 745 }).catch((err) => { 746 console.log('getResultSet failed: ' + err); 747 }); 748 const count = resultSet.getCount(); 749 console.log("getCount succeed:" + count); 750} catch (e) { 751 console.log("getCount failed: " + e); 752} 753``` 754 755### getPosition<sup>8+</sup> ### 756 757getPosition(): number 758 759获取结果集中当前的读取位置。 760 761**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 762 763**返回值：** 764 765| 类型 | 说明 | 766| ------ | -------------- | 767| number |返回当前读取位置。 | 768 769**示例：** 770 771```js 772let kvStore; 773try { 774 let resultSet; 775 kvStore.getResultSet('batch_test_string_key').then((result) => { 776 console.log('getResultSet succeeded.'); 777 resultSet = result; 778 }).catch((err) => { 779 console.log('getResultSet failed: ' + err); 780 }); 781 const position = resultSet.getPosition(); 782 console.log("getPosition succeed:" + position); 783} catch (e) { 784 console.log("getPosition failed: " + e); 785} 786``` 787 788 789### moveToFirst<sup>8+</sup> ### 790 791moveToFirst(): boolean 792 793将读取位置移动到第一行。如果结果集为空，则返回false。 794 795**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 796 797**返回值：** 798 799| 类型 | 说明 | 800| ------ | -------------- | 801| boolean |返回true表示操作成功；返回false则表示操作失败。 | 802 803**示例：** 804 805```js 806let kvStore; 807try { 808 let resultSet; 809 kvStore.getResultSet('batch_test_string_key').then((result) => { 810 console.log('getResultSet succeed.'); 811 resultSet = result; 812 }).catch((err) => { 813 console.log('getResultSet failed: ' + err); 814 }); 815 const moved1 = resultSet.moveToFirst(); 816 console.log("moveToFirst succeed: " + moved1); 817} catch (e) { 818 console.log("moveToFirst failed " + e); 819} 820``` 821 822 823### moveToLast<sup>8+</sup> ### 824 825moveToLast(): boolean 826 827将读取位置移动到最后一行。如果结果集为空，则返回false。 828 829**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 830 831**返回值：** 832 833| 类型 | 说明 | 834| ------ | -------------- | 835| boolean |返回true表示操作成功；返回false则表示操作失败。 | 836 837**示例：** 838 839```js 840let kvStore; 841try { 842 let resultSet; 843 kvStore.getResultSet('batch_test_string_key').then((result) => { 844 console.log('getResultSet succeed.'); 845 resultSet = result; 846 }).catch((err) => { 847 console.log('getResultSet failed: ' + err); 848 }); 849 const moved2 = resultSet.moveToLast(); 850 console.log("moveToLast succeed:" + moved2); 851} catch (e) { 852 console.log("moveToLast failed: " + e); 853} 854``` 855 856 857### moveToNext<sup>8+</sup> ### 858 859moveToNext(): boolean 860 861将读取位置移动到下一行。如果结果集为空，则返回false。 862 863**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 864 865**返回值：** 866 867| 类型 | 说明 | 868| ------ | -------------- | 869| boolean |返回true表示操作成功；返回false则表示操作失败。 | 870 871**示例：** 872 873```js 874let kvStore; 875try { 876 let resultSet; 877 kvStore.getResultSet('batch_test_string_key').then((result) => { 878 console.log('getResultSet succeed.'); 879 resultSet = result; 880 }).catch((err) => { 881 console.log('getResultSet failed: ' + err); 882 }); 883 const moved3 = resultSet.moveToNext(); 884 console.log("moveToNext succeed: " + moved3); 885} catch (e) { 886 console.log("moveToNext failed: " + e); 887} 888``` 889 890 891### moveToPrevious<sup>8+</sup> ### 892 893moveToPrevious(): boolean 894 895将读取位置移动到上一行。如果结果集为空，则返回false。 896 897**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 898 899**返回值：** 900 901| 类型 | 说明 | 902| ------ | -------------- | 903| boolean |返回true表示操作成功；返回false则表示操作失败。 | 904 905**示例：** 906 907```js 908let kvStore; 909try { 910 let resultSet; 911 kvStore.getResultSet('batch_test_string_key').then((result) => { 912 console.log('getResultSet succeed.'); 913 resultSet = result; 914 }).catch((err) => { 915 console.log('getResultSet failed: ' + err); 916 }); 917 const moved4 = resultSet.moveToPrevious(); 918 console.log("moveToPrevious succeed:" + moved4); 919} catch (e) { 920 console.log("moveToPrevious failed: " + e); 921} 922``` 923 924 925### move<sup>8+</sup> ### 926 927move(offset: number): boolean 928 929将读取位置移动到当前位置的相对偏移量。 930 931**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 932 933**参数：** 934 935| 参数名 | 参数类型 | 必填 | 说明 | 936| ----- | ------ | ---- | ----------------------- | 937| offset | number | 是 | 表示与当前位置的相对偏移量，负偏移表示向后移动，正偏移表示向前移动。 | 938 939**返回值：** 940 941| 类型 | 说明 | 942| ------ | -------------- | 943| boolean |返回true表示操作成功；返回false则表示操作失败。 | 944 945**示例：** 946 947```js 948let kvStore; 949try { 950 let resultSet; 951 kvStore.getResultSet('batch_test_string_key').then((result) => { 952 console.log('getResultSet succeed.'); 953 resultSet = result; 954 }).catch((err) => { 955 console.log('getResultSet failed: ' + err); 956 }); 957 const moved5 = resultSet.move(); 958 console.log("move succeed:" + moved5); 959} catch (e) { 960 console.log("move failed: " + e); 961} 962``` 963 964 965### moveToPosition<sup>8+</sup> ### 966 967moveToPosition(position: number): boolean 968 969将读取位置从 0 移动到绝对位置。 970 971**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 972 973**参数：** 974 975| 参数名 | 参数类型 | 必填 | 说明 | 976| ----- | ------ | ---- | ----------------------- | 977| position | number | 是 |表示绝对位置。 | 978 979**返回值：** 980 981| 类型 | 说明 | 982| ------ | -------------- | 983| boolean |返回true表示操作成功；返回false则表示操作失败。 | 984 985**示例：** 986 987```js 988let kvStore; 989try { 990 let resultSet; 991 kvStore.getResultSet('batch_test_string_key').then((result) => { 992 console.log('getResultSet succeed.'); 993 resultSet = result; 994 }).catch((err) => { 995 console.log('getResultSet failed: ' + err); 996 }); 997 const moved6 = resultSet.moveToPosition(); 998 console.log("moveToPosition succeed: " + moved6); 999} catch (e) { 1000 console.log("moveToPosition failed: " + e); 1001} 1002``` 1003 1004 1005### isFirst<sup>8+</sup> ### 1006 1007isFirst(): boolean 1008 1009检查读取位置是否为第一行。 1010 1011**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 1012 1013**返回值：** 1014 1015| 类型 | 说明 | 1016| ------ | -------------- | 1017| boolean |返回true表示读取位置为第一行；返回false表示读取位置不是第一行。 | 1018 1019**示例：** 1020 1021```js 1022let kvStore; 1023try { 1024 let resultSet; 1025 kvStore.getResultSet('batch_test_string_key').then((result) => { 1026 console.log('getResultSet succeed.'); 1027 resultSet = result; 1028 }).catch((err) => { 1029 console.log('getResultSet failed: ' + err); 1030 }); 1031 const isfirst = resultSet.isFirst(); 1032 console.log("Check isFirst succeed:" + isfirst); 1033} catch (e) { 1034 console.log("Check isFirst failed: " + e); 1035} 1036``` 1037 1038 1039### isLast<sup>8+</sup> ### 1040 1041isLast(): boolean 1042 1043检查读取位置是否为最后一行。 1044 1045**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 1046 1047**返回值：** 1048 1049| 类型 | 说明 | 1050| ------ | -------------- | 1051| boolean |返回true表示读取位置为最后一行；返回false表示读取位置不是最后一行。 | 1052 1053**示例：** 1054 1055```js 1056let kvStore; 1057try { 1058 let resultSet; 1059 kvStore.getResultSet('batch_test_string_key').then((result) => { 1060 console.log('getResultSet succeed.'); 1061 resultSet = result; 1062 }).catch((err) => { 1063 console.log('getResultSet failed: ' + err); 1064 }); 1065 const islast = resultSet.isLast(); 1066 console.log("Check isLast succeed: " + islast); 1067} catch (e) { 1068 console.log("Check isLast failed: " + e); 1069} 1070``` 1071 1072### isBeforeFirst<sup>8+</sup> ### 1073 1074isBeforeFirst(): boolean 1075 1076检查读取位置是否在第一行之前。 1077 1078**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 1079 1080**返回值：** 1081 1082| 类型 | 说明 | 1083| ------ | -------------- | 1084| boolean |返回true表示读取位置在第一行之前；返回false表示读取位置不在第一行之前。 | 1085 1086**示例：** 1087 1088```js 1089let kvStore; 1090try { 1091 let resultSet; 1092 kvStore.getResultSet('batch_test_string_key').then((result) => { 1093 console.log('getResultSet succeed.'); 1094 resultSet = result; 1095 }).catch((err) => { 1096 console.log('getResultSet failed: ' + err); 1097 }); 1098 const isbeforefirst = resultSet.isBeforeFirst(); 1099 console.log("Check isBeforeFirst succeed: " + isbeforefirst); 1100} catch (e) { 1101 console.log("Check isBeforeFirst failed: " + e); 1102} 1103``` 1104 1105 1106### isAfterLast<sup>8+</sup> ### 1107 1108isAfterLast(): boolean 1109 1110检查读取位置是否在最后一行之后。 1111 1112**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 1113 1114**返回值：** 1115 1116| 类型 | 说明 | 1117| ------ | -------------- | 1118| boolean |返回true表示读取位置在最后一行之后；返回false表示读取位置不在最后一行之后。 | 1119 1120**示例：** 1121 1122```js 1123let kvStore; 1124try { 1125 let resultSet; 1126 kvStore.getResultSet('batch_test_string_key').then((result) => { 1127 console.log('getResultSet succeed.'); 1128 resultSet = result; 1129 }).catch((err) => { 1130 console.log('getResultSet failed: ' + err); 1131 }); 1132 const isafterlast = resultSet.isAfterLast(); 1133 console.log("Check isAfterLast succeed:" + isafterlast); 1134} catch (e) { 1135 console.log("Check isAfterLast failed: " + e); 1136} 1137``` 1138 1139 1140### getEntry<sup>8+</sup> ### 1141 1142getEntry(): Entry 1143 1144从当前位置获取对应的键值对。 1145 1146**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 1147 1148**返回值：** 1149 1150| 类型 | 说明 | 1151| ------ | ------- | 1152| [Entry](#entry) |返回键值对。| 1153 1154**示例：** 1155 1156```js 1157let kvStore; 1158try { 1159 let resultSet; 1160 kvStore.getResultSet('batch_test_string_key').then((result) => { 1161 console.log('getResultSet succeed.'); 1162 resultSet = result; 1163 }).catch((err) => { 1164 console.log('getResultSet failed: ' + err); 1165 }); 1166 const entry = resultSet.getEntry(); 1167 console.log("getEntry succeed:" + JSON.stringify(entry)); 1168} catch (e) { 1169 console.log("getEntry failed: " + e); 1170} 1171``` 1172 1173 1174## Query<sup>8+</sup> ## 1175 1176使用谓词表示数据库查询，提供创建Query实例、查询数据库中的数据和添加谓词的方法。 1177 1178**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 1179 1180### constructor<sup>8+</sup> ### 1181 1182constructor() 1183 1184用于创建Schema实例的构造函数。 1185 1186**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 1187 1188 1189### reset<sup>8+</sup> ### 1190 1191reset(): Query 1192 1193重置Query对象。 1194 1195**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 1196 1197 1198**返回值：** 1199 1200| 类型 | 说明 | 1201| ------ | ------- | 1202| [Query](#query8) |返回重置的Query对象。| 1203 1204**示例：** 1205 1206```js 1207try { 1208 let query = new distributedData.Query(); 1209 query.equalTo("key", "value"); 1210 console.log("query is " + query.getSqlLike()); 1211 query.reset(); 1212 console.log("query is " + query.getSqlLike()); 1213 query = null; 1214} catch (e) { 1215 console.log("simply calls should be ok :" + e); 1216} 1217``` 1218 1219 1220### equalTo<sup>8+</sup> ### 1221 1222equalTo(field: string, value: number|string|boolean): Query 1223 1224构造一个Query对象来查询具有指定字段的条目，其值等于指定的值。 1225 1226**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 1227 1228**参数：** 1229 1230| 参数名 | 参数类型 | 必填 | 说明 | 1231| ----- | ------ | ---- | ----------------------- | 1232| fieId | string | 是 |表示指定字段，不能包含' ^ '。 | 1233| value | number\|string\|boolean | 是 | 表示指定的值。| 1234 1235**返回值：** 1236 1237| 类型 | 说明 | 1238| ------ | ------- | 1239| [Query](#query8) |返回Query对象。| 1240 1241**示例：** 1242 1243```js 1244try { 1245 let query = new distributedData.Query(); 1246 query.equalTo("field", "value"); 1247 console.log("query is " + query.getSqlLike()); 1248 query = null; 1249} catch (e) { 1250 console.log("duplicated calls should be ok :" + e); 1251} 1252``` 1253 1254 1255### notEqualTo<sup>8+</sup> ### 1256 1257notEqualTo(field: string, value: number|string|boolean): Query 1258 1259构造一个Query对象以查询具有指定字段且值不等于指定值的条目。 1260 1261**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 1262 1263**参数：** 1264 1265| 参数名 | 参数类型 | 必填 | 说明 | 1266| ----- | ------ | ---- | ----------------------- | 1267| fieId | string | 是 |表示指定字段，不能包含' ^ '。 | 1268| value | number\|string\|boolean | 是 | 表示指定的值。| 1269 1270**返回值：** 1271 1272| 类型 | 说明 | 1273| ------ | ------- | 1274| [Query](#query8) |返回Query对象。| 1275 1276**示例：** 1277 1278```js 1279try { 1280 let query = new distributedData.Query(); 1281 query.notEqualTo("field", "value"); 1282 console.log("query is " + query.getSqlLike()); 1283 query = null; 1284} catch (e) { 1285 console.log("duplicated calls should be ok :" + e); 1286} 1287``` 1288 1289 1290### greaterThan<sup>8+</sup> ### 1291 1292greaterThan(field: string, value: number|string|boolean): Query 1293 1294构造一个Query对象以查询具有大于指定值的指定字段的条目。 1295 1296**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 1297 1298**参数：** 1299 1300| 参数名 | 参数类型 | 必填 | 说明 | 1301| ----- | ------ | ---- | ----------------------- | 1302| fieId | string | 是 |表示指定字段，不能包含' ^ '。 | 1303| value | number\|string\|boolean | 是 | 表示指定的值。| 1304 1305**返回值：** 1306 1307| 类型 | 说明 | 1308| ------ | ------- | 1309| [Query](#query8) |返回Query对象。| 1310 1311**示例：** 1312 1313```js 1314try { 1315 let query = new distributedData.Query(); 1316 query.greaterThan("field", "value"); 1317 console.log("query is " + query.getSqlLike()); 1318 query = null; 1319} catch (e) { 1320 console.log("duplicated calls should be ok :" + e); 1321} 1322``` 1323 1324 1325### lessThan<sup>8+</sup> ### 1326 1327lessThan(field: string, value: number|string): Query 1328 1329构造一个Query对象以查询具有小于指定值的指定字段的条目。 1330 1331**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 1332 1333**参数：** 1334 1335| 参数名 | 参数类型 | 必填 | 说明 | 1336| ----- | ------ | ---- | ----------------------- | 1337| fieId | string | 是 |表示指定字段，不能包含' ^ '。 | 1338| value | number\|string\|boolean | 是 | 表示指定的值。| 1339 1340**返回值：** 1341 1342| 类型 | 说明 | 1343| ------ | ------- | 1344| [Query](#query8) |返回Query对象。| 1345 1346**示例：** 1347 1348```js 1349try { 1350 let query = new distributedData.Query(); 1351 query.lessThan("field", "value"); 1352 console.log("query is " + query.getSqlLike()); 1353 query = null; 1354} catch (e) { 1355 console.log("duplicated calls should be ok :" + e); 1356} 1357``` 1358 1359 1360### greaterThanOrEqualTo<sup>8+</sup> ### 1361 1362greaterThanOrEqualTo(field: string, value: number|string): Query 1363 1364构造一个Query对象以查询具有指定字段且值大于或等于指定值的条目。 1365 1366**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 1367 1368**参数：** 1369 1370| 参数名 | 参数类型 | 必填 | 说明 | 1371| ----- | ------ | ---- | ----------------------- | 1372| fieId | string | 是 |表示指定字段，不能包含' ^ '。 | 1373| value | number\|string\|boolean | 是 | 表示指定的值。| 1374 1375**返回值：** 1376 1377| 类型 | 说明 | 1378| ------ | ------- | 1379| [Query](#query8) |返回Query对象。| 1380 1381**示例：** 1382 1383```js 1384try { 1385 let query = new distributedData.Query(); 1386 query.greaterThanOrEqualTo("field", "value"); 1387 console.log("query is " + query.getSqlLike()); 1388 query = null; 1389} catch (e) { 1390 console.log("duplicated calls should be ok :" + e); 1391} 1392``` 1393 1394 1395### lessThanOrEqualTo<sup>8+</sup> ### 1396 1397lessThanOrEqualTo(field: string, value: number|string): Query 1398 1399构造一个Query对象以查询具有指定字段且值小于或等于指定值的条目。 1400 1401**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 1402 1403**参数：** 1404 1405| 参数名 | 参数类型 | 必填 | 说明 | 1406| ----- | ------ | ---- | ----------------------- | 1407| fieId | string | 是 |表示指定字段，不能包含' ^ '。 | 1408| value | number\|string\|boolean | 是 | 表示指定的值。| 1409 1410**返回值：** 1411 1412| 类型 | 说明 | 1413| ------ | ------- | 1414| [Query](#query8) |返回Query对象。| 1415 1416**示例：** 1417 1418```js 1419try { 1420 let query = new distributedData.Query(); 1421 query.lessThanOrEqualTo("field", "value"); 1422 console.log("query is " + query.getSqlLike()); 1423 query = null; 1424} catch (e) { 1425 console.log("duplicated calls should be ok :" + e); 1426} 1427``` 1428 1429 1430### isNull<sup>8+</sup> ### 1431 1432isNull(field: string): Query 1433 1434构造一个Query对象以查询具有值为null的指定字段的条目。 1435 1436**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 1437 1438**参数：** 1439 1440| 参数名 | 参数类型 | 必填 | 说明 | 1441| ----- | ------ | ---- | ----------------------- | 1442| fieId | string | 是 |表示指定字段，不能包含' ^ '。 | 1443 1444**返回值：** 1445 1446| 类型 | 说明 | 1447| ------ | ------- | 1448| [Query](#query8) |返回Query对象。| 1449 1450**示例：** 1451 1452```js 1453try { 1454 let query = new distributedData.Query(); 1455 query.isNull("field"); 1456 console.log("query is " + query.getSqlLike()); 1457 query = null; 1458} catch (e) { 1459 console.log("duplicated calls should be ok :" + e); 1460} 1461``` 1462 1463 1464### inNumber<sup>8+</sup> ### 1465 1466inNumber(field: string, valueList: number[]): Query 1467 1468构造一个Query对象以查询具有指定字段的条目，其值在指定的值列表中。 1469 1470 1471**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 1472 1473**参数：** 1474 1475| 参数名 | 参数类型 | 必填 | 说明 | 1476| ----- | ------ | ---- | ----------------------- | 1477| fieId | string | 是 |表示指定字段，不能包含' ^ '。 | 1478| valueList | number[] | 是 | 表示指定的值列表。| 1479 1480**返回值：** 1481 1482| 类型 | 说明 | 1483| ------ | ------- | 1484| [Query](#query8) |返回Query对象。| 1485 1486**示例：** 1487 1488```js 1489try { 1490 let query = new distributedData.Query(); 1491 query.inNumber("field", [0, 1]); 1492 console.log("query is " + query.getSqlLike()); 1493 query = null; 1494} catch (e) { 1495 console.log("duplicated calls should be ok :" + e); 1496} 1497``` 1498 1499 1500### inString<sup>8+</sup> ### 1501 1502inString(field: string, valueList: string[]): Query 1503 1504构造一个Query对象以查询具有指定字段的条目，其值在指定的字符串值列表中。 1505 1506**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 1507 1508**参数：** 1509 1510| 参数名 | 参数类型 | 必填 | 说明 | 1511| ----- | ------ | ---- | ----------------------- | 1512| fieId | string | 是 |表示指定字段，不能包含' ^ '。 | 1513| valueList | string[] | 是 | 表示指定的字符串值列表。| 1514 1515**返回值：** 1516 1517| 类型 | 说明 | 1518| ------ | ------- | 1519| [Query](#query8) |返回Query对象。| 1520 1521**示例：** 1522 1523```js 1524try { 1525 let query = new distributedData.Query(); 1526 query.inString("field", ['test1', 'test2']); 1527 console.log("query is " + query.getSqlLike()); 1528 query = null; 1529} catch (e) { 1530 console.log("duplicated calls should be ok :" + e); 1531} 1532``` 1533 1534 1535### notInNumber<sup>8+</sup> ### 1536 1537notInNumber(field: string, valueList: number[]): Query 1538 1539构造一个Query对象以查询具有指定字段的条目，该字段的值不在指定的值列表中。 1540 1541**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 1542 1543**参数：** 1544 1545| 参数名 | 参数类型 | 必填 | 说明 | 1546| ----- | ------ | ---- | ----------------------- | 1547| fieId | string | 是 |表示指定字段，不能包含' ^ '。 | 1548| valueList | number[] | 是 | 表示指定的值列表。| 1549 1550**返回值：** 1551 1552| 类型 | 说明 | 1553| ------ | ------- | 1554| [Query](#query8) |返回Query对象。| 1555 1556**示例：** 1557 1558```js 1559try { 1560 let query = new distributedData.Query(); 1561 query.notInNumber("field", [0, 1]); 1562 console.log("query is " + query.getSqlLike()); 1563 query = null; 1564} catch (e) { 1565 console.log("duplicated calls should be ok :" + e); 1566} 1567``` 1568 1569 1570### notInString<sup>8+</sup> ### 1571 1572notInString(field: string, valueList: string[]): Query 1573 1574构造一个Query对象以查询具有指定字段且值不在指定字符串值列表中的条目。 1575 1576**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 1577 1578**参数：** 1579 1580| 参数名 | 参数类型 | 必填 | 说明 | 1581| ----- | ------ | ---- | ----------------------- | 1582| fieId | string | 是 |表示指定字段，不能包含' ^ '。 | 1583| valueList | string[] | 是 | 表示指定的字符串值列表。| 1584 1585**返回值：** 1586 1587| 类型 | 说明 | 1588| ------ | ------- | 1589| [Query](#query8) |返回Query对象。| 1590 1591**示例：** 1592 1593```js 1594try { 1595 let query = new distributedData.Query(); 1596 query.notInString("field", ['test1', 'test2']); 1597 console.log("query is " + query.getSqlLike()); 1598 query = null; 1599} catch (e) { 1600 console.log("duplicated calls should be ok :" + e); 1601} 1602``` 1603 1604 1605### like<sup>8+</sup> ### 1606 1607like(field: string, value: string): Query 1608 1609构造一个Query对象以查询具有与指定字符串值相似的指定字段的条目。 1610 1611**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 1612 1613**参数：** 1614 1615| 参数名 | 参数类型 | 必填 | 说明 | 1616| ----- | ------ | ---- | ----------------------- | 1617| fieId | string | 是 |表示指定字段，不能包含' ^ '。 | 1618| value | string | 是 | 表示指定的字符串值。| 1619 1620**返回值：** 1621 1622| 类型 | 说明 | 1623| ------ | ------- | 1624| [Query](#query8) |返回Query对象。| 1625 1626**示例：** 1627 1628```js 1629try { 1630 let query = new distributedData.Query(); 1631 query.like("field", "value"); 1632 console.log("query is " + query.getSqlLike()); 1633 query = null; 1634} catch (e) { 1635 console.log("duplicated calls should be ok :" + e); 1636} 1637``` 1638 1639 1640### unlike<sup>8+</sup> ### 1641 1642unlike(field: string, value: string): Query 1643 1644构造一个Query对象以查询具有与指定字符串值不相似的指定字段的条目。 1645 1646**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 1647 1648**参数：** 1649 1650| 参数名 | 参数类型 | 必填 | 说明 | 1651| ----- | ------ | ---- | ----------------------- | 1652| fieId | string | 是 |表示指定字段，不能包含' ^ '。 | 1653| value | string | 是 | 表示指定的字符串值。| 1654 1655**返回值：** 1656 1657| 类型 | 说明 | 1658| ------ | ------- | 1659| [Query](#query8) |返回Query对象。| 1660 1661**示例：** 1662 1663```js 1664try { 1665 let query = new distributedData.Query(); 1666 query.unlike("field", "value"); 1667 console.log("query is " + query.getSqlLike()); 1668 query = null; 1669} catch (e) { 1670 console.log("duplicated calls should be ok :" + e); 1671} 1672``` 1673 1674 1675### and<sup>8+</sup> ### 1676 1677and(): Query 1678 1679构造一个带有与条件的查询对象。 1680 1681**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 1682 1683**返回值：** 1684 1685| 类型 | 说明 | 1686| ------ | ------- | 1687| [Query](#query8) |返回查询对象。| 1688 1689**示例：** 1690 1691```js 1692try { 1693 let query = new distributedData.Query(); 1694 query.notEqualTo("field", "value1"); 1695 query.and(); 1696 query.notEqualTo("field", "value2"); 1697 console.log("query is " + query.getSqlLike()); 1698 query = null; 1699} catch (e) { 1700 console.log("duplicated calls should be ok :" + e); 1701} 1702``` 1703 1704 1705### or<sup>8+</sup> ### 1706 1707or(): Query 1708 1709构造一个带有或条件的Query对象。 1710 1711**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 1712 1713**返回值：** 1714 1715| 类型 | 说明 | 1716| ------ | ------- | 1717| [Query](#query8) |返回查询对象。| 1718 1719**示例：** 1720 1721```js 1722try { 1723 let query = new distributedData.Query(); 1724 query.notEqualTo("field", "value1"); 1725 query.or(); 1726 query.notEqualTo("field", "value2"); 1727 console.log("query is " + query.getSqlLike()); 1728 query = null; 1729} catch (e) { 1730 console.log("duplicated calls should be ok :" + e); 1731} 1732``` 1733 1734 1735### orderByAsc<sup>8+</sup> ### 1736 1737orderByAsc(field: string): Query 1738 1739构造一个Query对象，将查询结果按升序排序。 1740 1741**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 1742 1743**参数：** 1744 1745| 参数名 | 参数类型 | 必填 | 说明 | 1746| ----- | ------ | ---- | ----------------------- | 1747| fieId | string | 是 |表示指定字段，不能包含' ^ '。 | 1748 1749**返回值：** 1750 1751| 类型 | 说明 | 1752| ------ | ------- | 1753| [Query](#query8) |返回Query对象。| 1754 1755**示例：** 1756 1757```js 1758try { 1759 let query = new distributedData.Query(); 1760 query.notEqualTo("field", "value"); 1761 query.orderByAsc("field"); 1762 console.log("query is " + query.getSqlLike()); 1763 query = null; 1764} catch (e) { 1765 console.log("duplicated calls should be ok :" + e); 1766} 1767``` 1768 1769 1770### orderByDesc<sup>8+</sup> ### 1771 1772orderByDesc(field: string): Query 1773 1774构造一个Query对象，将查询结果按降序排序。 1775 1776**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 1777 1778**参数：** 1779 1780| 参数名 | 参数类型 | 必填 | 说明 | 1781| ----- | ------ | ---- | ----------------------- | 1782| fieId | string | 是 |表示指定字段，不能包含' ^ '。 | 1783 1784**返回值：** 1785 1786| 类型 | 说明 | 1787| ------ | ------- | 1788| [Query](#query8) |返回Query对象。| 1789 1790**示例：** 1791 1792```js 1793try { 1794 let query = new distributedData.Query(); 1795 query.notEqualTo("field", "value"); 1796 query.orderByDesc("field"); 1797 console.log("query is " + query.getSqlLike()); 1798 query = null; 1799} catch (e) { 1800 console.log("duplicated calls should be ok :" + e); 1801} 1802``` 1803 1804 1805### limit<sup>8+</sup> ### 1806 1807limit(total: number, offset: number): Query 1808 1809构造一个Query对象来指定结果的数量和开始位置。 1810 1811**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 1812 1813**参数：** 1814 1815| 参数名 | 参数类型 | 必填 | 说明 | 1816| ----- | ------ | ---- | ----------------------- | 1817| total | number | 是 |表示指定的结果数。 | 1818| offset | number | 是 |表示起始位置。 | 1819 1820**返回值：** 1821 1822| 类型 | 说明 | 1823| ------ | ------- | 1824| [Query](#query8) |返回Query对象。| 1825 1826**示例：** 1827 1828```js 1829let total = 10; 1830let offset = 1; 1831try { 1832 let query = new distributedData.Query(); 1833 query.notEqualTo("field", "value"); 1834 query.limit(total, offset); 1835 console.log("query is " + query.getSqlLike()); 1836 query = null; 1837} catch (e) { 1838 console.log("duplicated calls should be ok :" + e); 1839} 1840``` 1841 1842 1843### isNotNull<sup>8+</sup> ### 1844 1845isNotNull(field: string): Query 1846 1847构造一个Query对象以查询具有值不为null的指定字段的条目。 1848 1849**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 1850 1851**参数：** 1852 1853| 参数名 | 参数类型 | 必填 | 说明 | 1854| ----- | ------ | ---- | ----------------------- | 1855| fieId | string | 是 |表示指定字段，不能包含' ^ '。 | 1856 1857**返回值：** 1858 1859| 类型 | 说明 | 1860| ------ | ------- | 1861| [Query](#query8) |返回Query对象。| 1862 1863**示例：** 1864 1865```js 1866try { 1867 let query = new distributedData.Query(); 1868 query.isNotNull("field"); 1869 console.log("query is " + query.getSqlLike()); 1870 query = null; 1871} catch (e) { 1872 console.log("duplicated calls should be ok :" + e); 1873} 1874``` 1875 1876 1877### beginGroup<sup>8+</sup> ### 1878 1879beginGroup(): Query 1880 1881创建一个带有左括号的查询条件组。 1882 1883**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 1884 1885**返回值：** 1886 1887| 类型 | 说明 | 1888| ------ | ------- | 1889| [Query](#query8) |返回Query对象。| 1890 1891**示例：** 1892 1893```js 1894try { 1895 let query = new distributedData.Query(); 1896 query.beginGroup(); 1897 query.isNotNull("field"); 1898 query.endGroup(); 1899 console.log("query is " + query.getSqlLike()); 1900 query = null; 1901} catch (e) { 1902 console.log("duplicated calls should be ok :" + e); 1903} 1904``` 1905 1906 1907### endGroup<sup>8+</sup> ### 1908 1909endGroup(): Query 1910 1911创建一个带有右括号的查询条件组。 1912 1913**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 1914 1915**返回值：** 1916 1917| 类型 | 说明 | 1918| ------ | ------- | 1919| [Query](#query8) |返回Query对象。| 1920 1921**示例：** 1922 1923```js 1924try { 1925 let query = new distributedData.Query(); 1926 query.beginGroup(); 1927 query.isNotNull("field"); 1928 query.endGroup(); 1929 console.log("query is " + query.getSqlLike()); 1930 query = null; 1931} catch (e) { 1932 console.log("duplicated calls should be ok :" + e); 1933} 1934``` 1935 1936 1937### prefixKey<sup>8+</sup> ### 1938 1939prefixKey(prefix: string): Query 1940 1941创建具有指定键前缀的查询条件。 1942 1943**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 1944 1945**参数：** 1946 1947| 参数名 | 参数类型 | 必填 | 说明 | 1948| ----- | ------ | ---- | ----------------------- | 1949| prefix | string | 是 |表示指定的键前缀。 | 1950 1951**返回值：** 1952 1953| 类型 | 说明 | 1954| ------ | ------- | 1955| [Query](#query8) |返回Query对象。| 1956 1957**示例：** 1958 1959```js 1960try { 1961 let query = new distributedData.Query(); 1962 query.prefixKey("$.name"); 1963 query.prefixKey("0"); 1964 console.log("query is " + query.getSqlLike()); 1965 query = null; 1966} catch (e) { 1967 console.log("duplicated calls should be ok :" + e); 1968} 1969``` 1970 1971 1972### setSuggestIndex<sup>8+</sup> ### 1973 1974setSuggestIndex(index: string): Query 1975 1976设置一个指定的索引，将优先用于查询。 1977 1978**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 1979 1980**参数：** 1981 1982| 参数名 | 参数类型 | 必填 | 说明 | 1983| ----- | ------ | ---- | ----------------------- | 1984| index | string | 是 |指示要设置的索引。 | 1985 1986**返回值：** 1987 1988| 类型 | 说明 | 1989| ------ | ------- | 1990| [Query](#query8) |返回Query对象。| 1991 1992**示例：** 1993 1994```js 1995try { 1996 let query = new distributedData.Query(); 1997 query.setSuggestIndex("$.name"); 1998 query.setSuggestIndex("0"); 1999 console.log("query is " + query.getSqlLike()); 2000 query = null; 2001} catch (e) { 2002 console.log("duplicated calls should be ok :" + e); 2003} 2004``` 2005 2006 2007### deviceId<sup>8+</sup> ### 2008 2009deviceId(deviceId:string):Query 2010 2011添加设备ID作为key的前缀。 2012 2013**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 2014 2015**参数：** 2016 2017| 参数名 | 参数类型 | 必填 | 说明 | 2018| ----- | ------ | ---- | ----------------------- | 2019| deviceId | string | 是 |指示查询的设备ID。 | 2020 2021 2022**返回值：** 2023 2024| 类型 | 说明 | 2025| ------ | ------- | 2026| [Query](#query8) |返回Query对象。| 2027 2028**示例：** 2029 2030```js 2031try { 2032 let query = new distributedData.Query(); 2033 query.deviceId("deviceId"); 2034 console.log("query is " + query.getSqlLike()); 2035} catch (e) { 2036 console.log("should be ok on Method Chaining : " + e); 2037} 2038``` 2039 2040 2041### getSqlLike<sup>8+</sup> ### 2042 2043getSqlLike():string 2044 2045获取Query对象的查询语句。 2046 2047**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 2048 2049**返回值：** 2050 2051| 类型 | 说明 | 2052| ------ | ------- | 2053| string |返回一个字段列中包含对应子串的结果。| 2054 2055**示例：** 2056 2057```js 2058try { 2059 let query = new distributedData.Query(); 2060 let sql1 = query.getSqlLike(); 2061 console.log("GetSqlLike sql=" + sql1); 2062} catch (e) { 2063 console.log("duplicated calls should be ok : " + e); 2064} 2065``` 2066 2067 2068## KVStore 2069 2070KVStore数据库实例，提供增加数据、删除数据和订阅数据变更、订阅数据同步完成的方法。 2071 2072在调用KVStore的方法前，需要先通过[getKVStore](#getkvstore)构建一个KVStore实例。 2073 2074### put 2075 2076put(key: string, value: Uint8Array | string | number | boolean, callback: AsyncCallback<void>): void 2077 2078添加指定类型键值对到数据库，使用callback异步回调。 2079 2080**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 2081 2082**参数：** 2083 2084| 参数名 | 参数类型 | 必填 | 说明 | 2085| ----- | ------ | ---- | ----------------------- | 2086| key | string | 是 |要添加数据的key，不能为空且长度不大于[MAX_KEY_LENGTH](#constants)。 | 2087| value | Uint8Array \| string \| number \| boolean | 是 |要添加数据的value，支持Uint8Array、number 、 string 、boolean，Uint8Array、string 的长度不大于[MAX_VALUE_LENGTH](#constants)。 | 2088| callback | AsyncCallback<void> | 是 |回调函数。 | 2089 2090**示例：** 2091 2092```js 2093let kvStore; 2094const KEY_TEST_STRING_ELEMENT = 'key_test_string'; 2095const VALUE_TEST_STRING_ELEMENT = 'value-test-string'; 2096try { 2097 kvStore.put(KEY_TEST_STRING_ELEMENT, VALUE_TEST_STRING_ELEMENT, function (err,data) { 2098 if (err != undefined) { 2099 console.log("put err: " + JSON.stringify(err)); 2100 return; 2101 } 2102 console.log("put success"); 2103 }); 2104}catch (e) { 2105 console.log("An unexpected error occurred. Error:" + e); 2106} 2107``` 2108 2109 2110### put 2111 2112put(key: string, value: Uint8Array | string | number | boolean): Promise<void> 2113 2114添加指定类型键值对到数据库，使用Promise异步回调。 2115 2116**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 2117 2118**参数：** 2119 2120| 参数名 | 参数类型 | 必填 | 说明 | 2121| ----- | ------ | ---- | ----------------------- | 2122| key | string | 是 |要添加数据的key，不能为空且长度不大于[MAX_KEY_LENGTH](#constants)。 | 2123| value | Uint8Array \| string \| number \| boolean | 是 |要添加数据的value，支持Uint8Array、number 、 string 、boolean，Uint8Array、string 的长度不大于[MAX_VALUE_LENGTH](#constants)。 | 2124 2125**返回值：** 2126 2127| 类型 | 说明 | 2128| ------ | ------- | 2129| Promise<void> |无返回结果的Promise对象。| 2130 2131**示例：** 2132 2133```js 2134let kvStore; 2135const KEY_TEST_STRING_ELEMENT = 'key_test_string'; 2136const VALUE_TEST_STRING_ELEMENT = 'value-test-string'; 2137try { 2138 kvStore.put(KEY_TEST_STRING_ELEMENT, VALUE_TEST_STRING_ELEMENT).then((data) => { 2139 console.log("put success: " + JSON.stringify(data)); 2140 }).catch((err) => { 2141 console.log("put err: " + JSON.stringify(err)); 2142 }); 2143}catch (e) { 2144 console.log("An unexpected error occurred. Error:" + e); 2145} 2146``` 2147 2148### delete 2149 2150delete(key: string, callback: AsyncCallback<void>): void 2151 2152从数据库中删除指定键值的数据，使用callback异步回调。 2153 2154**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 2155 2156**参数：** 2157 2158| 参数名 | 参数类型 | 必填 | 说明 | 2159| ----- | ------ | ---- | ----------------------- | 2160| key | string | 是 |要删除数据的key，不能为空且长度不大于[MAX_KEY_LENGTH](#constants)。 | 2161| callback | AsyncCallback<void> | 是 |回调函数。 | 2162 2163**示例：** 2164 2165```js 2166let kvStore; 2167const KEY_TEST_STRING_ELEMENT = 'key_test_string'; 2168const VALUE_TEST_STRING_ELEMENT = 'value-test-string'; 2169try { 2170 kvStore.put(KEY_TEST_STRING_ELEMENT, VALUE_TEST_STRING_ELEMENT, function (err,data) { 2171 if (err != undefined) { 2172 console.log("put err: " + JSON.stringify(err)); 2173 return; 2174 } 2175 console.log("put success"); 2176 kvStore.delete(KEY_TEST_STRING_ELEMENT, function (err,data) { 2177 if (err != undefined) { 2178 console.log("delete err: " + JSON.stringify(err)); 2179 return; 2180 } 2181 console.log("delete success"); 2182 }); 2183 }); 2184}catch (e) { 2185 console.log("An unexpected error occurred. Error:" + e); 2186} 2187``` 2188 2189### delete 2190 2191delete(key: string): Promise<void> 2192 2193从数据库中删除指定键值的数据，使用Promise异步回调。 2194 2195**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 2196 2197**参数：** 2198 2199| 参数名 | 参数类型 | 必填 | 说明 | 2200| ----- | ------ | ---- | ----------------------- | 2201| key | string | 是 |要删除数据的key，不能为空且长度不大于[MAX_KEY_LENGTH](#constants)。 | 2202 2203**返回值：** 2204 2205| 类型 | 说明 | 2206| ------ | ------- | 2207| Promise<void> |无返回结果的Promise对象。| 2208 2209**示例：** 2210 2211```js 2212let kvStore; 2213const KEY_TEST_STRING_ELEMENT = 'key_test_string'; 2214const VALUE_TEST_STRING_ELEMENT = 'value-test-string'; 2215try { 2216 kvStore.put(KEY_TEST_STRING_ELEMENT, VALUE_TEST_STRING_ELEMENT).then((data) => { 2217 console.log("put success: " + JSON.stringify(data)); 2218 kvStore.delete(KEY_TEST_STRING_ELEMENT).then((data) => { 2219 console.log("delete success"); 2220 }).catch((err) => { 2221 console.log("delete err: " + JSON.stringify(err)); 2222 }); 2223 }).catch((err) => { 2224 console.log("put err: " + JSON.stringify(err)); 2225 }); 2226}catch (e) { 2227 console.log("An unexpected error occurred. Error:" + e); 2228} 2229``` 2230### on('dataChange') 2231 2232on(event: 'dataChange', type: SubscribeType, observer: Callback<ChangeNotification>): void 2233 2234订阅指定类型的数据变更通知。 2235 2236**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 2237 2238**参数：** 2239 2240| 参数名 | 参数类型 | 必填 | 说明 | 2241| ----- | ------ | ---- | ----------------------- | 2242| event |string | 是 |订阅的事件名，固定为'dataChange'，表示数据变更事件。 | 2243| type |[SubscribeType](#subscribetype) | 是 |表示订阅的类型。 | 2244| observer |Callback<[ChangeNotification](#changenotification)> | 是 |回调函数。 | 2245 2246**示例：** 2247 2248```js 2249let kvStore; 2250kvStore.on('dataChange', distributedData.SubscribeType.SUBSCRIBE_TYPE_LOCAL, function (data) { 2251 console.log("dataChange callback call data: " + JSON.stringify(data)); 2252}); 2253``` 2254 2255 2256### on('syncComplete') 2257 2258on(event: 'syncComplete', syncCallback: Callback<Array<[string, number]>>): void 2259 2260订阅同步完成事件回调通知。 2261 2262**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 2263 2264**参数：** 2265 2266| 参数名 | 参数类型 | 必填 | 说明 | 2267| ----- | ------ | ---- | ----------------------- | 2268| event |string | 是 |订阅的事件名，固定为'syncComplete'，表示同步完成事件。 | 2269| syncCallback |Callback<Array<[string, number]>> | 是 |回调函数。 | 2270 2271**示例：** 2272 2273```js 2274let kvStore; 2275kvStore.on('syncComplete', function (data) { 2276 console.log("callback call data: " + data); 2277}); 2278``` 2279 2280### off('dataChange')<sup>8+</sup> 2281 2282off(event:'dataChange', observer?: Callback<ChangeNotification>): void 2283 2284取消订阅数据变更通知。 2285 2286**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 2287 2288**参数：** 2289 2290| 参数名 | 参数类型 | 必填 | 说明 | 2291| ----- | ------ | ---- | ----------------------- | 2292| event |string | 是 |取消订阅的事件名，固定为'dataChange'，表示数据变更事件。 | 2293| observer |Callback<[ChangeNotification](#changenotification)> |否 |回调函数。 | 2294 2295**示例：** 2296 2297```js 2298let kvStore; 2299class KvstoreModel { 2300 call(data) { 2301 console.log("dataChange: " + data); 2302 } 2303 subscribeDataChange() { 2304 if (kvStore != null) { 2305 kvStore.on('dataChange', distributedData.SubscribeType.SUBSCRIBE_TYPE_REMOTE, this.call); 2306 } 2307 } 2308 unsubscribeDataChange() { 2309 if (kvStore != null) { 2310 kvStore.off('dataChange', this.call); 2311 } 2312 } 2313} 2314``` 2315 2316 2317### putBatch<sup>8+</sup> 2318 2319putBatch(entries: Entry[], callback: AsyncCallback<void>): void 2320 2321批量插入键值对到KVStore数据库中，使用callback异步回调。 2322 2323**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 2324 2325**参数：** 2326 2327| 参数名 | 参数类型 | 必填 | 说明 | 2328| ----- | ------ | ---- | ----------------------- | 2329| entries |[Entry](#entry)[] | 是 |表示要批量插入的键值对。 | 2330| callback |Asyncallback<void> |是 |回调函数。 | 2331 2332**示例：** 2333 2334```js 2335let kvStore; 2336try { 2337 let entries = []; 2338 for (var i = 0; i < 10; i++) { 2339 var key = 'batch_test_string_key'; 2340 var entry = { 2341 key : key + i, 2342 value : { 2343 type : distributedData.ValueType.STRING, 2344 value : 'batch_test_string_value' 2345 } 2346 } 2347 entries.push(entry); 2348 } 2349 console.log('entries: ' + JSON.stringify(entries)); 2350 kvStore.putBatch(entries, async function (err,data) { 2351 console.log('putBatch success'); 2352 kvStore.getEntries('batch_test_string_key', function (err,entries) { 2353 console.log('getEntries success'); 2354 console.log('entries.length: ' + entries.length); 2355 console.log('entries[0]: ' + JSON.stringify(entries[0])); 2356 }); 2357 }); 2358}catch(e) { 2359 console.log('PutBatch e ' + JSON.stringify(e)); 2360} 2361``` 2362 2363 2364### putBatch<sup>8+</sup> 2365 2366putBatch(entries: Entry[]): Promise<void> 2367 2368批量插入键值对到KVStore数据库中，使用Promise异步回调。 2369 2370**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 2371 2372**参数：** 2373 2374| 参数名 | 参数类型 | 必填 | 说明 | 2375| ----- | ------ | ---- | ----------------------- | 2376| entries |[Entry](#entry)[] | 是 |表示要批量插入的键值对。 | 2377 2378**返回值：** 2379 2380| 类型 | 说明 | 2381| ------ | ------- | 2382| Promise<void> |无返回结果的Promise对象。| 2383 2384**示例：** 2385 2386```js 2387let kvStore; 2388try { 2389 let entries = []; 2390 for (var i = 0; i < 10; i++) { 2391 var key = 'batch_test_string_key'; 2392 var entry = { 2393 key : key + i, 2394 value : { 2395 type : distributedData.ValueType.STRING, 2396 value : 'batch_test_string_value' 2397 } 2398 } 2399 entries.push(entry); 2400 } 2401 console.log('entries: ' + JSON.stringify(entries)); 2402 kvStore.putBatch(entries).then(async (err) => { 2403 console.log('putBatch success'); 2404 kvStore.getEntries('batch_test_string_key').then((entries) => { 2405 console.log('getEntries success'); 2406 console.log('PutBatch ' + JSON.stringify(entries)); 2407 }).catch((err) => { 2408 console.log('getEntries fail ' + JSON.stringify(err)); 2409 }); 2410 }).catch((err) => { 2411 console.log('putBatch fail ' + JSON.stringify(err)); 2412 }); 2413}catch(e) { 2414 console.log('PutBatch e ' + JSON.stringify(e)); 2415} 2416``` 2417 2418 2419### deleteBatch<sup>8+</sup> 2420 2421deleteBatch(keys: string[], callback: AsyncCallback<void>): void 2422 2423批量删除KVStore数据库中的键值对，使用callback异步回调。 2424 2425**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 2426 2427**参数：** 2428 2429| 参数名 | 参数类型 | 必填 | 说明 | 2430| ----- | ------ | ---- | ----------------------- | 2431| keys |string[] | 是 |表示要批量删除的键值对。 | 2432| callback |AsyncCallback<void> | 是 |回调函数。 | 2433 2434**示例：** 2435 2436```js 2437let kvStore; 2438try { 2439 let entries = []; 2440 let keys = []; 2441 for (var i = 0; i < 5; i++) { 2442 var key = 'batch_test_string_key'; 2443 var entry = { 2444 key : key + i, 2445 value : { 2446 type : distributedData.ValueType.STRING, 2447 value : 'batch_test_string_value' 2448 } 2449 } 2450 entries.push(entry); 2451 keys.push(key + i); 2452 } 2453 console.log('entries: ' + JSON.stringify(entries)); 2454 kvStore.putBatch(entries, async function (err,data) { 2455 console.log('putBatch success'); 2456 kvStore.deleteBatch(keys, async function (err,data) { 2457 console.log('deleteBatch success'); 2458 }); 2459 }); 2460}catch(e) { 2461 console.log('DeleteBatch e ' + e); 2462} 2463``` 2464 2465 2466### deleteBatch<sup>8+</sup> ### 2467 2468deleteBatch(keys: string[]): Promise<void> 2469 2470批量删除KVStore数据库中的键值对，使用Promise异步回调。 2471 2472**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 2473 2474**参数：** 2475 2476| 参数名 | 参数类型 | 必填 | 说明 | 2477| ----- | ------ | ---- | ----------------------- | 2478| keys |string[] | 是 |表示要批量删除的键值对。 | 2479 2480**返回值：** 2481 2482| 类型 | 说明 | 2483| ------ | ------- | 2484| Promise<void> |无返回结果的Promise对象。| 2485 2486**示例：** 2487 2488```js 2489let kvStore; 2490try { 2491 let entries = []; 2492 let keys = []; 2493 for (var i = 0; i < 5; i++) { 2494 var key = 'batch_test_string_key'; 2495 var entry = { 2496 key : key + i, 2497 value : { 2498 type : distributedData.ValueType.STRING, 2499 value : 'batch_test_string_value' 2500 } 2501 } 2502 entries.push(entry); 2503 keys.push(key + i); 2504 } 2505 console.log('entries: ' + JSON.stringify(entries)); 2506 kvStore.putBatch(entries).then(async (err) => { 2507 console.log('putBatch success'); 2508 kvStore.deleteBatch(keys).then((err) => { 2509 console.log('deleteBatch success'); 2510 }).catch((err) => { 2511 console.log('deleteBatch fail ' + JSON.stringify(err)); 2512 }); 2513 }).catch((err) => { 2514 console.log('putBatch fail ' + JSON.stringify(err)); 2515 }); 2516}catch(e) { 2517 console.log('DeleteBatch e ' + e); 2518} 2519``` 2520 2521 2522### startTransaction<sup>8+</sup> ### 2523 2524startTransaction(callback: AsyncCallback<void>): void 2525 2526启动KVStore数据库中的事务，使用callback异步回调。 2527 2528**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 2529 2530**参数：** 2531 2532| 参数名 | 参数类型 | 必填 | 说明 | 2533| ----- | ------ | ---- | ----------------------- | 2534| callback |AsyncCallback<void> | 是 |回调函数。 | 2535 2536**示例：** 2537 2538```js 2539let kvStore; 2540function putBatchString(len, prefix) { 2541 let entries = []; 2542 for (var i = 0; i < len; i++) { 2543 var entry = { 2544 key : prefix + i, 2545 value : { 2546 type : distributedData.ValueType.STRING, 2547 value : 'batch_test_string_value' 2548 } 2549 } 2550 entries.push(entry); 2551 } 2552 return entries; 2553} 2554try { 2555 var count = 0; 2556 kvStore.on('dataChange', 0, function (data) { 2557 console.log('startTransaction 0' + data) 2558 count++; 2559 }); 2560 kvStore.startTransaction(async function (err,data) { 2561 console.log('startTransaction success'); 2562 let entries = putBatchString(10, 'batch_test_string_key'); 2563 console.log('entries: ' + JSON.stringify(entries)); 2564 kvStore.putBatch(entries, async function (err,data) { 2565 console.log('putBatch success'); 2566 }); 2567 }); 2568}catch(e) { 2569 console.log('startTransaction e ' + e); 2570} 2571``` 2572 2573 2574### startTransaction<sup>8+</sup> ### 2575 2576startTransaction(): Promise<void> 2577 2578启动KVStore数据库中的事务，使用Promise异步回调。 2579 2580**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 2581 2582**返回值：** 2583 2584| 类型 | 说明 | 2585| ------ | ------- | 2586| Promise<void> |无返回结果的Promise对象。| 2587 2588**示例：** 2589 2590```js 2591let kvStore; 2592try { 2593 var count = 0; 2594 kvStore.on('dataChange', distributedData.SubscribeType.SUBSCRIBE_TYPE_ALL, function (data) { 2595 console.log('startTransaction ' + JSON.stringify(data)); 2596 count++; 2597 }); 2598 kvStore.startTransaction().then(async (err) => { 2599 console.log('startTransaction success'); 2600 }).catch((err) => { 2601 console.log('startTransaction fail ' + JSON.stringify(err)); 2602 }); 2603}catch(e) { 2604 console.log('startTransaction e ' + e); 2605} 2606``` 2607 2608 2609### commit<sup>8+</sup> ### 2610 2611commit(callback: AsyncCallback<void>): void 2612 2613提交KVStore数据库中的事务，使用callback异步回调。 2614 2615**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 2616 2617**参数：** 2618 2619| 参数名 | 参数类型 | 必填 | 说明 | 2620| ----- | ------ | ---- | ----------------------- | 2621| callback |AsyncCallback<void> | 是 |回调函数。 | 2622 2623**示例：** 2624 2625```js 2626let kvStore; 2627try { 2628 kvStore.commit(function (err,data) { 2629 if (err == undefined) { 2630 console.log('commit success'); 2631 } else { 2632 console.log('commit fail'); 2633 } 2634 }); 2635}catch(e) { 2636 console.log('Commit e ' + e); 2637} 2638``` 2639 2640 2641### commit<sup>8+</sup> ### 2642 2643commit(): Promise<void> 2644 2645提交KVStore数据库中的事务，使用Promise异步回调。 2646 2647**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 2648 2649**返回值：** 2650 2651| 类型 | 说明 | 2652| ------ | ------- | 2653| Promise<void> |无返回结果的Promise对象。| 2654 2655**示例：** 2656 2657```js 2658let kvStore; 2659try { 2660 kvStore.commit().then(async (err) => { 2661 console.log('commit success'); 2662 }).catch((err) => { 2663 console.log('commit fail ' + JSON.stringify(err)); 2664 }); 2665}catch(e) { 2666 console.log('Commit e ' + e); 2667} 2668``` 2669 2670 2671### rollback<sup>8+</sup> ### 2672 2673rollback(callback: AsyncCallback<void>): void 2674 2675在KVStore数据库中回滚事务，使用callback异步回调。 2676 2677**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 2678 2679**参数：** 2680 2681| 参数名 | 参数类型 | 必填 | 说明 | 2682| ----- | ------ | ---- | ----------------------- | 2683| callback |AsyncCallback<void> | 是 |回调函数。 | 2684 2685**示例：** 2686 2687```js 2688let kvStore; 2689try { 2690 kvStore.rollback(function (err,data) { 2691 if (err == undefined) { 2692 console.log('commit success'); 2693 } else { 2694 console.log('commit fail'); 2695 } 2696 }); 2697}catch(e) { 2698 console.log('Rollback e ' + e); 2699} 2700``` 2701 2702 2703### rollback<sup>8+</sup> ### 2704 2705rollback(): Promise<void> 2706 2707在KVStore数据库中回滚事务，使用Promise异步回调。 2708 2709**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 2710 2711**返回值：** 2712 2713| 类型 | 说明 | 2714| ------ | ------- | 2715| Promise<void> |无返回结果的Promise对象。| 2716 2717**示例：** 2718 2719```js 2720let kvStore; 2721try { 2722 kvStore.rollback().then(async (err) => { 2723 console.log('rollback success'); 2724 }).catch((err) => { 2725 console.log('rollback fail ' + JSON.stringify(err)); 2726 }); 2727}catch(e) { 2728 console.log('Rollback e ' + e); 2729} 2730``` 2731 2732 2733### enableSync<sup>8+</sup> ### 2734 2735enableSync(enabled: boolean, callback: AsyncCallback<void>): void 2736 2737设定是否开启同步，使用callback异步回调。 2738 2739**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 2740 2741**参数：** 2742 2743| 参数名 | 参数类型 | 必填 | 说明 | 2744| ----- | ------ | ---- | ----------------------- | 2745| enabled |boolean | 是 |设定是否开启同步，true表示开启同步，false表示不启用同步。 | 2746| callback |AsyncCallback<void> | 是 |回调函数。 | 2747 2748**示例：** 2749 2750```js 2751let kvStore; 2752try { 2753 kvStore.enableSync(true, function (err,data) { 2754 if (err == undefined) { 2755 console.log('enableSync success'); 2756 } else { 2757 console.log('enableSync fail'); 2758 } 2759 }); 2760}catch(e) { 2761 console.log('EnableSync e ' + e); 2762} 2763``` 2764 2765 2766### enableSync<sup>8+</sup> ### 2767 2768enableSync(enabled: boolean): Promise<void> 2769 2770设定是否开启同步，使用Promise异步回调。 2771 2772**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 2773 2774**参数：** 2775 2776| 参数名 | 参数类型 | 必填 | 说明 | 2777| ----- | ------ | ---- | ----------------------- | 2778| enabled |boolean | 是 |设定是否开启同步，true表示开启同步，false表示不启用同步。 | 2779 2780**返回值：** 2781 2782| 类型 | 说明 | 2783| ------ | ------- | 2784| Promise<void> |无返回结果的Promise对象。| 2785 2786**示例：** 2787 2788```js 2789let kvStore; 2790try { 2791 kvStore.enableSync(true).then((err) => { 2792 console.log('enableSync success'); 2793 }).catch((err) => { 2794 console.log('enableSync fail ' + JSON.stringify(err)); 2795 }); 2796}catch(e) { 2797 console.log('EnableSync e ' + e); 2798} 2799``` 2800 2801 2802### setSyncRange<sup>8+</sup> ### 2803 2804setSyncRange(localLabels: string[], remoteSupportLabels: string[], callback: AsyncCallback<void>): void 2805 2806设置同步范围标签，使用callback异步回调。 2807 2808**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 2809 2810**参数：** 2811 2812| 参数名 | 参数类型 | 必填 | 说明 | 2813| ----- | ------ | ---- | ----------------------- | 2814| localLabels |string[] | 是 |表示本地设备的同步标签。 | 2815| remoteSupportLabels |string[] | 是 |表示要同步数据的设备的同步标签。 | 2816| callback |AsyncCallback<void> | 是 |回调函数。 | 2817 2818**示例：** 2819 2820```js 2821let kvStore; 2822try { 2823 const localLabels = ['A', 'B']; 2824 const remoteSupportLabels = ['C', 'D']; 2825 kvStore.setSyncRange(localLabels, remoteSupportLabels, function (err,data) { 2826 console.log('SetSyncRange put success'); 2827 }); 2828}catch(e) { 2829 console.log('SetSyncRange e ' + e); 2830} 2831``` 2832 2833 2834### setSyncRange<sup>8+</sup> ### 2835 2836setSyncRange(localLabels: string[], remoteSupportLabels: string[]): Promise<void> 2837 2838设置同步范围标签，使用Promise异步回调。 2839 2840**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 2841 2842**参数：** 2843 2844| 参数名 | 参数类型 | 必填 | 说明 | 2845| ----- | ------ | ---- | ----------------------- | 2846| localLabels |string[] | 是 |表示本地设备的同步标签。 | 2847| remoteSupportLabels |string[] | 是 |表示要同步数据的设备的同步标签。 | 2848 2849 2850**返回值：** 2851 2852| 类型 | 说明 | 2853| ------ | ------- | 2854| Promise<void> |无返回结果的Promise对象。| 2855 2856**示例：** 2857 2858```js 2859let kvStore; 2860try { 2861 const localLabels = ['A', 'B']; 2862 const remoteSupportLabels = ['C', 'D']; 2863 kvStore.setSyncRange(localLabels, remoteSupportLabels).then((err) => { 2864 console.log('setSyncRange success'); 2865 }).catch((err) => { 2866 console.log('delete fail ' + err); 2867 }); 2868}catch(e) { 2869 console.log('SetSyncRange e ' + e); 2870} 2871``` 2872 2873 2874## SubscribeType 2875 2876订阅类型枚举。 2877 2878**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 2879 2880| 名称 | 值 | 说明 | 2881| ----- | ------ | ----------------------- | 2882| SUBSCRIBE_TYPE_LOCAL |0 |表示订阅本地数据变更。 | 2883| SUBSCRIBE_TYPE_REMOTE |1 |表示订阅远端数据变更。 | 2884| SUBSCRIBE_TYPE_ALL |2 |表示订阅远端和本地数据变更。 | 2885 2886## ChangeNotification 2887 2888数据变更时通知的对象，包括数据插入的数据、更新的数据、删除的数据和设备ID。 2889 2890**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 2891 2892| 名称 | 参数类型 |可读 |可写 | 说明 | 2893| ----- | ------- | -----| ------|------------------------ | 2894| insertEntries | [Entry](#entry)[] | 是 | 是 |数据添加记录。 | 2895| updateEntries | [Entry](#entry)[] | 是 | 是 |数据更新记录。 | 2896| deleteEntries | [Entry](#entry)[] | 是 | 是 |数据删除记录。 | 2897| deviceId | string | 是 | 是 |设备ID，此处为设备UUID。 | 2898 2899## Entry 2900 2901存储在数据库中的键值对。 2902 2903**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 2904 2905| 名称 | 参数类型 |可读 |可写 | 说明 | 2906| ----- | ------- | -----| ------|------------------------ | 2907| key | string | 是 | 是 |键值。 | 2908| value | [Value](#value) | 是 | 是 |值对象。 | 2909 2910 2911## Value 2912 2913存储在数据库中的值对象。 2914 2915**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 2916 2917| 名称 | 参数类型 |可读 |可写 | 说明 | 2918| ----- | ------- | -----| ------|------------------------ | 2919| type | [ValueType](#value) | 是 | 是 |值类型。 | 2920| value | Uint8Array \| string \| number \| boolean| 是 | 是 |值。 | 2921 2922## ValueType 2923 2924数据类型枚举。 2925 2926**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 2927 2928| 名称 | 值 | 说明 | 2929| ----- | ------ | ----------------------- | 2930| STRING |0 |表示值类型为字符串。 | 2931| INTEGER |1 |表示值类型为整数。 | 2932| FLOAT |2 |表示值类型为浮点数。 | 2933| BYTE_ARRAY |3 |表示值类型为字节数组。 | 2934| BOOLEAN |4 |表示值类型为布尔值。 | 2935| DOUBLE |5 |表示值类型为双浮点数。 | 2936 2937## SingleKVStore 2938 2939单版本数据库，继承自[KVStore](#kvstore)数据库，提供查询数据和同步数据的方法。 2940 2941单版本数据库，不对数据所属设备进行区分，不同设备使用相同键写入数据会互相覆盖。比如，可以使用单版本数据库实现个人日历、联系人数据在不同设备间的数据同步。 2942 2943在调用SingleKVStore的方法前，需要先通过[getKVStore](#getkvstore)构建一个SingleKVStore实例。 2944 2945### get 2946 2947get(key: string, callback: AsyncCallback<Uint8Array | string | boolean | number>): void 2948 2949获取指定键的值，使用callback异步回调。 2950 2951**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 2952 2953**参数：** 2954 2955| 参数名 | 参数类型 | 必填 | 说明 | 2956| ----- | ------ | ---- | ----------------------- | 2957| key |string | 是 |要查询数据的key，不能为空且长度不大于[MAX_KEY_LENGTH](#constants)。 | 2958| callback |AsyncCallback<Uint8Array \| string \| boolean \| number>) | 是 |回调函数。返回获取查询的值。 | 2959 2960**示例：** 2961 2962```js 2963let kvStore; 2964const KEY_TEST_STRING_ELEMENT = 'key_test_string'; 2965const VALUE_TEST_STRING_ELEMENT = 'value-test-string'; 2966try { 2967 kvStore.put(KEY_TEST_STRING_ELEMENT, VALUE_TEST_STRING_ELEMENT, function (err,data) { 2968 if (err != undefined) { 2969 console.log("put err: " + JSON.stringify(err)); 2970 return; 2971 } 2972 console.log("put success"); 2973 kvStore.get(KEY_TEST_STRING_ELEMENT, function (err,data) { 2974 console.log("get success data: " + data); 2975 }); 2976 }); 2977}catch (e) { 2978 console.log("An unexpected error occurred. Error:" + e); 2979} 2980``` 2981 2982 2983### get 2984 2985get(key: string): Promise<Uint8Array | string | boolean | number> 2986 2987获取指定键的值，使用Promise异步回调。 2988 2989**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 2990 2991**参数：** 2992 2993| 参数名 | 参数类型 | 必填 | 说明 | 2994| ----- | ------ | ---- | ----------------------- | 2995| key |string | 是 |要查询数据的key，不能为空且长度不大于[MAX_KEY_LENGTH](#constants)。 | 2996 2997 2998**返回值：** 2999 3000| 类型 | 说明 | 3001| ------ | ------- | 3002|Promise<Uint8Array \| string \| boolean \| number> |Promise对象。返回获取查询的值。| 3003 3004**示例：** 3005 3006```js 3007let kvStore; 3008const KEY_TEST_STRING_ELEMENT = 'key_test_string'; 3009const VALUE_TEST_STRING_ELEMENT = 'value-test-string'; 3010try { 3011 kvStore.put(KEY_TEST_STRING_ELEMENT, VALUE_TEST_STRING_ELEMENT).then((data) => { 3012 console.log("put success: " + JSON.stringify(data)); 3013 kvStore.get(KEY_TEST_STRING_ELEMENT).then((data) => { 3014 console.log("get success data: " + data); 3015 }).catch((err) => { 3016 console.log("get err: " + JSON.stringify(err)); 3017 }); 3018 }).catch((err) => { 3019 console.log("put err: " + JSON.stringify(err)); 3020 }); 3021}catch (e) { 3022 console.log("An unexpected error occurred. Error:" + e); 3023} 3024``` 3025 3026### getEntries<sup>8+</sup> ### 3027 3028getEntries(keyPrefix: string, callback: AsyncCallback<Entry[]>): void 3029 3030获取匹配指定键前缀的所有键值对，使用callback异步回调。 3031 3032**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 3033 3034**参数：** 3035 3036| 参数名 | 参数类型 | 必填 | 说明 | 3037| ----- | ------ | ---- | ----------------------- | 3038| keyPrefix |string | 是 |表示要匹配的键前缀。 | 3039| callback |AsyncCallback<[Entry](#entry)[]> | 是 |回调函数。返回匹配指定前缀的键值对列表。 | 3040 3041**示例：** 3042 3043```js 3044let kvStore; 3045try { 3046 let entries = []; 3047 for (var i = 0; i < 10; i++) { 3048 var key = 'batch_test_number_key'; 3049 var entry = { 3050 key : key + i, 3051 value : { 3052 type : distributedData.ValueType.INTEGER, 3053 value : 222 3054 } 3055 } 3056 entries.push(entry); 3057 } 3058 kvStore.putBatch(entries, async function (err,data) { 3059 console.log('putBatch success'); 3060 kvStore.getEntries('batch_test_number_key', function (err,entries) { 3061 console.log('getEntries success'); 3062 console.log('entries.length: ' + entries.length); 3063 console.log('entries[0]: ' + JSON.stringify(entries[0])); 3064 }); 3065 }); 3066}catch(e) { 3067 console.log('PutBatch e ' + e); 3068} 3069``` 3070 3071 3072### getEntries<sup>8+</sup> ### 3073 3074getEntries(keyPrefix: string): Promise<Entry[]> 3075 3076获取匹配指定键前缀的所有键值对，使用Promise异步回调。 3077 3078**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 3079 3080**参数：** 3081 3082| 参数名 | 参数类型 | 必填 | 说明 | 3083| ----- | ------ | ---- | ----------------------- | 3084| keyPrefix |string | 是 |表示要匹配的键前缀。 | 3085 3086**返回值：** 3087 3088| 类型 | 说明 | 3089| ------ | ------- | 3090|Promise<[Entry](#entry)[]> |Promise对象。返回匹配指定前缀的键值对列表。| 3091 3092**示例：** 3093 3094```js 3095let kvStore; 3096try { 3097 let entries = []; 3098 for (var i = 0; i < 10; i++) { 3099 var key = 'batch_test_string_key'; 3100 var entry = { 3101 key : key + i, 3102 value : { 3103 type : distributedData.ValueType.STRING, 3104 value : 'batch_test_string_value' 3105 } 3106 } 3107 entries.push(entry); 3108 } 3109 console.log('entries: ' + entries); 3110 kvStore.putBatch(entries).then(async (err) => { 3111 console.log('putBatch success'); 3112 kvStore.getEntries('batch_test_string_key').then((entries) => { 3113 console.log('getEntries success'); 3114 console.log('entries.length: ' + entries.length); 3115 console.log('entries[0]: ' + JSON.stringify(entries[0])); 3116 console.log('entries[0].value: ' + JSON.stringify(entries[0].value)); 3117 console.log('entries[0].value.value: ' + entries[0].value.value); 3118 }).catch((err) => { 3119 console.log('getEntries fail ' + JSON.stringify(err)); 3120 }); 3121 }).catch((err) => { 3122 console.log('putBatch fail ' + JSON.stringify(err)); 3123 }); 3124}catch(e) { 3125 console.log('PutBatch e ' + e); 3126} 3127``` 3128 3129 3130### getEntries<sup>8+</sup> ### 3131 3132getEntries(query: Query, callback: AsyncCallback<Entry[]>): void 3133 3134获取与指定Query对象匹配的键值对列表，使用callback异步回调。 3135 3136**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 3137 3138**参数：** 3139 3140| 参数名 | 参数类型 | 必填 | 说明 | 3141| ----- | ------ | ---- | ----------------------- | 3142| query |[Query](#query8) | 是 |表示要匹配的键前缀。 | 3143| callback |AsyncCallback<[Entry](#entry)[]> | 是 |回调函数。返回与指定Query对象匹配的键值对列表。 | 3144 3145**示例：** 3146 3147```js 3148let kvStore; 3149try { 3150 var arr = new Uint8Array([21,31]); 3151 let entries = []; 3152 for (var i = 0; i < 10; i++) { 3153 var key = 'batch_test_bool_key'; 3154 var entry = { 3155 key : key + i, 3156 value : { 3157 type : distributedData.ValueType.BYTE_ARRAY, 3158 value : arr 3159 } 3160 } 3161 entries.push(entry); 3162 } 3163 console.log('entries: ' + JSON.stringify(entries)); 3164 kvStore.putBatch(entries, async function (err,data) { 3165 console.log('putBatch success'); 3166 const query = new distributedData.Query(); 3167 query.prefixKey("batch_test"); 3168 kvStore.getEntries(query, function (err,entries) { 3169 console.log('getEntries success'); 3170 console.log('entries.length: ' + entries.length); 3171 console.log('entries[0]: ' + JSON.stringify(entries[0])); 3172 }); 3173 }); 3174 console.log('GetEntries success'); 3175}catch(e) { 3176 console.log('GetEntries e ' + e); 3177} 3178``` 3179 3180 3181### getEntries<sup>8+</sup> ### 3182 3183getEntries(query: Query): Promise<Entry[]> 3184 3185获取与指定Query对象匹配的键值对列表，使用Promise异步回调。 3186 3187**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 3188 3189**参数：** 3190 3191| 参数名 | 参数类型 | 必填 | 说明 | 3192| ----- | ------ | ---- | ----------------------- | 3193| query |[Query](#query8) | 是 |表示查询对象。 | 3194 3195**返回值：** 3196 3197| 类型 | 说明 | 3198| ------ | ------- | 3199|Promise<[Entry](#entry)[]> |Promise对象。返回与指定Query对象匹配的键值对列表。| 3200 3201**示例：** 3202 3203```js 3204let kvStore; 3205try { 3206 var arr = new Uint8Array([21,31]); 3207 let entries = []; 3208 for (var i = 0; i < 10; i++) { 3209 var key = 'batch_test_bool_key'; 3210 var entry = { 3211 key : key + i, 3212 value : { 3213 type : distributedData.ValueType.BYTE_ARRAY, 3214 value : arr 3215 } 3216 } 3217 entries.push(entry); 3218 } 3219 console.log('entries: ' + JSON.stringify(entries)); 3220 kvStore.putBatch(entries).then(async (err) => { 3221 console.log('putBatch success'); 3222 const query = new distributedData.Query(); 3223 query.prefixKey("batch_test"); 3224 kvStore.getEntries(query).then((entries) => { 3225 console.log('getEntries success'); 3226 }).catch((err) => { 3227 console.log('getEntries fail ' + JSON.stringify(err)); 3228 }); 3229 }).catch((err) => { 3230 console.log('GetEntries putBatch fail ' + JSON.stringify(err)) 3231 }); 3232 console.log('GetEntries success'); 3233}catch(e) { 3234 console.log('GetEntries e ' + e); 3235} 3236``` 3237 3238 3239### getResultSet<sup>8+</sup><a name="singlekvstore_getresultset"></a> ### 3240 3241getResultSet(keyPrefix: string, callback: AsyncCallback<KvStoreResultSet>): void 3242 3243从KvStore数据库中获取具有指定前缀的结果集，使用callback异步回调。 3244 3245**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 3246 3247**参数：** 3248 3249| 参数名 | 参数类型 | 必填 | 说明 | 3250| ----- | ------ | ---- | ----------------------- | 3251| keyPrefix |string | 是 |表示要匹配的键前缀。 | 3252| callback |AsyncCallback<[KvStoreResultSet](#kvstoreresultset8)> | 是 |回调函数。返回具有指定前缀的结果集。 | 3253 3254**示例：** 3255 3256```js 3257let kvStore; 3258try { 3259 let resultSet; 3260 let entries = []; 3261 for (var i = 0; i < 10; i++) { 3262 var key = 'batch_test_string_key'; 3263 var entry = { 3264 key : key + i, 3265 value : { 3266 type : distributedData.ValueType.STRING, 3267 value : 'batch_test_string_value' 3268 } 3269 } 3270 entries.push(entry); 3271 } 3272 kvStore.putBatch(entries, async function (err, data) { 3273 console.log('GetResultSet putBatch success'); 3274 kvStore.getResultSet('batch_test_string_key', async function (err, result) { 3275 console.log('GetResultSet getResultSet succeed.'); 3276 resultSet = result; 3277 kvStore.closeResultSet(resultSet, function (err, data) { 3278 console.log('GetResultSet closeResultSet success'); 3279 }) 3280 }); 3281 }); 3282}catch(e) { 3283 console.log('GetResultSet e ' + e); 3284} 3285``` 3286 3287 3288### getResultSet<sup>8+</sup> ### 3289 3290getResultSet(keyPrefix: string): Promise<KvStoreResultSet> 3291 3292从KVStore数据库中获取具有指定前缀的结果集，使用Promise异步回调。 3293 3294**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 3295 3296**参数：** 3297 3298| 参数名 | 参数类型 | 必填 | 说明 | 3299| ----- | ------ | ---- | ----------------------- | 3300| keyPrefix |string | 是 |表示要匹配的键前缀。 | 3301 3302**返回值：** 3303 3304| 类型 | 说明 | 3305| ------ | ------- | 3306|Promise<[KvStoreResultSet](#kvstoreresultset8)> |Promise对象。返回具有指定前缀的结果集。| 3307 3308**示例：** 3309 3310```js 3311let kvStore; 3312try { 3313 let resultSet; 3314 let entries = []; 3315 for (var i = 0; i < 10; i++) { 3316 var key = 'batch_test_string_key'; 3317 var entry = { 3318 key : key + i, 3319 value : { 3320 type : distributedData.ValueType.STRING, 3321 value : 'batch_test_string_value' 3322 } 3323 } 3324 entries.push(entry); 3325 } 3326 kvStore.putBatch(entries).then(async (err) => { 3327 console.log('putBatch success'); 3328 }).catch((err) => { 3329 console.log('PutBatch putBatch fail ' + JSON.stringify(err)); 3330 }); 3331 kvStore.getResultSet('batch_test_string_key').then((result) => { 3332 console.log('GetResult getResultSet succeed.'); 3333 resultSet = result; 3334 }).catch((err) => { 3335 console.log('getResultSet failed: ' + JSON.stringify(err)); 3336 }); 3337 kvStore.closeResultSet(resultSet).then((err) => { 3338 console.log('GetResult closeResultSet success'); 3339 }).catch((err) => { 3340 console.log('closeResultSet fail ' + JSON.stringify(err)); 3341 }); 3342}catch(e) { 3343 console.log('GetResult e ' + e); 3344} 3345``` 3346 3347 3348### getResultSet<sup>8+</sup> ### 3349 3350getResultSet(query: Query, callback: AsyncCallback<KvStoreResultSet>): void 3351 3352获取与指定Query对象匹配的KvStoreResultSet对象，使用callback异步回调。 3353 3354**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 3355 3356**参数：** 3357 3358| 参数名 | 参数类型 | 必填 | 说明 | 3359| ----- | ------ | ---- | ----------------------- | 3360| query |Query | 是 |表示查询对象。 | 3361| callback |AsyncCallback<[KvStoreResultSet](#kvstoreresultset8)> | 是 |回调函数，获取与指定Query对象匹配的KvStoreResultSet对象。 | 3362 3363**示例：** 3364 3365```js 3366let kvStore; 3367try { 3368 let resultSet; 3369 let entries = []; 3370 for (var i = 0; i < 10; i++) { 3371 var key = 'batch_test_string_key'; 3372 var entry = { 3373 key : key + i, 3374 value : { 3375 type : distributedData.ValueType.STRING, 3376 value : 'batch_test_string_value' 3377 } 3378 } 3379 entries.push(entry); 3380 } 3381 kvStore.putBatch(entries, async function (err, data) { 3382 console.log('putBatch success'); 3383 const query = new distributedData.Query(); 3384 query.prefixKey("batch_test"); 3385 kvStore.getResultSet(query, async function (err, result) { 3386 console.log('getResultSet succeed.'); 3387 resultSet = result; 3388 }); 3389 }); 3390} catch(e) { 3391 console.log('GetResultSet e ' + e); 3392} 3393``` 3394 3395 3396### getResultSet<sup>8+</sup> ### 3397 3398getResultSet(query: Query): Promise<KvStoreResultSet> 3399 3400获取与指定Query对象匹配的KvStoreResultSet对象，使用Promise异步回调。 3401 3402**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 3403 3404**参数：** 3405 3406| 参数名 | 参数类型 | 必填 | 说明 | 3407| ----- | ------ | ---- | ----------------------- | 3408| query |[Query](#query8) | 是 |表示查询对象。 | 3409 3410**返回值：** 3411 3412| 类型 | 说明 | 3413| ------ | ------- | 3414|Promise<[KvStoreResultSet](#kvstoreresultset8)> |Promise对象。获取与指定Query对象匹配的KvStoreResultSet对象。| 3415 3416**示例：** 3417 3418```js 3419let kvStore; 3420try { 3421 let resultSet; 3422 let entries = []; 3423 for (var i = 0; i < 10; i++) { 3424 var key = 'batch_test_string_key'; 3425 var entry = { 3426 key : key + i, 3427 value : { 3428 type : distributedData.ValueType.STRING, 3429 value : 'batch_test_string_value' 3430 } 3431 } 3432 entries.push(entry); 3433 } 3434 kvStore.putBatch(entries).then(async (err) => { 3435 console.log('putBatch success'); 3436 }).catch((err) => { 3437 console.log('putBatch fail ' + JSON.stringify(err)); 3438 }); 3439 const query = new distributedData.Query(); 3440 query.prefixKey("batch_test"); 3441 kvStore.getResultSet(query).then((result) => { 3442 console.log(' getResultSet succeed.'); 3443 resultSet = result; 3444 }).catch((err) => { 3445 console.log('getResultSet failed: ' + JSON.stringify(err)); 3446 }); 3447}catch(e) { 3448 console.log('GetResultSet e ' + e); 3449} 3450``` 3451 3452### closeResultSet<sup>8+</sup> ### 3453 3454closeResultSet(resultSet: KvStoreResultSet, callback: AsyncCallback<void>): void 3455 3456关闭由[SingleKvStore.getResultSet](#singlekvstore_getresultset)返回的KvStoreResultSet对象，使用callback异步回调。 3457 3458**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 3459 3460**参数：** 3461 3462| 参数名 | 参数类型 | 必填 | 说明 | 3463| ----- | ------ | ---- | ----------------------- | 3464| resultSet |[KvStoreResultSet](#kvstoreresultset8) | 是 |表示要关闭的KvStoreResultSet对象。 | 3465| callback |AsyncCallback<void> | 是 |回调函数。 | 3466 3467**示例：** 3468 3469```js 3470let kvStore; 3471try { 3472 let resultSet = null; 3473 kvStore.closeResultSet(resultSet, function (err, data) { 3474 if (err == undefined) { 3475 console.log('closeResultSet success'); 3476 } else { 3477 console.log('closeResultSet fail'); 3478 } 3479 }); 3480}catch(e) { 3481 console.log('CloseResultSet e ' + e); 3482} 3483``` 3484 3485 3486### closeResultSet<sup>8+</sup> ### 3487 3488closeResultSet(resultSet: KvStoreResultSet): Promise<void> 3489 3490关闭由[SingleKvStore.getResultSet](#singlekvstore_getresultset)返回的KvStoreResultSet对象，使用Promise异步回调。 3491 3492**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 3493 3494**参数：** 3495 3496| 参数名 | 参数类型 | 必填 | 说明 | 3497| ----- | ------ | ---- | ----------------------- | 3498| resultSet |[KvStoreResultSet](#kvstoreresultset8) | 是 |表示要关闭的KvStoreResultSet对象。 | 3499 3500**返回值：** 3501 3502| 类型 | 说明 | 3503| ------ | ------- | 3504|Promise<void> |无返回结果的Promise对象。| 3505 3506**示例：** 3507 3508```js 3509let kvStore; 3510try { 3511 let resultSet = null; 3512 kvStore.closeResultSet(resultSet).then(() => { 3513 console.log('closeResultSet success'); 3514 }).catch((err) => { 3515 console.log('closeResultSet fail ' + JSON.stringify(err)); 3516 }); 3517}catch(e) { 3518 console.log('CloseResultSet e ' + e); 3519} 3520``` 3521 3522 3523### getResultSize<sup>8+</sup> ### 3524 3525getResultSize(query: Query, callback: AsyncCallback<number>): void 3526 3527获取与指定Query对象匹配的结果数，使用callback异步回调。 3528 3529**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 3530 3531**参数：** 3532 3533| 参数名 | 参数类型 | 必填 | 说明 | 3534| ----- | ------ | ---- | ----------------------- | 3535| query |[Query](#query8) | 是 |表示查询对象。 | 3536| callback |AsyncCallback<number> | 是 |回调函数。返回与指定Query对象匹配的结果数。 | 3537 3538**示例：** 3539 3540```js 3541let kvStore; 3542try { 3543 let entries = []; 3544 for (var i = 0; i < 10; i++) { 3545 var key = 'batch_test_string_key'; 3546 var entry = { 3547 key : key + i, 3548 value : { 3549 type : distributedData.ValueType.STRING, 3550 value : 'batch_test_string_value' 3551 } 3552 } 3553 entries.push(entry); 3554 } 3555 kvStore.putBatch(entries, async function (err, data) { 3556 console.log('putBatch success'); 3557 const query = new distributedData.Query(); 3558 query.prefixKey("batch_test"); 3559 kvStore.getResultSize(query, async function (err, resultSize) { 3560 console.log('getResultSet succeed.'); 3561 }); 3562 }); 3563} catch(e) { 3564 console.log('GetResultSize e ' + e); 3565} 3566``` 3567 3568 3569### getResultSize<sup>8+</sup> ### 3570 3571getResultSize(query: Query): Promise<number> 3572 3573获取与指定Query对象匹配的结果数，使用Promise异步回调。 3574 3575**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 3576 3577**参数：** 3578 3579| 参数名 | 参数类型 | 必填 | 说明 | 3580| ----- | ------ | ---- | ----------------------- | 3581| query |[Query](#query8) | 是 |表示查询对象。 | 3582 3583**返回值：** 3584 3585| 类型 | 说明 | 3586| ------ | ------- | 3587|Promise<number> |Promise对象。获取与指定Query对象匹配的结果数。| 3588 3589**示例：** 3590 3591```js 3592let kvStore; 3593try { 3594 let entries = []; 3595 for (var i = 0; i < 10; i++) { 3596 var key = 'batch_test_string_key'; 3597 var entry = { 3598 key : key + i, 3599 value : { 3600 type : distributedData.ValueType.STRING, 3601 value : 'batch_test_string_value' 3602 } 3603 } 3604 entries.push(entry); 3605 } 3606 kvStore.putBatch(entries).then(async (err) => { 3607 console.log('putBatch success'); 3608 }).catch((err) => { 3609 console.log('putBatch fail ' + JSON.stringify(err)); 3610 }); 3611 const query = new distributedData.Query(); 3612 query.prefixKey("batch_test"); 3613 kvStore.getResultSize(query).then((resultSize) => { 3614 console.log('getResultSet succeed.'); 3615 }).catch((err) => { 3616 console.log('getResultSet failed: ' + JSON.stringify(err)); 3617 }); 3618}catch(e) { 3619 console.log('GetResultSize e ' + e); 3620} 3621``` 3622 3623 3624### removeDeviceData<sup>8+</sup> ### 3625 3626removeDeviceData(deviceId: string, callback: AsyncCallback<void>): void 3627 3628删除指定设备的数据，使用callback异步回调。 3629 3630**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 3631 3632**参数：** 3633 3634| 参数名 | 参数类型 | 必填 | 说明 | 3635| ----- | ------ | ---- | ----------------------- | 3636| deviceId |string | 是 |表示要删除设备的名称。 | 3637| callback |AsyncCallback<void> | 是 |回调函数。 | 3638 3639**示例：** 3640 3641```js 3642let kvStore; 3643const KEY_TEST_STRING_ELEMENT = 'key_test_string_2'; 3644const VALUE_TEST_STRING_ELEMENT = 'value-string-002'; 3645try { 3646 kvStore.put(KEY_TEST_STRING_ELEMENT, VALUE_TEST_STRING_ELEMENT, async function (err,data) { 3647 console.log('put success'); 3648 const deviceid = 'no_exist_device_id'; 3649 kvStore.removeDeviceData(deviceid, async function (err,data) { 3650 if (err == undefined) { 3651 console.log('removeDeviceData success'); 3652 } else { 3653 console.log('removeDeviceData fail'); 3654 kvStore.get(KEY_TEST_STRING_ELEMENT, async function (err,data) { 3655 console.log('RemoveDeviceData get success'); 3656 }); 3657 } 3658 }); 3659 }); 3660}catch(e) { 3661 console.log('RemoveDeviceData e ' + e); 3662} 3663``` 3664 3665 3666### removeDeviceData<sup>8+</sup> ### 3667 3668removeDeviceData(deviceId: string): Promise<void> 3669 3670删除指定设备的数据，使用Promise异步回调。 3671 3672**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 3673 3674**参数：** 3675 3676| 参数名 | 参数类型 | 必填 | 说明 | 3677| ----- | ------ | ---- | ----------------------- | 3678| deviceId |string | 是 |表示要删除设备的名称。 | 3679 3680**返回值：** 3681 3682| 类型 | 说明 | 3683| ------ | ------- | 3684|Promise<void> |无返回结果的Promise对象。| 3685 3686**示例：** 3687 3688```js 3689let kvStore; 3690const KEY_TEST_STRING_ELEMENT = 'key_test_string_2'; 3691const VALUE_TEST_STRING_ELEMENT = 'value-string-001'; 3692try { 3693 kvStore.put(KEY_TEST_STRING_ELEMENT, VALUE_TEST_STRING_ELEMENT).then((err) => { 3694 console.log('removeDeviceData put success'); 3695 }).catch((err) => { 3696 console.log('put fail ' + JSON.stringify(err)); 3697 }); 3698 const deviceid = 'no_exist_device_id'; 3699 kvStore.removeDeviceData(deviceid).then((err) => { 3700 console.log('removeDeviceData success'); 3701 }).catch((err) => { 3702 console.log('removeDeviceData fail ' + JSON.stringify(err)); 3703 }); 3704 kvStore.get(KEY_TEST_STRING_ELEMENT).then((data) => { 3705 console.log('get success data:' + data); 3706 }).catch((err) => { 3707 console.log('RemoveDeviceData get fail ' + JSON.stringify(err)); 3708 }); 3709}catch(e) { 3710 console.log('RemoveDeviceData e ' + e); 3711} 3712``` 3713 3714 3715### on('syncComplete')<sup>8+</sup> ### 3716 3717on(event: 'syncComplete', syncCallback: Callback<Array<[string, number]>>): void 3718 3719订阅同步完成事件回调通知。 3720 3721**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 3722 3723**参数：** 3724 3725| 参数名 | 参数类型 | 必填 | 说明 | 3726| ----- | ------ | ---- | ----------------------- | 3727| event |string | 是 |订阅的事件名，固定为'syncComplete'，表示同步完成事件。 | 3728| syncCallback |Callback<Array<[string, number]>> | 是 |回调函数。用于向调用方发送同步结果的回调。 | 3729 3730**示例：** 3731 3732```js 3733let kvStore; 3734const KEY_TEST_FLOAT_ELEMENT = 'key_test_float'; 3735const VALUE_TEST_FLOAT_ELEMENT = 321.12; 3736try { 3737 kvStore.on('syncComplete', function (data) { 3738 console.log('syncComplete ' + data) 3739 }); 3740 kvStore.put(KEY_TEST_FLOAT_ELEMENT, VALUE_TEST_FLOAT_ELEMENT).then((data) => { 3741 console.log('syncComplete put success'); 3742 }).catch((error) => { 3743 console.log('syncComplete put fail ' + error); 3744 }); 3745}catch(e) { 3746 console.log('syncComplete put e ' + e); 3747} 3748``` 3749 3750 3751### off('syncComplete')<sup>8+</sup> ### 3752 3753off(event: 'syncComplete', syncCallback?: Callback<Array<[string, number]>>): void 3754 3755取消订阅同步完成事件回调通知。 3756 3757**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 3758 3759**参数：** 3760 3761| 参数名 | 参数类型 | 必填 | 说明 | 3762| ----- | ------ | ---- | ----------------------- | 3763| event |string | 是 |取消订阅的事件名，固定为'syncComplete'，表示同步完成事件。 | 3764| syncCallback |Callback<Array<[string, number]>> | 否 |回调函数。用于向调用方发送同步结果的回调。 | 3765 3766**示例：** 3767 3768```js 3769let kvStore; 3770class KvstoreModel { 3771 call(data) { 3772 console.log("syncComplete: " + data); 3773 } 3774 subscribeSyncComplete() { 3775 if (kvStore != null) { 3776 kvStore.on('syncComplete', this.call); 3777 } 3778 } 3779 unsubscribeSyncComplete() { 3780 if (kvStore != null) { 3781 kvStore.off('syncComplete', this.call); 3782 } 3783 } 3784} 3785``` 3786 3787 3788### sync 3789 3790sync(deviceIdList: string[], mode: SyncMode, allowedDelayMs?: number): void 3791 3792在手动同步方式下，触发数据库同步。关于分布式数据服务的同步方式说明，请见[分布式数据服务概述](../../database/database-mdds-overview.md)。 3793 3794**需要权限**： ohos.permission.DISTRIBUTED_DATASYNC。 3795 3796**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 3797 3798**参数：** 3799 3800| 参数名 | 参数类型 | 必填 | 说明 | 3801| ----- | ------ | ---- | ----------------------- | 3802| deviceIdList |string[] | 是 |同一组网环境下，需要同步的设备的deviceId列表。 | 3803| mode |[SyncMode](#syncmode) | 是 |同步模式。 | 3804| allowedDelayMs |number | 否 |可选参数，允许延时时间，单位：ms（毫秒）。 | 3805 3806**示例：** 3807 3808```js 3809let kvStore; 3810kvStore.sync('deviceIds', distributedData.SyncMode.PULL_ONLY, 1000); 3811``` 3812 3813### setSyncParam<sup>8+</sup> ### 3814 3815setSyncParam(defaultAllowedDelayMs: number, callback: AsyncCallback<void>): void 3816 3817设置数据库同步允许的默认延迟，使用callback异步回调。 3818 3819**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 3820 3821**参数：** 3822 3823| 参数名 | 参数类型 | 必填 | 说明 | 3824| ----- | ------ | ---- | ----------------------- | 3825| defaultAllowedDelayMs |number | 是 |表示数据库同步允许的默认延迟，以毫秒为单位。 | 3826| callback |AsyncCallback<void> | 是 |回调函数。 | 3827 3828**示例：** 3829 3830```js 3831let kvStore; 3832try { 3833 const defaultAllowedDelayMs = 500; 3834 kvStore.setSyncParam(defaultAllowedDelayMs, function (err,data) { 3835 console.log('SetSyncParam put success'); 3836 }); 3837}catch(e) { 3838 console.log('testSingleKvStoreSetSyncParam e ' + e); 3839} 3840``` 3841 3842 3843### setSyncParam<sup>8+</sup> ### 3844 3845setSyncParam(defaultAllowedDelayMs: number): Promise<void> 3846 3847设置数据库同步允许的默认延迟，使用Promise异步回调。 3848 3849**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 3850 3851**参数：** 3852 3853| 参数名 | 参数类型 | 必填 | 说明 | 3854| ----- | ------ | ---- | ----------------------- | 3855| defaultAllowedDelayMs |number | 是 |表示数据库同步允许的默认延迟，以毫秒为单位。 | 3856 3857 3858**返回值：** 3859 3860| 类型 | 说明 | 3861| ------ | ------- | 3862|Promise<void> |无返回结果的Promise对象。| 3863 3864**示例：** 3865 3866```js 3867let kvStore; 3868try { 3869 const defaultAllowedDelayMs = 500; 3870 kvStore.setSyncParam(defaultAllowedDelayMs).then((err) => { 3871 console.log('SetSyncParam put success'); 3872 }).catch((err) => { 3873 console.log('SetSyncParam put fail ' + JSON.stringify(err)); 3874 }); 3875}catch(e) { 3876 console.log('SetSyncParam e ' + e); 3877} 3878``` 3879 3880 3881### getSecurityLevel<sup>8+</sup> ### 3882 3883getSecurityLevel(callback: AsyncCallback<SecurityLevel>): void 3884 3885获取数据库的安全级别，使用callback异步回调。 3886 3887**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 3888 3889**参数：** 3890 3891| 参数名 | 参数类型 | 必填 | 说明 | 3892| ----- | ------ | ---- | ----------------------- | 3893| callback |AsyncCallback<[SecurityLevel](#securitylevel)> | 是 |回调函数。返回数据库的安全级别。 | 3894 3895**示例：** 3896 3897```js 3898let kvStore; 3899try { 3900 kvStore.getSecurityLevel(function (err,data) { 3901 console.log('getSecurityLevel success'); 3902 }); 3903}catch(e) { 3904 console.log('GetSecurityLevel e ' + e); 3905} 3906``` 3907 3908 3909### getSecurityLevel<sup>8+</sup> ### 3910 3911getSecurityLevel(): Promise<SecurityLevel> 3912 3913获取数据库的安全级别，使用Promise异步回调。 3914 3915**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 3916 3917**返回值：** 3918 3919| 类型 | 说明 | 3920| ------ | ------- | 3921|Promise<[SecurityLevel](#securitylevel)> |Promise对象。返回数据库的安全级别。| 3922 3923**示例：** 3924 3925```js 3926let kvStore; 3927try { 3928 kvStore.getSecurityLevel().then((data) => { 3929 console.log(' getSecurityLevel success'); 3930 }).catch((err) => { 3931 console.log('getSecurityLevel fail ' + JSON.stringify(err)); 3932 }); 3933}catch(e) { 3934 console.log('GetSecurityLevel e ' + e); 3935} 3936``` 3937 3938 3939## DeviceKVStore<sup>8+</sup> ## 3940 3941设备协同数据库，继承自KVStore，提供查询数据和同步数据的方法。 3942 3943设备协同数据库，以设备维度对数据进行区分，每台设备仅能写入和修改本设备的数据，其它设备的数据对其是只读的，无法修改其它设备的数据。 3944 3945比如，可以使用设备协同数据库实现设备间的图片分享，可以查看其他设备的图片，但无法修改和删除其他设备的图片。 3946 3947在调用DeviceKVStore的方法前，需要先通过[getKVStore](#getkvstore)构建一个DeviceKVStore实例。 3948 3949### get<sup>8+</sup> ### 3950 3951get(deviceId: string, key: string, callback: AsyncCallback<boolean|string|number|Uint8Array>): void 3952 3953获取与指定设备ID和key匹配的string值，使用callback异步回调。 3954 3955**系统能力：** SystemCapability.DistributedDataManager.KVStore.DistributedKVStore 3956 3957**参数：** 3958 3959| 参数名 | 参数类型 | 必填 | 说明 | 3960| ----- | ------ | ---- | ----------------------- | 3961| deviceId |string | 是 |标识要查询其数据的设备。 | 3962| key |string | 是 |表示要查询key值的键。 | 3963| callback |AsyncCallback<boolean\|string\|number\|Uint8Array> | 是 |回调函数，返回匹配给定条件的字符串值。 | 3964 3965**示例：** 3966 3967```js 3968let kvStore; 3969const KEY_TEST_STRING_ELEMENT = 'key_test_string_2'; 3970const VALUE_TEST_STRING_ELEMENT = 'value-string-002'; 3971try{ 3972 kvStore.put(KEY_TEST_STRING_ELEMENT, VALUE_TEST_STRING_ELEMENT, async function (err,data) { 3973 console.log('put success'); 3974 kvStore.get('localDeviceId', KEY_TEST_STRING_ELEMENT, function (err,data) { 3975 console.log('get success'); 3976 }); 3977 }) 3978}catch(e) { 3979 console.log('get e' + e); 3980} 3981``` 3982 3983 3984### get<sup>8+</sup> ### 3985 3986get(deviceId: string, key: string): Promise<boolean|string|number|Uint8Array> 3987 3988获取与指定设备ID和key匹配的string值，使用Promise异步回调。 3989 3990**系统能力：** SystemCapability.DistributedDataManager.KVStore.DistributedKVStore 3991 3992**参数：** 3993 3994| 参数名 | 参数类型 | 必填 | 说明 | 3995| ----- | ------ | ---- | ----------------------- | 3996| deviceId |string | 是 |标识要查询其数据的设备。 | 3997| key |string | 是 |表示要查询key值的键。 | 3998 3999**返回值：** 4000 4001| 类型 | 说明 | 4002| ------ | ------- | 4003|Promise<boolean\|string\|number\|Uint8Array> |Promise对象。返回匹配给定条件的字符串值。| 4004 4005**示例：** 4006 4007```js 4008let kvStore; 4009const KEY_TEST_STRING_ELEMENT = 'key_test_string_2'; 4010const VALUE_TEST_STRING_ELEMENT = 'value-string-002'; 4011try { 4012 kvStore.put(KEY_TEST_STRING_ELEMENT, VALUE_TEST_STRING_ELEMENT).then(async (data) => { 4013 console.log(' put success'); 4014 kvStore.get('localDeviceId', KEY_TEST_STRING_ELEMENT).then((data) => { 4015 console.log('get success'); 4016 }).catch((err) => { 4017 console.log('get fail ' + JSON.stringify(err)); 4018 }); 4019 }).catch((error) => { 4020 console.log('put error' + error); 4021 }); 4022} catch (e) { 4023 console.log('Get e ' + e); 4024} 4025``` 4026 4027 4028### getEntries<sup>8+</sup> ### 4029 4030getEntries(deviceId: string, keyPrefix: string, callback: AsyncCallback<Entry[]>): void 4031 4032获取与指定设备ID和key前缀匹配的所有键值对，使用callback异步回调。 4033 4034**系统能力：** SystemCapability.DistributedDataManager.KVStore.DistributedKVStore 4035 4036**参数：** 4037 4038| 参数名 | 参数类型 | 必填 | 说明 | 4039| ----- | ------ | ---- | ----------------------- | 4040| deviceId |string | 是 |标识要查询其数据的设备。 | 4041| keyPrefix |string | 是 |表示要匹配的键前缀。 | 4042| callback |AsyncCallback<[Entry](#entry)[]> | 是 |回调函数，返回满足给定条件的所有键值对的列表。 | 4043 4044**示例：** 4045 4046```js 4047let kvStore; 4048try { 4049 let entries = []; 4050 for (var i = 0; i < 10; i++) { 4051 var key = 'batch_test_string_key'; 4052 var entry = { 4053 key : key + i, 4054 value : { 4055 type : distributedData.ValueType.STRING, 4056 value : 'batch_test_string_value' 4057 } 4058 } 4059 entries.push(entry); 4060 } 4061 console.log('entries: ' + entries); 4062 kvStore.putBatch(entries, async function (err,data) { 4063 console.log('putBatch success'); 4064 kvStore.getEntries('localDeviceId', 'batch_test_string_key', function (err,entries) { 4065 console.log('getEntries success'); 4066 console.log('entries.length: ' + entries.length); 4067 console.log('entries[0]: ' + JSON.stringify(entries[0])); 4068 }); 4069 }); 4070}catch(e) { 4071 console.log('PutBatch e ' + e); 4072} 4073``` 4074 4075 4076### getEntries<sup>8+</sup> ### 4077 4078getEntries(deviceId: string, keyPrefix: string): Promise<Entry[]> 4079 4080获取与指定设备ID和key前缀匹配的所有键值对，使用Promise异步回调。 4081 4082**系统能力：** SystemCapability.DistributedDataManager.KVStore.DistributedKVStore 4083 4084**参数：** 4085 4086| 参数名 | 参数类型 | 必填 | 说明 | 4087| ----- | ------ | ---- | ----------------------- | 4088| deviceId |string | 是 |标识要查询其数据的设备。 | 4089| keyPrefix |string | 是 |表示要匹配的键前缀。 | 4090 4091**返回值：** 4092 4093| 类型 | 说明 | 4094| ------ | ------- | 4095|Promise<[Entry](#entry)[]> |Promise对象。返回匹配给定条件的所有键值对的列表。| 4096 4097**示例：** 4098 4099```js 4100let kvStore; 4101try { 4102 let entries = []; 4103 for (var i = 0; i < 10; i++) { 4104 var key = 'batch_test_string_key'; 4105 var entry = { 4106 key : key + i, 4107 value : { 4108 type : distributedData.ValueType.STRING, 4109 value : 'batch_test_string_value' 4110 } 4111 } 4112 entries.push(entry); 4113 } 4114 console.log('entries: ' + entries); 4115 kvStore.putBatch(entries).then(async (err) => { 4116 console.log('putBatch success'); 4117 kvStore.getEntries('localDeviceId', 'batch_test_string_key').then((entries) => { 4118 console.log('getEntries success'); 4119 console.log('entries.length: ' + entries.length); 4120 console.log('entries[0]: ' + JSON.stringify(entries[0])); 4121 console.log('entries[0].value: ' + JSON.stringify(entries[0].value)); 4122 console.log('entries[0].value.value: ' + entries[0].value.value); 4123 }).catch((err) => { 4124 console.log('getEntries fail ' + JSON.stringify(err)); 4125 }); 4126 }).catch((err) => { 4127 console.log('putBatch fail ' + JSON.stringify(err)); 4128 }); 4129}catch(e) { 4130 console.log('PutBatch e ' + e); 4131} 4132``` 4133 4134 4135### getEntries<sup>8+</sup> ### 4136 4137getEntries(query: Query, callback: AsyncCallback<Entry[]>): void 4138 4139获取与指定Query对象匹配的键值对列表，使用callback异步回调。 4140 4141**系统能力：** SystemCapability.DistributedDataManager.KVStore.DistributedKVStore 4142 4143**参数：** 4144 4145| 参数名 | 参数类型 | 必填 | 说明 | 4146| ----- | ------ | ---- | ----------------------- | 4147| query |[Query](#query8) | 是 |表示查询对象。 | 4148| callback |AsyncCallback<[Entry](#entry)[]> | 是 |回调函数，返回与指定Query对象匹配的键值对列表。 | 4149 4150**示例：** 4151 4152```js 4153let kvStore; 4154try { 4155 var arr = new Uint8Array([21,31]); 4156 let entries = []; 4157 for (var i = 0; i < 10; i++) { 4158 var key = 'batch_test_bool_key'; 4159 var entry = { 4160 key : key + i, 4161 value : { 4162 type : distributedData.ValueType.BYTE_ARRAY, 4163 value : arr 4164 } 4165 } 4166 entries.push(entry); 4167 } 4168 console.log('entries: ' + JSON.stringify(entries)); 4169 kvStore.putBatch(entries, async function (err,data) { 4170 console.log('putBatch success'); 4171 const query = new distributedData.Query(); 4172 query.prefixKey("batch_test"); 4173 query.deviceId('localDeviceId'); 4174 kvStore.getEntries(query, function (err,entries) { 4175 console.log('getEntries success'); 4176 console.log('entries.length: ' + entries.length); 4177 console.log('entries[0]: ' + JSON.stringify(entries[0])); 4178 }); 4179 }); 4180 console.log('GetEntries success'); 4181}catch(e) { 4182 console.log('GetEntries e ' + e); 4183} 4184``` 4185 4186 4187### getEntries<sup>8+</sup> ### 4188 4189getEntries(query: Query): Promise<Entry[]> 4190 4191获取与指定Query对象匹配的键值对列表，使用Promise异步回调。 4192 4193**系统能力：** SystemCapability.DistributedDataManager.KVStore.DistributedKVStore 4194 4195**参数：** 4196 4197| 参数名 | 参数类型 | 必填 | 说明 | 4198| ----- | ------ | ---- | ----------------------- | 4199| query |[Query](#query8) | 是 |表示查询对象。 | 4200 4201**返回值：** 4202 4203| 类型 | 说明 | 4204| ------ | ------- | 4205|Promise<[Entry](#entry)[]> |Promise对象。返回与指定Query对象匹配的键值对列表。| 4206 4207**示例：** 4208 4209```js 4210let kvStore; 4211try { 4212 var arr = new Uint8Array([21,31]); 4213 let entries = []; 4214 for (var i = 0; i < 10; i++) { 4215 var key = 'batch_test_bool_key'; 4216 var entry = { 4217 key : key + i, 4218 value : { 4219 type : distributedData.ValueType.BYTE_ARRAY, 4220 value : arr 4221 } 4222 } 4223 entries.push(entry); 4224 } 4225 console.log('entries: ' + JSON.stringify(entries)); 4226 kvStore.putBatch(entries).then(async (err) => { 4227 console.log('putBatch success'); 4228 const query = new distributedData.Query(); 4229 query.prefixKey("batch_test"); 4230 kvStore.getEntries(query).then((entries) => { 4231 console.log('getEntries success'); 4232 }).catch((err) => { 4233 console.log('getEntries fail ' + JSON.stringify(err)); 4234 }); 4235 }).catch((err) => { 4236 console.log('GetEntries putBatch fail ' + JSON.stringify(err)) 4237 }); 4238 console.log('GetEntries success'); 4239}catch(e) { 4240 console.log('GetEntries e ' + e); 4241} 4242``` 4243 4244 4245### getEntries<sup>8+</sup> ### 4246 4247getEntries(deviceId: string, query: Query, callback: AsyncCallback<Entry[]>): void 4248 4249获取与指定设备ID和Query对象匹配的键值对列表，使用callback异步回调。 4250 4251**系统能力：** SystemCapability.DistributedDataManager.KVStore.DistributedKVStore 4252 4253**参数：** 4254 4255| 参数名 | 参数类型 | 必填 | 说明 | 4256| ----- | ------ | ---- | ----------------------- | 4257| deviceId |string | 是 |键值对所属的设备ID。 | 4258| query |[Query](#query8) | 是 |表示查询对象。 | 4259| callback |AsyncCallback<[Entry](#entry)[]> | 是 |回调函数。返回与指定设备ID和Query对象匹配的键值对列表。 | 4260 4261**示例：** 4262 4263```js 4264let kvStore; 4265try { 4266 var arr = new Uint8Array([21,31]); 4267 let entries = []; 4268 for (var i = 0; i < 10; i++) { 4269 var key = 'batch_test_bool_key'; 4270 var entry = { 4271 key : key + i, 4272 value : { 4273 type : distributedData.ValueType.BYTE_ARRAY, 4274 value : arr 4275 } 4276 } 4277 entries.push(entry); 4278 } 4279 console.log('entries: ' + JSON.stringify(entries)); 4280 kvStore.putBatch(entries, async function (err,data) { 4281 console.log('putBatch success'); 4282 var query = new distributedData.Query(); 4283 query.deviceId('localDeviceId'); 4284 query.prefixKey("batch_test"); 4285 kvStore.getEntries('localDeviceId', query, function (err,entries) { 4286 console.log('getEntries success'); 4287 console.log('entries.length: ' + entries.length); 4288 console.log('entries[0]: ' + JSON.stringify(entries[0])); 4289 }) 4290 }); 4291 console.log('GetEntries success'); 4292}catch(e) { 4293 console.log('GetEntries e ' + e); 4294} 4295``` 4296 4297 4298### getEntries<sup>8+</sup> ### 4299 4300getEntries(deviceId: string, query: Query): Promise<Entry[]> 4301 4302获取与指定设备ID和Query对象匹配的键值对列表，使用Promise异步回调。 4303 4304**系统能力：** SystemCapability.DistributedDataManager.KVStore.DistributedKVStore 4305 4306**参数：** 4307 4308| 参数名 | 参数类型 | 必填 | 说明 | 4309| ----- | ------ | ---- | ----------------------- | 4310| deviceId |string | 是 |键值对所属的设备ID。 | 4311| query |[Query](#query8) | 是 |表示查询对象。 | 4312 4313**返回值：** 4314 4315| 类型 | 说明 | 4316| ------ | ------- | 4317|Promise<[Entry](#entry)[]> |Promise对象。返回与指定设备ID和Query对象匹配的键值对列表。| 4318 4319**示例：** 4320 4321```js 4322let kvStore; 4323try { 4324 var arr = new Uint8Array([21,31]); 4325 let entries = []; 4326 for (var i = 0; i < 10; i++) { 4327 var key = 'batch_test_bool_key'; 4328 var entry = { 4329 key : key + i, 4330 value : { 4331 type : distributedData.ValueType.BYTE_ARRAY, 4332 value : arr 4333 } 4334 } 4335 entries.push(entry); 4336 } 4337 console.log('entries: ' + JSON.stringify(entries)); 4338 kvStore.putBatch(entries).then(async (err) => { 4339 console.log('putBatch success'); 4340 var query = new distributedData.Query(); 4341 query.deviceId('localDeviceId'); 4342 query.prefixKey("batch_test"); 4343 kvStore.getEntries('localDeviceId', query).then((entries) => { 4344 console.log('getEntries success'); 4345 }).catch((err) => { 4346 console.log('getEntries fail ' + JSON.stringify(err)); 4347 }); 4348 }).catch((err) => { 4349 console.log('putBatch fail ' + JSON.stringify(err)); 4350 }); 4351 console.log('GetEntries success'); 4352}catch(e) { 4353 console.log('GetEntries e ' + e); 4354} 4355``` 4356 4357 4358### getResultSet<sup>8+</sup><a name="devicekvstore_getresultset"></a> ### 4359 4360getResultSet(deviceId: string, keyPrefix: string, callback: AsyncCallback<KvStoreResultSet>): void 4361 4362获取与指定设备ID和key前缀匹配的KvStoreResultSet对象，使用callback异步回调。 4363 4364**系统能力：** SystemCapability.DistributedDataManager.KVStore.DistributedKVStore 4365 4366**参数：** 4367 4368| 参数名 | 参数类型 | 必填 | 说明 | 4369| ----- | ------ | ---- | ----------------------- | 4370| deviceId |string | 是 |标识要查询其数据的设备。 | 4371| keyPrefix |string | 是 |表示要匹配的键前缀。 | 4372| callback |AsyncCallback<[KvStoreResultSet](#kvstoreresultset8)[]> | 是 |回调函数。返回与指定设备ID和key前缀匹配的KvStoreResultSet对象。 | 4373 4374**示例：** 4375 4376```js 4377let kvStore; 4378try { 4379 let resultSet; 4380 kvStore.getResultSet('localDeviceId', 'batch_test_string_key', async function (err, result) { 4381 console.log('getResultSet succeed.'); 4382 resultSet = result; 4383 kvStore.closeResultSet(resultSet, function (err, data) { 4384 console.log('closeResultSet success'); 4385 }) 4386 }); 4387}catch(e) { 4388 console.log('GetResultSet e ' + e); 4389} 4390``` 4391 4392 4393### getResultSet<sup>8+</sup> ### 4394 4395getResultSet(deviceId: string, keyPrefix: string): Promise<KvStoreResultSet> 4396 4397获取与指定设备ID和key前缀匹配的KvStoreResultSet对象，使用Promise异步回调。 4398 4399**系统能力：** SystemCapability.DistributedDataManager.KVStore.DistributedKVStore 4400 4401**参数：** 4402 4403| 参数名 | 参数类型 | 必填 | 说明 | 4404| ----- | ------ | ---- | ----------------------- | 4405| deviceId |string | 是 |标识要查询其数据的设备。 | 4406| keyPrefix |string | 是 |表示要匹配的键前缀。 | 4407 4408**返回值：** 4409 4410| 类型 | 说明 | 4411| ------ | ------- | 4412|Promise<[KvStoreResultSet](#kvstoreresultset8)[]> |Promise对象。返回与指定设备ID和key前缀匹配的KvStoreResultSet对象。| 4413 4414**示例：** 4415 4416```js 4417let kvStore; 4418try { 4419 let resultSet; 4420 kvStore.getResultSet('localDeviceId', 'batch_test_string_key').then((result) => { 4421 console.log('getResultSet succeed.'); 4422 resultSet = result; 4423 }).catch((err) => { 4424 console.log('getResultSet failed: ' + JSON.stringify(err)); 4425 }); 4426 kvStore.closeResultSet(resultSet).then((err) => { 4427 console.log('closeResultSet success'); 4428 }).catch((err) => { 4429 console.log('closeResultSet fail ' + JSON.stringify(err)); 4430 }); 4431}catch(e) { 4432 console.log('GetResultSet e ' + e); 4433} 4434``` 4435 4436 4437### getResultSet<sup>8+</sup> ### 4438 4439getResultSet(query: Query, callback: AsyncCallback<KvStoreResultSet>): void 4440 4441获取与指定Query对象匹配的KvStoreResultSet对象，使用callback异步回调。 4442 4443**系统能力：** SystemCapability.DistributedDataManager.KVStore.DistributedKVStore 4444 4445**参数：** 4446 4447| 参数名 | 参数类型 | 必填 | 说明 | 4448| ----- | ------ | ---- | ----------------------- | 4449| query |[Query](#query8) | 是 |表示查询对象。 | 4450| callback |AsyncCallback<[KvStoreResultSet](#kvstoreresultset8)[]> | 是 |回调函数，返回与指定Query对象匹配的KvStoreResultSet对象。 | 4451 4452**示例：** 4453 4454```js 4455let kvStore; 4456try { 4457 let resultSet; 4458 let entries = []; 4459 for (var i = 0; i < 10; i++) { 4460 var key = 'batch_test_string_key'; 4461 var entry = { 4462 key : key + i, 4463 value : { 4464 type : distributedData.ValueType.STRING, 4465 value : 'batch_test_string_value' 4466 } 4467 } 4468 entries.push(entry); 4469 } 4470 kvStore.putBatch(entries, async function (err, data) { 4471 console.log('putBatch success'); 4472 const query = new distributedData.Query(); 4473 query.prefixKey("batch_test"); 4474 query.deviceId('localDeviceId'); 4475 kvStore.getResultSet(query, async function (err, result) { 4476 console.log('getResultSet succeed.'); 4477 resultSet = result; 4478 kvStore.closeResultSet(resultSet, function (err, data) { 4479 console.log('closeResultSet success'); 4480 }) 4481 }); 4482 }); 4483} catch(e) { 4484 console.log('GetResultSet e ' + e); 4485} 4486``` 4487 4488 4489### getResultSet<sup>8+</sup> ### 4490 4491getResultSet(query: Query): Promise<KvStoreResultSet> 4492 4493获取与指定Query对象匹配的KvStoreResultSet对象，使用Promise异步回调。 4494 4495**系统能力：** SystemCapability.DistributedDataManager.KVStore.DistributedKVStore 4496 4497**参数：** 4498 4499| 参数名 | 参数类型 | 必填 | 说明 | 4500| ----- | ------ | ---- | ----------------------- | 4501| query |[Query](#query8) | 是 |表示查询对象。 | 4502 4503**返回值：** 4504 4505| 类型 | 说明 | 4506| ------ | ------- | 4507|Promise<[KvStoreResultSet](#kvstoreresultset8)[]> |Promise对象。返回与指定Query对象匹配的KvStoreResultSet对象。| 4508 4509**示例：** 4510 4511```js 4512let kvStore; 4513try { 4514 let resultSet; 4515 let entries = []; 4516 for (var i = 0; i < 10; i++) { 4517 var key = 'batch_test_string_key'; 4518 var entry = { 4519 key : key + i, 4520 value : { 4521 type : distributedData.ValueType.STRING, 4522 value : 'batch_test_string_value' 4523 } 4524 } 4525 entries.push(entry); 4526 } 4527 kvStore.putBatch(entries).then(async (err) => { 4528 console.log('putBatch success'); 4529 }).catch((err) => { 4530 console.log('putBatch fail ' + err); 4531 }); 4532 const query = new distributedData.Query(); 4533 query.deviceId('localDeviceId'); 4534 query.prefixKey("batch_test"); 4535 console.log("GetResultSet " + query.getSqlLike()); 4536 kvStore.getResultSet(query).then((result) => { 4537 console.log('getResultSet succeed.'); 4538 resultSet = result; 4539 }).catch((err) => { 4540 console.log('getResultSet failed: ' + JSON.stringify(err)); 4541 }); 4542 kvStore.closeResultSet(resultSet).then((err) => { 4543 console.log('closeResultSet success'); 4544 }).catch((err) => { 4545 console.log('closeResultSet fail ' + JSON.stringify(err)); 4546 }); 4547}catch(e) { 4548 console.log('GetResultSet e ' + e); 4549} 4550``` 4551 4552 4553### getResultSet<sup>8+</sup> ### 4554 4555getResultSet(deviceId: string, query: Query, callback: AsyncCallback<KvStoreResultSet>): void 4556 4557获取与指定设备ID和Query对象匹配的KvStoreResultSet对象，使用callback异步回调。 4558 4559**系统能力：** SystemCapability.DistributedDataManager.KVStore.DistributedKVStore 4560 4561**参数：** 4562 4563| 参数名 | 参数类型 | 必填 | 说明 | 4564| ----- | ------ | ---- | ----------------------- | 4565| deviceId |string | 是 |KvStoreResultSet对象所属的设备ID。 | 4566| query |[Query](#query8) | 是 |表示查询对象。 | 4567| callback |AsyncCallback<[KvStoreResultSet](#kvstoreresultset8)[]> | 是 |回调函数。返回与指定设备ID和Query对象匹配的KvStoreResultSet对象。 | 4568 4569**示例：** 4570 4571```js 4572let kvStore; 4573try { 4574 let resultSet; 4575 let entries = []; 4576 for (var i = 0; i < 10; i++) { 4577 var key = 'batch_test_string_key'; 4578 var entry = { 4579 key : key + i, 4580 value : { 4581 type : distributedData.ValueType.STRING, 4582 value : 'batch_test_string_value' 4583 } 4584 } 4585 entries.push(entry); 4586 } 4587 kvStore.putBatch(entries, async function (err, data) { 4588 console.log('putBatch success'); 4589 const query = new distributedData.Query(); 4590 query.prefixKey("batch_test"); 4591 kvStore.getResultSet('localDeviceId', query, async function (err, result) { 4592 console.log('getResultSet succeed.'); 4593 resultSet = result; 4594 kvStore.closeResultSet(resultSet, function (err, data) { 4595 console.log('closeResultSet success'); 4596 }) 4597 }); 4598 }); 4599} catch(e) { 4600 console.log('GetResultSet e ' + e); 4601} 4602``` 4603 4604 4605### getResultSet<sup>8+</sup> ### 4606 4607getResultSet(deviceId: string, query: Query): Promise<KvStoreResultSet> 4608 4609获取与指定设备ID和Query对象匹配的KvStoreResultSet对象，使用Promise异步回调。 4610 4611**系统能力：** SystemCapability.DistributedDataManager.KVStore.DistributedKVStore 4612 4613**参数：** 4614 4615| 参数名 | 参数类型 | 必填 | 说明 | 4616| ----- | ------ | ---- | ----------------------- | 4617| deviceId |string | 是 |KvStoreResultSet对象所属的设备ID。 | 4618| query |[Query](#query8) | 是 |表示查询对象。 | 4619 4620**返回值：** 4621 4622| 类型 | 说明 | 4623| ------ | ------- | 4624|Promise<[KvStoreResultSet](#kvstoreresultset8)[]> |Promise对象。返回与指定设备ID和Query对象匹配的KvStoreResultSet对象。| 4625 4626**示例：** 4627 4628```js 4629let kvStore; 4630try { 4631 let resultSet; 4632 let entries = []; 4633 for (var i = 0; i < 10; i++) { 4634 var key = 'batch_test_string_key'; 4635 var entry = { 4636 key : key + i, 4637 value : { 4638 type : distributedData.ValueType.STRING, 4639 value : 'batch_test_string_value' 4640 } 4641 } 4642 entries.push(entry); 4643 } 4644 kvStore.putBatch(entries).then(async (err) => { 4645 console.log('GetResultSet putBatch success'); 4646 }).catch((err) => { 4647 console.log('PutBatch putBatch fail ' + JSON.stringify(err)); 4648 }); 4649 const query = new distributedData.Query(); 4650 query.prefixKey("batch_test"); 4651 kvStore.getResultSet('localDeviceId', query).then((result) => { 4652 console.log('GetResultSet getResultSet succeed.'); 4653 resultSet = result; 4654 }).catch((err) => { 4655 console.log('GetResultSet getResultSet failed: ' + JSON.stringify(err)); 4656 }); 4657 query.deviceId('localDeviceId'); 4658 console.log("GetResultSet " + query.getSqlLike()); 4659 kvStore.closeResultSet(resultSet).then((err) => { 4660 console.log('GetResultSet closeResultSet success'); 4661 }).catch((err) => { 4662 console.log('GetResultSet closeResultSet fail ' + JSON.stringify(err)); 4663 }); 4664 4665}catch(e) { 4666 console.log('GetResultSet e ' + e); 4667} 4668``` 4669 4670 4671### closeResultSet<sup>8+</sup> ### 4672 4673closeResultSet(resultSet: KvStoreResultSet, callback: AsyncCallback<void>): void 4674 4675关闭由[DeviceKVStore.getResultSet](#devicekvstore_getresultset)返回的KvStoreResultSet对象，使用callback异步回调。 4676 4677**系统能力：** SystemCapability.DistributedDataManager.KVStore.DistributedKVStore 4678 4679**参数：** 4680 4681| 参数名 | 参数类型 | 必填 | 说明 | 4682| ----- | ------ | ---- | ----------------------- | 4683| resultSet |[KvStoreResultSet](#getresultset8) | 是 |指示要关闭的KvStoreResultSet对象。 | 4684| callback |AsyncCallback<void> | 是 |回调函数。 | 4685 4686**示例：** 4687 4688```js 4689let kvStore; 4690try { 4691 console.log('CloseResultSet success'); 4692 let resultSet = null; 4693 kvStore.closeResultSet(resultSet, function (err, data) { 4694 if (err == undefined) { 4695 console.log('closeResultSet success'); 4696 } else { 4697 console.log('closeResultSet fail'); 4698 } 4699 }); 4700}catch(e) { 4701 console.log('CloseResultSet e ' + e); 4702} 4703``` 4704 4705 4706### closeResultSet<sup>8+</sup> ### 4707 4708closeResultSet(resultSet: KvStoreResultSet): Promise<void> 4709 4710关闭由[DeviceKVStore.getResultSet](#devicekvstore_getresultset)返回的KvStoreResultSet对象，使用Promise异步回调。 4711 4712**系统能力：** SystemCapability.DistributedDataManager.KVStore.DistributedKVStore 4713 4714**参数：** 4715 4716| 参数名 | 参数类型 | 必填 | 说明 | 4717| ----- | ------ | ---- | ----------------------- | 4718| resultSet |[KvStoreResultSet](#getresultset8) | 是 |指示要关闭的KvStoreResultSet对象。 | 4719 4720**返回值：** 4721 4722| 类型 | 说明 | 4723| ------ | ------- | 4724|Promise<void> |无返回结果的Promise对象。| 4725 4726**示例：** 4727 4728```js 4729let kvStore; 4730try { 4731 console.log('CloseResultSet success'); 4732 let resultSet = null; 4733 kvStore.closeResultSet(resultSet).then(() => { 4734 console.log('closeResultSet success'); 4735 }).catch((err) => { 4736 console.log('closeResultSet fail ' + JSON.stringify(err)); 4737 }); 4738}catch(e) { 4739 console.log('CloseResultSet e ' + e); 4740} 4741``` 4742 4743 4744### getResultSize<sup>8+</sup> ### 4745 4746getResultSize(query: Query, callback: AsyncCallback<number>): void 4747 4748获取与指定Query对象匹配的结果数，使用callback异步回调。 4749 4750**系统能力：** SystemCapability.DistributedDataManager.KVStore.DistributedKVStore 4751 4752**参数：** 4753 4754| 参数名 | 参数类型 | 必填 | 说明 | 4755| ----- | ------ | ---- | ----------------------- | 4756| query |[Query](#query8) | 是 |表示查询对象。 | 4757| callback |AsyncCallback<number> | 是 |回调函数，返回与指定Query对象匹配的结果数。 | 4758 4759**示例：** 4760 4761```js 4762let kvStore; 4763try { 4764 let entries = []; 4765 for (var i = 0; i < 10; i++) { 4766 var key = 'batch_test_string_key'; 4767 var entry = { 4768 key : key + i, 4769 value : { 4770 type : distributedData.ValueType.STRING, 4771 value : 'batch_test_string_value' 4772 } 4773 } 4774 entries.push(entry); 4775 } 4776 kvStore.putBatch(entries, async function (err, data) { 4777 console.log('putBatch success'); 4778 const query = new distributedData.Query(); 4779 query.prefixKey("batch_test"); 4780 query.deviceId('localDeviceId'); 4781 kvStore.getResultSize(query, async function (err, resultSize) { 4782 console.log('getResultSet succeed.'); 4783 }); 4784 }); 4785} catch(e) { 4786 console.log('GetResultSize e ' + e); 4787} 4788``` 4789 4790 4791### getResultSize<sup>8+</sup> ### 4792 4793getResultSize(query: Query): Promise<number> 4794 4795获取与指定Query对象匹配的结果数，使用Promise异步回调。 4796 4797**系统能力：** SystemCapability.DistributedDataManager.KVStore.DistributedKVStore 4798 4799**参数：** 4800 4801| 参数名 | 参数类型 | 必填 | 说明 | 4802| ----- | ------ | ---- | ----------------------- | 4803| query |[Query](#query8) | 是 |表示查询对象。 | 4804 4805**返回值：** 4806 4807| 类型 | 说明 | 4808| ------ | ------- | 4809|Promise<number> |Promise对象。返回与指定Query对象匹配的结果数。| 4810 4811**示例：** 4812 4813```js 4814let kvStore; 4815try { 4816 let entries = []; 4817 for (var i = 0; i < 10; i++) { 4818 var key = 'batch_test_string_key'; 4819 var entry = { 4820 key : key + i, 4821 value : { 4822 type : distributedData.ValueType.STRING, 4823 value : 'batch_test_string_value' 4824 } 4825 } 4826 entries.push(entry); 4827 } 4828 kvStore.putBatch(entries).then(async (err) => { 4829 console.log('putBatch success'); 4830 }).catch((err) => { 4831 console.log('putBatch fail ' + JSON.stringify(err)); 4832 }); 4833 const query = new distributedData.Query(); 4834 query.prefixKey("batch_test"); 4835 query.deviceId('localDeviceId'); 4836 kvStore.getResultSize(query).then((resultSize) => { 4837 console.log('getResultSet succeed.'); 4838 }).catch((err) => { 4839 console.log('getResultSet failed: ' + JSON.stringify(err)); 4840 }); 4841}catch(e) { 4842 console.log('GetResultSize e ' + e); 4843} 4844``` 4845 4846 4847### getResultSize<sup>8+</sup> ### 4848 4849getResultSize(deviceId: string, query: Query, callback: AsyncCallback<number>): void; 4850 4851获取与指定设备ID和Query对象匹配的结果数，使用callback异步回调。 4852 4853**系统能力：** SystemCapability.DistributedDataManager.KVStore.DistributedKVStore 4854 4855**参数：** 4856 4857| 参数名 | 参数类型 | 必填 | 说明 | 4858| ----- | ------ | ---- | ----------------------- | 4859| deviceId |string | 是 |KvStoreResultSet对象所属的设备ID。 | 4860| query |[Query](#query8) | 是 |表示查询对象。 | 4861| callback |AsyncCallback<number> | 是 |回调函数。返回与指定设备ID和Query对象匹配的结果数。 | 4862 4863**示例：** 4864 4865```js 4866let kvStore; 4867try { 4868 let entries = []; 4869 for (var i = 0; i < 10; i++) { 4870 var key = 'batch_test_string_key'; 4871 var entry = { 4872 key : key + i, 4873 value : { 4874 type : distributedData.ValueType.STRING, 4875 value : 'batch_test_string_value' 4876 } 4877 } 4878 entries.push(entry); 4879 } 4880 kvStore.putBatch(entries, async function (err, data) { 4881 console.log('putBatch success'); 4882 const query = new distributedData.Query(); 4883 query.prefixKey("batch_test"); 4884 kvStore.getResultSize('localDeviceId', query, async function (err, resultSize) { 4885 console.log('getResultSet succeed.'); 4886 }); 4887 }); 4888} catch(e) { 4889 console.log('GetResultSize e ' + e); 4890} 4891``` 4892 4893 4894### getResultSize<sup>8+</sup> ### 4895 4896getResultSize(deviceId: string, query: Query): Promise<number> 4897 4898获取与指定设备ID和Query对象匹配的结果数，使用Promise异步回调。 4899 4900**系统能力：** SystemCapability.DistributedDataManager.KVStore.DistributedKVStore 4901 4902**参数：** 4903 4904| 参数名 | 参数类型 | 必填 | 说明 | 4905| ----- | ------ | ---- | ----------------------- | 4906| deviceId |string | 是 |KvStoreResultSet对象所属的设备ID。 | 4907| query |[Query](#query8) | 是 |表示查询对象。 | 4908 4909**返回值：** 4910 4911| 类型 | 说明 | 4912| ------ | ------- | 4913|Promise<number> |Promise对象。返回与指定设备ID和Query对象匹配的结果数。| 4914 4915**示例：** 4916 4917```js 4918let kvStore; 4919try { 4920 let entries = []; 4921 for (var i = 0; i < 10; i++) { 4922 var key = 'batch_test_string_key'; 4923 var entry = { 4924 key : key + i, 4925 value : { 4926 type : distributedData.ValueType.STRING, 4927 value : 'batch_test_string_value' 4928 } 4929 } 4930 entries.push(entry); 4931 } 4932 kvStore.putBatch(entries).then(async (err) => { 4933 console.log('putBatch success'); 4934 }).catch((err) => { 4935 console.log('putBatch fail ' + JSON.stringify(err)); 4936 }); 4937 var query = new distributedData.Query(); 4938 query.prefixKey("batch_test"); 4939 kvStore.getResultSize('localDeviceId', query).then((resultSize) => { 4940 console.log('getResultSet succeed.'); 4941 }).catch((err) => { 4942 console.log('getResultSet failed: ' + JSON.stringify(err)); 4943 }); 4944}catch(e) { 4945 console.log('GetResultSize e ' + e); 4946} 4947``` 4948 4949 4950### removeDeviceData<sup>8+</sup> ### 4951 4952removeDeviceData(deviceId: string, callback: AsyncCallback<void>): void 4953 4954从当前数据库中删除指定设备的数据，使用callback异步回调。 4955 4956**系统能力：** SystemCapability.DistributedDataManager.KVStore.DistributedKVStore 4957 4958**参数：** 4959 4960| 参数名 | 参数类型 | 必填 | 说明 | 4961| ----- | ------ | ---- | ----------------------- | 4962| deviceId |string | 是 |标识要删除其数据的设备。 | 4963| callback |AsyncCallback<void> | 是 |回调函数。 | 4964 4965**示例：** 4966 4967```js 4968let kvStore; 4969const KEY_TEST_STRING_ELEMENT = 'key_test_string'; 4970const VALUE_TEST_STRING_ELEMENT = 'value-string-001'; 4971try { 4972 kvStore.put(KEY_TEST_STRING_ELEMENT, VALUE_TEST_STRING_ELEMENT, async function (err,data) { 4973 console.log('RemoveDeviceData put success'); 4974 const deviceid = 'no_exist_device_id'; 4975 kvStore.removeDeviceData(deviceid, async function (err,data) { 4976 if (err == undefined) { 4977 console.log('removeDeviceData success'); 4978 } else { 4979 console.log('removeDeviceData fail'); 4980 kvStore.get('localDeviceId', KEY_TEST_STRING_ELEMENT, async function (err,data) { 4981 console.log('RemoveDeviceData get success'); 4982 }); 4983 } 4984 }); 4985 }); 4986}catch(e) { 4987 console.log('RemoveDeviceData e ' + e); 4988} 4989``` 4990 4991 4992### removeDeviceData<sup>8+</sup> ### 4993 4994removeDeviceData(deviceId: string): Promise<void> 4995 4996从当前数据库中删除指定设备的数据，使用Promise异步回调。 4997 4998**系统能力：** SystemCapability.DistributedDataManager.KVStore.DistributedKVStore 4999 5000**参数：** 5001 5002| 参数名 | 参数类型 | 必填 | 说明 | 5003| ----- | ------ | ---- | ----------------------- | 5004| deviceId |string | 是 |标识要删除其数据的设备。 | 5005 5006**返回值：** 5007 5008| 类型 | 说明 | 5009| ------ | ------- | 5010|Promise<void> |无返回结果的Promise对象。| 5011 5012**示例：** 5013 5014```js 5015let kvStore; 5016const KEY_TEST_STRING_ELEMENT = 'key_test_string'; 5017const VALUE_TEST_STRING_ELEMENT = 'value-string-001'; 5018try { 5019 kvStore.put(KEY_TEST_STRING_ELEMENT, VALUE_TEST_STRING_ELEMENT).then((err) => { 5020 console.log('RemoveDeviceData put success'); 5021 }).catch((err) => { 5022 console.log('RemoveDeviceData put fail ' + JSON.stringify(err)); 5023 }); 5024 const deviceid = 'no_exist_device_id'; 5025 kvStore.removeDeviceData(deviceid).then((err) => { 5026 console.log('removeDeviceData success'); 5027 }).catch((err) => { 5028 console.log('removeDeviceData fail ' + JSON.stringify(err)); 5029 }); 5030 kvStore.get('localDeviceId', KEY_TEST_STRING_ELEMENT).then((data) => { 5031 console.log('RemoveDeviceData get success data:' + data); 5032 }).catch((err) => { 5033 console.log('RemoveDeviceData get fail ' + JSON.stringify(err)); 5034 }); 5035}catch(e) { 5036 console.log('RemoveDeviceData e ' + e); 5037} 5038``` 5039 5040 5041### sync<sup>8+</sup> ### 5042 5043sync(deviceIdList: string[], mode: SyncMode, allowedDelayMs?: number): void 5044 5045在手动同步方式下，触发数据库同步。关于分布式数据服务的同步方式说明，请见[分布式数据服务概述](../../database/database-mdds-overview.md)。 5046 5047**需要权限**： ohos.permission.DISTRIBUTED_DATASYNC。 5048 5049**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 5050 5051**参数：** 5052 5053| 参数名 | 参数类型 | 必填 | 说明 | 5054| ----- | ------ | ---- | ----------------------- | 5055| deviceIdList |string[] | 是 |需要同步DeviceKvStore数据库的设备ID列表。 | 5056| mode |[SyncMode](#syncmode) | 是 |同步模式。 | 5057| allowedDelayMs |number | 否 |可选参数，允许延时时间，单位：ms（毫秒）。 | 5058 5059**示例：** 5060 5061```js 5062let kvStore; 5063const KEY_TEST_SYNC_ELEMENT = 'key_test_sync'; 5064const VALUE_TEST_SYNC_ELEMENT = 'value-string-001'; 5065try { 5066 kvStore.on('syncComplete', function (data) { 5067 console.log('Sync dataChange'); 5068 }); 5069 kvStore.put(KEY_TEST_SYNC_ELEMENT + 'testSync101', VALUE_TEST_SYNC_ELEMENT, function (err,data) { 5070 console.log('Sync put success'); 5071 const devices = ['deviceList']; 5072 const mode = distributedData.SyncMode.PULL_ONLY; 5073 kvStore.sync(devices, mode); 5074 }); 5075}catch(e) { 5076 console.log('Sync e' + e); 5077} 5078``` 5079 5080### on('syncComplete')<sup>8+</sup> ### 5081 5082on(event: 'syncComplete', syncCallback: Callback<Array<[string, number]>>): void 5083 5084订阅同步完成事件回调通知。 5085 5086**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 5087 5088**参数：** 5089 5090| 参数名 | 参数类型 | 必填 | 说明 | 5091| ----- | ------ | ---- | ----------------------- | 5092| event |string | 是 |订阅的事件名，固定为'syncComplete'，表示同步完成事件。 | 5093| syncCallback |Callback<Array<[string, number]>> | 是 |回调函数。用于向调用方发送同步结果的回调。 | 5094 5095**示例：** 5096 5097```js 5098let kvStore; 5099const KEY_TEST_FLOAT_ELEMENT = 'key_test_float'; 5100const VALUE_TEST_FLOAT_ELEMENT = 321.12; 5101try { 5102 kvStore.on('syncComplete', function (data) { 5103 console.log('syncComplete ' + data) 5104 }); 5105 kvStore.put(KEY_TEST_FLOAT_ELEMENT, VALUE_TEST_FLOAT_ELEMENT).then((data) => { 5106 console.log('syncComplete put success'); 5107 }).catch((error) => { 5108 console.log('syncComplete put fail ' + error); 5109 }); 5110}catch(e) { 5111 console.log('syncComplete put e ' + e); 5112} 5113``` 5114 5115 5116### off('syncComplete')<sup>8+</sup> ### 5117 5118off(event: 'syncComplete', syncCallback?: Callback<Array<[string, number]>>): void 5119 5120取消订阅同步完成事件回调通知，该方法为同步方法。 5121 5122**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 5123 5124**参数：** 5125 5126| 参数名 | 参数类型 | 必填 | 说明 | 5127| ----- | ------ | ---- | ----------------------- | 5128| event |string | 是 |取消订阅的事件名，固定为'syncComplete'，表示同步完成事件。 | 5129| syncCallback |Callback<Array<[string, number]>> | 否 |回调函数。用于向调用方发送同步结果的回调。 | 5130 5131**示例：** 5132 5133```js 5134let kvStore; 5135class KvstoreModel { 5136 call(data) { 5137 console.log("syncComplete: " + data); 5138 } 5139 subscribeSyncComplete() { 5140 if (kvStore != null) { 5141 kvStore.on('syncComplete', this.call); 5142 } 5143 } 5144 unsubscribeSyncComplete() { 5145 if (kvStore != null) { 5146 kvStore.off('syncComplete', this.call); 5147 } 5148 } 5149} 5150``` 5151 5152## SyncMode 5153 5154同步模式枚举。 5155 5156**系统能力：** SystemCapability.DistributedDataManager.KVStore.Core 5157 5158| 名称 | 值 | 说明 | 5159| ----- | ------ | ----------------------- | 5160| PULL_ONLY |0 |表示只能从远端拉取数据到本端。 | 5161| PUSH_ONLY |1 |表示只能从本端推送数据到远端。 | 5162| PUSH_PULL |2 |表示从本端推送数据到远端，然后从远端拉取数据到本端。 | 5163