From 64d41d7ba93123fe4ffdea8d3c30ef31bdaa9280 Mon Sep 17 00:00:00 2001
From: sun-dou <sundou3@huawei.com>
Date: Tue, 22 Feb 2022 20:43:45 +0800
Subject: [PATCH] update docs

Signed-off-by: sun-dou <sundou3@huawei.com>
---
 .../database-relational-guidelines.md         | 116 ++++++++
 .../reference/apis/js-apis-data-rdb.md        | 278 ++++++++++++++++++
 .../subsys-data-relational-database-guide.md  | 154 ++++++++--
 3 files changed, 528 insertions(+), 20 deletions(-)

diff --git a/zh-cn/application-dev/database/database-relational-guidelines.md b/zh-cn/application-dev/database/database-relational-guidelines.md
index 127fa0bae8..bd24f69f50 100644
--- a/zh-cn/application-dev/database/database-relational-guidelines.md
+++ b/zh-cn/application-dev/database/database-relational-guidelines.md
@@ -76,6 +76,8 @@
 
 | 类名 | 接口名 | 描述 |
 | -------- | -------- | -------- |
+| RdbPredicates |inDevices(devices: Array<string>): RdbPredicates | 同步分布式数据库时指定组网内的远程设备。<br/>-&nbsp;devices：组网内指定的远程设备ID。<br/>-&nbsp;RdbPredicates：返回与指定字段匹配的谓词。 |
+| RdbPredicates |inAllDevices(): RdbPredicates | 同步分布式数据库时连接到组网内的所有远程设备。<br/>-&nbsp;RdbPredicates：返回与指定字段匹配的谓词。 |
 | RdbPredicates | equalTo(field:&nbsp;string,&nbsp;value:&nbsp;ValueType):&nbsp;RdbPredicates | 配置谓词以匹配数据字段为ValueType且值等于指定值的字段。<br/>-&nbsp;field：数据库表中的列名。<br/>-&nbsp;value：指示要与谓词匹配的值。<br/>-&nbsp;RdbPredicates：返回与指定字段匹配的谓词。 |
 | RdbPredicates | notEqualTo(field:&nbsp;string,&nbsp;value:&nbsp;ValueType):&nbsp;RdbPredicates | 配置谓词以匹配数据字段为ValueType且值不等于指定值的字段。<br/>-&nbsp;field：数据库表中的列名。<br/>-&nbsp;value：指示要与谓词匹配的值。<br/>-&nbsp;RdbPredicates：返回与指定字段匹配的谓词。 |
 | RdbPredicates | beginWrap():&nbsp;RdbPredicates | 向谓词添加左括号。<br/>-&nbsp;RdbPredicates：返回带有左括号的谓词。 |
@@ -145,6 +147,54 @@
 | RdbStore | changeEncryptKey(newEncryptKey:Uint8Array,&nbsp;callback:&nbsp;AsyncCallback&lt;number&gt;):void; | 数据库更改秘钥接口，通过callback&nbsp;可以异步处理返回结果。返回结果0成功，非0失败。 |
 | RdbStore | changeEncryptKey(newEncryptKey:Uint8Array):&nbsp;Promise&lt;number&gt;; | 数据库更改秘钥接口，通过await&nbsp;可以同步处理返回结果。返回结果0成功，非0失败。 |
 
+**设置分布式列表。**
+
+用户可以对当前数据库中的列表设置为分布式列表。
+
+**表9** 设置分布式列表
+
+| 类名 | 接口名 | 描述 |
+| -------- | -------- | -------- |
+| RdbStore | setDistributedTables(tables: Array<string>, callback: AsyncCallback<void>): void;| 设置分布式列表，结果以callback形式返回。<br/>-&nbsp;tables：要设置的分布式列表表名。<br/>-&nbsp;callback：指定callback回调函数。 |
+| RdbStore | setDistributedTables(tables: Array<string>): Promise<void>; | 设置分布式列表，结果以Promise形式返回。<br/>-&nbsp;tables：要设置的分布式列表表名。 |
+
+**根据本地表名获取指定远程设备的分布式表名。**
+
+用户根据本地表名获取指定远程设备的分布式表名。在查询远程设备数据库时，需要使用分布式表名。
+
+**表10** 根据本地表名获取指定远程设备的分布式表名
+
+| 类名 | 接口名 | 描述 |
+| -------- | -------- | -------- |
+| RdbStore | obtainDistributedTableName(device: string, table: string, callback: AsyncCallback<string>): void; | 根据本地表名获取指定远程设备的分布式表名。在查询远程设备数据库时，需要使用分布式表名, 结果以callbck形式返回。<br/>-&nbsp;device：远程设备。<br/>-&nbsp;table：本地表名。<br/>-&nbsp;callback：指定的callback回调函数，如果操作成功，返回远程设备的分布式表名。  |
+| RdbStore | obtainDistributedTableName(device: string, table: string): Promise<string>; | 根据本地表名获取指定远程设备的分布式表名。在查询远程设备数据库时，需要使用分布式表名，结果以Promise形式返回。<br/>-&nbsp;device：远程设备。<br/>-&nbsp;table：本地表名。 |
+
+**在设备之间同步数据。**
+
+**表11** 在设备之间同步数据
+
+| 类名 | 接口名 | 描述 |
+| -------- | -------- | -------- |
+| RdbStore | sync(mode: SyncMode, predicates: RdbPredicates, callback: AsyncCallback<Array<[string, number]>>): void;| 在设备之间同步数据，结果以callback形式返回。<br/>-&nbsp;mode：指同步模式。SYNC_MODE_PUSH 表示数据从本地设备推送到远程设备；SYNC_MODE_PULL 表示数据从远程设备拉至本地设备。<br/>-&nbsp;predicates：约束同步数据和设备。<br/>-&nbsp;callback：指定的callback回调函数，string：设备ID；number：每个设备同步状态，0表示成功，其他值表示失败。 |
+| RdbStore | sync(mode: SyncMode, predicates: RdbPredicates): Promise<Array<[string, number]>>;| 在设备之间同步数据，结果以Promise形式返回。<br/>-&nbsp;mode：指同步模式。SYNC_MODE_PUSH 表示数据从本地设备推送到远程设备；SYNC_MODE_PULL 表示数据从远程设备拉至本地设备。<br/>-&nbsp;predicates：约束同步数据和设备。  |
+
+
+**注册数据库的观察者。**
+
+**表12** 注册数据库的观察者
+
+| 类名 | 接口名 | 描述 |
+| -------- | -------- | -------- |
+| RdbStore |on(event: 'dataChange', type: SubscribeType, observer: Callback<Array<string>>): void;| 注册数据库的观察者。当分布式数据库中的数据发生更改时，将调用回调。<br/>-&nbsp;type：指在{@code SubscribeType}中定义的订阅类型；SUBSCRIBE_TYPE_REMOTE 订阅远程数据更改。<br/>-&nbsp;observer：指分布式数据库中数据更改事件的观察者。 |
+
+**从数据库中删除指定类型的指定观察者。**
+
+**表13** 从数据库中删除指定类型的指定观察者
+
+| 类名 | 接口名 | 描述 |
+| -------- | -------- | -------- |
+| RdbStore |off(event:'dataChange', type: SubscribeType, observer: Callback<Array<string>>): void;| 从数据库中删除指定类型的指定观察者，结果以callbck形式返回。。<br/>-&nbsp;type：指在{@code SubscribeType}中定义的订阅类型；SUBSCRIBE_TYPE_REMOTE 订阅远程数据更改。<br/>-&nbsp;observer：指已注册的数据更改观察者。 |
+
 
 ## 开发步骤
 
@@ -198,3 +248,69 @@
    
    resultSet.close()
    ```
+
+4. 设置分布式同步表。
+   1. 数据库调用接口设置分布式同步列表。
+   2. 判断是否设置成功。
+
+   示例代码如下：
+
+   ```
+   let promise = rdbStore.setDistributedTables(["test"])
+   promise.then(() => {
+       console.info("setDistributedTables success.")
+   }).catch((err) => {
+       console.info("setDistributedTables failed."")
+   })
+   ```
+
+ 5. 分布式数据同步。
+    1. 构造用于同步分布式表的谓词对象，指定组网内的远程设备。
+    2. 调用同步数据的接口 。
+    3. 判断是否数据同步成功。
+
+    示例代码如下：
+
+    ```
+    let predicate = new dataRdb.RdbPredicates('test')
+    predicate.inDevices(['12345678abcde'])
+    let promise = rdbStore.sync(rdb.SyncMode.SYNC_MODE_PUSH, predicate)
+    promise.then(result) {
+        console.log('sync done.')
+        for (let i = 0; i < result.length; i++) {
+            console.log('device=' + result[i][0] + ' status=' + result[i][1])
+        }
+    }).catch((err) => {
+        console.log('sync failed')
+    })
+    ```
+
+6. 分布式数据订阅。
+    1. 调用分布式数据订阅接口，注册数据库的观察者。
+    2. 当分布式数据库中的数据发生更改时，将调用回调。
+
+    示例代码如下：
+
+    ```
+    function storeObserver(devices) {
+        for (let i = 0; i < devices.length; i++) {
+            console.log('device=' + device[i] + ' data changed')
+        }
+    }
+    try {
+        rdbStore.on('dataChange', rdb.SubscribeType.SUBSCRIBE_TYPE_REMOTE, storeObserver)
+    } catch (err) {
+        console.log('register observer failed')
+    }
+    ```
+
+7. 跨设备查询。
+    1. 根据本地表名获取指定远程设备的分布式表名。
+    2. 调用结果集接口，返回查询结果。
+
+    示例代码如下：
+
+    ```
+    let tableName = rdbStore.obtainDistributedTableName(deviceId, "test");
+    let resultSet = rdbStore.querySql("SELECT * FROM " + tableName)
+    ```
\ No newline at end of file
diff --git a/zh-cn/application-dev/reference/apis/js-apis-data-rdb.md b/zh-cn/application-dev/reference/apis/js-apis-data-rdb.md
index 9a4cb242e2..a9cae3a9fc 100644
--- a/zh-cn/application-dev/reference/apis/js-apis-data-rdb.md
+++ b/zh-cn/application-dev/reference/apis/js-apis-data-rdb.md
@@ -152,6 +152,48 @@ constructor(name: string)
   let predicates = new data_rdb.RdbPredicates("EMPLOYEE")
   ```
 
+### inDevices
+
+inDevices(devices: Array<string>): RdbPredicates;
+
+
+同步分布式数据库时指定组网内的远程设备。
+
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | devices | Array<string> | 是 | 指定的组网内的远程设备ID。 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | [RdbPredicates](#rdbpredicates) | 返回与指定字段匹配的谓词。 |
+
+- 示例：
+  ```
+  let predicates = new data_rdb.RdbPredicates("EMPLOYEE")
+  predicate.inDevices(['12345678abcde'])
+  ```
+
+### inAllDevices
+
+inAllDevices(): RdbPredicates;
+
+
+同步分布式数据库时连接到组网内的所有远程设备。
+
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | [RdbPredicates](#rdbpredicates) | 返回与指定字段匹配的谓词。 |
+
+- 示例：
+  ```
+  let predicates = new data_rdb.RdbPredicates("EMPLOYEE")
+  predicates.inAllDevices()
+  ```
 
 ### equalTo
 
@@ -1183,6 +1225,224 @@ executeSql(sql: string, bindArgs?: Array&lt;ValueType&gt;):Promise&lt;void&gt;
   promise.then(() => {
       console.info(TAG + 'delete done.')})
   ```
+
+### setDistributedTables
+
+setDistributedTables(tables: Array<string>, callback: AsyncCallback<void>): void;
+
+设置分布式列表，结果以callbck形式返回。
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | tables | Array<string> | 是 | 要设置的分布式列表表名 |
+  | callback | AsyncCallback&lt;void&gt; | 是 | 指定callback回调函数。 |
+
+- 示例：
+  ```
+  rdbStore.setDistributedTables(["EMPLOYEE"], function (err) {
+      if (err) {
+          console.info('setDistributedTables failed.')
+          return
+      }
+      console.info('setDistributedTables success.')
+  })
+  ```
+
+
+### setDistributedTables
+
+ setDistributedTables(tables: Array<string>): Promise<void>;
+
+设置分布式列表，结果以Promise形式返回。
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | tables | Array<string> | 是 | 要设置的分布式列表表名。 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | Promise&lt;void&gt; | 指定Promise回调函数。 |
+
+- 示例：
+  ```
+  let promise = rdbStore.setDistributedTables(["EMPLOYEE"])
+  promise.then(() => {
+      console.info("setDistributedTables success.")
+  }).catch((err) => {
+      console.info("setDistributedTables failed."")
+  })
+  ```
+
+### obtainDistributedTableName
+
+obtainDistributedTableName(device: string, table: string, callback: AsyncCallback<string>): void;
+
+根据本地表名获取指定远程设备的分布式表名。在查询远程设备数据库时，需要使用分布式表名, 结果以callbck形式返回。
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | device | string | 是 | 远程设备 。|
+  | table | string | 是 | 本地表名。 |
+  | callback | AsyncCallback&lt;string&gt; | 是 | 指定的callback回调函数。如果操作成功，返回远程设备的分布式表名。 |
+
+- 示例：
+  ```
+  rdbStore.obtainDistributedTableName(deviceId, "EMPLOYEE", function (err, tableName) {
+      if (err) {
+          console.info('obtainDistributedTableName failed.')
+          return
+      }
+      console.info('obtainDistributedTableName success, tableName=.' + tableName)
+   })
+  ```
+
+
+### obtainDistributedTableName
+
+ obtainDistributedTableName(device: string, table: string): Promise<string>;
+
+根据本地表名获取指定远程设备的分布式表名。在查询远程设备数据库时，需要使用分布式表名，结果以Promise形式返回。
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | device | string | 是 | 远程设备。 |
+  | table | string | 是 | 本地表名。 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | Promise&lt;string&gt; | 指定Promise回调函数。如果操作成功，返回远程设备的分布式表名。 |
+
+- 示例：
+  ```
+  let promise = rdbStore.obtainDistributedTableName(deviceId, "EMPLOYEE")
+  promise.then((tableName) => {
+      console.info('obtainDistributedTableName success, tableName=' + tableName)
+  }).catch((err) => {
+      console.info('obtainDistributedTableName failed.')
+  })
+  ```
+
+### sync
+
+sync(mode: SyncMode, predicates: RdbPredicates, callback: AsyncCallback<Array<[string, number]>>): void;
+
+在设备之间同步数据, 结果以callbck形式返回。
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | mode | SyncMode | 是 | 指同步模式。该值可以是推、拉。 |
+  | predicates | RdbPredicates | 是 | 约束同步数据和设备。 |
+  | callback | AsyncCallback&lt;Array<[string, number]>&gt; | 是 | 指定的callback回调函数，用于向调用者发送同步结果。string：设备ID；number：每个设备同步状态，0表示成功，其他值表示失败。|
+
+- 示例：
+  ```
+  let predicate = new rdb.RdbPredicates('EMPLOYEE')
+  predicate.inDevices(['12345678abcde'])
+  rdbStore.sync(rdb.SyncMode.SYNC_MODE_PUSH, predicate, function (err, result) {
+      if (err) {
+          console.log('sync failed')
+          return
+       }
+      console.log('sync done.')
+      for (let i = 0; i < result.length; i++) {
+          console.log('device=' + result[i][0] + ' status=' + result[i][1])
+       }
+  })
+  ```
+
+
+### sync
+
+ sync(mode: SyncMode, predicates: RdbPredicates): Promise<Array<[string, number]>>;
+
+在设备之间同步数据，结果以Promise形式返回。
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | mode | SyncMode | 是 | 指同步模式。该值可以是推、拉。 |
+  | predicates | RdbPredicates | 是 | 约束同步数据和设备。 |
+
+- 返回值：
+  | 类型 | 说明 |
+  | -------- | -------- |
+  | Promise&lt;Array<[string, number]>&gt; | 指定Promise回调函数，用于向调用者发送同步结果。string：设备ID；number：每个设备同步状态，0表示成功，其他值表示失败。 |
+
+- 示例：
+  ```
+  let predicate = new rdb.RdbPredicates('EMPLOYEE')
+  predicate.inDevices(['12345678abcde'])
+  let promise = rdbStore.sync(rdb.SyncMode.SYNC_MODE_PUSH, predicate)
+  promise.then(result) {
+      console.log('sync done.')
+      for (let i = 0; i < result.length; i++) {
+          console.log('device=' + result[i][0] + ' status=' + result[i][1])
+      }
+   }).catch((err) => {
+       console.log('sync failed')
+   })
+  ```
+
+### on
+
+on(event: 'dataChange', type: SubscribeType, observer: Callback<Array<string>>): void;
+
+注册数据库的观察者。当分布式数据库中的数据发生更改时，将调用回调。
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | type | SubscribeType | 是 | 指在{@code SubscribeType}中定义的订阅类型。 |
+  | observer | Callback<Array<string>> | 是 | 指分布式数据库中数据更改事件的观察者。 |
+
+- 示例：
+  ```
+  function storeObserver(devices) {
+      for (let i = 0; i < devices.length; i++) {
+          console.log('device=' + device[i] + ' data changed')
+       }
+   }
+   try {
+       rdbStore.on('dataChange', rdb.SubscribeType.SUBSCRIBE_TYPE_REMOTE, storeObserver)
+   } catch (err) {
+       console.log('register observer failed')
+   }
+  ```
+
+### off
+
+off(event:'dataChange', type: SubscribeType, observer: Callback<Array<string>>): void;
+
+从数据库中删除指定类型的指定观察者, 结果以callbck形式返回。
+
+- 参数：
+  | 参数名 | 类型 | 必填 | 说明 |
+  | -------- | -------- | -------- | -------- |
+  | type | SubscribeType | 是 | 指在{@code SubscribeType}中定义的订阅类型。 |
+  | observer | Callback<Array<string>> | 是 | 指已注册的数据更改观察者。|
+
+- 示例：
+  ```
+  function storeObserver(devices) {
+      for (let i = 0; i < devices.length; i++) {
+          console.log('device=' + device[i] + ' data changed')
+      }
+  }
+  try {
+      rdbStore.off('dataChange', rdb.SubscribeType.SUBSCRIBE_TYPE_REMOTE, storeObserver)
+  } catch (err) {
+      console.log('unregister observer failed')
+  }
+  ```
+
+
 ## StoreConfig
 
 管理关系数据库配置。
@@ -1211,3 +1471,21 @@ executeSql(sql: string, bindArgs?: Array&lt;ValueType&gt;):Promise&lt;void&gt;
 | 名称 | 参数类型 | 必填 | 说明 |
 | -------- | -------- | -------- | -------- |
 | [key:&nbsp;string] | [ValueType](#valuetype)\|&nbsp;Uint8Array&nbsp;\|&nbsp;null | 是 | 用于存储键值对。 |
+
+
+## SyncMode
+
+指数据库同步模式。
+
+| 名称 | 说明 |
+| -------- | -------- |
+| SYNC_MODE_PUSH | 表示数据从本地设备推送到远程设备。 |
+| SYNC_MODE_PULL | 表示数据从远程设备拉至本地设备。 |
+
+## SubscribeType
+
+描述订阅类型。
+
+| 名称 | 说明 |
+| -------- | -------- |
+| SUBSCRIBE_TYPE_REMOTE | 订阅远程数据更改。 |
diff --git a/zh-cn/device-dev/subsystems/subsys-data-relational-database-guide.md b/zh-cn/device-dev/subsystems/subsys-data-relational-database-guide.md
index 15df71090d..ef830096d1 100644
--- a/zh-cn/device-dev/subsystems/subsys-data-relational-database-guide.md
+++ b/zh-cn/device-dev/subsystems/subsys-data-relational-database-guide.md
@@ -36,7 +36,7 @@
 - RdbPredicates：开发者无需编写复杂的SQL语句，仅通过调用该类中条件相关的方法，如equalTo、notEqualTo、groupBy、orderByAsc、beginsWith等，就可自动完成SQL语句拼接，方便用户聚焦业务操作。
 - RawRdbPredicates：可满足复杂SQL语句的场景，支持开发者自己设置where条件子句和whereArgs参数。不支持equalTo等条件接口的使用。
 
-  表7 数据库谓词API
+  表3 数据库谓词API
   | 类名 | 接口名 | 描述 |
   |  ----  |  ----  |  ----  |
   | RdbPredicates | AbsPredicates *EqualTo(std::string field, std::string value) | 设置谓词条件，满足field字段与value值相等。 |
@@ -46,6 +46,9 @@
   | RdbPredicates | AbsPredicates *OrderByAsc(std::string field) | 设置谓词条件，根据field字段升序排列。 |
   | RdbPredicates | void SetWhereClause(std::string whereClause) | 设置where条件子句。 |
   | RdbPredicates | void SetWhereArgs(std::vector\<std::string\> whereArgs) | 设置whereArgs参数，该值表示where子句中占位符的值。 |
+  | RdbPredicates | AbsRdbPredicates *InDevices(std::vector<std::string>& devices) | 设置谓词条件，同步分布式数据库时指定组网内的远程设备。 |
+  | RdbPredicates | AbsRdbPredicates *InAllDevices() | 设置谓词条件，同步分布式数据库时连接到组网内的所有远程设备。|
+
 
 ### 数据表的增删改查
 
@@ -55,7 +58,7 @@
 
   关系型数据库提供了插入数据的接口，通过ValuesBucket输入要存储的数据，通过返回值判断是否插入成功，插入成功时返回最新插入数据所在的行号，失败时则返回-1。
 
-  表3 数据表插入API
+  表4 数据表插入API
 
   | 类名 | 接口名 | 描述 |
   |  ----  |  ----  |  ----  |
@@ -74,7 +77,7 @@
 
   调用更新接口，传入要更新的数据，并通过AbsRdbPredicates指定更新条件。该接口的返回值表示更新操作影响的行数。如果更新失败，则返回0。
 
-  表4 数据表更新API
+  表6 数据表更新API
   | 类名 | 接口名 | 描述 |
   |  ----  |  ----  |  ----  |
   | RdbStore | int Update(int &changedRows, const ValuesBucket &values, const AbsRdbPredicates &predicates) | 更新数据库表中符合谓词指定条件的数据。<ul><li> changedRows：更新的记录条数。 </li><li> values：以ValuesBucket存储的要更新的数据。 </li><li> predicates：指定了更新操作的表名和条件。AbsRdbPredicates的实现类有两个：RdbPredicates和RawRdbPredicates。<ul><li> RdbPredicates：支持调用谓词提供的equalTo等接口，设置更新条件。</li><li> RawRdbPredicates：仅支持设置表名、where条件子句、whereArgs三个参数，不支持equalTo等接口调用。 </li></ul></li></ul> |
@@ -86,7 +89,7 @@
   - 直接调用查询接口。使用该接口，会将包含查询条件的谓词自动拼接成完整的SQL语句进行查询操作，无需用户传入原生的SQL语句。
   - 执行原生的SQL语句进行查询操作。
 
-  表6 数据表查询API
+  表7 数据表查询API
   | 类名 | 接口名 | 描述 |
   |  ----  |  ----  |  ----  |
   | RdbStore | std::unique_ptr<AbsSharedResultSet> Query(const AbsRdbPredicates &predicates, const std::vector\<std::string\> columns) | 查询数据。<ul><li> predicates：谓词，可以设置查询条件。AbsRdbPredicates的实现类有两个：RdbPredicates和RawRdbPredicates。<ul><li> RdbPredicates：支持调用谓词提供的equalTo等接口，设置更新条件。</li><li> RawRdbPredicates：仅支持设置表名、where条件子句、whereArgs三个参数，不支持equalTo等接口调用。 </li></ul> <li> columns：规定查询返回的列。</li></ul></li></ul> |
@@ -96,22 +99,61 @@
 
 关系型数据库提供了查询返回的结果集ResultSet，其指向查询结果中的一行数据，供用户对查询结果进行遍历和访问。ResultSet对外API如下所示。
 
-  表8 结果集API
-  | 类名 | 接口名 | 描述 |
-  |  ----  |  ----  |  ----  |
-  | ResultSet | int GoTo(int offset) | 从结果集当前位置移动指定偏移量。 |
-  | ResultSet | int GoToRow(int position) | 将结果集移动到指定位置。 |
-  | ResultSet | int GoToNextRow() | 将结果集向后移动一行。 |
-  | ResultSet | int GoToPreviousRow() | 将结果集向前移动一行。 |
-  | ResultSet | int IsStarted(bool &result) | 判断结果集是否被移动过。 |
-  | ResultSet | int IsEnded(bool &result) | 判断结果集是否被移动到最后一行之后。 | 
-  | ResultSet | int IsAtFirstRow(bool &result) | 判断结果集当前位置是否在第一行。 |
-  | ResultSet | int IsAtLastRow(bool &result) | 判断结果集当前位置是否在最后一行。 |
-  | ResultSet | int GetRowCount(int &count) | 获取当前结果集中的记录条数。 |
-  | ResultSet | int GetColumnCount(int &count) | 获取结果集中的列数。 |
-  | ResultSet | int GetString(int columnIndex, std::string &value) | 获取当前行指定列的值，以String类型返回。 |
-  | ResultSet | int GetBlob(int columnIndex, std::vector\<uint8_t\> &blob) | 获取当前行指定列的值，以字节数组形式返回。 |
-  | ResultSet | int GetDouble(int columnIndex, double &value) | 获取当前行指定列的值，以double型返回。 |
+表8 结果集API
+| 类名 | 接口名 | 描述 |
+|  ----  |  ----  |  ----  |
+| ResultSet | int GoTo(int offset) | 从结果集当前位置移动指定偏移量。 |
+| ResultSet | int GoToRow(int position) | 将结果集移动到指定位置。 |
+| ResultSet | int GoToNextRow() | 将结果集向后移动一行。 |
+| ResultSet | int GoToPreviousRow() | 将结果集向前移动一行。 |
+| ResultSet | int IsStarted(bool &result) | 判断结果集是否被移动过。 |
+| ResultSet | int IsEnded(bool &result) | 判断结果集是否被移动到最后一行之后。 |
+| ResultSet | int IsAtFirstRow(bool &result) | 判断结果集当前位置是否在第一行。 |
+| ResultSet | int IsAtLastRow(bool &result) | 判断结果集当前位置是否在最后一行。 |
+| ResultSet | int GetRowCount(int &count) | 获取当前结果集中的记录条数。 |
+| ResultSet | int GetColumnCount(int &count) | 获取结果集中的列数。 |
+| ResultSet | int GetString(int columnIndex, std::string &value) | 获取当前行指定列的值，以String类型返回。 |
+| ResultSet | int GetBlob(int columnIndex, std::vector\<uint8_t\> &blob) | 获取当前行指定列的值，以字节数组形式返回。 |
+| ResultSet | int GetDouble(int columnIndex, double &value) | 获取当前行指定列的值，以double型返回。 |
+
+### 设置分布式列表
+
+用户可以对当前数据库中的列表设置为分布式列表。
+
+表9 设置分布式列表
+| 类名 | 接口名 | 描述 |
+|  ----  |  ----  |  ----  |
+| RdbStore | bool SetDistributedTables(const std::vector<std::string>& tables) | 设置分布式列表。<ul><li> tables：要设置的分布式列表表名 </li></ul>
+
+### 根据本地表名获取指定远程设备的分布式表名
+
+用户根据本地表名获取指定远程设备的分布式表名。在查询远程设备数据库时，需要使用分布式表名。
+
+表9 根据本地表名获取指定远程设备的分布式表名
+| 类名 | 接口名 | 描述 |
+|  ----  |  ----  |  ----  |
+| RdbStore | std::string ObtainDistributedTableName(const std::string& device, const std::string& table) | 根据本地表名获取指定远程设备的分布式表名。在查询远程设备数据库时，需要使用分布式表名。<ul><li> device：远程设备ID </li><li> table：本地表名</li></ul>
+
+### 在设备之间同步数据
+
+表10 在设备之间同步数据
+| 类名 | 接口名 | 描述 |
+|  ----  |  ----  |  ----  |
+| RdbStore | bool Sync(const SyncOption& option, const AbsRdbPredicates& predicate, const SyncCallback& callback) | 在设备之间同步数据。<ul><li> option：同步选项；mode：同步模式(PUSH表示数据从本地设备推送到远程设备/PULL表示数据从远程设备拉至本地设备)；isBlock：是否阻塞 </li><li> callback：指定的callback回调函数</li></ul>
+
+### 注册数据库的观察者
+
+表10 注册数据库的观察者
+| 类名 | 接口名 | 描述 |
+|  ----  |  ----  |  ----  |
+| RdbStore | bool Subscribe(const SubscribeOption& option, RdbStoreObserver *observer) | 注册数据库的观察者。当分布式数据库中的数据发生更改时，将调用回调。<ul><li> option：订阅类型；</li><li> observer：指分布式数据库中数据更改事件的观察者</li></ul>
+
+### 从数据库中删除指定类型的指定观察者
+
+表10 从数据库中删除指定类型的指定观察者
+| 类名 | 接口名 | 描述 |
+|  ----  |  ----  |  ----  |
+| RdbStore | bool UnSubscribe(const SubscribeOption& option, RdbStoreObserver *observer) | 从数据库中删除指定类型的指定观察者。<ul><li> option：订阅类型；</li><li> observer：指已注册的数据更改观察者</li></ul>
 
 ## 约束与限制
 
@@ -189,3 +231,75 @@
     resultSet.goToNextRow();
     ```
 
+4. 设置分布式同步表
+
+    a. 调用接口设置分布式同步表。
+
+    示例代码如下：
+
+    ```
+    store->SetDistributedTables("test");
+    ```
+
+5. 分布式数据同步
+
+    a. 定义同步模式和阻塞状态。
+
+    b. 构造用于同步分布式表的谓词对象，指定组网内的远程设备。
+
+    c. 调用接口同步数据。
+
+    示例代码如下：
+
+    ```
+    SyncOption option;
+    option.mode = PUSH;
+    option.isBlock = true;
+    AbsRdbPredicates predicate("test");
+    predicate.InAllDevices();
+    store->Sync(option, predicate, []（const SyncResult& result) {
+        for (const auto& [device, status] : result) {
+            LogI("device=%s status=%d", device.c_str(), status);
+        }
+    });
+    ```
+
+6. 分布式数据订阅
+
+    a. 重写数据更改观察者OnChange()函数。
+
+    b. 定义分布式数据订阅类型。
+
+    c. 调用接口实现分布式数据订阅，或取消订阅。
+
+    示例代码如下：
+
+    ```
+    class MyObserver : public RdbStoreObserver {
+    public:
+        void OnChange(const std::vector<std::string>& devices) override {
+            for (const auto& device : devices) {
+                LOGI("device=%s data change", device.c_str());
+            }
+        }
+    };
+
+    SubscribeOption option;
+    option.mode = SubscribeMode::REMOTE;
+    MyObserver observer;
+    store->Subscribe(option, &observer);  // 分布式数据订阅
+
+    store->UnSubscribe(option, &observer);  // 取消订阅
+    ```
+
+7. 跨设备查询
+
+   a. 根据本地表名获取指定远程设备的分布式表名。
+
+   b. 根据指定SQL语句查询数据库中的数据。
+
+   示例代码如下：
+   ```
+    std::string tableName = store->ObtainDistributedTableName("123456789abcd", "test");
+    auto resultSet = store->QuerySql("SELECT * from ?;", tableName);
+    ```
-- 
GitLab