update guidelines, rdb, relationalStore, resultset

Signed-off-by: N PaDaBoo <xuejianwu@huawei.com>

update guidelines, rdb, relationalStore, resultset
Signed-off-by: N PaDaBoo <xuejianwu@huawei.com>
2259205f · PaDaBoo · 0b742776 · 2259205f · 2259205f · 2259205f
4 changed file
--- a/zh-cn/application-dev/database/database-relational-guidelines.md
+++ b/zh-cn/application-dev/database/database-relational-guidelines.md
@@ -7,7 +7,7 @@
 ## 接口说明
-以下是关系型数据库的常用接口说明，大部分为异步接口。异步接口均有callback和Promise两种返回形式，下表均以Promise形式为例，更多接口及使用方式请见[关系型数据库](../reference/apis/js-apis-data-rdb.md)。
+以下是关系型数据库的常用接口说明，大部分为异步接口。异步接口均有callback和Promise两种返回形式，下表均以Promise形式为例，更多接口及使用方式请见[关系型数据库](../reference/apis/js-apis-data-relationalStore.md)。
 ### 数据库的创建和删除
@@ -17,8 +17,8 @@
 | 接口名                                                       | 描述                                                         |
 | ------------------------------------------------------------ | ------------------------------------------------------------ |
-| getRdbStoreV9(context: Context, config: StoreConfigV9, version: number): Promise&lt;RdbStoreV9&gt; | 获得一个相关的RdbStoreV9，操作关系型数据库，用户可以根据自己的需求配置RdbStoreV9的参数，然后通过RdbStoreV9调用相关接口可以执行相关的数据操作，使用Promise异步回调。<br/>-context：应用程序或功能的上下文。<br/>-config：与此RDB存储相关的数据库配置。<br/>-version：数据库版本。目前暂不支持通过version自动识别数据库升级降级操作，只能由开发者自行维护。 |
+| getRdbStore(context: Context, config: StoreConfig): Promise&lt;RdbStore&gt; | 获得一个相关的RdbStore，操作关系型数据库，用户可以根据自己的需求配置RdbStore的参数，然后通过RdbStore调用相关接口可以执行相关的数据操作，使用Promise异步回调。<br/>-context：应用程序或功能的上下文。<br/>-config：与此RDB存储相关的数据库配置。 |
-| deleteRdbStoreV9(context: Context, name: string): Promise&lt;void&gt; | 使用指定的数据库文件配置删除数据库，使用Promise异步回调。<br/>-context：应用程序或功能的上下文。<br/>-name：数据库名称。 |
+| deleteRdbStore(context: Context, name: string): Promise&lt;void&gt; | 使用指定的数据库文件配置删除数据库，使用Promise异步回调。<br/>-context：应用程序或功能的上下文。<br/>-name：数据库名称。 |
 ### 数据库的增删改查
@@ -33,29 +33,29 @@
  | 类名       | 接口名                                                       | 描述                                                         |
  | ---------- | ------------------------------------------------------------ | ------------------------------------------------------------ |
-  | RdbStoreV9 | insert(table: string, values: ValuesBucket): Promise&lt;number&gt; | 向目标表中插入一行数据，使用Promise异步回调。<br>如果操作成功，返回行ID；否则返回-1。<br/>-table：指定的目标表名。<br/>-values：表示要插入到表中的数据行。 |
+  | RdbStore | insert(table: string, values: ValuesBucket): Promise&lt;number&gt; | 向目标表中插入一行数据，使用Promise异步回调。<br>如果操作成功，返回行ID；否则返回-1。<br/>-table：指定的目标表名。<br/>-values：表示要插入到表中的数据行。 |
 - **更新**
-  调用更新接口，传入要更新的数据，并通过RdbPredicatesV9指定更新条件。该接口的返回值表示更新操作影响的行数。如果更新失败，则返回0。
+  调用更新接口，传入要更新的数据，并通过RdbPredicates指定更新条件。该接口的返回值表示更新操作影响的行数。如果更新失败，则返回0。
  **表3** 数据库更新API
  | 类名       | 接口名                                                       | 描述                                                         |
  | ---------- | ------------------------------------------------------------ | ------------------------------------------------------------ |
-  | RdbStoreV9 | update(values: ValuesBucket, predicates: RdbPredicatesV9): Promise&lt;number&gt; | 根据RdbPredicatesV9的指定实例对象更新数据库中的数据，使用Promise异步回调。<br>返回受影响的行数。<br/>-values：以ValuesBucket存储的要更新的数据。<br/>-predicates：表示RdbPredicatesV9的实例对象指定的更新条件。 |
+  | RdbStore | update(values: ValuesBucket, predicates: RdbPredicates): Promise&lt;number&gt; | 根据RdbPredicates的指定实例对象更新数据库中的数据，使用Promise异步回调。<br>返回受影响的行数。<br/>-values：以ValuesBucket存储的要更新的数据。<br/>-predicates：表示RdbPredicates的实例对象指定的更新条件。 |
 - **删除** 
-  调用删除接口，通过RdbPredicatesV9指定删除条件。该接口的返回值表示删除的数据行数，可根据此值判断是否删除成功。如果删除失败，则返回0。
+  调用删除接口，通过RdbPredicates指定删除条件。该接口的返回值表示删除的数据行数，可根据此值判断是否删除成功。如果删除失败，则返回0。
  **表4** 数据库删除API
  | 类名       | 接口名                                                     | 描述                                                         |
  | ---------- | ---------------------------------------------------------- | ------------------------------------------------------------ |
-  | RdbStoreV9 | delete(predicates: RdbPredicatesV9): Promise&lt;number&gt; | 根据RdbPredicatesV9的指定实例对象从数据库中删除数据，使用Promise异步回调。<br>返回受影响的行数。 <br/>-predicates：RdbPredicatesV9的实例对象指定的删除条件。 |
+  | RdbStore | delete(predicates: RdbPredicates): Promise&lt;number&gt; | 根据RdbPredicates的指定实例对象从数据库中删除数据，使用Promise异步回调。<br>返回受影响的行数。 <br/>-predicates：RdbPredicates的实例对象指定的删除条件。 |
 - **查询** 
@@ -69,32 +69,32 @@
 | 类名       | 接口名                                                       | 描述                                                         |
 | ---------- | ------------------------------------------------------------ | ------------------------------------------------------------ |
-| RdbStoreV9 | query(predicates: RdbPredicatesV9, columns?: Array&lt;string&gt;): Promise&lt;ResultSetV9&gt; | 根据指定条件查询数据库中的数据，使用Promise异步回调。<br/>-predicates：表示RdbPredicatesV9的实例对象指定的查询条件。<br/>-columns：表示要查询的列。如果值为空，则查询应用于所有列。 |
+| RdbStore | query(predicates: RdbPredicates, columns?: Array&lt;string&gt;): Promise&lt;ResultSet&gt; | 根据指定条件查询数据库中的数据，使用Promise异步回调。<br/>-predicates：表示RdbPredicates的实例对象指定的查询条件。<br/>-columns：表示要查询的列。如果值为空，则查询应用于所有列。 |
-| RdbStoreV9 | querySql(sql: string, bindArgs?: Array&lt;ValueType&gt;): Promise&lt;ResultSetV9&gt; | 根据指定SQL语句查询数据库中的数据，使用Promise异步回调。<br/>-sql：指定要查询的SQL语句。<br/>-bindArgs：SQL语句中参数的值。 |
+| RdbStore | querySql(sql: string, bindArgs?: Array&lt;ValueType&gt;): Promise&lt;ResultSet&gt; | 根据指定SQL语句查询数据库中的数据，使用Promise异步回调。<br/>-sql：指定要查询的SQL语句。<br/>-bindArgs：SQL语句中参数的值。 |
-| RdbStoreV9 | remoteQuery(device: string, table: string, predicates: RdbPredicatesV9, columns: Array&lt;string&gt;): Promise&lt;ResultSetV9&gt; | 根据指定条件查询指定远程设备数据库中的数据。使用Promise异步回调。<br/>-device：指定远程查询的设备networkId。<br/>-table：指定远程查询的表名。<br/>-predicates：表示RdbPredicatesV9的实例对象，指定查询的条件。<br/>-columns：表示要查询的列。如果值为空，则查询应用于所有列。 |
+| RdbStore | remoteQuery(device: string, table: string, predicates: RdbPredicates, columns: Array&lt;string&gt;): Promise&lt;ResultSet&gt; | 根据指定条件查询指定远程设备数据库中的数据。使用Promise异步回调。<br/>-device：指定远程查询的设备networkId。<br/>-table：指定远程查询的表名。<br/>-predicates：表示RdbPredicates的实例对象，指定查询的条件。<br/>-columns：表示要查询的列。如果值为空，则查询应用于所有列。 |
 ### 数据库谓词的使用
-关系型数据库提供了用于设置数据库操作条件的谓词RdbPredicatesV9，该类确定RDB中条件表达式的值是true还是false。
+关系型数据库提供了用于设置数据库操作条件的谓词RdbPredicates，该类确定RDB中条件表达式的值是true还是false。
-以下列举几个常用谓词，更多谓词的使用请见[关系型数据库谓词](../reference/apis/js-apis-data-rdb.md#rdbpredicates)。
+以下列举几个常用谓词，更多谓词的使用请见[关系型数据库谓词](../reference/apis/js-apis-data-relationalStore.md#rdbpredicates)。
 **表6** 数据库谓词API
 | 类名            | 接口名                                                       | 描述                                                         |
 | --------------- | ------------------------------------------------------------ | ------------------------------------------------------------ |
-| RdbPredicatesV9 | equalTo(field: string, value: ValueType): RdbPredicatesV9    | 配置谓词以匹配数据字段为ValueType且值等于指定值的字段。<br/>-field：数据库表中的列名。<br/>-value：指示要与谓词匹配的值。<br/>-RdbPredicatesV9：返回与指定字段匹配的谓词。 |
+| RdbPredicates | equalTo(field: string, value: ValueType): RdbPredicates    | 配置谓词以匹配数据字段为ValueType且值等于指定值的字段。<br/>-field：数据库表中的列名。<br/>-value：指示要与谓词匹配的值。<br/>-RdbPredicates：返回与指定字段匹配的谓词。 |
-| RdbPredicatesV9 | notEqualTo(field: string, value: ValueType): RdbPredicatesV9 | 配置谓词以匹配数据字段为ValueType且值不等于指定值的字段。<br/>-field：数据库表中的列名。<br/>-value：指示要与谓词匹配的值。<br/>-RdbPredicatesV9：返回与指定字段匹配的谓词。 |
+| RdbPredicates | notEqualTo(field: string, value: ValueType): RdbPredicates | 配置谓词以匹配数据字段为ValueType且值不等于指定值的字段。<br/>-field：数据库表中的列名。<br/>-value：指示要与谓词匹配的值。<br/>-RdbPredicates：返回与指定字段匹配的谓词。 |
-| RdbPredicatesV9 | or(): RdbPredicatesV9                                        | 将或条件添加到谓词中。<br/>-RdbPredicatesV9：返回带有或条件的谓词。 |
+| RdbPredicates | or(): RdbPredicates                                        | 将或条件添加到谓词中。<br/>-RdbPredicates：返回带有或条件的谓词。 |
-| RdbPredicatesV9 | and(): RdbPredicatesV9                                       | 向谓词添加和条件。<br/>-RdbPredicatesV9：返回带有和条件的谓词。 |
+| RdbPredicates | and(): RdbPredicates                                       | 向谓词添加和条件。<br/>-RdbPredicates：返回带有和条件的谓词。 |
-| RdbPredicatesV9 | contains(field: string, value: string): RdbPredicatesV9      | 配置谓词以匹配数据字段为String且value包含指定值的字段。<br/>-field：数据库表中的列名。<br/>-value：指示要与谓词匹配的值。<br/>-RdbPredicatesV9：返回带有包含条件的谓词。 |
+| RdbPredicates | contains(field: string, value: string): RdbPredicates      | 配置谓词以匹配数据字段为String且value包含指定值的字段。<br/>-field：数据库表中的列名。<br/>-value：指示要与谓词匹配的值。<br/>-RdbPredicates：返回带有包含条件的谓词。 |
 ### 查询结果集的使用
-关系型数据库提供了查询返回的结果集ResultSetV9，其指向查询结果中的一行数据，供用户对查询结果进行遍历和访问。
+关系型数据库提供了查询返回的结果集ResultSet，其指向查询结果中的一行数据，供用户对查询结果进行遍历和访问。
-更多结果集的接口使用，请见[结果集](../reference/apis/js-apis-data-resultset.md)。
+更多结果集的接口使用，请见[结果集](../reference/apis/js-apis-data-relationalStore.md#resultset)。
 > **须知：**
 > **结果集使用完后，请一定要调用close方法显式关闭。**
@@ -103,12 +103,12 @@
 | 类名        | 接口名                                   | 描述                                       |
 | ----------- | ---------------------------------------- | ------------------------------------------ |
-| ResultSetV9 | goToFirstRow(): boolean                  | 将结果集移动到第一行。                     |
+| ResultSet | goToFirstRow(): boolean                  | 将结果集移动到第一行。                     |
-| ResultSetV9 | getString(columnIndex: number): string   | 获取当前行指定列的值，以String类型返回。   |
+| ResultSet | getString(columnIndex: number): string   | 获取当前行指定列的值，以String类型返回。   |
-| ResultSetV9 | getBlob(columnIndex: number): Uint8Array | 获取当前行指定列的值，以字节数组形式返回。 |
+| ResultSet | getBlob(columnIndex: number): Uint8Array | 获取当前行指定列的值，以字节数组形式返回。 |
-| ResultSetV9 | getDouble(columnIndex: number): number   | 获取当前行指定列的值，以double型返回。     |
+| ResultSet | getDouble(columnIndex: number): number   | 获取当前行指定列的值，以double型返回。     |
-| ResultSetV9 | getLong(columnIndex: number): number     | 获取当前行指定列的值，以Long形式返回。     |
+| ResultSet | getLong(columnIndex: number): number     | 获取当前行指定列的值，以Long形式返回。     |
-| ResultSetV9 | close(): void                            | 关闭结果集。                               |
+| ResultSet | close(): void                            | 关闭结果集。                               |
@@ -116,7 +116,7 @@
 > **说明：**  
 >
-> - 在使用RdbStoreV9的setDistributedTables、obtainDistributedTableName、sync、on、off接口时，需要请求相应的权限：ohos.permission.DISTRIBUTED_DATASYNC。
+> - 在使用RdbStore的setDistributedTables、obtainDistributedTableName、sync、on、off接口时，需要请求相应的权限：ohos.permission.DISTRIBUTED_DATASYNC。
 > - 使用分布式列表前，需要先建立设备间组网，具体接口及使用可见[设备管理](../reference/apis/js-apis-device-manager.md)。
 **设置分布式列表**
@@ -125,7 +125,7 @@
 | 类名       | 接口名                                                       | 描述                                                         |
 | ---------- | ------------------------------------------------------------ | ------------------------------------------------------------ |
-| RdbStoreV9 | setDistributedTables(tables: Array\<string>): Promise\<void> | 设置分布式列表，使用Promise异步回调。<br/>-tables：要设置的分布式列表表名。 |
+| RdbStore | setDistributedTables(tables: Array\<string>): Promise\<void> | 设置分布式列表，使用Promise异步回调。<br/>-tables：要设置的分布式列表表名。 |
 **根据本地表名获取指定远程设备的分布式表名**
@@ -135,7 +135,7 @@
 | 类名       | 接口名                                                       | 描述                                                         |
 | ---------- | ------------------------------------------------------------ | ------------------------------------------------------------ |
-| RdbStoreV9 | obtainDistributedTableName(device: string, table: string): Promise\<string> | 根据本地表名获取指定远程设备的分布式表名。在查询远程设备数据库时，需要使用分布式表名，使用Promise异步回调。<br/>-device：远程设备。<br/>-table：本地表名。 |
+| RdbStore | obtainDistributedTableName(device: string, table: string): Promise\<string> | 根据本地表名获取指定远程设备的分布式表名。在查询远程设备数据库时，需要使用分布式表名，使用Promise异步回调。<br/>-device：远程设备。<br/>-table：本地表名。 |
 **在设备之间同步数据**
@@ -143,7 +143,7 @@
 | 类名       | 接口名                                                       | 描述                                                         |
 | ---------- | ------------------------------------------------------------ | ------------------------------------------------------------ |
-| RdbStoreV9 | sync(mode: SyncMode, predicates: RdbPredicatesV9): Promise\<Array\<[string, number]>> | 在设备之间同步数据，使用Promise异步回调。<br/>-mode：指同步模式。SYNC_MODE_PUSH 表示数据从本地设备推送到远程设备；SYNC_MODE_PULL 表示数据从远程设备拉至本地设备。<br/>-predicates：约束同步数据和设备。<br>-string：设备ID；number：每个设备同步状态，0表示成功，其他值表示失败。 |
+| RdbStore | sync(mode: SyncMode, predicates: RdbPredicates): Promise\<Array\<[string, number]>> | 在设备之间同步数据，使用Promise异步回调。<br/>-mode：指同步模式。SYNC_MODE_PUSH 表示数据从本地设备推送到远程设备；SYNC_MODE_PULL 表示数据从远程设备拉至本地设备。<br/>-predicates：约束同步数据和设备。<br>-string：设备ID；number：每个设备同步状态，0表示成功，其他值表示失败。 |
 **注册数据库的观察者**
@@ -151,7 +151,7 @@
 | 类名       | 接口名                                                       | 描述                                                         |
 | ---------- | ------------------------------------------------------------ | ------------------------------------------------------------ |
-| RdbStoreV9 | on(event: 'dataChange', type: SubscribeType, observer: Callback\<Array\<string>>): void | 注册数据库的观察者。当分布式数据库中的数据发生更改时，将调用回调。<br/>-type：订阅类型；SUBSCRIBE_TYPE_REMOTE 订阅远程数据更改。<br/>-observer：指分布式数据库中数据更改事件的观察者。 |
+| RdbStore | on(event: 'dataChange', type: SubscribeType, observer: Callback\<Array\<string>>): void | 注册数据库的观察者。当分布式数据库中的数据发生更改时，将调用回调。<br/>-type：订阅类型；SUBSCRIBE_TYPE_REMOTE 订阅远程数据更改。<br/>-observer：指分布式数据库中数据更改事件的观察者。 |
 **从数据库中删除指定类型的指定观察者**
@@ -159,7 +159,7 @@
 | 类名       | 接口名                                                       | 描述                                                         |
 | ---------- | ------------------------------------------------------------ | ------------------------------------------------------------ |
-| RdbStoreV9 | off(event:'dataChange', type: SubscribeType, observer: Callback\<Array\<string>>): void; | 从数据库中删除指定类型的指定观察者，使用callback异步回调。<br/>-type：订阅类型；SUBSCRIBE_TYPE_REMOTE 订阅远程数据更改。<br/>-observer：指已注册的数据更改观察者。 |
+| RdbStore | off(event:'dataChange', type: SubscribeType, observer: Callback\<Array\<string>>): void; | 从数据库中删除指定类型的指定观察者，使用callback异步回调。<br/>-type：订阅类型；SUBSCRIBE_TYPE_REMOTE 订阅远程数据更改。<br/>-observer：指已注册的数据更改观察者。 |
 ### 数据库的备份和恢复
@@ -169,7 +169,7 @@
 | 类名       | 接口名                                        | 描述                                                         |
 | ---------- | --------------------------------------------- | ------------------------------------------------------------ |
-| RdbStoreV9 | backup(destName: string): Promise&lt;void&gt; | 以指定名称备份数据库，使用Promise异步回调。<br/>-destName：指定数据库的备份文件名。 |
+| RdbStore | backup(destName: string): Promise&lt;void&gt; | 以指定名称备份数据库，使用Promise异步回调。<br/>-destName：指定数据库的备份文件名。 |
 **恢复**
@@ -177,17 +177,17 @@
 | 类名       | 接口名                                        | 描述                                                         |
 | ---------- | --------------------------------------------- | ------------------------------------------------------------ |
-| RdbStoreV9 | restore(srcName: string): Promise&lt;void&gt; | 从指定的数据库备份文件恢复数据库，使用Promise异步回调。<br/>-srcName：指定数据库的备份文件名。 |
+| RdbStore | restore(srcName: string): Promise&lt;void&gt; | 从指定的数据库备份文件恢复数据库，使用Promise异步回调。<br/>-srcName：指定数据库的备份文件名。 |
-**事务**
+### 事务
 **表15** 事务
 | 类名     | 接口名                  | 描述                              |
 | -------- | ----------------------- | --------------------------------- |
-| RdbStoreV9 | beginTransaction(): void | 在开始执行SQL语句之前，开始事务。 |
+| RdbStore | beginTransaction(): void | 在开始执行SQL语句之前，开始事务。 |
-| RdbStoreV9 | commit(): void           | 提交已执行的SQL语句。             |
+| RdbStore | commit(): void           | 提交已执行的SQL语句。             |
-| RdbStoreV9 | rollBack(): void         | 回滚已经执行的SQL语句。           |
+| RdbStore | rollBack(): void         | 回滚已经执行的SQL语句。           |
 ## 开发步骤
@@ -202,23 +202,23 @@
   FA模型示例：
    ```js
-   import data_rdb from '@ohos.data.rdb'
+   import data_rdb from '@ohos.data.relationalStore'
    // 获取context
   import featureAbility from '@ohos.ability.featureAbility'
   let context = featureAbility.getContext()
   const CREATE_TABLE_TEST = "CREATE TABLE IF NOT EXISTS test (" + "id INTEGER PRIMARY KEY AUTOINCREMENT, " + "name TEXT NOT NULL, " + "age INTEGER, " + "salary REAL, " + "blobType BLOB)";
-   const STORE_CONFIGV9 = { name: "RdbTest.db",
+   const STORE_CONFIG = { name: "RdbTest.db",
                         securityLevel: data_rdb.SecurityLevel.S1}
-   data_rdb.getRdbStoreV9(context, STORE_CONFIGV9, 1, function (err, rdbStoreV9) {
+   data_rdb.getRdbStore(context, STORE_CONFIG, function (err, rdbStore) {
-      rdbStoreV9.executeSql(CREATE_TABLE_TEST)
+      rdbStore.executeSql(CREATE_TABLE_TEST)
      console.info('create table done.')
   })
    ```
    Stage模型示例：
     ```ts
-   import data_rdb from '@ohos.data.rdb'
+   import data_rdb from '@ohos.data.relationalStore'
    // 获取context
   import Ability from '@ohos.application.Ability'
   let context = null
@@ -230,10 +230,10 @@
   const CREATE_TABLE_TEST = "CREATE TABLE IF NOT EXISTS test (" + "id INTEGER PRIMARY KEY AUTOINCREMENT, " + "name TEXT NOT NULL, " + "age INTEGER, " + "salary REAL, " + "blobType BLOB)";
-   const STORE_CONFIGV9 = { name: "rdbstore.db",
+   const STORE_CONFIG = { name: "rdbstore.db",
                          securityLevel: data_rdb.SecurityLevel.S1}
-   data_rdb.getRdbStoreV9(context, STORE_CONFIGV9, 1, function (err, rdbStoreV9) {
+   data_rdb.getRdbStore(context, STORE_CONFIG, function (err, rdbStore) {
-       rdbStoreV9.executeSql(CREATE_TABLE_TEST)
+       rdbStore.executeSql(CREATE_TABLE_TEST)
       console.info('create table done.')
   })
     ```
@@ -249,7 +249,21 @@
    ```js
    var u8 = new Uint8Array([1, 2, 3])
    const valueBucket = { "name": "Tom", "age": 18, "salary": 100.5, "blobType": u8 }
-    let insertPromise = rdbStoreV9.insert("test", valueBucket)
+    let insertPromise = rdbStore.insert("test", valueBucket)
+    ```
+    ```js
+    beginTransaction()
+    try {
+        var u8 = new Uint8Array([1, 2, 3])
+        const valueBucket1 = { "name": "Tom", "age": 18, "salary": 100.5, "blobType": u8 }
+        const valueBucket2 = { "name": "Jam", "age": 19, "salary": 200.5, "blobType": u8 }
+        let insertPromise1 = rdbStoreV9.insert("test", valueBucket1)
+        let insertPromise2 = rdbStoreV9.insert("test", valueBucket2)
+        commit()
+    } catch (e) {
+        rollBack()
+    }
    ```
 3. 查询数据。
@@ -263,17 +277,17 @@
   示例代码如下：
    ```js
-    let predicatesV9 = new data_rdb.RdbPredicatesV9("test");
+    let predicates = new data_rdb.RdbPredicates("test");
-    predicatesV9.equalTo("name", "Tom")
+    predicates.equalTo("name", "Tom")
-    let promisequery = rdbStoreV9.query(predicatesV9)
+    let promisequery = rdbStore.query(predicates)
-    promisequery.then((resultSetV9) => {
+    promisequery.then((resultSet) => {
-        resultSetV9.goToFirstRow()
+        resultSet.goToFirstRow()
-        const id = resultSetV9.getLong(resultSetV9.getColumnIndex("id"))
+        const id = resultSet.getLong(resultSet.getColumnIndex("id"))
-        const name = resultSetV9.getString(resultSetV9.getColumnIndex("name"))
+        const name = resultSet.getString(resultSet.getColumnIndex("name"))
-        const age = resultSetV9.getLong(resultSetV9.getColumnIndex("age"))
+        const age = resultSet.getLong(resultSet.getColumnIndex("age"))
-        const salary = resultSetV9.getDouble(resultSetV9.getColumnIndex("salary"))
+        const salary = resultSet.getDouble(resultSet.getColumnIndex("salary"))
-        const blobType = resultSetV9.getBlob(resultSetV9.getColumnIndex("blobType"))
+        const blobType = resultSet.getBlob(resultSet.getColumnIndex("blobType"))
-        resultSetV9.close()
+        resultSet.close()
    })
    ```
@@ -301,7 +315,7 @@
    context.requestPermissionsFromUser(['ohos.permission.DISTRIBUTED_DATASYNC'], 666, function (result) {
        console.info(`result.requestCode=${result.requestCode}`)
    })
-    let promise = rdbStoreV9.setDistributedTables(["test"])
+    let promise = rdbStore.setDistributedTables(["test"])
    promise.then(() => {
        console.info("setDistributedTables success.")
    }).catch((err) => {
@@ -320,9 +334,9 @@
    示例代码如下：
    ```js
-    let predicateV9 = new data_rdb.RdbPredicatesV9('test')
+    let predicate = new data_rdb.RdbPredicates('test')
-    predicateV9.inDevices(['12345678abcde'])
+    predicate.inDevices(['12345678abcde'])
-    let promise = rdbStoreV9.sync(data_rdb.SyncMode.SYNC_MODE_PUSH, predicateV9)
+    let promise = rdbStore.sync(data_rdb.SyncMode.SYNC_MODE_PUSH, predicate)
    promise.then((result) => {
        console.log('sync done.')
        for (let i = 0; i < result.length; i++) {
@@ -349,7 +363,7 @@
    }
    try {
-        rdbStoreV9.on('dataChange', data_rdb.SubscribeType.SUBSCRIBE_TYPE_REMOTE, storeObserver)
+        rdbStore.on('dataChange', data_rdb.SubscribeType.SUBSCRIBE_TYPE_REMOTE, storeObserver)
    } catch (err) {
        console.log('register observer failed')
    }
@@ -364,8 +378,8 @@
    示例代码如下：
    ```js
-    let tableName = rdbStoreV9.obtainDistributedTableName(deviceId, "test");
+    let tableName = rdbStore.obtainDistributedTableName(deviceId, "test");
-    let resultSetV9 = rdbStoreV9.querySql("SELECT * FROM " + tableName)
+    let resultSet = rdbStore.querySql("SELECT * FROM " + tableName)
    ```
 8. 远程查询。
@@ -378,17 +392,17 @@
   示例代码如下：
    ```js
-    let rdbPredicateV9 = new data_rdb.RdbPredicatesV9('employee')
+    let rdbPredicate = new data_rdb.RdbPredicates('employee')
-    predicatesV9.greaterThan("id", 0) 
+    predicates.greaterThan("id", 0) 
-    let promiseQuery = rdbStoreV9.remoteQuery('12345678abcde', 'employee', rdbPredicateV9)
+    let promiseQuery = rdbStore.remoteQuery('12345678abcde', 'employee', rdbPredicate)
-    promiseQuery.then((resultSetV9) => {
+    promiseQuery.then((resultSet) => {
-        while (resultSetV9.goToNextRow()) {
+        while (resultSet.goToNextRow()) {
-            let idx = resultSetV9.getLong(0);
+            let idx = resultSet.getLong(0);
-            let name = resultSetV9.getString(1);
+            let name = resultSet.getString(1);
-            let age = resultSetV9.getLong(2);
+            let age = resultSet.getLong(2);
            console.info(idx + " " + name + " " + age);
        }
-        resultSetV9.close();
+        resultSet.close();
    }).catch((err) => {
        console.info("failed to remoteQuery, err: " + err)
    })
@@ -401,7 +415,7 @@
    示例代码如下：
    ```js
-    let promiseBackup = rdbStoreV9.backup("dbBackup.db")
+    let promiseBackup = rdbStore.backup("dbBackup.db")
    promiseBackup.then(() => {
        console.info('Backup success.')
    }).catch((err) => {
@@ -413,7 +427,7 @@
    示例代码如下：
    ```js
-    let promiseRestore = rdbStoreV9.restore("dbBackup.db")
+    let promiseRestore = rdbStore.restore("dbBackup.db")
    promiseRestore.then(() => {
        console.info('Restore success.')
    }).catch((err) => {

--- a/zh-cn/application-dev/reference/apis/js-apis-data-rdb.md
+++ b/zh-cn/application-dev/reference/apis/js-apis-data-rdb.md
-# @ohos.data.rdb<sup>(deprecated)</sup> (关系型数据库)
+# @ohos.data.rdb (关系型数据库)
-从API version 9开始，本模块被@ohos.data.relationalStore代替。
 关系型数据库（Relational Database，RDB）是一种基于关系模型来管理数据的数据库。关系型数据库基于SQLite组件提供了一套完整的对本地数据库进行管理的机制，对外提供了一系列的增、删、改、查等接口，也可以直接运行用户输入的SQL语句来满足复杂的场景需要。
 该模块提供以下关系型数据库相关的常用功能：
- [RdbPredicates](#rdbpredicatesdeprecated)： 数据库中用来代表数据实体的性质、特征或者数据实体之间关系的词项，主要用来定义数据库的操作条件。
+- [RdbPredicates](#rdbpredicates)： 数据库中用来代表数据实体的性质、特征或者数据实体之间关系的词项，主要用来定义数据库的操作条件。
- [RdbStore](#rdbstoredeprecated)：提供管理关系数据库(RDB)方法的接口。
+- [RdbStore](#rdbstore)：提供管理关系数据库(RDB)方法的接口。
 > **说明：**
 > 
-> 本模块首批接口从API version 7开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。
+> 从API Version 9开始，该接口不再维护，推荐使用新接口[@ohos.data.relationalStore](js-apis-data-relationalStore.md)。
 >
->从API version 9开始，本模块被@ohos.data.relationalStore代替。
+> 本模块首批接口从API version 7开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。
 ## 导入模块
 ```js
 import data_rdb from '@ohos.data.rdb';
 ```
-## data_rdb.getRdbStore<sup>(deprecated)</sup>
+## data_rdb.getRdbStore
 getRdbStore(context: Context, config: StoreConfig, version: number, callback: AsyncCallback&lt;RdbStore&gt;): void
 获得一个相关的RdbStore，操作关系型数据库，用户可以根据自己的需求配置RdbStore的参数，然后通过RdbStore调用相关接口可以执行相关的数据操作，使用callback异步回调。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.getRdbStore](js-apis-data-relationalStore.md#data_rdbgetrdbstore9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数：**
@@ -84,16 +79,12 @@ data_rdb.getRdbStore(context, STORE_CONFIG, 1, function (err, rdbStore) {
 })
 ```
-## data_rdb.getRdbStore<sup>(deprecated)</sup>
+## data_rdb.getRdbStore
 getRdbStore(context: Context, config: StoreConfig, version: number): Promise&lt;RdbStore&gt;
 获得一个相关的RdbStore，操作关系型数据库，用户可以根据自己的需求配置RdbStore的参数，然后通过RdbStore调用相关接口可以执行相关的数据操作，使用Promise异步回调。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.getRdbStore](js-apis-data-relationalStore.md#data_rdbgetrdbstore9-1)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数：**
@@ -151,16 +142,12 @@ promise.then(async (rdbStore) => {
 })
 ```
-## data_rdb.deleteRdbStore<sup>(deprecated)</sup>
+## data_rdb.deleteRdbStore
 deleteRdbStore(context: Context, name: string, callback: AsyncCallback&lt;void&gt;): void
 删除数据库，使用callback异步回调。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.deleteRdbStore](js-apis-data-relationalStore.md#data_rdbdeleterdbstore9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数：**
@@ -212,16 +199,12 @@ data_rdb.deleteRdbStore(context, "RdbTest.db", function (err) {
 })
 ```
-## data_rdb.deleteRdbStore<sup>(deprecated)</sup>
+## data_rdb.deleteRdbStore
 deleteRdbStore(context: Context, name: string): Promise&lt;void&gt;
 使用指定的数据库文件配置删除数据库，使用Promise异步回调。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.deleteRdbStore](js-apis-data-relationalStore.md#data_rdbdeleterdbstore9-1)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数**
@@ -287,14 +270,10 @@ promise.then(()=>{
 | S3   | 3    | 表示数据库的安全级别为高级别，当数据泄露时会产生重大影响。例如，包含用户运动、健康、位置等信息的数据库。 |
 | S4   | 4    | 表示数据库的安全级别为关键级别，当数据泄露时会产生严重影响。例如，包含认证凭据、财务数据等信息的数据库。 |
-## ValueType<sup>(deprecated)</sup>
+## ValueType
 用于表示允许的数据字段类型。
-> **说明：**
->
-> 从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.ValueType](js-apis-data-relationalStore.md#valuetype9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 | 类型    | 说明                 |
@@ -304,28 +283,20 @@ promise.then(()=>{
 | boolean | 表示值类型为布尔值。 |
-## ValuesBucket<sup>(deprecated)</sup>
+## ValuesBucket
 用于存储键值对的类型。
-> **说明：**
->
-> 从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.ValuesBucket](js-apis-data-relationalStore.md#valuesbucket9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 | 键类型 | 值类型                                                      |
 | ------ | ----------------------------------------------------------- |
 | string | [ValueType](#valuetype)\|&nbsp;Uint8Array&nbsp;\|&nbsp;null |
-## SyncMode<sup>(deprecated)</sup>
+## SyncMode<sup>8+</sup>
 指数据库同步模式。
-> **说明：**
->
-> 从 API Version 8 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.SyncMode](js-apis-data-relationalStore.md#syncmode9)替代。
 **系统能力：**SystemCapability.DistributedDataManager.RelationalStore.Core
 | 名称           | 值   | 说明                               |
@@ -333,14 +304,10 @@ promise.then(()=>{
 | SYNC_MODE_PUSH | 0    | 表示数据从本地设备推送到远程设备。 |
 | SYNC_MODE_PULL | 1    | 表示数据从远程设备拉至本地设备。   |
-## SubscribeType<sup>(deprecated)</sup>
+## SubscribeType<sup>8+</sup>
 描述订阅类型。
-> **说明：**
->
-> 从 API Version 8 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.SubscribeType](js-apis-data-relationalStore.md#subscribetype9)替代。
 **需要权限：** ohos.permission.DISTRIBUTED_DATASYNC
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
@@ -349,40 +316,26 @@ promise.then(()=>{
 | --------------------- | ---- | ------------------ |
 | SUBSCRIBE_TYPE_REMOTE | 0    | 订阅远程数据更改。 |
-## StoreConfig<sup>(deprecated)</sup>
+## StoreConfig
 管理关系数据库配置。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.StoreConfig](js-apis-data-relationalStore.md#storeconfig9)替代。
 **系统能力：**SystemCapability.DistributedDataManager.RelationalStore.Core
 | 名称 | 类型 | 必填 | 说明 |
 | -------- | -------- | -------- | -------- |
 | name | string | 是 | 数据库文件名。 |
-## RdbPredicates<sup>(deprecated)</sup>
+## RdbPredicates
 表示关系型数据库（RDB）的谓词。该类确定RDB中条件表达式的值是true还是false。
-> **说明：**
+### constructor
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbPredicates](js-apis-data-relationalStore.md#rdbpredicates9)替代。
-### constructor<sup>(deprecated)</sup>
 constructor(name: string)
 构造函数。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbPredicates.constructor](js-apis-data-relationalStore.md#constructor9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数：**
@@ -397,16 +350,12 @@ constructor(name: string)
 let predicates = new data_rdb.RdbPredicates("EMPLOYEE")
 ```
-### inDevices<sup>(deprecated)</sup>
+### inDevices<sup>8+</sup>
 inDevices(devices: Array&lt;string&gt;): RdbPredicates
 同步分布式数据库时连接到组网内指定的远程设备。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbPredicates.inDevices](js-apis-data-relationalStore.md#indevices9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数：**
@@ -428,16 +377,12 @@ let predicates = new data_rdb.RdbPredicates("EMPLOYEE")
 predicates.inDevices(['12345678abcde'])
 ```
-### inAllDevices<sup>(deprecated)</sup>
+### inAllDevices
 inAllDevices(): RdbPredicates
 同步分布式数据库时连接到组网内所有的远程设备。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbPredicates.inAllDevices](js-apis-data-relationalStore.md#inalldevices9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **返回值**：
@@ -453,17 +398,12 @@ let predicates = new data_rdb.RdbPredicates("EMPLOYEE")
 predicates.inAllDevices()
 ```
-### equalTo<sup>(deprecated)</sup>
+### equalTo
 equalTo(field: string, value: ValueType): RdbPredicates
 配置谓词以匹配数据字段为ValueType且值等于指定值的字段。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbPredicates.equalTo](js-apis-data-relationalStore.md#equalto9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数：**
@@ -487,16 +427,12 @@ predicates.equalTo("NAME", "lisi")
 ```
-### notEqualTo<sup>(deprecated)</sup>
+### notEqualTo
 notEqualTo(field: string, value: ValueType): RdbPredicates
 配置谓词以匹配数据字段为ValueType且值不等于指定值的字段。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbPredicates.notEqualTo](js-apis-data-relationalStore.md#notequalto9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数：**
@@ -520,16 +456,12 @@ predicates.notEqualTo("NAME", "lisi")
 ```
-### beginWrap<sup>(deprecated)</sup>
+### beginWrap
 beginWrap(): RdbPredicates
 向谓词添加左括号。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbPredicates.beginWrap](js-apis-data-relationalStore.md#beginwrap9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **返回值**：
@@ -550,16 +482,12 @@ predicates.equalTo("NAME", "lisi")
    .endWrap()
 ```
-### endWrap<sup>(deprecated)</sup>
+### endWrap
 endWrap(): RdbPredicates
 向谓词添加右括号。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbPredicates.endWrap](js-apis-data-relationalStore.md#endwrap9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **返回值**：
@@ -580,16 +508,12 @@ predicates.equalTo("NAME", "lisi")
    .endWrap()
 ```
-### or<sup>(deprecated)</sup>
+### or
 or(): RdbPredicates
 将或条件添加到谓词中。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbPredicates.or](js-apis-data-relationalStore.md#or9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **返回值**：
@@ -607,16 +531,12 @@ predicates.equalTo("NAME", "Lisa")
    .equalTo("NAME", "Rose")
 ```
-### and<sup>(deprecated)</sup>
+### and
 and(): RdbPredicates
 向谓词添加和条件。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbPredicates.and](js-apis-data-relationalStore.md#and9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **返回值**：
@@ -634,17 +554,12 @@ predicates.equalTo("NAME", "Lisa")
    .equalTo("SALARY", 200.5)
 ```
-### contains<sup>(deprecated)</sup>
+### contains
 contains(field: string, value: string): RdbPredicates
 配置谓词以匹配数据字段为string且value包含指定值的字段。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbPredicates.contains](js-apis-data-relationalStore.md#contains9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数：**
@@ -667,16 +582,12 @@ let predicates = new data_rdb.RdbPredicates("EMPLOYEE")
 predicates.contains("NAME", "os")
 ```
-### beginsWith<sup>(deprecated)</sup>
+### beginsWith
 beginsWith(field: string, value: string): RdbPredicates
 配置谓词以匹配数据字段为string且值以指定字符串开头的字段。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbPredicates.beginsWith](js-apis-data-relationalStore.md#beginswith9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数：**
@@ -699,16 +610,12 @@ let predicates = new data_rdb.RdbPredicates("EMPLOYEE")
 predicates.beginsWith("NAME", "os")
 ```
-### endsWith<sup>(deprecated)</sup>
+### endsWith
 endsWith(field: string, value: string): RdbPredicates
 配置谓词以匹配数据字段为string且值以指定字符串结尾的字段。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbPredicates.endsWith](js-apis-data-relationalStore.md#endswith9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数：**
@@ -731,16 +638,12 @@ let predicates = new data_rdb.RdbPredicates("EMPLOYEE")
 predicates.endsWith("NAME", "se")
 ```
-### isNull<sup>(deprecated)</sup>
+### isNull
 isNull(field: string): RdbPredicates
 配置谓词以匹配值为null的字段。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbPredicates.isNull](js-apis-data-relationalStore.md#isnull9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数：**
@@ -761,16 +664,12 @@ let predicates = new data_rdb.RdbPredicates("EMPLOYEE")
 predicates.isNull("NAME")
 ```
-### isNotNull<sup>(deprecated)</sup>
+### isNotNull
 isNotNull(field: string): RdbPredicates
 配置谓词以匹配值不为null的指定字段。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbPredicates.isNotNull](js-apis-data-relationalStore.md#isnotnull9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数：**
@@ -792,17 +691,12 @@ let predicates = new data_rdb.RdbPredicates("EMPLOYEE")
 predicates.isNotNull("NAME")
 ```
-### like<sup>(deprecated)</sup>
+### like
 like(field: string, value: string): RdbPredicates
 配置谓词以匹配数据字段为string且值类似于指定字符串的字段。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbPredicates.like](js-apis-data-relationalStore.md#like9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数：**
@@ -825,17 +719,12 @@ let predicates = new data_rdb.RdbPredicates("EMPLOYEE")
 predicates.like("NAME", "%os%")
 ```
-### glob<sup>(deprecated)</sup>
+### glob
 glob(field: string, value: string): RdbPredicates
 配置RdbPredicates匹配数据字段为string的指定字段。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbPredicates.glob](js-apis-data-relationalStore.md#glob9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数：**
@@ -858,16 +747,12 @@ let predicates = new data_rdb.RdbPredicates("EMPLOYEE")
 predicates.glob("NAME", "?h*g")
 ```
-### between<sup>(deprecated)</sup>
+### between
 between(field: string, low: ValueType, high: ValueType): RdbPredicates
 将谓词配置为匹配数据字段为ValueType且value在给定范围内的指定字段。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbPredicates.between](js-apis-data-relationalStore.md#between9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数：**
@@ -891,16 +776,12 @@ let predicates = new data_rdb.RdbPredicates("EMPLOYEE")
 predicates.between("AGE", 10, 50)
 ```
-### notBetween<sup>(deprecated)</sup>
+### notBetween
 notBetween(field: string, low: ValueType, high: ValueType): RdbPredicates
 配置RdbPredicates以匹配数据字段为ValueType且value超出给定范围的指定字段。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbPredicates.notBetweens](js-apis-data-relationalStore.md#notbetween9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数：**
@@ -924,16 +805,12 @@ let predicates = new data_rdb.RdbPredicates("EMPLOYEE")
 predicates.notBetween("AGE", 10, 50)
 ```
-### greaterThan<sup>(deprecated)</sup>
+### greaterThan
 greaterThan(field: string, value: ValueType): RdbPredicates
 配置谓词以匹配数据字段为ValueType且值大于指定值的字段。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbPredicates.greaterThan](js-apis-data-relationalStore.md#greaterthan9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数：**
@@ -956,17 +833,12 @@ let predicates = new data_rdb.RdbPredicates("EMPLOYEE")
 predicates.greaterThan("AGE", 18)
 ```
-### lessThan<sup>(deprecated)</sup>
+### lessThan
 lessThan(field: string, value: ValueType): RdbPredicates
 配置谓词以匹配数据字段为valueType且value小于指定值的字段。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbPredicates.lessThan](js-apis-data-relationalStore.md#lessthan9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数：**
@@ -989,16 +861,12 @@ let predicates = new data_rdb.RdbPredicates("EMPLOYEE")
 predicates.lessThan("AGE", 20)
 ```
-### greaterThanOrEqualTo<sup>(deprecated)</sup>
+### greaterThanOrEqualTo
 greaterThanOrEqualTo(field: string, value: ValueType): RdbPredicates
 配置谓词以匹配数据字段为ValueType且value大于或等于指定值的字段。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbPredicates.greaterThanOrEqualTo](js-apis-data-relationalStore.md#greaterthanorequalto9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数：**
@@ -1021,16 +889,12 @@ let predicates = new data_rdb.RdbPredicates("EMPLOYEE")
 predicates.greaterThanOrEqualTo("AGE", 18)
 ```
-### lessThanOrEqualTo<sup>(deprecated)</sup>
+### lessThanOrEqualTo
 lessThanOrEqualTo(field: string, value: ValueType): RdbPredicates
 配置谓词以匹配数据字段为ValueType且value小于或等于指定值的字段。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbPredicates.lessThanOrEqualTo](js-apis-data-relationalStore.md#lessthanorequalto9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数：**
@@ -1053,16 +917,12 @@ let predicates = new data_rdb.RdbPredicates("EMPLOYEE")
 predicates.lessThanOrEqualTo("AGE", 20)
 ```
-### orderByAsc<sup>(deprecated)</sup>
+### orderByAsc
 orderByAsc(field: string): RdbPredicates
 配置谓词以匹配其值按升序排序的列。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbPredicates.orderByAsc](js-apis-data-relationalStore.md#orderbyasc9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数：**
@@ -1084,16 +944,12 @@ let predicates = new data_rdb.RdbPredicates("EMPLOYEE")
 predicates.orderByAsc("NAME")
 ```
-### orderByDesc<sup>(deprecated)</sup>
+### orderByDesc
 orderByDesc(field: string): RdbPredicates
 配置谓词以匹配其值按降序排序的列。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbPredicates.orderByDesc](js-apis-data-relationalStore.md#orderbydesc9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数：**
@@ -1115,17 +971,12 @@ let predicates = new data_rdb.RdbPredicates("EMPLOYEE")
 predicates.orderByDesc("AGE")
 ```
-### distinct<sup>(deprecated)</sup>
+### distinct
 distinct(): RdbPredicates
 配置谓词以过滤重复记录并仅保留其中一个。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbPredicates.distinct](js-apis-data-relationalStore.md#distinct9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **返回值**：
@@ -1141,16 +992,12 @@ let predicates = new data_rdb.RdbPredicates("EMPLOYEE")
 predicates.equalTo("NAME", "Rose").distinct()
 ```
-### limitAs<sup>(deprecated)</sup>
+### limitAs
 limitAs(value: number): RdbPredicates
 设置最大数据记录数的谓词。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbPredicates.limitAs](js-apis-data-relationalStore.md#limitas9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数：**
@@ -1172,16 +1019,12 @@ let predicates = new data_rdb.RdbPredicates("EMPLOYEE")
 predicates.equalTo("NAME", "Rose").limitAs(3)
 ```
-### offsetAs<sup>(deprecated)</sup>
+### offsetAs
 offsetAs(rowOffset: number): RdbPredicates
 配置RdbPredicates以指定返回结果的起始位置。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbPredicates.offsetAs](js-apis-data-relationalStore.md#offsetas9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数：**
@@ -1203,16 +1046,12 @@ let predicates = new data_rdb.RdbPredicates("EMPLOYEE")
 predicates.equalTo("NAME", "Rose").offsetAs(3)
 ```
-### groupBy<sup>(deprecated)</sup>
+### groupBy
 groupBy(fields: Array&lt;string&gt;): RdbPredicates
 配置RdbPredicates按指定列分组查询结果。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbPredicates.groupBy](js-apis-data-relationalStore.md#groupby9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数：**
@@ -1234,16 +1073,12 @@ let predicates = new data_rdb.RdbPredicates("EMPLOYEE")
 predicates.groupBy(["AGE", "NAME"])
 ```
-### indexedBy<sup>(deprecated)</sup>
+### indexedBy
 indexedBy(field: string): RdbPredicates
 配置RdbPredicates以指定索引列。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbPredicates.indexedBy](js-apis-data-relationalStore.md#indexedby9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数：**
@@ -1266,16 +1101,12 @@ let predicates = new data_rdb.RdbPredicates("EMPLOYEE")
 predicates.indexedBy("SALARY_INDEX")
 ```
-### in<sup>(deprecated)</sup>
+### in
 in(field: string, value: Array&lt;ValueType&gt;): RdbPredicates
 配置RdbPredicates以匹配数据字段为ValueType数组且值在给定范围内的指定字段。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbPredicates.in](js-apis-data-relationalStore.md#in9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数：**
@@ -1298,16 +1129,12 @@ let predicates = new data_rdb.RdbPredicates("EMPLOYEE")
 predicates.in("AGE", [18, 20])
 ```
-### notIn<sup>(deprecated)</sup>
+### notIn
 notIn(field: string, value: Array&lt;ValueType&gt;): RdbPredicates
 将RdbPredicates配置为匹配数据字段为ValueType且值超出给定范围的指定字段。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbPredicates.notIn](js-apis-data-relationalStore.md#notin9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数：**
@@ -1330,26 +1157,18 @@ let predicates = new data_rdb.RdbPredicates("EMPLOYEE")
 predicates.notIn("NAME", ["Lisa", "Rose"])
 ```
-## RdbStore<sup>(deprecated)</sup>
+## RdbStore
 提供管理关系数据库(RDB)方法的接口。
-> **说明：**
->
-> 从 API Version 7开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbStore](js-apis-data-relationalStore.md#rdbstore9)替代。
 在使用以下相关接口前，请使用[executeSql](#executesql)接口初始化数据库表结构和相关数据，具体可见[关系型数据库开发指导](../../database/database-relational-guidelines.md)。
-### insert<sup>(deprecated)</sup>
+### insert
 insert(table: string, values: ValuesBucket, callback: AsyncCallback&lt;number&gt;):void
 向目标表中插入一行数据，使用callback异步回调。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbStore.insert](js-apis-data-relationalStore.md#insert9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数：**
@@ -1378,17 +1197,12 @@ rdbStore.insert("EMPLOYEE", valueBucket, function (status, rowId) {
 })
 ```
-### insert<sup>(deprecated)</sup>
+### insert
 insert(table: string, values: ValuesBucket):Promise&lt;number&gt;
 向目标表中插入一行数据，使用Promise异步回调。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbStore.insert](js-apis-data-relationalStore.md#insert9-1)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数：**
@@ -1421,16 +1235,12 @@ promise.then((rowId) => {
 })
 ```
-### batchInsert<sup>(deprecated)</sup>
+### batchInsert
 batchInsert(table: string, values: Array&lt;ValuesBucket&gt;, callback: AsyncCallback&lt;number&gt;):void
 向目标表中插入一组数据，使用callback异步回调。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbStore.batchInsert](js-apis-data-relationalStore.md#batchinsert9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数：**
@@ -1473,16 +1283,12 @@ rdbStore.batchInsert("EMPLOYEE", valueBuckets, function(status, insertNum) {
 })
 ```
-### batchInsert<sup>(deprecated)</sup>
+### batchInsert
 batchInsert(table: string, values: Array&lt;ValuesBucket&gt;):Promise&lt;number&gt;
 向目标表中插入一组数据，使用Promise异步回调。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbStore.batchInsert](js-apis-data-relationalStore.md#batchinsert9-1)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数：**
@@ -1529,16 +1335,12 @@ promise.then((insertNum) => {
 })
 ```
-### update<sup>(deprecated)</sup>
+### update
 update(values: ValuesBucket, predicates: RdbPredicates, callback: AsyncCallback&lt;number&gt;):void
 根据RdbPredicates的指定实例对象更新数据库中的数据，使用callback异步回调。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbStore.update](js-apis-data-relationalStore.md#update9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数：**
@@ -1569,16 +1371,12 @@ rdbStore.update(valueBucket, predicates, function (err, ret) {
 })
 ```
-### update<sup>(deprecated)</sup>
+### update
 update(values: ValuesBucket, predicates: RdbPredicates):Promise&lt;number&gt;
 根据RdbPredicates的指定实例对象更新数据库中的数据，使用Promise异步回调。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbStore.update](js-apis-data-relationalStore.md#update9-1)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数：**
@@ -1613,16 +1411,12 @@ promise.then(async (ret) => {
 })
 ```
-### delete<sup>(deprecated)</sup>
+### delete
 delete(predicates: RdbPredicates, callback: AsyncCallback&lt;number&gt;):void
 根据RdbPredicates的指定实例对象从数据库中删除数据，使用callback异步回调。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbStore.delete](js-apis-data-relationalStore.md#delete9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数：**
@@ -1646,17 +1440,12 @@ rdbStore.delete(predicates, function (err, rows) {
 })
 ```
-### delete<sup>(deprecated)</sup>
+### delete
 delete(predicates: RdbPredicates):Promise&lt;number&gt;
 根据RdbPredicates的指定实例对象从数据库中删除数据，使用Promise异步回调。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbStore.delete](js-apis-data-relationalStore.md#delete9-1)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数：**
@@ -1684,16 +1473,12 @@ promise.then((rows) => {
 })
 ```
-### query<sup>(deprecated)</sup>
+### query
 query(predicates: RdbPredicates, columns: Array&lt;string&gt;, callback: AsyncCallback&lt;ResultSet&gt;):void
 根据指定条件查询数据库中的数据，使用callback异步回调。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbStore.query](js-apis-data-relationalStore.md#query9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数：**
@@ -1719,16 +1504,12 @@ rdbStore.query(predicates, ["ID", "NAME", "AGE", "SALARY", "CODES"], function (e
 })
 ```
-### query<sup>(deprecated)</sup>
+### query
 query(predicates: RdbPredicates, columns?: Array&lt;string&gt;):Promise&lt;ResultSet&gt;
 根据指定条件查询数据库中的数据，使用Promise异步回调。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbStore.query](js-apis-data-relationalStore.md#query9-1)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数：**
@@ -1758,16 +1539,12 @@ query(predicates: RdbPredicates, columns?: Array&lt;string&gt;):Promise&lt;Resul
  })
  ```
-### querySql<sup>(deprecated)</sup>
+### querySql
 querySql(sql: string, bindArgs: Array&lt;ValueType&gt;, callback: AsyncCallback&lt;ResultSet&gt;):void
 根据指定SQL语句查询数据库中的数据，使用callback异步回调。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbStore.querySql](js-apis-data-relationalStore.md#querysql9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数：**
@@ -1791,17 +1568,12 @@ rdbStore.querySql("SELECT * FROM EMPLOYEE CROSS JOIN BOOK WHERE BOOK.NAME = ?",
 })
 ```
-### querySql<sup>(deprecated)</sup>
+### querySql
 querySql(sql: string, bindArgs?: Array&lt;ValueType&gt;):Promise&lt;ResultSet&gt;
 根据指定SQL语句查询数据库中的数据，使用Promise异步回调。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbStore.querySql](js-apis-data-relationalStore.md#querysql9-1)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数：**
@@ -1829,16 +1601,12 @@ promise.then((resultSet) => {
 })
 ```
-### executeSql<sup>(deprecated)</sup>
+### executeSql
 executeSql(sql: string, bindArgs: Array&lt;ValueType&gt;, callback: AsyncCallback&lt;void&gt;):void
 执行包含指定参数但不返回值的SQL语句，使用callback异步回调。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbStore.executeSql](js-apis-data-relationalStore.md#executesql9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数：**
@@ -1862,16 +1630,12 @@ rdbStore.executeSql(SQL_CREATE_TABLE, null, function(err) {
 })
 ```
-### executeSql<sup>(deprecated)</sup>
+### executeSql
 executeSql(sql: string, bindArgs?: Array&lt;ValueType&gt;):Promise&lt;void&gt;
 执行包含指定参数但不返回值的SQL语句，使用Promise异步回调。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbStore.executeSql](js-apis-data-relationalStore.md#executesql9-1)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数：**
@@ -1899,16 +1663,12 @@ promise.then(() => {
 })
 ```
-### beginTransaction<sup>(deprecated)</sup>
+### beginTransaction
 beginTransaction():void
 在开始执行SQL语句之前，开始事务。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbStore.beginTransaction](js-apis-data-relationalStore.md#begintransaction9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **示例：**
@@ -1930,16 +1690,12 @@ data_rdb.getRdbStore(context, STORE_CONFIG, 1, async function (err, rdbStore) {
 })
 ```
-### commit<sup>(deprecated)</sup>
+### commit
 commit():void
 提交已执行的SQL语句。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbStore.commit](js-apis-data-relationalStore.md#commit9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **示例：**
@@ -1961,16 +1717,12 @@ data_rdb.getRdbStore(context, STORE_CONFIG, 1, async function (err, rdbStore) {
 })
 ```
-### rollBack<sup>(deprecated)</sup>
+### rollBack
 rollBack():void
 回滚已经执行的SQL语句。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbStore.rollBack](js-apis-data-relationalStore.md#rollback9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **示例：**
@@ -1997,16 +1749,12 @@ data_rdb.getRdbStore(context, STORE_CONFIG, 1, async function (err, rdbStore) {
 })
 ```
-### setDistributedTables<sup>(deprecated)</sup>
+### setDistributedTables
 setDistributedTables(tables: Array&lt;string&gt;, callback: AsyncCallback&lt;void&gt;): void
 设置分布式列表，使用callback异步回调。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbStore.setDistributedTables](js-apis-data-relationalStore.md#setdistributedtables9)替代。
 **需要权限：** ohos.permission.DISTRIBUTED_DATASYNC
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
@@ -2030,16 +1778,12 @@ rdbStore.setDistributedTables(["EMPLOYEE"], function (err) {
 })
 ```
-### setDistributedTables<sup>(deprecated)</sup>
+### setDistributedTables
 setDistributedTables(tables: Array&lt;string&gt;): Promise&lt;void&gt;
 设置分布式列表，使用Promise异步回调。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbStore.setDistributedTables](js-apis-data-relationalStore.md#setdistributedtables9-1)替代。
 **需要权限：** ohos.permission.DISTRIBUTED_DATASYNC
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
@@ -2067,17 +1811,12 @@ promise.then(() => {
 })
 ```
-### obtainDistributedTableName<sup>(deprecated)</sup>
+### obtainDistributedTableName
 obtainDistributedTableName(device: string, table: string, callback: AsyncCallback&lt;string&gt;): void
 根据本地表名获取指定远程设备的分布式表名。在查询远程设备数据库时，需要使用分布式表名, 使用callback异步回调。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbStore.obtainDistributedTableName](js-apis-data-relationalStore.md#obtaindistributedtablename9)替代。
 **需要权限：** ohos.permission.DISTRIBUTED_DATASYNC
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
@@ -2102,16 +1841,12 @@ rdbStore.obtainDistributedTableName("12345678abcde", "EMPLOYEE", function (err,
 })
 ```
-### obtainDistributedTableName<sup>(deprecated)</sup>
+### obtainDistributedTableName
 obtainDistributedTableName(device: string, table: string): Promise&lt;string&gt;
 根据本地表名获取指定远程设备的分布式表名。在查询远程设备数据库时，需要使用分布式表名，使用Promise异步回调。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbStore.obtainDistributedTableName](js-apis-data-relationalStore.md#obtaindistributedtablename9-1)替代。
 **需要权限：** ohos.permission.DISTRIBUTED_DATASYNC
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
@@ -2140,16 +1875,12 @@ promise.then((tableName) => {
 })
 ```
-### sync<sup>(deprecated)</sup>
+### sync<sup>8+</sup>
 sync(mode: SyncMode, predicates: RdbPredicates, callback: AsyncCallback&lt;Array&lt;[string, number]&gt;&gt;): void
 在设备之间同步数据, 使用callback异步回调。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbStore.sync](js-apis-data-relationalStore.md#sync9)替代。
 **需要权限：** ohos.permission.DISTRIBUTED_DATASYNC
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
@@ -2158,7 +1889,7 @@ sync(mode: SyncMode, predicates: RdbPredicates, callback: AsyncCallback&lt;Array
 | 参数名 | 类型 | 必填 | 说明 |
 | -------- | -------- | -------- | -------- |
-| mode | [SyncMode](#syncmodedeprecated) | 是 | 指同步模式。该值可以是推、拉。 |
+| mode | [SyncMode](#syncmode8) | 是 | 指同步模式。该值可以是推、拉。 |
 | predicates | [RdbPredicates](#rdbpredicates) | 是 | 约束同步数据和设备。 |
 | callback | AsyncCallback&lt;Array&lt;[string, number]&gt;&gt; | 是 | 指定的callback回调函数，用于向调用者发送同步结果。string：设备ID；number：每个设备同步状态，0表示成功，其他值表示失败。|
@@ -2179,16 +1910,12 @@ rdbStore.sync(data_rdb.SyncMode.SYNC_MODE_PUSH, predicates, function (err, resul
 })
 ```
-### sync<sup>(deprecated)</sup>
+### sync
 sync(mode: SyncMode, predicates: RdbPredicates): Promise&lt;Array&lt;[string, number]&gt;&gt;
 在设备之间同步数据，使用Promise异步回调。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbStore.sync](js-apis-data-relationalStore.md#sync9-1)替代。
 **需要权限：** ohos.permission.DISTRIBUTED_DATASYNC
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
@@ -2197,7 +1924,7 @@ rdbStore.sync(data_rdb.SyncMode.SYNC_MODE_PUSH, predicates, function (err, resul
 | 参数名 | 类型 | 必填 | 说明 |
 | -------- | -------- | -------- | -------- |
-| mode | [SyncMode](#syncmodedeprecated) | 是 | 指同步模式。该值可以是推、拉。 |
+| mode | [SyncMode](#syncmode8) | 是 | 指同步模式。该值可以是推、拉。 |
 | predicates | [RdbPredicates](#rdbpredicates) | 是 | 约束同步数据和设备。 |
 **返回值**：
@@ -2222,16 +1949,12 @@ promise.then((result) =>{
 })
 ```
-### on('dataChange')<sup>(deprecated)</sup>
+### on('dataChange')
 on(event: 'dataChange', type: SubscribeType, observer: Callback&lt;Array&lt;string&gt;&gt;): void
 注册数据库的观察者。当分布式数据库中的数据发生更改时，将调用回调。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbStore.on](js-apis-data-relationalStore.md#ondatachange9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数：**
@@ -2239,7 +1962,7 @@ on(event: 'dataChange', type: SubscribeType, observer: Callback&lt;Array&lt;stri
 | 参数名 | 类型 | 必填 | 说明 |
 | -------- | -------- | -------- | -------- |
 | event | string | 是 | 取值为'dataChange'，表示数据更改。 |
-| type | [SubscribeType](#subscribetypedeprecated) | 是 | 指在{@code SubscribeType}中定义的订阅类型。 |
+| type | [SubscribeType](#subscribetype8) | 是 | 指在{@code SubscribeType}中定义的订阅类型。 |
 | observer | Callback&lt;Array&lt;string&gt;&gt; | 是 | 指分布式数据库中数据更改事件的观察者。 |
 **示例：**
@@ -2257,16 +1980,12 @@ try {
 }
 ```
-### off('dataChange')<sup>(deprecated)</sup>
+### off('dataChange')
 off(event:'dataChange', type: SubscribeType, observer: Callback&lt;Array&lt;string&gt;&gt;): void
 从数据库中删除指定类型的指定观察者, 使用callback异步回调。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.RdbStore.off](js-apis-data-relationalStore.md#offdatachange9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数：**
@@ -2274,7 +1993,7 @@ off(event:'dataChange', type: SubscribeType, observer: Callback&lt;Array&lt;stri
 | 参数名 | 类型 | 必填 | 说明 |
 | -------- | -------- | -------- | -------- |
 | event | string | 是 | 取值为'dataChange'，表示数据更改。 |
-| type | [SubscribeType](#subscribetypedeprecated)    | 是 | 指在{@code SubscribeType}中定义的订阅类型。 |
+| type | [SubscribeType](#subscribetype8)    | 是 | 指在{@code SubscribeType}中定义的订阅类型。 |
 | observer | Callback&lt;Array&lt;string&gt;&gt; | 是 | 指已注册的数据更改观察者。|
 **示例：**

--- a/zh-cn/application-dev/reference/apis/js-apis-data-relationalStore.md
+++ b/zh-cn/application-dev/reference/apis/js-apis-data-relationalStore.md
@@ -4,9 +4,9 @@
 该模块提供以下关系型数据库相关的常用功能：
- [RdbPredicates](#rdbpredicates9)： 数据库中用来代表数据实体的性质、特征或者数据实体之间关系的词项，主要用来定义数据库的操作条件。
+- [RdbPredicates](#rdbpredicates)： 数据库中用来代表数据实体的性质、特征或者数据实体之间关系的词项，主要用来定义数据库的操作条件。
- [RdbStore](#rdbstore9)：提供管理关系数据库(RDB)方法的接口。
+- [RdbStore](#rdbstore)：提供管理关系数据库(RDB)方法的接口。
- [Resultset](#resultset9)：提供用户调用关系型数据库查询接口之后返回的结果集合。
+- [Resultset](#resultset)：提供用户调用关系型数据库查询接口之后返回的结果集合。
 > **说明：**
 > 
@@ -18,9 +18,9 @@
 import data_rdb from '@ohos.data.relationalStore';
 ```
-## data_rdb.getRdbStore<sup>9+</sup>
+## data_rdb.getRdbStore
-getRdbStore(context: Context, config: StoreConfig, version: number, callback: AsyncCallback&lt;RdbStore&gt;): void
+getRdbStore(context: Context, config: StoreConfig, callback: AsyncCallback&lt;RdbStore&gt;): void
 获得一个相关的RdbStore，操作关系型数据库，用户可以根据自己的需求配置RdbStore的参数，然后通过RdbStore调用相关接口可以执行相关的数据操作，使用callback异步回调。
@@ -32,8 +32,7 @@ getRdbStore(context: Context, config: StoreConfig, version: number, callback: As
 | -------- | ---------------------------------------------- | ---- | ------------------------------------------------------------ |
 | context  | Context                                        | 是   | 应用的上下文。 <br>FA模型的应用Context定义见[Context](js-apis-inner-app-context.md)。<br>Stage模型的应用Context定义见[Context](js-apis-ability-context.md)。 |
 | config   | [StoreConfig](#storeconfig)               | 是   | 与此RDB存储相关的数据库配置。                                |
-| version  | number                                         | 是   | 数据库版本。<br>目前暂不支持通过version自动识别数据库升级降级操作，只能由开发者自行维护。                                                 |
+| callback | AsyncCallback&lt;[RdbStore](#rdbstore)&gt; | 是   | 指定callback回调函数，返回RdbStore对象。                   |
-| callback | AsyncCallback&lt;[RdbStore](#rdbstore9)&gt; | 是   | 指定callback回调函数，返回RdbStore对象。                   |
 **错误码：**
@@ -58,10 +57,17 @@ const STORE_CONFIG = {
    name: "RdbTest.db",
    securityLevel: data_rdb.SecurityLevel.S1
 }
-data_rdb.getRdbStore(context, STORE_CONFIG, 1, function (err, RdbStore) {
+data_rdb.getRdbStore(context, STORE_CONFIG, function (err, RdbStore) {
    if (err) {
        console.info("Get RdbStore failed, err: " + err)
        return
+    }    
+    if (rdbStore.openStatus == OpenStatus.ON_CREATA) {
+        console.log("RdbStore status is ON_CREATA")
+    } else if (rdbStore.openStatus == OpenStatus.ON_OPEN) {
+        console.log("RdbStore status is ON_OPEN")
+    } else {
+        return
    }
    console.log("Get RdbStore successfully.")
 })
@@ -84,18 +90,25 @@ const STORE_CONFIG = {
    name: "RdbTest.db",
    securityLevel: data_rdb.SecurityLevel.S1
 }
-data_rdb.getRdbStore(context, STORE_CONFIG, 1, function (err, RdbStore) {
+data_rdb.getRdbStore(context, STORE_CONFIG, function (err, RdbStore) {
    if (err) {
        console.info("Get RdbStore failed, err: " + err)
        return
    }
+    if (rdbStore.openStatus == OpenStatus.ON_CREATA) {
+        console.log("RdbStore status is ON_CREATA")
+    } else if (rdbStore.openStatus == OpenStatus.ON_OPEN) {
+        console.log("RdbStore status is ON_OPEN")
+    } else {
+        return
+    }
    console.log("Get RdbStore successfully.")
 })
 ```
-## data_rdb.getRdbStore<sup>9+</sup>
+## data_rdb.getRdbStore
-getRdbStore(context: Context, config: StoreConfig, version: number): Promise&lt;RdbStore&gt;
+getRdbStore(context: Context, config: StoreConfig): Promise&lt;RdbStore&gt;
 获得一个相关的RdbStore，操作关系型数据库，用户可以根据自己的需求配置RdbStore的参数，然后通过RdbStore调用相关接口可以执行相关的数据操作，使用Promise异步回调。
@@ -107,13 +120,12 @@ getRdbStore(context: Context, config: StoreConfig, version: number): Promise&lt;
 | ------- | -------------------------------- | ---- | ------------------------------------------------------------ |
 | context | Context                          | 是   | 应用的上下文。 <br>FA模型的应用Context定义见[Context](js-apis-inner-app-context.md)。<br>Stage模型的应用Context定义见[Context](js-apis-ability-context.md)。 |
 | config  | [StoreConfig](#storeconfig) | 是   | 与此RDB存储相关的数据库配置。                                |
-| version | number                           | 是   | 数据库版本。<br>目前暂不支持通过version自动识别数据库升级降级操作，只能由开发者自行维护。                                                 |
 **返回值**：
 | 类型                                      | 说明                              |
 | ----------------------------------------- | --------------------------------- |
-| Promise&lt;[RdbStore](#rdbstore9)&gt; | Promise对象。返回RdbStore对象。 |
+| Promise&lt;[RdbStore](#rdbstore)&gt; | Promise对象。返回RdbStore对象。 |
 **错误码：**
@@ -138,8 +150,15 @@ const STORE_CONFIG = {
    name: "RdbTest.db",
    securityLevel: data_rdb.SecurityLevel.S1
 }
-let promise = data_rdb.getRdbStore(context, STORE_CONFIG, 1);
+let promise = data_rdb.getRdbStore(context, STORE_CONFIG);
 promise.then(async (rdbStore) => {
+    if (rdbStore.openStatus == OpenStatus.ON_CREATA) {
+        console.log("RdbStore status is ON_CREATA")
+    } else if (rdbStore.openStatus == OpenStatus.ON_OPEN) {
+        console.log("RdbStore status is ON_OPEN")
+    } else {
+        return
+    }
    console.log("Get RdbStore successfully.")
 }).catch((err) => {
    console.log("Get RdbStore failed, err: " + err)
@@ -163,15 +182,22 @@ const STORE_CONFIG = {
    name: "RdbTest.db",
    securityLevel: data_rdb.SecurityLevel.S1
 }
-let promise = data_rdb.getRdbStore(context, STORE_CONFIG, 1);
+let promise = data_rdb.getRdbStore(context, STORE_CONFIG);
 promise.then(async (rdbStore) => {
+    if (rdbStore.openStatus == OpenStatus.ON_CREATA) {
+        console.log("RdbStore status is ON_CREATA")
+    } else if (rdbStore.openStatus == OpenStatus.ON_OPEN) {
+        console.log("RdbStore status is ON_OPEN")
+    } else {
+        return
+    }
    console.log("Get RdbStore successfully.")
 }).catch((err) => {
    console.log("Get RdbStore failed, err: " + err)
 })
 ```
-## data_rdb.deleteRdbStore<sup>9+</sup>
+## data_rdb.deleteRdbStore
 deleteRdbStore(context: Context, name: string, callback: AsyncCallback&lt;void&gt;): void
@@ -236,7 +262,7 @@ data_rdb.deleteRdbStore(context, "RdbTest.db", function (err) {
 })
 ```
-## data_rdb.deleteRdbStore<sup>9+</sup>
+## data_rdb.deleteRdbStore
 deleteRdbStore(context: Context, name: string): Promise&lt;void&gt;
@@ -304,7 +330,7 @@ promise.then(()=>{
 })
 ```
-## StoreConfig<sup>9+</sup>
+## StoreConfig
 管理关系数据库配置。
@@ -316,7 +342,7 @@ promise.then(()=>{
 | securityLevel | SecurityLevel | 是   | 设置数据库安全级别                                        |
 | encrypt       | boolean       | 否   | 指定数据库是否加密。<br/> true:加密。<br/> false:非加密。 |
-## SecurityLevel<sup>9+</sup>
+## SecurityLevel
 数据库的安全级别枚举。
@@ -329,7 +355,7 @@ promise.then(()=>{
 | S3   | 3    | 表示数据库的安全级别为高级别，当数据泄露时会产生重大影响。例如，包含用户运动、健康、位置等信息的数据库。 |
 | S4   | 4    | 表示数据库的安全级别为关键级别，当数据泄露时会产生严重影响。例如，包含认证凭据、财务数据等信息的数据库。 |
-## ValueType<sup>9+</sup>
+## ValueType
 用于表示允许的数据字段类型。
@@ -341,7 +367,7 @@ promise.then(()=>{
 | string  | 表示值类型为字符。   |
 | boolean | 表示值类型为布尔值。 |
-## ValuesBucket<sup>9+</sup>
+## ValuesBucket
 用于存储键值对的类型。
@@ -351,7 +377,7 @@ promise.then(()=>{
 | ------ | ----------------------------------------------------------- |
 | string | [ValueType](#valuetype)\|&nbsp;Uint8Array&nbsp;\|&nbsp;null |
-## SyncMode<sup>9+</sup>
+## SyncMode
 指数据库同步模式。
@@ -362,7 +388,7 @@ promise.then(()=>{
 | SYNC_MODE_PUSH | 0    | 表示数据从本地设备推送到远程设备。 |
 | SYNC_MODE_PULL | 1    | 表示数据从远程设备拉至本地设备。   |
-## SubscribeType<sup>9+</sup>
+## SubscribeType
 描述订阅类型。
@@ -388,11 +414,11 @@ promise.then(()=>{
 | ON_CONFLICT_IGNORE   | 4    | 表示当冲突发生时，跳过包含违反约束的行并继续处理 SQL 语句的后续行。 |
 | ON_CONFLICT_REPLACE  | 5    | 表示当冲突发生时，在插入或更新当前行之前删除导致约束违例的预先存在的行，并且命令会继续正常执行。 |
-## RdbPredicates<sup>9+</sup>
+## RdbPredicates
 表示关系型数据库（RDB）的谓词。该类确定RDB中条件表达式的值是true还是false。
-### constructor<sup>9+</sup>
+### constructor
 constructor(name: string)
@@ -412,7 +438,7 @@ constructor(name: string)
 let predicates = new data_rdb.RdbPredicates("EMPLOYEE")
 ```
-### inDevices<sup>9+</sup>
+### inDevices
 inDevices(devices: Array&lt;string&gt;): RdbPredicates
@@ -431,7 +457,7 @@ inDevices(devices: Array&lt;string&gt;): RdbPredicates
 | 类型                                 | 说明                       |
 | ------------------------------------ | -------------------------- |
-| [RdbPredicates](#rdbpredicates9) | 返回与指定字段匹配的谓词。 |
+| [RdbPredicates](#rdbpredicates) | 返回与指定字段匹配的谓词。 |
 **示例：**
@@ -440,7 +466,7 @@ let predicates = new data_rdb.RdbPredicates("EMPLOYEE")
 predicates.inDevices(['12345678abcde'])
 ```
-### inAllDevices<sup>9+</sup>
+### inAllDevices
 inAllDevices(): RdbPredicates
@@ -453,7 +479,7 @@ inAllDevices(): RdbPredicates
 | 类型                                 | 说明                       |
 | ------------------------------------ | -------------------------- |
-| [RdbPredicates](#rdbpredicates9) | 返回与指定字段匹配的谓词。 |
+| [RdbPredicates](#rdbpredicates) | 返回与指定字段匹配的谓词。 |
 **示例：**
@@ -462,7 +488,7 @@ let predicates = new data_rdb.RdbPredicates("EMPLOYEE")
 predicates.inAllDevices()
 ```
-### equalTo<sup>9+</sup>
+### equalTo
 equalTo(field: string, value: ValueType): RdbPredicates
@@ -482,7 +508,7 @@ equalTo(field: string, value: ValueType): RdbPredicates
 | 类型                                 | 说明                       |
 | ------------------------------------ | -------------------------- |
-| [RdbPredicates](#rdbpredicates9) | 返回与指定字段匹配的谓词。 |
+| [RdbPredicates](#rdbpredicates) | 返回与指定字段匹配的谓词。 |
 **示例：**
@@ -492,7 +518,7 @@ predicates.equalTo("NAME", "lisi")
 ```
-### notEqualTo<sup>9+</sup>
+### notEqualTo
 notEqualTo(field: string, value: ValueType): RdbPredicates
@@ -512,7 +538,7 @@ notEqualTo(field: string, value: ValueType): RdbPredicates
 | 类型                                 | 说明                       |
 | ------------------------------------ | -------------------------- |
-| [RdbPredicates](#rdbpredicates9) | 返回与指定字段匹配的谓词。 |
+| [RdbPredicates](#rdbpredicates) | 返回与指定字段匹配的谓词。 |
 **示例：**
@@ -522,7 +548,7 @@ predicates.notEqualTo("NAME", "lisi")
 ```
-### beginWrap<sup>9+</sup>
+### beginWrap
 beginWrap(): RdbPredicates
@@ -535,7 +561,7 @@ beginWrap(): RdbPredicates
 | 类型                                 | 说明                      |
 | ------------------------------------ | ------------------------- |
-| [RdbPredicates](#rdbpredicates9) | 返回带有左括号的Rdb谓词。 |
+| [RdbPredicates](#rdbpredicates) | 返回带有左括号的Rdb谓词。 |
 **示例：**
@@ -549,7 +575,7 @@ predicates.equalTo("NAME", "lisi")
    .endWrap()
 ```
-### endWrap<sup>9+</sup>
+### endWrap
 endWrap(): RdbPredicates
@@ -561,7 +587,7 @@ endWrap(): RdbPredicates
 | 类型                                 | 说明                      |
 | ------------------------------------ | ------------------------- |
-| [RdbPredicates](#rdbpredicates9) | 返回带有右括号的Rdb谓词。 |
+| [RdbPredicates](#rdbpredicates) | 返回带有右括号的Rdb谓词。 |
 **示例：**
@@ -575,7 +601,7 @@ predicates.equalTo("NAME", "lisi")
    .endWrap()
 ```
-### or<sup>9+</sup>
+### or
 or(): RdbPredicates
@@ -587,7 +613,7 @@ or(): RdbPredicates
 | 类型                                 | 说明                      |
 | ------------------------------------ | ------------------------- |
-| [RdbPredicates](#rdbpredicates9) | 返回带有或条件的Rdb谓词。 |
+| [RdbPredicates](#rdbpredicates) | 返回带有或条件的Rdb谓词。 |
 **示例：**
@@ -598,7 +624,7 @@ predicates.equalTo("NAME", "Lisa")
    .equalTo("NAME", "Rose")
 ```
-### and<sup>9+</sup>
+### and
 and(): RdbPredicates
@@ -610,7 +636,7 @@ and(): RdbPredicates
 | 类型                                 | 说明                      |
 | ------------------------------------ | ------------------------- |
-| [RdbPredicates](#rdbpredicates9) | 返回带有和条件的Rdb谓词。 |
+| [RdbPredicates](#rdbpredicates) | 返回带有和条件的Rdb谓词。 |
 **示例：**
@@ -621,7 +647,7 @@ predicates.equalTo("NAME", "Lisa")
    .equalTo("SALARY", 200.5)
 ```
-### contains<sup>9+</sup>
+### contains
 contains(field: string, value: string): RdbPredicates
@@ -640,7 +666,7 @@ contains(field: string, value: string): RdbPredicates
 | 类型                                 | 说明                       |
 | ------------------------------------ | -------------------------- |
-| [RdbPredicates](#rdbpredicates9) | 返回与指定字段匹配的谓词。 |
+| [RdbPredicates](#rdbpredicates) | 返回与指定字段匹配的谓词。 |
 **示例：**
@@ -649,7 +675,7 @@ let predicates = new data_rdb.RdbPredicates("EMPLOYEE")
 predicates.contains("NAME", "os")
 ```
-### beginsWith<sup>9+</sup>
+### beginsWith
 beginsWith(field: string, value: string): RdbPredicates
@@ -668,7 +694,7 @@ beginsWith(field: string, value: string): RdbPredicates
 | 类型                                 | 说明                       |
 | ------------------------------------ | -------------------------- |
-| [RdbPredicates](#rdbpredicates9) | 返回与指定字段匹配的谓词。 |
+| [RdbPredicates](#rdbpredicates) | 返回与指定字段匹配的谓词。 |
 **示例：**
@@ -677,7 +703,7 @@ let predicates = new data_rdb.RdbPredicates("EMPLOYEE")
 predicates.beginsWith("NAME", "os")
 ```
-### endsWith<sup>9+</sup>
+### endsWith
 endsWith(field: string, value: string): RdbPredicates
@@ -696,7 +722,7 @@ endsWith(field: string, value: string): RdbPredicates
 | 类型                                 | 说明                       |
 | ------------------------------------ | -------------------------- |
-| [RdbPredicates](#rdbpredicates9) | 返回与指定字段匹配的谓词。 |
+| [RdbPredicates](#rdbpredicates) | 返回与指定字段匹配的谓词。 |
 **示例：**
@@ -705,7 +731,7 @@ let predicates = new data_rdb.RdbPredicates("EMPLOYEE")
 predicates.endsWith("NAME", "se")
 ```
-### isNull<sup>9+</sup>
+### isNull
 isNull(field: string): RdbPredicates
@@ -723,7 +749,7 @@ isNull(field: string): RdbPredicates
 | 类型                                 | 说明                       |
 | ------------------------------------ | -------------------------- |
-| [RdbPredicates](#rdbpredicates9) | 返回与指定字段匹配的谓词。 |
+| [RdbPredicates](#rdbpredicates) | 返回与指定字段匹配的谓词。 |
 **示例**：
@@ -732,7 +758,7 @@ let predicates = new data_rdb.RdbPredicates("EMPLOYEE")
 predicates.isNull("NAME")
 ```
-### isNotNull<sup>9+</sup>
+### isNotNull
 isNotNull(field: string): RdbPredicates
@@ -750,7 +776,7 @@ isNotNull(field: string): RdbPredicates
 | 类型                                 | 说明                       |
 | ------------------------------------ | -------------------------- |
-| [RdbPredicates](#rdbpredicates9) | 返回与指定字段匹配的谓词。 |
+| [RdbPredicates](#rdbpredicates) | 返回与指定字段匹配的谓词。 |
 **示例：**
@@ -759,7 +785,7 @@ let predicates = new data_rdb.RdbPredicates("EMPLOYEE")
 predicates.isNotNull("NAME")
 ```
-### like<sup>9+</sup>
+### like
 like(field: string, value: string): RdbPredicates
@@ -778,7 +804,7 @@ like(field: string, value: string): RdbPredicates
 | 类型                                 | 说明                       |
 | ------------------------------------ | -------------------------- |
-| [RdbPredicates](#rdbpredicates9) | 返回与指定字段匹配的谓词。 |
+| [RdbPredicates](#rdbpredicates) | 返回与指定字段匹配的谓词。 |
 **示例：**
@@ -787,7 +813,7 @@ let predicates = new data_rdb.RdbPredicates("EMPLOYEE")
 predicates.like("NAME", "%os%")
 ```
-### glob<sup>9+</sup>
+### glob
 glob(field: string, value: string): RdbPredicates
@@ -806,7 +832,7 @@ glob(field: string, value: string): RdbPredicates
 | 类型                                 | 说明                       |
 | ------------------------------------ | -------------------------- |
-| [RdbPredicates](#rdbpredicates9) | 返回与指定字段匹配的谓词。 |
+| [RdbPredicates](#rdbpredicates) | 返回与指定字段匹配的谓词。 |
 **示例：**
@@ -815,7 +841,7 @@ let predicates = new data_rdb.RdbPredicates("EMPLOYEE")
 predicates.glob("NAME", "?h*g")
 ```
-### between<sup>9+</sup>
+### between
 between(field: string, low: ValueType, high: ValueType): RdbPredicates
@@ -835,7 +861,7 @@ between(field: string, low: ValueType, high: ValueType): RdbPredicates
 | 类型                                 | 说明                       |
 | ------------------------------------ | -------------------------- |
-| [RdbPredicates](#rdbpredicates9) | 返回与指定字段匹配的谓词。 |
+| [RdbPredicates](#rdbpredicates) | 返回与指定字段匹配的谓词。 |
 **示例：**
@@ -844,7 +870,7 @@ let predicates = new data_rdb.RdbPredicates("EMPLOYEE")
 predicates.between("AGE", 10, 50)
 ```
-### notBetween<sup>9+</sup>
+### notBetween
 notBetween(field: string, low: ValueType, high: ValueType): RdbPredicates
@@ -864,7 +890,7 @@ notBetween(field: string, low: ValueType, high: ValueType): RdbPredicates
 | 类型                                 | 说明                       |
 | ------------------------------------ | -------------------------- |
-| [RdbPredicates](#rdbpredicates9) | 返回与指定字段匹配的谓词。 |
+| [RdbPredicates](#rdbpredicates) | 返回与指定字段匹配的谓词。 |
 **示例：**
@@ -873,7 +899,7 @@ let predicates = new data_rdb.RdbPredicates("EMPLOYEE")
 predicates.notBetween("AGE", 10, 50)
 ```
-### greaterThan<sup>9+</sup>
+### greaterThan
 greaterThan(field: string, value: ValueType): RdbPredicates
@@ -892,7 +918,7 @@ greaterThan(field: string, value: ValueType): RdbPredicates
 | 类型                                 | 说明                       |
 | ------------------------------------ | -------------------------- |
-| [RdbPredicates](#rdbpredicates9) | 返回与指定字段匹配的谓词。 |
+| [RdbPredicates](#rdbpredicates) | 返回与指定字段匹配的谓词。 |
 **示例：**
@@ -901,7 +927,7 @@ let predicates = new data_rdb.RdbPredicates("EMPLOYEE")
 predicates.greaterThan("AGE", 18)
 ```
-### lessThan<sup>9+</sup>
+### lessThan
 lessThan(field: string, value: ValueType): RdbPredicates
@@ -920,7 +946,7 @@ lessThan(field: string, value: ValueType): RdbPredicates
 | 类型                                 | 说明                       |
 | ------------------------------------ | -------------------------- |
-| [RdbPredicates](#rdbpredicates9) | 返回与指定字段匹配的谓词。 |
+| [RdbPredicates](#rdbpredicates) | 返回与指定字段匹配的谓词。 |
 **示例：**
@@ -929,7 +955,7 @@ let predicates = new data_rdb.RdbPredicates("EMPLOYEE")
 predicates.lessThan("AGE", 20)
 ```
-### greaterThanOrEqualTo<sup>9+</sup>
+### greaterThanOrEqualTo
 greaterThanOrEqualTo(field: string, value: ValueType): RdbPredicates
@@ -948,7 +974,7 @@ greaterThanOrEqualTo(field: string, value: ValueType): RdbPredicates
 | 类型                                 | 说明                       |
 | ------------------------------------ | -------------------------- |
-| [RdbPredicates](#rdbpredicates9) | 返回与指定字段匹配的谓词。 |
+| [RdbPredicates](#rdbpredicates) | 返回与指定字段匹配的谓词。 |
 **示例：**
@@ -957,7 +983,7 @@ let predicates = new data_rdb.RdbPredicates("EMPLOYEE")
 predicates.greaterThanOrEqualTo("AGE", 18)
 ```
-### lessThanOrEqualTo<sup>9+</sup>
+### lessThanOrEqualTo
 lessThanOrEqualTo(field: string, value: ValueType): RdbPredicates
@@ -976,7 +1002,7 @@ lessThanOrEqualTo(field: string, value: ValueType): RdbPredicates
 | 类型                                 | 说明                       |
 | ------------------------------------ | -------------------------- |
-| [RdbPredicates](#rdbpredicates9) | 返回与指定字段匹配的谓词。 |
+| [RdbPredicates](#rdbpredicates) | 返回与指定字段匹配的谓词。 |
 **示例：**
@@ -985,7 +1011,7 @@ let predicates = new data_rdb.RdbPredicates("EMPLOYEE")
 predicates.lessThanOrEqualTo("AGE", 20)
 ```
-### orderByAsc<sup>9+</sup>
+### orderByAsc
 orderByAsc(field: string): RdbPredicates
@@ -1003,7 +1029,7 @@ orderByAsc(field: string): RdbPredicates
 | 类型                                 | 说明                       |
 | ------------------------------------ | -------------------------- |
-| [RdbPredicates](#rdbpredicates9) | 返回与指定字段匹配的谓词。 |
+| [RdbPredicates](#rdbpredicates) | 返回与指定字段匹配的谓词。 |
 **示例：**
@@ -1012,7 +1038,7 @@ let predicates = new data_rdb.RdbPredicates("EMPLOYEE")
 predicates.orderByAsc("NAME")
 ```
-### orderByDesc<sup>9+</sup>
+### orderByDesc
 orderByDesc(field: string): RdbPredicates
@@ -1030,7 +1056,7 @@ orderByDesc(field: string): RdbPredicates
 | 类型                                 | 说明                       |
 | ------------------------------------ | -------------------------- |
-| [RdbPredicates](#rdbpredicates9) | 返回与指定字段匹配的谓词。 |
+| [RdbPredicates](#rdbpredicates) | 返回与指定字段匹配的谓词。 |
 **示例：**
@@ -1039,7 +1065,7 @@ let predicates = new data_rdb.RdbPredicates("EMPLOYEE")
 predicates.orderByDesc("AGE")
 ```
-### distinct<sup>9+</sup>
+### distinct
 distinct(): RdbPredicates
@@ -1051,7 +1077,7 @@ distinct(): RdbPredicates
 | 类型                                 | 说明                           |
 | ------------------------------------ | ------------------------------ |
-| [RdbPredicates](#rdbpredicates9) | 返回可用于过滤重复记录的谓词。 |
+| [RdbPredicates](#rdbpredicates) | 返回可用于过滤重复记录的谓词。 |
 **示例：**
@@ -1060,7 +1086,7 @@ let predicates = new data_rdb.RdbPredicates("EMPLOYEE")
 predicates.equalTo("NAME", "Rose").distinct()
 ```
-### limitAs<sup>9+</sup>
+### limitAs
 limitAs(value: number): RdbPredicates
@@ -1078,7 +1104,7 @@ limitAs(value: number): RdbPredicates
 | 类型                                 | 说明                                 |
 | ------------------------------------ | ------------------------------------ |
-| [RdbPredicates](#rdbpredicates9) | 返回可用于设置最大数据记录数的谓词。 |
+| [RdbPredicates](#rdbpredicates) | 返回可用于设置最大数据记录数的谓词。 |
 **示例：**
@@ -1087,7 +1113,7 @@ let predicates = new data_rdb.RdbPredicates("EMPLOYEE")
 predicates.equalTo("NAME", "Rose").limitAs(3)
 ```
-### offsetAs<sup>9+</sup>
+### offsetAs
 offsetAs(rowOffset: number): RdbPredicates
@@ -1105,7 +1131,7 @@ offsetAs(rowOffset: number): RdbPredicates
 | 类型                                 | 说明                                 |
 | ------------------------------------ | ------------------------------------ |
-| [RdbPredicates](#rdbpredicates9) | 返回具有指定返回结果起始位置的谓词。 |
+| [RdbPredicates](#rdbpredicates) | 返回具有指定返回结果起始位置的谓词。 |
 **示例：**
@@ -1114,7 +1140,7 @@ let predicates = new data_rdb.RdbPredicates("EMPLOYEE")
 predicates.equalTo("NAME", "Rose").offsetAs(3)
 ```
-### groupBy<sup>9+</sup>
+### groupBy
 groupBy(fields: Array&lt;string&gt;): RdbPredicates
@@ -1132,7 +1158,7 @@ groupBy(fields: Array&lt;string&gt;): RdbPredicates
 | 类型                                 | 说明                   |
 | ------------------------------------ | ---------------------- |
-| [RdbPredicates](#rdbpredicates9) | 返回分组查询列的谓词。 |
+| [RdbPredicates](#rdbpredicates) | 返回分组查询列的谓词。 |
 **示例：**
@@ -1141,7 +1167,7 @@ let predicates = new data_rdb.RdbPredicates("EMPLOYEE")
 predicates.groupBy(["AGE", "NAME"])
 ```
-### indexedBy<sup>9+</sup>
+### indexedBy
 indexedBy(field: string): RdbPredicates
@@ -1160,7 +1186,7 @@ indexedBy(field: string): RdbPredicates
 | 类型                                 | 说明                                  |
 | ------------------------------------ | ------------------------------------- |
-| [RdbPredicates](#rdbpredicates9) | 返回具有指定索引列的RdbPredicates。 |
+| [RdbPredicates](#rdbpredicates) | 返回具有指定索引列的RdbPredicates。 |
 **示例：**
@@ -1169,7 +1195,7 @@ let predicates = new data_rdb.RdbPredicates("EMPLOYEE")
 predicates.indexedBy("SALARY_INDEX")
 ```
-### in<sup>9+</sup>
+### in
 in(field: string, value: Array&lt;ValueType&gt;): RdbPredicates
@@ -1188,7 +1214,7 @@ in(field: string, value: Array&lt;ValueType&gt;): RdbPredicates
 | 类型                                 | 说明                       |
 | ------------------------------------ | -------------------------- |
-| [RdbPredicates](#rdbpredicates9) | 返回与指定字段匹配的谓词。 |
+| [RdbPredicates](#rdbpredicates) | 返回与指定字段匹配的谓词。 |
 **示例：**
@@ -1197,7 +1223,7 @@ let predicates = new data_rdb.RdbPredicates("EMPLOYEE")
 predicates.in("AGE", [18, 20])
 ```
-### notIn<sup>9+</sup>
+### notIn
 notIn(field: string, value: Array&lt;ValueType&gt;): RdbPredicates
@@ -1216,7 +1242,7 @@ notIn(field: string, value: Array&lt;ValueType&gt;): RdbPredicates
 | 类型                                 | 说明                       |
 | ------------------------------------ | -------------------------- |
-| [RdbPredicates](#rdbpredicates9) | 返回与指定字段匹配的谓词。 |
+| [RdbPredicates](#rdbpredicates) | 返回与指定字段匹配的谓词。 |
 **示例：**
@@ -1225,13 +1251,13 @@ let predicates = new data_rdb.RdbPredicates("EMPLOYEE")
 predicates.notIn("NAME", ["Lisa", "Rose"])
 ```
-## RdbStore<sup>9+</sup>
+## RdbStore
 提供管理关系数据库(RDB)方法的接口。
 在使用以下相关接口前，请使用[executeSql](#executesql)接口初始化数据库表结构和相关数据，具体可见[关系型数据库开发指导](../../database/database-relational-guidelines.md)。
-### insert<sup>9+</sup>
+### insert
 insert(table: string, values: ValuesBucket, callback: AsyncCallback&lt;number&gt;):void
@@ -1300,7 +1326,7 @@ rdbStore.insert("EMPLOYEE", valueBucket, data_rdb.ConflictResolution.ON_CONFLICT
 })
 ```
-### insert<sup>9+</sup>
+### insert
 insert(table: string, values: ValuesBucket):Promise&lt;number&gt;
@@ -1377,7 +1403,7 @@ promise.then((rowId) => {
 })
 ```
-### batchInsert<sup>9+</sup>
+### batchInsert
 batchInsert(table: string, values: Array&lt;ValuesBucket&gt;, callback: AsyncCallback&lt;number&gt;):void
@@ -1425,7 +1451,7 @@ rdbStore.batchInsert("EMPLOYEE", valueBuckets, function(status, insertNum) {
 })
 ```
-### batchInsert<sup>9+</sup>
+### batchInsert
 batchInsert(table: string, values: Array&lt;ValuesBucket&gt;):Promise&lt;number&gt;
@@ -1477,7 +1503,7 @@ promise.then((insertNum) => {
 })
 ```
-### update<sup>9+</sup>
+### update
 update(values: ValuesBucket, predicates: RdbPredicates, callback: AsyncCallback&lt;number&gt;):void
@@ -1490,7 +1516,7 @@ update(values: ValuesBucket, predicates: RdbPredicates, callback: AsyncCallback&
 | 参数名     | 类型                                 | 必填 | 说明                                                         |
 | ---------- | ------------------------------------ | ---- | ------------------------------------------------------------ |
 | values     | [ValuesBucket](#valuesbucket)        | 是   | values指示数据库中要更新的数据行。键值对与数据库表的列名相关联。 |
-| predicates | [RdbPredicates](#rdbpredicates9) | 是   | RdbPredicates的实例对象指定的更新条件。                    |
+| predicates | [RdbPredicates](#rdbpredicates) | 是   | RdbPredicates的实例对象指定的更新条件。                    |
 | callback   | AsyncCallback&lt;number&gt;          | 是   | 指定的callback回调方法。返回受影响的行数。                   |
 **示例：**
@@ -1526,7 +1552,7 @@ update(values: ValuesBucket, predicates: RdbPredicates, conflict: ConflictResolu
 | 参数名     | 类型                                        | 必填 | 说明                                                         |
 | ---------- | ------------------------------------------- | ---- | ------------------------------------------------------------ |
 | values     | [ValuesBucket](#valuesbucket)               | 是   | values指示数据库中要更新的数据行。键值对与数据库表的列名相关联。 |
-| predicates | [RdbPredicates](#rdbpredicates9)            | 是   | RdbPredicates的实例对象指定的更新条件。                      |
+| predicates | [RdbPredicates](#rdbpredicates)            | 是   | RdbPredicates的实例对象指定的更新条件。                      |
 | conflict   | [ConflictResolution](#conflictresolution10) | 是   | 指定冲突解决方式。                                           |
 | callback   | AsyncCallback&lt;number&gt;                 | 是   | 指定的callback回调方法。返回受影响的行数。                   |
@@ -1550,7 +1576,7 @@ rdbStore.update(valueBucket, predicates, data_rdb.ConflictResolution.ON_CONFLICT
 })
 ```
-### update<sup>9+</sup>
+### update
 update(values: ValuesBucket, predicates: RdbPredicates):Promise&lt;number&gt;
@@ -1563,7 +1589,7 @@ update(values: ValuesBucket, predicates: RdbPredicates):Promise&lt;number&gt;
 | 参数名       | 类型                                 | 必填 | 说明                                                         |
 | ------------ | ------------------------------------ | ---- | ------------------------------------------------------------ |
 | values       | [ValuesBucket](#valuesbucket)        | 是   | values指示数据库中要更新的数据行。键值对与数据库表的列名相关联。 |
-| predicates | [RdbPredicates](#rdbpredicates9) | 是   | RdbPredicates的实例对象指定的更新条件。                    |
+| predicates | [RdbPredicates](#rdbpredicates) | 是   | RdbPredicates的实例对象指定的更新条件。                    |
 **返回值**：
@@ -1603,7 +1629,7 @@ update(values: ValuesBucket, predicates: RdbPredicates, conflict: ConflictResolu
 | 参数名     | 类型                                        | 必填 | 说明                                                         |
 | ---------- | ------------------------------------------- | ---- | ------------------------------------------------------------ |
 | values     | [ValuesBucket](#valuesbucket)               | 是   | values指示数据库中要更新的数据行。键值对与数据库表的列名相关联。 |
-| predicates | [RdbPredicates](#rdbpredicates9)            | 是   | RdbPredicates的实例对象指定的更新条件。                      |
+| predicates | [RdbPredicates](#rdbpredicates)            | 是   | RdbPredicates的实例对象指定的更新条件。                      |
 | conflict   | [ConflictResolution](#conflictresolution10) | 是   | 指定冲突解决方式。                                           |
 **返回值**：
@@ -1631,7 +1657,7 @@ promise.then(async (ret) => {
 })
 ```
-### update<sup>9+</sup>
+### update
 update(table: string, values: ValuesBucket, predicates: dataSharePredicates.DataSharePredicates, callback: AsyncCallback&lt;number&gt;):void
@@ -1671,7 +1697,7 @@ rdbStore.update("EMPLOYEE", valueBucket, predicates, function (err, ret) {
 })
 ```
-### update<sup>9+</sup>
+### update
 update(table: string, values: ValuesBucket, predicates: dataSharePredicates.DataSharePredicates):Promise&lt;number&gt;
@@ -1715,7 +1741,7 @@ promise.then(async (ret) => {
 })
 ```
-### delete<sup>9+</sup>
+### delete
 delete(predicates: RdbPredicates, callback: AsyncCallback&lt;number&gt;):void
@@ -1727,7 +1753,7 @@ delete(predicates: RdbPredicates, callback: AsyncCallback&lt;number&gt;):void
 | 参数名     | 类型                                 | 必填 | 说明                                      |
 | ---------- | ------------------------------------ | ---- | ----------------------------------------- |
-| predicates | [RdbPredicates](#rdbpredicates9) | 是   | RdbPredicates的实例对象指定的删除条件。 |
+| predicates | [RdbPredicates](#rdbpredicates) | 是   | RdbPredicates的实例对象指定的删除条件。 |
 | callback   | AsyncCallback&lt;number&gt;          | 是   | 指定callback回调函数。返回受影响的行数。  |
 **示例：**
@@ -1744,7 +1770,7 @@ rdbStore.delete(predicates, function (err, rows) {
 })
 ```
-### delete<sup>9+</sup>
+### delete
 delete(predicates: RdbPredicates):Promise&lt;number&gt;
@@ -1756,7 +1782,7 @@ delete(predicates: RdbPredicates):Promise&lt;number&gt;
 | 参数名     | 类型                                 | 必填 | 说明                                      |
 | ---------- | ------------------------------------ | ---- | ----------------------------------------- |
-| predicates | [RdbPredicates](#rdbpredicates9) | 是   | RdbPredicates的实例对象指定的删除条件。 |
+| predicates | [RdbPredicates](#rdbpredicates) | 是   | RdbPredicates的实例对象指定的删除条件。 |
 **返回值**：
@@ -1777,7 +1803,7 @@ promise.then((rows) => {
 })
 ```
-### delete<sup>9+</sup>
+### delete
 delete(table: string, predicates: dataSharePredicates.DataSharePredicates, callback: AsyncCallback&lt;number&gt;):void
@@ -1810,7 +1836,7 @@ rdbStore.delete("EMPLOYEE", predicates, function (err, rows) {
 })
 ```
-### delete<sup>9+</sup>
+### delete
 delete(table: string, predicates: dataSharePredicates.DataSharePredicates):Promise&lt;number&gt;
@@ -1847,7 +1873,7 @@ promise.then((rows) => {
 })
 ```
-### query<sup>9+</sup>
+### query
 query(predicates: RdbPredicates, columns: Array&lt;string&gt;, callback: AsyncCallback&lt;ResultSet&gt;):void
@@ -1859,7 +1885,7 @@ query(predicates: RdbPredicates, columns: Array&lt;string&gt;, callback: AsyncCa
 | 参数名     | 类型                                                         | 必填 | 说明                                                        |
 | ---------- | ------------------------------------------------------------ | ---- | ----------------------------------------------------------- |
-| predicates | [RdbPredicates](#rdbpredicates9)                         | 是   | RdbPredicates的实例对象指定的查询条件。                   |
+| predicates | [RdbPredicates](#rdbpredicates)                         | 是   | RdbPredicates的实例对象指定的查询条件。                   |
 | columns    | Array&lt;string&gt;                                          | 是   | 表示要查询的列。如果值为空，则查询应用于所有列。            |
 | callback   | AsyncCallback&lt;[ResultSet](js-apis-data-resultset.md)&gt; | 是   | 指定callback回调函数。如果操作成功，则返回ResultSet对象。 |
@@ -1878,7 +1904,7 @@ rdbStore.query(predicates, ["ID", "NAME", "AGE", "SALARY", "CODES"], function (e
 })
 ```
-### query<sup>9+</sup>
+### query
 query(predicates: RdbPredicates, columns?: Array&lt;string&gt;):Promise&lt;ResultSet&gt;
@@ -1890,7 +1916,7 @@ query(predicates: RdbPredicates, columns?: Array&lt;string&gt;):Promise&lt;Resul
 | 参数名     | 类型                                 | 必填 | 说明                                             |
 | ---------- | ------------------------------------ | ---- | ------------------------------------------------ |
-| predicates | [RdbPredicates](#rdbpredicates9) | 是   | RdbPredicates的实例对象指定的查询条件。        |
+| predicates | [RdbPredicates](#rdbpredicates) | 是   | RdbPredicates的实例对象指定的查询条件。        |
 | columns    | Array&lt;string&gt;                  | 否   | 表示要查询的列。如果值为空，则查询应用于所有列。 |
 **返回值**：
@@ -1913,7 +1939,7 @@ promise.then((resultSet) => {
 })
  ```
-### query<sup>9+</sup>
+### query
 query(table: string, predicates: dataSharePredicates.DataSharePredicates, columns: Array&lt;string&gt;, callback: AsyncCallback&lt;ResultSet&gt;):void
@@ -1948,7 +1974,7 @@ rdbStore.query("EMPLOYEE", predicates, ["ID", "NAME", "AGE", "SALARY", "CODES"],
 })
 ```
-### query<sup>9+</sup>
+### query
 query(table: string, predicates: dataSharePredicates.DataSharePredicates, columns?: Array&lt;string&gt;):Promise&lt;ResultSet&gt;
@@ -1987,7 +2013,7 @@ promise.then((resultSet) => {
 })
 ```
-### remoteQuery<sup>9+</sup>
+### remoteQuery
 remoteQuery(device: string, table: string, predicates: RdbPredicates, columns: Array&lt;string&gt; , callback: AsyncCallback&lt;ResultSet&gt;): void
@@ -2001,7 +2027,7 @@ remoteQuery(device: string, table: string, predicates: RdbPredicates, columns: A
 | ---------- | ------------------------------------------------------------ | ---- | ----------------------------------------------------------- |
 | device     | string                                                       | 是   | 指定的远程设备的networkId。                                 |
 | table      | string                                                       | 是   | 指定的目标表名。                                            |
-| predicates | [RdbPredicates](#rdbpredicates9)                         | 是   | RdbPredicates的实例对象，指定查询的条件。                 |
+| predicates | [RdbPredicates](#rdbpredicates)                         | 是   | RdbPredicates的实例对象，指定查询的条件。                 |
 | columns    | Array&lt;string&gt;                                          | 是   | 表示要查询的列。如果值为空，则查询应用于所有列。            |
 | callback   | AsyncCallback&lt;[ResultSet](js-apis-data-resultset.md#resultset)&gt; | 是   | 指定callback回调函数。如果操作成功，则返回ResultSet对象。 |
@@ -2021,7 +2047,7 @@ rdbStore.remoteQuery("deviceId", "EMPLOYEE", predicates, ["ID", "NAME", "AGE", "
 })
 ```
-### remoteQuery<sup>9+</sup>
+### remoteQuery
 remoteQuery(device: string, table: string, predicates: RdbPredicates, columns: Array&lt;string&gt;): Promise&lt;ResultSet&gt;
@@ -2035,7 +2061,7 @@ remoteQuery(device: string, table: string, predicates: RdbPredicates, columns: A
 | ---------- | ------------------------------------ | ---- | ------------------------------------------------ |
 | device     | string                               | 是   | 指定的远程设备的networkId。                      |
 | table      | string                               | 是   | 指定的目标表名。                                 |
-| predicates | [RdbPredicates](#rdbpredicates9) | 是   | RdbPredicates的实例对象，指定查询的条件。      |
+| predicates | [RdbPredicates](#rdbpredicates) | 是   | RdbPredicates的实例对象，指定查询的条件。      |
 | columns    | Array&lt;string&gt;                  | 是   | 表示要查询的列。如果值为空，则查询应用于所有列。 |
 **返回值**：
@@ -2058,7 +2084,7 @@ promise.then((resultSet) => {
 })
 ```
-### querySql<sup>9+</sup>
+### querySql
 querySql(sql: string, bindArgs: Array&lt;ValueType&gt;, callback: AsyncCallback&lt;ResultSet&gt;):void
@@ -2087,7 +2113,7 @@ rdbStore.querySql("SELECT * FROM EMPLOYEE CROSS JOIN BOOK WHERE BOOK.NAME = ?",
 })
 ```
-### querySql<sup>9+</sup>
+### querySql
 querySql(sql: string, bindArgs?: Array&lt;ValueType&gt;):Promise&lt;ResultSet&gt;
@@ -2120,7 +2146,7 @@ promise.then((resultSet) => {
 })
 ```
-### executeSql<sup>9+</sup>
+### executeSql
 executeSql(sql: string, bindArgs: Array&lt;ValueType&gt;, callback: AsyncCallback&lt;void&gt;):void
@@ -2149,7 +2175,7 @@ rdbStore.executeSql(SQL_CREATE_TABLE, null, function(err) {
 })
 ```
-### executeSql<sup>9+</sup>
+### executeSql
 executeSql(sql: string, bindArgs?: Array&lt;ValueType&gt;):Promise&lt;void&gt;
@@ -2182,7 +2208,7 @@ promise.then(() => {
 })
 ```
-### beginTransaction<sup>9+</sup>
+### beginTransaction
 beginTransaction():void
@@ -2197,7 +2223,7 @@ import featureAbility from '@ohos.ability.featureAbility'
 let context = featureAbility.getContext()
 const STORE_CONFIG = { name: "RdbTest.db",
                     securityLevel: data_rdb.SecurityLevel.S1}
-data_rdb.getRdbStore(context, STORE_CONFIG, 1, async function (err, rdbStore) {
+data_rdb.getRdbStore(context, STORE_CONFIG, async function (err, rdbStore) {
    rdbStore.beginTransaction()
 	const valueBucket = {
 		"name": "lisi",
@@ -2210,7 +2236,7 @@ data_rdb.getRdbStore(context, STORE_CONFIG, 1, async function (err, rdbStore) {
 })
 ```
-### commit<sup>9+</sup>
+### commit
 commit():void
@@ -2225,7 +2251,7 @@ import featureAbility from '@ohos.ability.featureAbility'
 let context = featureAbility.getContext()
 const STORE_CONFIG = { name: "RdbTest.db",
                     securityLevel: data_rdb.SecurityLevel.S1}
-data_rdb.getRdbStore(context, STORE_CONFIG, 1, async function (err, rdbStore) {
+data_rdb.getRdbStore(context, STORE_CONFIG, async function (err, rdbStore) {
    rdbStore.beginTransaction()
 	const valueBucket = {
 		"name": "lisi",
@@ -2238,7 +2264,7 @@ data_rdb.getRdbStore(context, STORE_CONFIG, 1, async function (err, rdbStore) {
 })
 ```
-### rollBack<sup>9+</sup>
+### rollBack
 rollBack():void
@@ -2253,7 +2279,7 @@ import featureAbility from '@ohos.ability.featureAbility'
 let context = featureAbility.getContext()
 const STORE_CONFIG = { name: "RdbTest.db",
                     securityLevel: data_rdb.SecurityLevel.S1}
-data_rdb.getRdbStore(context, STORE_CONFIG, 1, async function (err, rdbStore) {
+data_rdb.getRdbStore(context, STORE_CONFIG, async function (err, rdbStore) {
    try {
 		rdbStore.beginTransaction()
 		const valueBucket = {
@@ -2271,7 +2297,7 @@ data_rdb.getRdbStore(context, STORE_CONFIG, 1, async function (err, rdbStore) {
 })
 ```
-### backup<sup>9+</sup>
+### backup
 backup(destName:string, callback: AsyncCallback&lt;void&gt;):void
@@ -2298,7 +2324,7 @@ rdbStore.backup("dbBackup.db", function(err) {
 })
 ```
-### backup<sup>9+</sup>
+### backup
 backup(destName:string): Promise&lt;void&gt;
@@ -2329,7 +2355,7 @@ promiseBackup.then(()=>{
 })
 ```
-### restore<sup>9+</sup>
+### restore
 restore(srcName:string, callback: AsyncCallback&lt;void&gt;):void
@@ -2356,7 +2382,7 @@ rdbStore.restore("dbBackup.db", function(err) {
 })
 ```
-### restore<sup>9+</sup>
+### restore
 restore(srcName:string): Promise&lt;void&gt;
@@ -2387,7 +2413,7 @@ promiseRestore.then(()=>{
 })
 ```
-### setDistributedTables<sup>9+</sup>
+### setDistributedTables
 setDistributedTables(tables: Array&lt;string&gt;, callback: AsyncCallback&lt;void&gt;): void
@@ -2416,7 +2442,7 @@ rdbStore.setDistributedTables(["EMPLOYEE"], function (err) {
 })
 ```
-### setDistributedTables<sup>9+</sup>
+### setDistributedTables
 setDistributedTables(tables: Array&lt;string&gt;): Promise&lt;void&gt;
@@ -2449,7 +2475,7 @@ promise.then(() => {
 })
 ```
-### obtainDistributedTableName<sup>9+</sup>
+### obtainDistributedTableName
 obtainDistributedTableName(device: string, table: string, callback: AsyncCallback&lt;string&gt;): void
@@ -2479,7 +2505,7 @@ rdbStore.obtainDistributedTableName("12345678abcde", "EMPLOYEE", function (err,
 })
 ```
-### obtainDistributedTableName<sup>9+</sup>
+### obtainDistributedTableName
 obtainDistributedTableName(device: string, table: string): Promise&lt;string&gt;
@@ -2513,7 +2539,7 @@ promise.then((tableName) => {
 })
 ```
-### sync<sup>9+</sup>
+### sync
 sync(mode: SyncMode, predicates: RdbPredicates, callback: AsyncCallback&lt;Array&lt;[string, number]&gt;&gt;): void
@@ -2527,8 +2553,8 @@ sync(mode: SyncMode, predicates: RdbPredicates, callback: AsyncCallback&lt;Array
 | 参数名     | 类型                                               | 必填 | 说明                                                         |
 | ---------- | -------------------------------------------------- | ---- | ------------------------------------------------------------ |
-| mode       | [SyncMode](#syncmode9)                             | 是   | 指同步模式。该值可以是推、拉。                               |
+| mode       | [SyncMode](#syncmode)                             | 是   | 指同步模式。该值可以是推、拉。                               |
-| predicates | [RdbPredicates](#rdbpredicates9)               | 是   | 约束同步数据和设备。                                         |
+| predicates | [RdbPredicates](#rdbpredicates)               | 是   | 约束同步数据和设备。                                         |
 | callback   | AsyncCallback&lt;Array&lt;[string, number]&gt;&gt; | 是   | 指定的callback回调函数，用于向调用者发送同步结果。string：设备ID；number：每个设备同步状态，0表示成功，其他值表示失败。 |
 **示例：**
@@ -2548,7 +2574,7 @@ rdbStore.sync(data_rdb.SyncMode.SYNC_MODE_PUSH, predicates, function (err, resul
 })
 ```
-### sync<sup>9+</sup>
+### sync
 sync(mode: SyncMode, predicates: RdbPredicates): Promise&lt;Array&lt;[string, number]&gt;&gt;
@@ -2562,8 +2588,8 @@ rdbStore.sync(data_rdb.SyncMode.SYNC_MODE_PUSH, predicates, function (err, resul
 | 参数名     | 类型                                 | 必填 | 说明                           |
 | ---------- | ------------------------------------ | ---- | ------------------------------ |
-| mode       | [SyncMode](#syncmode9)               | 是   | 指同步模式。该值可以是推、拉。 |
+| mode       | [SyncMode](#syncmode)               | 是   | 指同步模式。该值可以是推、拉。 |
-| predicates | [RdbPredicates](#rdbpredicates9) | 是   | 约束同步数据和设备。           |
+| predicates | [RdbPredicates](#rdbpredicates) | 是   | 约束同步数据和设备。           |
 **返回值**：
@@ -2587,7 +2613,7 @@ promise.then((resultSet) =>{
 })
 ```
-### on('dataChange')<sup>9+</sup>
+### on('dataChange')
 on(event: 'dataChange', type: SubscribeType, observer: Callback&lt;Array&lt;string&gt;&gt;): void
@@ -2600,7 +2626,7 @@ on(event: 'dataChange', type: SubscribeType, observer: Callback&lt;Array&lt;stri
 | 参数名   | 类型                                | 必填 | 说明                                        |
 | -------- | ----------------------------------- | ---- | ------------------------------------------- |
 | event    | string                              | 是   | 取值为'dataChange'，表示数据更改。          |
-| type     | [SubscribeType](#subscribetype9)    | 是   | 指在{@code SubscribeType}中定义的订阅类型。 |
+| type     | [SubscribeType](#subscribetype)    | 是   | 指在{@code SubscribeType}中定义的订阅类型。 |
 | observer | Callback&lt;Array&lt;string&gt;&gt; | 是   | 指分布式数据库中数据更改事件的观察者。      |
 **示例：**
@@ -2618,7 +2644,7 @@ try {
 }
 ```
-### off('dataChange')<sup>9+</sup>
+### off('dataChange')
 off(event:'dataChange', type: SubscribeType, observer: Callback&lt;Array&lt;string&gt;&gt;): void
@@ -2631,7 +2657,7 @@ off(event:'dataChange', type: SubscribeType, observer: Callback&lt;Array&lt;stri
 | 参数名   | 类型                                | 必填 | 说明                                        |
 | -------- | ----------------------------------- | ---- | ------------------------------------------- |
 | event    | string                              | 是   | 取值为'dataChange'，表示数据更改。          |
-| type     | [SubscribeType](#subscribetype9)    | 是   | 指在{@code SubscribeType}中定义的订阅类型。 |
+| type     | [SubscribeType](#subscribetype)    | 是   | 指在{@code SubscribeType}中定义的订阅类型。 |
 | observer | Callback&lt;Array&lt;string&gt;&gt; | 是   | 指已注册的数据更改观察者。                  |
 **示例：**
@@ -2649,13 +2675,13 @@ try {
 }
 ```
-## ResultSet<sup>9+</sup>
+## ResultSet
 提供通过查询数据库生成的数据库结果集的访问方法。结果集是指用户调用关系型数据库查询接口之后返回的结果集合，提供了多种灵活的数据访问方式，以便用户获取各项数据。
 ### 使用说明
-需要通过[RdbStore.query()](#query9)获取resultSet对象。
+需要通过[RdbStore.query()](#query)获取resultSet对象。
 ```js
 import dataRdb from '@ohos.data.rdb';
@@ -2668,7 +2694,7 @@ promise.then((resultSet) => {
 });
 ```
-### 属性<sup>9+</sup>
+### 属性
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
@@ -2684,7 +2710,7 @@ promise.then((resultSet) => {
 | isStarted    | boolean             | 是   | 检查指针是否移动过。             |
 | isClosed     | boolean             | 是   | 检查当前结果集是否关闭。         |
-### getColumnIndex<sup>9+</sup>
+### getColumnIndex
 getColumnIndex(columnName: string): number
@@ -2722,7 +2748,7 @@ const age = resultSet.getLong(resultSet.getColumnIndex("AGE"));
 const salary = resultSet.getDouble(resultSet.getColumnIndex("SALARY"));
  ```
-### getColumnName<sup>9+</sup>
+### getColumnName
 getColumnName(columnIndex: number): string
@@ -2758,7 +2784,7 @@ const name = resultSet.getColumnName(1);
 const age = resultSet.getColumnName(2);
  ```
-### goTo<sup>9+</sup>
+### goTo
 goTo(offset:number): boolean
@@ -2799,7 +2825,7 @@ promise.then((resultSet) => {
 });
  ```
-### goToRow<sup>9+</sup>
+### goToRow
 goToRow(position: number): boolean
@@ -2840,7 +2866,7 @@ promise.then((resultSet) => {
 });
  ```
-### goToFirstRow<sup>9+</sup>
+### goToFirstRow
 goToFirstRow(): boolean
@@ -2876,7 +2902,7 @@ promise.then((resultSet) => {
 });
  ```
-### goToLastRow<sup>9+</sup>
+### goToLastRow
 goToLastRow(): boolean
@@ -2911,7 +2937,7 @@ promise.then((resultSet) => {
 });
  ```
-### goToNextRow<sup>9+</sup>
+### goToNextRow
 goToNextRow(): boolean
@@ -2946,7 +2972,7 @@ promise.then((resultSet) => {
 });
  ```
-### goToPreviousRow<sup>9+</sup>
+### goToPreviousRow
 goToPreviousRow(): boolean
@@ -2981,7 +3007,7 @@ promise.then((resultSet) => {
 });
  ```
-### getBlob<sup>9+</sup>
+### getBlob
 getBlob(columnIndex: number): Uint8Array
@@ -3015,7 +3041,7 @@ getBlob(columnIndex: number): Uint8Array
 const codes = resultSet.getBlob(resultSet.getColumnIndex("CODES"));
  ```
-### getString<sup>9+</sup>
+### getString
 getString(columnIndex: number): string
@@ -3049,7 +3075,7 @@ getString(columnIndex: number): string
 const name = resultSet.getString(resultSet.getColumnIndex("NAME"));
  ```
-### getLong<sup>9+</sup>
+### getLong
 getLong(columnIndex: number): number
@@ -3083,7 +3109,7 @@ getLong(columnIndex: number): number
 const age = resultSet.getLong(resultSet.getColumnIndex("AGE"));
  ```
-### getDouble<sup>9+</sup>
+### getDouble
 getDouble(columnIndex: number): number
@@ -3117,7 +3143,7 @@ getDouble(columnIndex: number): number
 const salary = resultSet.getDouble(resultSet.getColumnIndex("SALARY"));
  ```
-### isColumnNull<sup>9+</sup>
+### isColumnNull
 isColumnNull(columnIndex: number): boolean
@@ -3151,7 +3177,7 @@ isColumnNull(columnIndex: number): boolean
 const isColumnNull = resultSet.isColumnNull(resultSet.getColumnIndex("CODES"));
  ```
-### close<sup>9+</sup>
+### close
 close(): void

--- a/zh-cn/application-dev/reference/apis/js-apis-data-resultset.md
+++ b/zh-cn/application-dev/reference/apis/js-apis-data-resultset.md
@@ -4,16 +4,14 @@
 > **说明：**
 > 
+> 从API Version 9开始，该接口不再维护，推荐使用新接口[@ohos.data.relationalStore.ResultSet](js-apis-data-relationalStore.md#resultset)。
+>
 > 本模块首批接口从API version 7开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。
 ## ResultSet<sup>(deprecated)</sup>
 提供通过查询数据库生成的数据库结果集的访问方法。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.ResultSet](js-apis-data-relationalStore.md#resultset9)替代。
 ### 使用说明
 需要通过[RdbStore.query()](js-apis-data-rdb.md#query)获取resultSet对象。
@@ -31,10 +29,6 @@ promise.then((resultSet) => {
 ### 属性<sup>(deprecated)</sup>
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.ResultSet.属性](js-apis-data-relationalStore.md#属性9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 | 名称 | 类型 | 必填 | 说明 |
@@ -55,10 +49,6 @@ getColumnIndex(columnName: string): number
 根据指定的列名获取列索引。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.ResultSet.getColumnIndex](js-apis-data-relationalStore.md#getcolumnindex9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数：**
@@ -89,11 +79,6 @@ getColumnName(columnIndex: number): string
 根据指定的列索引获取列名。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.ResultSet.getColumnName](js-apis-data-relationalStore.md#getcolumnname9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数：**
@@ -122,10 +107,6 @@ goTo(offset:number): boolean
 向前或向后转至结果集的指定行，相对于其当前位置偏移。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.ResultSet.goTo](js-apis-data-relationalStore.md#goto9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数：**
@@ -159,10 +140,6 @@ goToRow(position: number): boolean
 转到结果集的指定行。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.ResultSet.goToRow](js-apis-data-relationalStore.md#gotorow9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数：**
@@ -196,11 +173,6 @@ goToFirstRow(): boolean
 转到结果集的第一行。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.ResultSet.goToFirstRow](js-apis-data-relationalStore.md#gotofirstrow9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **返回值：**
@@ -228,10 +200,6 @@ goToLastRow(): boolean
 转到结果集的最后一行。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.ResultSet.goToLastRow](js-apis-data-relationalStore.md#gotolastrow9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **返回值：**
@@ -259,10 +227,6 @@ goToNextRow(): boolean
 转到结果集的下一行。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.ResultSet.goToNextRow](js-apis-data-relationalStore.md#gotonextrow9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **返回值：**
@@ -290,10 +254,6 @@ goToPreviousRow(): boolean
 转到结果集的上一行。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.ResultSet.goToPreviousRow](js-apis-data-relationalStore.md#gotopreviousrow9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **返回值：**
@@ -321,10 +281,6 @@ getBlob(columnIndex: number): Uint8Array
 以字节数组的形式获取当前行中指定列的值。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.ResultSet.getBlob](js-apis-data-relationalStore.md#getblob9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数：**
@@ -351,10 +307,6 @@ getString(columnIndex: number): string
 以字符串形式获取当前行中指定列的值。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.ResultSet.getString](js-apis-data-relationalStore.md#getstring9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数：**
@@ -381,10 +333,6 @@ getLong(columnIndex: number): number
 以Long形式获取当前行中指定列的值。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.ResultSet.getLong](js-apis-data-relationalStore.md#getlong9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数：**
@@ -411,10 +359,6 @@ getDouble(columnIndex: number): number
 以double形式获取当前行中指定列的值。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.ResultSet.getDouble](js-apis-data-relationalStore.md#getdouble9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数：**
@@ -441,11 +385,6 @@ isColumnNull(columnIndex: number): boolean
 检查当前行中指定列的值是否为null。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.ResultSet.isColumnNull](js-apis-data-relationalStore.md#iscolumnnull9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **参数：**
@@ -472,10 +411,6 @@ close(): void
 关闭结果集。
-> **说明：**
->
-> 从 API Version 7 开始支持，从 API Version 9 开始废弃，建议使用[@ohos.data.relationalStore.ResultSet.close](js-apis-data-relationalStore.md#close9)替代。
 **系统能力：** SystemCapability.DistributedDataManager.RelationalStore.Core
 **示例：**