dolphindb 2.0.526 → 2.0.529

package/docs.zh.json

@@ -734,13 +734,13 @@
                     {
                         "type": "text",
                         "value": [
-                            "对共享内存表（包括共享流表）或流数据引擎对象应用此命令后，没有该表权限的用户将无法对该表进行任何操作。",
+                            "支持当前用户通过此命令，给自己创建的表增加权限限制。增加权限限制后，只有通过管理员赋予权限后才可访问该表。",
                             "",
                             "请注意：",
                             "",
-                            "只能由管理员或者创建该对象的用户执行该命令。",
+                            "1. 只能由创建 table 的用户或者管理员执行该命令。",
                             "",
-                            "对于使用了该命令的对象，管理员仍然可以赋予其他用户对该对象的权限。"
+                            "2. 如果管理员已经为其他用户 grant/deny/revoke 该表的权限，则该表自动添加权限限制，其他未经授权的用户无法再访问该表，建表用户无需调用 ``addAccessControl`` 对表进行访问管理。"
                         ]
                     }
                 ]
@@ -2082,13 +2082,13 @@
                             "",
                             "`newData` 可以是标量、向量、表或集合。",
                             "",
-                            "* 如果obj是向量，则newData必须是标量或向量。结果是比obj更长的向量。",
+                            "* 如果 *obj* 是向量，则 *newData* 必须是标量或向量。结果是比 *obj* 更长的向量。",
                             "",
-                            "* 如果obj是矩阵，则 newData 必须是长度为obj行数倍数的向量。结果是新的矩阵，行数和obj相同，具有更多的列数。",
+                            "* 如果 *obj* 是矩阵，则 *newData* 必须是长度为 *obj* 行数倍数的向量。结果是新的矩阵，行数和 *obj* 相同，具有更多的列数。",
                             "",
-                            "* 如果obj是表，则newData必须是一个列数和obj相同的表。newData的列名不需要和obj的相同。结果是和obj具有相同列数和列名的表，但行数比obj多。",
-                            "",
-                            "* 如果newData和obj的数据类型不同，append! 函数会尝试将 newData转换为obj的数据类型。如果无法这么做，将返回一个错误信息。",
+                            "* 如果 *obj* 是表，则 *newData* 必须是一个列数和 *obj* 相同的表。结果是和 *obj* 具有相同列数和列名的表，但行数比 *obj* 多。",
+                            " ",
+                            "* 如果 *newData* 和 *obj* 的数据类型不同，append! 函数会尝试将 *newData* 转换为 *obj* 的数据类型。如果无法转换，将返回一个错误信息。",
                             ""
                         ]
                     }
@@ -2101,7 +2101,9 @@
                     {
                         "type": "text",
                         "value": [
-                            "将newData中的数据追加到obj。在 DolphinDB 中，函数中的感叹号(!)表示直接修改数据本身（就地操作）。"
+                            "将 *newData* 中的数据追加到 *obj*。在 DolphinDB 中，函数中的感叹号(!)表示直接修改数据本身（就地操作）。",
+                            "",
+                            "请注意，该函数不会检查两表中各列列名与顺序，只要两表中对应位置的列的数据类型一致，即可执行。如果两表中各列顺序有差别，该操作不会自动对齐各列。所以，对数据表进行 append! 操作时，请检查两表中各列列名与顺序，以免出错。绝大部分情况下两表中各列列名与顺序应当完全一致。"
                         ]
                     }
                 ]
@@ -2265,94 +2267,7 @@
                             "    $ Trades.append!(t1)",
                             "    $ select count(*) from Trades",
                             "",
-                            "    1500000",
-                            ""
-                        ]
-                    },
-                    {
-                        "type": "text",
-                        "value": [
-                            "* 使用 *append!* 把数据追加到本地磁盘表。",
-                            ""
-                        ]
-                    },
-                    {
-                        "type": "code",
-                        "language": "console",
-                        "value": [
-                            "",
-                            "    $ n=1000000",
-                            "    $ t=table(rand(`IBM`MS`APPL`AMZN,n) as symbol, rand(10.0, n) as value)",
-                            "    $ db = database(\"C:/DolphinDB/Data/rangedb_tradedata\", RANGE, `A`F`M`S`ZZZZ)",
-                            "    $ Trades = db.createPartitionedTable(t, \"Trades\", \"symbol\")",
-                            "    $ Trades.append!(t);",
-                            ""
-                        ]
-                    },
-                    {
-                        "type": "text",
-                        "value": [
-                            "下例说明，对本地磁盘表执行完 *append!* 操作后，需将表的元数据加载到内存之后，方可执行查询操作。",
-                            ""
-                        ]
-                    },
-                    {
-                        "type": "code",
-                        "language": "console",
-                        "value": [
-                            "",
-                            "    $ select count(*) from Trades;",
-                            "    0",
-                            "",
-                            "    $ Trades=loadTable(db, `Trades)",
-                            "    $ select count(*) from Trades;",
-                            "",
-                            "    1000000",
-                            ""
-                        ]
-                    },
-                    {
-                        "type": "text",
-                        "value": [
-                            "把其他表的数据追加到表Trades中。",
-                            ""
-                        ]
-                    },
-                    {
-                        "type": "code",
-                        "language": "console",
-                        "value": [
-                            "",
-                            "    $ n=500000",
-                            "    $ t1=table(rand(`FB`GE`MSFT,n) as symbol, rand(100.0, n) as value)",
-                            "    $ Trades.append!(t1)",
-                            ""
-                        ]
-                    },
-                    {
-                        "type": "text",
-                        "value": [
-                            "如果需要使用表Trades的最新数据，我们需要重新加载。",
-                            ""
-                        ]
-                    },
-                    {
-                        "type": "code",
-                        "language": "console",
-                        "value": [
-                            "",
-                            "    $ Trades=loadTable(db, `Trades)",
-                            "    $ size(Trades);",
-                            "",
-                            "    1500000",
-                            ""
-                        ]
-                    },
-                    {
-                        "type": "text",
-                        "value": [
-                            ".. meta::   ",
-                            "   :keywords: 磁盘表"
+                            "    1500000"
                         ]
                     }
                 ]
@@ -2613,7 +2528,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "asfreq(X, Y)"
+                            "asfreq(X, rule, [closed], [label], [origin='start_day'])"
                         ]
                     }
                 ]
@@ -2659,7 +2574,27 @@
                             "\"N\"          nanosecond",
                             "============ =================",
                             "",
-                            "参数Y字符串亦可配合使用数字，例如\"2M\"表示频率为每两个月。"
+                            "参数 *Y* 字符串亦可配合使用数字，例如\"2M\"表示频率为每两个月。",
+                            "",
+                            "`closed` 字符串，表示分组区间哪一个边界是闭合的。",
+                            "",
+                            "* *rule* 为 'M', 'A', 'Q', 'BM', 'BA', 'BQ' 和 'W'  时，*closed* 的默认取值为 'right' ，否则，*closed* 的默认取值为 'left'。",
+                            "* *origin* 取 'end' 或者  'end_day' 时，*closed* 的默认值为 'right'。",
+                            "* 1.30.18/2.00.6 版本，当 *rule* 的精度为天以上时，不支持使用默认值以外的选项。",
+                            "",
+                            "`label` 字符串，表示将分组区间的哪一个边界作为 *label* 输出。",
+                            "",
+                            "* *rule* 为 'M', 'A', 'Q', 'BM', 'BA', 'BQ' 和 'W'  时，*label* 的默认取值为 'right' ，否则，*label* 的默认取值为 'left'。",
+                            "* *origin* 取 'end' 或者  'end_day' 时，*label* 的默认值为 'right'。",
+                            "* 1.30.18/2.00.6 版本，当 *rule* 的精度为天以上时，不支持使用默认值以外的选项。",
+                            "",
+                            "`origin` 字符串或和 *X* 具有相同时间类型的标量，表示基于时间戳调整分组。取值为 'epoch', start', 'start_day', 'end', 'end_day' 或自定义的时间对象，默认值为 'start_day'。",
+                            "",
+                            "* 'epoch'：分组起始点为1970-01-01。",
+                            "* 'start'：分组起始点为时间序列的第一个值。",
+                            "* 'start_day'：分组起始点是时间序列的第一个值对应日期的午夜零点。",
+                            "* 'end'：分组起始点是时间序列的最后一个时间戳。",
+                            "* 'end_day'：分组起始点是时间序列的最后一个时间戳对应日期的午夜24点（即下一日的零点）。"
                         ]
                     }
                 ]
@@ -2826,7 +2761,90 @@
                             "2020.01.01  1",
                             "2020.01.03  2",
                             "2020.01.05  ",
-                            "=========== =="
+                            "=========== ==",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ index = temporalAdd(2022.10.01 23:30:00,7*(0..8),`m)",
+                            "    $ s = indexedSeries(index, 3*(0..8))",
+                            "    $ s.asfreq(\"8min\")",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "=================== ====",
+                            "label\t            col1",
+                            "=================== ====",
+                            "2022.10.01T23:28:00\t",
+                            "2022.10.01T23:36:00\t",
+                            "2022.10.01T23:44:00\t6",
+                            "2022.10.01T23:52:00\t",
+                            "2022.10.02T00:00:00\t",
+                            "2022.10.02T00:08:00\t",
+                            "2022.10.02T00:16:00\t",
+                            "2022.10.02T00:24:00",
+                            "=================== ====",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ s.asfreq(rule=`8min,closed=`right)",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "=================== ====",
+                            "label\t            col1",
+                            "=================== ====",
+                            "2022.10.01T23:36:00\t",
+                            "2022.10.01T23:44:00\t6",
+                            "2022.10.01T23:52:00\t",
+                            "2022.10.02T00:00:00\t",
+                            "2022.10.02T00:08:00\t",
+                            "2022.10.02T00:16:00\t",
+                            "2022.10.02T00:24:00\t",
+                            "2022.10.02T00:32:00",
+                            "=================== ====",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ s.asfreq(rule=`8min,closed=`right,origin=`end)",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "=================== ====",
+                            "label\t            col1",
+                            "=================== ====",
+                            "2022.10.01T23:30:00\t0",
+                            "2022.10.01T23:38:00\t",
+                            "2022.10.01T23:46:00\t",
+                            "2022.10.01T23:54:00\t",
+                            "2022.10.02T00:02:00\t",
+                            "2022.10.02T00:10:00\t",
+                            "2022.10.02T00:18:00\t",
+                            "2022.10.02T00:26:00\t24",
+                            "=================== ===="
                         ]
                     }
                 ]
@@ -3217,9 +3235,9 @@
                     {
                         "type": "text",
                         "value": [
-                            "找出 *location* 中最大值所在的位置，然后返回 *value* 中该位置对应的值。若 *location* 和 *value* 是矩阵，则 *location* 和 *value* 的每列一一对应，分别计算 ``atImax(atImin)``。",
+                            "找出 *location* 中最大值所在的位置，然后返回 *value* 中该位置对应的值。如果 *location* 中有多个相同的最大值，则取第一个最大值所在的位置。",
                             "",
-                            "如果 *location* 中有多个相同的最大值，则取第一个最大值所在的位置。",
+                            "若 *location* 和 *value* 是矩阵，则 *location* 和 *value* 的每列一一对应，分别计算 ``atImax``。",
                             "",
                             "atImax(location, value) 相当于 value[imax(location)]。",
                             ""
@@ -3294,9 +3312,9 @@
                     {
                         "type": "text",
                         "value": [
-                            "找出 *location* 中最小值所在的位置，然后返回 *value* 中该位置对应的值。若 *location* 和 *value* 是矩阵，则 *location* 和 *value* 的每列一一对应，分别计算 ``atImax(atImin)``。",
+                            "找出 *location* 中最小值所在的位置，然后返回 *value* 中该位置对应的值。如果 *location* 中有多个相同的最小值，则取第一个最小值所在的位置。",
                             "",
-                            "如果 *location* 中有多个相同的最小值，则取第一个最小值所在的位置。",
+                            "若 *location* 和 *value* 是矩阵，则 *location* 和 *value* 的每列一一对应，分别计算 ``atImin``。",
                             "",
                             "atImin(location, value) 相当于 value[imin(location)]。",
                             ""
@@ -4463,7 +4481,7 @@
                             "",
                             "操作大数组的方法和操作一个常规数组一样。",
                             "",
-                            "当我们调用 :doc:`../a/array` 函数时，如果没有足够的连续内存块，或数组占据的内存超过了一个特定的阈值（默认的阈值是 256 MB），系统会改为创建一个大数组。"
+                            "当我们调用 :doc:`../a/array` 函数时，如果没有足够的连续内存块，或数组占据的内存超过了一个特定的阈值（默认的阈值是 2048 MB），系统会改为创建一个大数组。"
                         ]
                     }
                 ]
@@ -4718,7 +4736,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "`X` 和 `Y` 是长度相同的向量，`Y` 也可以是一个标量。"
+                            "`X` 和 `Y` 可以是数值型的标量，向量，矩阵，或数据表。"
                         ]
                     }
                 ]
@@ -4754,6 +4772,67 @@
             }
         ]
     },
+    "bitNot": {
+        "title": "bitNot",
+        "type": "function",
+        "children": [
+            {
+                "title": "语法",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "bitNot(X)"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "参数",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "`X` 可以是数值型的标量，向量，矩阵，或数据表。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "详情",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "返回按位取反的结果。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "例子",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ bitNot(3)",
+                            "    -4",
+                            "",
+                            "    $ av = array(INT[], 0, 10).append!([1 2 3, 4 5])",
+                            "    $ bitNot(av)",
+                            "    [[-2,-3,-4],[-5,-6]]"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "bitOr": {
         "title": "bitOr",
         "type": "function",
@@ -4777,7 +4856,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "`X` 和 `Y` 是长度相同的向量，`Y` 是一个标量。"
+                            "`X` 和 `Y` 可以是数值型的标量，向量，矩阵，或数据表。"
                         ]
                     }
                 ]
@@ -4837,7 +4916,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "`X` 和 `Y` 是长度相同的向量，`Y` 是一个标量。"
+                            "`X` 和 `Y` 可以是数值型的标量，向量，矩阵，或数据表。"
                         ]
                     }
                 ]
@@ -7717,11 +7796,11 @@
                     {
                         "type": "text",
                         "value": [
-                            "`obj`  是矩阵或表。",
+                            "`obj`  矩阵或表。",
                             "",
-                            "`row` 是非负整数，表示行数。",
+                            "`row` 非负整数，表示行坐标。",
                             "",
-                            "`col` 是非负整数，表示列数。"
+                            "`col` 非负整数，表示列坐标。"
                         ]
                     }
                 ]
@@ -7785,6 +7864,95 @@
             }
         ]
     },
+    "cells": {
+        "title": "cells",
+        "type": "function",
+        "children": [
+            {
+                "title": "语法",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "cells(obj, row, col)"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "参数",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "`obj`  矩阵。",
+                            "",
+                            "`row` 整型向量，表示行坐标。",
+                            "",
+                            "`col` 与 row 等长的整型向量，表示列坐标。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "详情",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "返回一个由矩阵中 row 和 col 定位的元素组成的向量。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "例子",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ m=(1..15).reshape(3:5)",
+                            "    $ m;",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "===== ===== ===== ===== =====",
+                            "col1  col2  col3  col4  col5",
+                            "===== ===== ===== ===== =====",
+                            "1     4     7     10    13",
+                            "2     5     8     11    14",
+                            "3     6     9     12    15",
+                            "===== ===== ===== ===== =====",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    // 取矩阵中下标为 [0,1] 和 [0,2] 两个元素",
+                            "    $ cells(m, 0 0, 1 2)",
+                            "    [4,7]",
+                            "    // 取矩阵对角线上的元素",
+                            "    $ index = 0..2",
+                            "    $ cells(m, v, v)",
+                            "    [1, 5, 9]"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "changePwd": {
         "title": "changePwd",
         "type": "command",
@@ -7808,9 +7976,9 @@
                     {
                         "type": "text",
                         "value": [
-                            "`oldPwd` 是表示用户旧密码的字符串。",
+                            "`oldPwd` 表示用户旧密码的字符串。",
                             "",
-                            "`newPwd` 是表示用户新密码的字符串。"
+                            "`newPwd` 表示用户新密码的字符串，长度范围为 6~20 个字符。"
                         ]
                     }
                 ]
@@ -11375,7 +11543,7 @@
                             "",
                             "为了便于观察和对比计算结果，系统会对第一个数据窗口的起始时间进行调整。调整规则与 :doc:`createTimeSeriesEngine` 相同。",
                             "",
-                            "`garbageSize`  是正整数。它是可选参数，默认值是2,000（单位为字节）。如果没有指定 *keyColumn*，当内存中历史数据的数量超过 *garbageSize* 时，系统会清理本次计算不需要的历史数据。如果指定了 *keyColumn*，意味着需要分组计算时，内存清理是各分组独立进行的。当一个组的历史数据记录数超出 *garbageSize* 时，会清理该组不再需要的历史数据。若一个组的历史数据记录数未超出 *garbageSize*，则该组数据不会被清理。如果 *metrics* 中没有聚合函数，这个参数不起作用。",
+                            "`garbageSize`  是正整数。它是可选参数，默认值是2,000（单位为行）。如果没有指定 *keyColumn*，当内存中历史数据的数量超过 *garbageSize* 时，系统会清理本次计算不需要的历史数据。如果指定了 *keyColumn*，意味着需要分组计算时，内存清理是各分组独立进行的。当一个组的历史数据记录数超出 *garbageSize* 时，会清理该组不再需要的历史数据。若一个组的历史数据记录数未超出 *garbageSize*，则该组数据不会被清理。如果 *metrics* 中没有聚合函数，这个参数不起作用。",
                             "",
                             "若要开启快照机制 (snapshot)，必须指定 *snapshotDir* 与 *snapshotIntervalInMsgCount*。",
                             "",
@@ -11558,7 +11726,7 @@
                             "",
                             "\\1. 只有一个连接列：当左表和右表的连接列名相同时，*matchingColumn* 是一个字符串标量，否则是一个长度为 2 的 tuple，例如：左表连接列名为 sym，右表连接列名为 sym1，则 *matchingColumn* = [[\\`sym],[\\`sym1]]。",
                             "",
-                            "\\2. 有多个连接列：当左表和右表的连接列名相同时，*matchingColumn* 是一个字符串向量，否则是一个长度为 2 的 tuple，例如：左表连接列名为 timestamp, sym，右表连接列名为 timestamp, sym1，则 *matchingColumn* = [[\\`timestamp, \\`sym], [\\`timestamp,\\`sym1]]。",
+                            "\\2. 有多个连接列：当左表和右表的连接列名相同时，*matchingColumn* 是一个字符串向量，否则是一个长度为 2 的 tuple，例如：左表连接列名为 orderNo, sym，右表连接列名为 orderNo, sym1，则 *matchingColumn* = [[\\`orderNo, \\`sym], [\\`orderNo,\\`sym1]]。",
                             "",
                             "`timeColumn` 可选参数，当 *useSystemTime* = false 时，指定要连接的两个表中时间列的名称。 `leftTable` 和 `rightTable` 时间列名称可以不同，但数据类型需保持一致。当 `leftTable` 和 `rightTable` 时间列名称不同时，`timeColumn` 为一个长度为2的字符串向量。",
                             "",
@@ -11572,7 +11740,7 @@
                             "",
                             "如果指定了 *delayedTime*，若左表中最新时间 t2 与上一条未计算的时间差大于 *delayedTime* 设置值，则 t2 这条记录可以直接触发左表和右表 join，或者左表中的数据在经过 2 * *delayedTime* （小于2秒按2秒计算）后还没有 join 输出，则直接触发 join。",
                             "",
-                            "`garbageSize` 可选参数，是正整数，默认值是5,000（单位为字节）。随着订阅的流数据不断注入 asof join  引擎，存放在内存中的数据会越来越多，行数超过 *garbageSize* 值时，系统会清理本次计算不需要的历史数据。"
+                            "`garbageSize` 可选参数，是正整数，默认值是5,000（单位为行）。随着订阅的流数据不断注入 asof join  引擎，存放在内存中的数据会越来越多，行数超过 *garbageSize* 值时，系统会清理本次计算不需要的历史数据。"
                         ]
                     }
                 ]
@@ -11981,7 +12149,8 @@
                     {
                         "type": "text",
                         "value": [
-                            "createDailyTimeSeriesEngine(name, windowSize, step, metrics, dummyTable, outputTable, [timeColumn], [useSystemTime=false], [keyColumn], [garbageSize], [updateTime], [useWindowStartTime], [roundTime=true], [snapshotDir], [snapshotIntervalInMsgCount], [fill='none'], [sessionBegin], [sessionEnd], [mergeSessionEnd=false], [forceTriggerTime], [raftGroup], [forceTriggerSessionEndTime])"
+                            "createDailyTimeSeriesEngine(name, windowSize, step, metrics, dummyTable, outputTable, [timeColumn], [useSystemTime=false], [keyColumn], [garbageSize], [updateTime], [useWindowStartTime], [roundTime=true], [snapshotDir], [snapshotIntervalInMsgCount], [fill='none'], [sessionBegin], [sessionEnd], [mergeSessionEnd=false], [forceTriggerTime], [raftGroup], [forceTriggerSessionEndTime], [keyPurgeFreqInSec], [closed='left'])",
+                            "  "
                         ]
                     }
                 ]
@@ -12141,6 +12310,183 @@
             }
         ]
     },
+    "createDistributedInMemoryTable": {
+        "title": "createDistributedInMemoryTable",
+        "type": "function",
+        "children": [
+            {
+                "title": "语法",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "createDistributedInMemoryTable(tableName, colNames, colTypes, globalPartitionType, globalPartitionScheme, globalPartitionColumn, [localPartitionType], [localPartitionScheme], [localPartitionColumn])",
+                            "  "
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "详情",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "创建一个分布式共享内存表，按指定分区方案，将数据存储在不同在节点上。该函数只能在数据节点/计算节点执行。",
+                            "",
+                            "按全局分区方案将分布式共享内存表的数据分散地存储在不同节点（数据节点/计算节点）的内存中。每个节点最多只能存放一个分区的数据。分布式共享内存表支持并行读写，因此，它适用于需要对内存表进行分布式计算的场景。",
+                            "",
+                            "分布式共享内存表的分区分为两级：",
+                            "",
+                            "* 第一级为全局分区。全局分区可以将内存表的数据按照分区存放在不同的节点上。",
+                            "* 第二级为局部分区（可选配置）。局部分区对存储在单个节点内的分区数据进行再分区。",
+                            "",
+                            "若同时配置了全局分区和局部分区，等同于对分布式共享内存表进行了组合分区。",
+                            "",
+                            "注意：",
+                            "",
+                            "\\(1) 仅支持在集群模式下创建分布式共享内存表。",
+                            "",
+                            "\\(2) 全局分区的数量必须不小于2，且不能超过数据节点和计算节点总数。",
+                            "",
+                            "\\(3) 其它节点访问分布式共享内存表前，需要执行 :doc:`../l/loadDistributedInMemoryTable` 函数加载表。",
+                            "",
+                            "\\(4) 通过命令 :doc:`/FunctionsandCommands/CommandsReferences/d/dropDistributedInMemoryTable` 删除分布式共享内存表。",
+                            "",
+                            "\\(5) 分布式共享内存表的操作暂不支持事务。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "参数",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "`tableName` 字符串标量，表示分布式共享内存表的名称。",
+                            "",
+                            "`colNames` 字符串向量，用于指定表的列名。",
+                            "",
+                            "`colTypes` 由数据类型组成的向量，用于指定 *colNames* 各列的类型。",
+                            "",
+                            "`globalPartitionType` 必选参数，表示集群全局的分区类型，仅支持范围分区(RANGE)，哈希分区(HASH)，数值分区(VALUE)，列表分区(LIST)。",
+                            "",
+                            "`globalPartitionScheme` 必选参数，表示集群全局的分区方案。",
+                            "",
+                            "分区类型及对应的分区方案见下表：",
+                            "",
+                            "+--------+--------+------------------------------------------------------------+",
+                            "|分区类型|分区符号|分区方案                                                    |",
+                            "+========+========+============================================================+",
+                            "|范围分区|RANGE   |向量。向量的任意两个相邻元素定义分区的范围。                |",
+                            "+--------+--------+------------------------------------------------------------+",
+                            "|哈希分区|HASH    |元组。第一个元素是分区列的数据类型，第二个元素是分区的数量。|",
+                            "+--------+--------+------------------------------------------------------------+",
+                            "|值分区  |VALUE   |向量。向量的每个元素定义了一个分区。                        |",
+                            "+--------+--------+------------------------------------------------------------+",
+                            "|列表分区|LIST    |向量。向量的每个元素定义了一个分区。                        |",
+                            "+--------+--------+------------------------------------------------------------+",
+                            "",
+                            "`globalPartitionColumn` 必选参数，字符串标量，表示集群全局的分区列。",
+                            "",
+                            "以上参数对应整个集群的分区配置，分布式共享内存表将按照上述分区方案将数据分区后存储到各个节点。各个节点的数据可以通过以下参数，进行节点内部的二次分区。",
+                            "",
+                            "`localPartitionType` 可选参数，表示节点内部的分区类型，仅支持范围分区(RANGE)，哈希分区(HASH)，数值分区(VALUE)，列表分区(LIST)。",
+                            "",
+                            "`localPartitionScheme` 可选参数，表示节点内部的分区方案。",
+                            "",
+                            "`localPartitionColumn` 可选参数，字符串标量，表示节点内部的分区列。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "例子",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "* 创建分布式共享内存表",
+                            "",
+                            "本例的集群拥有两个数据节点 node1 和 node2，在 node1 上创建一个分布式共享内存表。因为分区的数量不能超过数据节点和计算节点数总和，建议进行 HASH 分区。",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ pt = createDistributedInMemoryTable(`dt, `time`id`value, `DATETIME`INT`LONG, HASH, [INT, 2],`id)",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "* 加载分布式共享内存表",
+                            "",
+                            "在 node2 上加载分布式共享内存表，并插入数据。",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ time = take(2021.08.20 00:00:00..2021.08.30 00:00:00, 40);",
+                            "    $ id = 0..39;",
+                            "    $ value = rand(100, 40);",
+                            "    $ tmp = table(time, id, value);",
+                            "",
+                            "    $ pt = loadDistributedInMemoryTable(`dt)",
+                            "    $ pt.append!(tmp);",
+                            "",
+                            "    $ select * from pt;",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "* 查看分布式共享内存表是否存在。",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ objs(true)",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "* 删除分布式共享内存表",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ dropDistributedInMemoryTable(`dt)"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "createEqualJoinEngine": {
         "title": "createEqualJoinEngine",
         "type": "function",
@@ -12168,7 +12514,7 @@
                             "",
                             "`name` 必选参数，是一个字符串，表示流数据 equal join 引擎的名称。",
                             "",
-                            "`garbageSize` 可选参数，是正整数，默认值是5,000（单位为字节）。当内存中历史数据行数超过 *garbageSize* 时，会清理本次计算不需要的历史数据。",
+                            "`garbageSize` 可选参数，是正整数，默认值是5,000（单位为行）。当内存中历史数据行数超过 *garbageSize* 时，会清理本次计算不需要的历史数据。",
                             "",
                             "`maxDelayedTime` 可选参数，为正整数，默认值为3s，equal join 引擎接收到的能够参与计算的数据的最大延时时间。超过 *maxDelayedTime* 延迟时间的数据会被丢弃。不建议 *maxDelayedTime* 值设置过小。",
                             "",
@@ -12666,15 +13012,15 @@
                     {
                         "type": "text",
                         "value": [
-                            "`dbHandle`  是 :doc:`../d/database` 函数返回的数据库句柄。它可以是本地磁盘数据库，也可以是分布式数据库。dbHandle 为空字符串或没有指定时，表示内存数据库的句柄。",
+                            "`dbHandle`   :doc:`../d/database` 函数返回的数据库句柄。它可以是本地磁盘数据库，也可以是分布式数据库。*dbHandle* 为空字符串或没有指定时，表示内存数据库的句柄。",
                             "",
-                            "`table`  可以是一个表或包含多个表的元组。系统将会根据该表的结构创建新的分区表。",
+                            "`table`  一个表或包含多个表的元组。系统将会根据该表的结构创建新的分区表。",
                             "",
-                            "`tableName`  是一个字符串，表示的分区表的名称。",
+                            "`tableName`  一个字符串，表示的分区表的名称。",
                             "",
-                            "`partitionColumns`  是一个字符串或字符串向量，表示分区列。对于组合分区，partitionColumns 是一个字符串向量。对非顺序分区，此参数为必选参数。",
+                            "`partitionColumns`  一个字符串或字符串向量，表示分区列。对于组合分区，partitionColumns 是一个字符串向量。对非顺序分区，此参数为必选参数。",
                             "",
-                            "`compressMethods`  是一个字典，指定某些列使用 lz4 或者 delta 压缩算法存储。key 为字段名，value 为压缩算法（\"lz4\" 或 \"delta\"）。若未指定，默认采用 lz4 压缩算法。请注意，delta 算法仅可用于 SHORT, INT, LONG 与时间或日期类型数据。"
+                            "`compressMethods`  一个字典，指定某些列使用 lz4 或者 delta 压缩算法存储。key 为字段名，value 为压缩算法（\"lz4\" 或 \"delta\"）。若未指定，默认采用 lz4 压缩算法。请注意，delta 算法仅可用于 SHORT, INT, LONG 与时间或日期类型数据。"
                         ]
                     }
                 ]
@@ -12958,11 +13304,11 @@
                             "",
                             "下列状态函数在 DolphinDB 的响应式状态引擎中的实现均得到了优化。目前，状态引擎不允许使用未经优化的状态函数。应避免使用聚合函数。",
                             "",
-                            "* 累计窗口函数：cumavg, cumsum, cumprod, cumcount, cummin, cummax, cumvar, cumvarp, cumstd, cumstdp, cumcorr, cumcovar, cumbeta, cumwsum, cumwavg, cumfirstNot, cumlastNot",
+                            "* 累计窗口函数：cumavg, cumsum, cumprod, cumcount, cummin, cummax, cumvar, cumvarp, cumstd, cumstdp, cumcorr, cumcovar, cumbeta, cumwsum, cumwavg, cumfirstNot, cumlastNot, cummed, cumpercentile ",
                             "* 滑动窗口函数：ema, mavg, msum, mcount, mprod, mvar, mvarp, mstd, mstdp, mskew, mkurtosis, mmin, mmax, mimin, mimax, mmed, mpercentile, mrank, mcorr, mcovar, mbeta, mwsum, mwavg, mmad, mfirst, mlast, mslr, tmove, tmfirst, tmlast, tmsum, tmavg, tmcount, tmvar, tmvarp, tmstd, tmstdp, tmprod, tmskew, tmkurtosis, tmmin, tmmax, tmmed, tmpercentile, tmrank, tmcovar, tmbeta, tmcorr, tmwavg, tmwsum, tmoving, moving, sma,wma, dema, tema, trima, linearTimeTrend, talib, t3, ma",
                             "* 序列相关函数：deltas, ratios, ffill, move, prev, iterate, ewmMean, ewmVar, ewmStd, ewmCov, ewmCorr",
                             "* topN相关函数：msumTopN, mavgTopN, mstdpTopN, mstdTopN, mvarpTopN, mvarTopN, mcorrTopN, mbetaTopN, mcovarTopN, mwsumTopN",
-                            "* 其他函数：talibNull",
+                            "* 其他函数：talibNull, dynamicGroupCumsum, dynamicGroupCumcount",
                             "",
                             "注意，:doc:`/Functionalprogramming/TemplateFunctions/talib` 作为状态函数时，第一个参数 `func` 只能是响应式状态引擎支持的状态函数。",
                             "",
@@ -13005,17 +13351,19 @@
                             "",
                             "`keyPurgeFilter` 可选参数，是一个由条件表达式组成的元代码，表示清理条件。各表达式只能引用 *outputTable* 中的字段。",
                             "",
-                            "`keyPurgeFreqInSecond` 正整数，表示数据清理的时间间隔（以秒为单位）。",
+                            "`keyPurgeFreqInSecond` 正整数，表示触发数据清理需要满足的时间间隔（以秒为单位）。",
                             "",
-                            "清理触发所需要满足的条件：",
+                            "响应式状态引擎提供了 *keyPurgeFilter*,  *keyPurgeFreqInSecond* 两个参数，用来清理不再需要的分组数据。",
                             "",
-                            "\\1. 达到 *keyPurgeFreqInSecond* 指定的时间间隔，并且有数据继续流入（引擎会先进行计算再判断历史数据是否满足清理条件）。",
+                            "每次数据注入时，系统会依次根据以下条件决定是否触发数据清理：",
                             "",
-                            "\\2. 待清理的分组数不小于总分组数的10%。  ",
+                            "\\(1) 检测本次数据注入与上一次数据注入的时间间隔是否大于等于 keyPurgeFreqInSecond（第一次数据注入时，检测注入时间和引擎创建时间的间隔）；",
                             "",
-                            "\\3. 满足 *keyPurgeFilter* 清理条件。",
+                            "\\(2) 若满足上述条件，系统将根据 keyPurgeFilter 指定的条件，过滤出待清理的数据；",
+                            "",
+                            "\\(3) 若待清理的数据所属的分组数大于等于所有分组数的 10%，则触发清理。",
                             "  ",
-                            "若需要查看清理前后的状态，可以调用 :doc:`../g/getStreamEngineStat` 函数中的 numGroups，来查看响应式状态引擎的分组数。",
+                            "若需要查看清理前后的状态，可以通过调用 :doc:`../g/getStreamEngineStat` 函数查看 ReactiveStreamEngine 引擎状态的 numGroups 列，来对比响应式状态引擎清理前后分组数的变化。",
                             "",
                             "`raftGroup` 是流数据高可用订阅端 raft 组的 ID (大于1的整数，由流数据高可用相关的配置项 *streamingRaftGroups* 指定)。设置该参数表示开启计算引擎高可用。在 leader 节点创建流数据引擎后，会同步在 follower 节点创建该引擎。每次保存的 snapshot 也会同步到 follower。当 raft 组的 leader 节点宕机时，会自动切换新 leader 节点重新订阅流数据表。请注意，若要指定 *raftGroup*，必须同时指定 *snapshotDir*。"
                         ]
@@ -13152,7 +13500,7 @@
                             "",
                             "* 当 *useSystemTime* = false（缺省值）时，根据 *timeColumn* 列中数据来决定数据窗口。",
                             "",
-                            "`useSessionStartTime`: 可选参数，是一个布尔值，表示输出表中的时刻是否为数据窗口起始时刻，即每个窗口中第一条数据的时刻。默认值为 true，表示输出表中的时刻为数据窗口结束时刻，即每个窗口中最后一条数据的时刻+ *sessionGap*。如果指定 *updateTime*，*useSessionStartTime* 必须为 true。"
+                            "`useSessionStartTime`: 可选参数，是一个布尔值，默认值为 true，表示输出表中的时刻是否为数据窗口起始时刻，即每个窗口中第一条数据的时刻。若设置为 false，则表示输出表中的时刻为数据窗口结束时刻，即每个窗口中最后一条数据的时刻+ *sessionGap*。如果指定 *updateTime*，*useSessionStartTime* 必须为 true。"
                         ]
                     }
                 ]
@@ -13280,13 +13628,13 @@
                     {
                         "type": "text",
                         "value": [
-                            "`dbHandle`  是 :doc:`../d/database` 函数返回的分布式数据库句柄。",
+                            "`dbHandle`   :doc:`../d/database` 函数返回的分布式数据库句柄。",
                             "",
-                            "`table` 是一个表，系统将根据该表的结构在数据库中创建一个空的维度表。",
+                            "`table` 一个表，系统将根据该表的结构在数据库中创建一个空的维度表。",
                             "",
-                            "`tableName` 是一个字符串，表示维度表的名称。",
+                            "`tableName` 一个字符串，表示维度表的名称。",
                             "",
-                            "`compressMethods` 是一个字典，指定某些列使用 lz4 或者 delta 压缩算法存储。key 为字段名，value 为压缩算法（\"lz4\"或\"delta\"）。若未指定，默认采用lz4压缩算法。请注意，delta 算法仅可用于 SHORT, INT, LONG 与时间或日期类型数据。"
+                            "`compressMethods` 一个字典，指定某些列使用 lz4 或者 delta 压缩算法存储。key 为字段名，value 为压缩算法（\"lz4\"或\"delta\"）。若未指定，默认采用lz4压缩算法。请注意，delta 算法仅可用于 SHORT, INT, LONG 与时间或日期类型数据。"
                         ]
                     }
                 ]
@@ -13397,7 +13745,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "createTimeSeriesEngine(name, windowSize, step, metrics, dummyTable, outputTable, [timeColumn], [useSystemTime=false], [keyColumn], [garbageSize], [updateTime], [useWindowStartTime=false], [roundTime=true], [snapshotDir], [snapshotIntervalInMsgCount], [fill='none'], [forceTriggerTime], [raftGroup])",
+                            "createTimeSeriesEngine(name, windowSize, step, metrics, dummyTable, outputTable, [timeColumn], [useSystemTime=false], [keyColumn], [garbageSize], [updateTime], [useWindowStartTime=false], [roundTime=true], [snapshotDir], [snapshotIntervalInMsgCount], [fill='none'], [forceTriggerTime], [raftGroup], [keyPurgeFreqInSec], [closed='left'])",
                             "",
                             "别名：createTimeSeriesAggregator"
                         ]
@@ -13443,7 +13791,7 @@
                             "",
                             "例如，一个数据窗口从10:10:10到10:10:19。若 *useSystemTime* = true，则只要该窗口中至少有一条数据，该窗口的计算会在窗口结束后的10:10:20触发。若 *useSystemTime* = false，且10:10:19后的第一条数据为10:10:25，则该窗口的计算会在10:10:25触发。",
                             "",
-                            "`windowSize` 必选参数，是一个正整数标量或向量，指定数据窗口的长度。若为向量，其长度必须与 *metrics* 中元素个数一致。数据窗口包含其左边界，但不包含右边界。",
+                            "`windowSize` 必选参数，是一个正整数标量或向量，指定数据窗口的长度。若为向量，其长度必须与 *metrics* 中元素个数一致。",
                             "",
                             "`step`  必选参数，是一个正整数，表示计算窗口右边界的位移量。 *windowSize* 必须是 *step* 的整数倍，否则会抛出异常。",
                             "",
@@ -13608,7 +13956,7 @@
                             "",
                             "`keyColumn` 可选参数，是字符串标量或向量，表示分组列名。若设置，则分组进行聚合计算，例如以每支股票为一组进行聚合计算。",
                             "",
-                            "`garbageSize` 可选参数，是正整数，默认值是50,000（单位为字节）。随着订阅的流数据不断积累，进入时间序列引擎，存放在内存中的数据会越来越多，这时需要清理不再需要的历史数据。当内存中历史数据行数超过 *garbageSize* 值时，系统会清理本次计算不需要的历史数据。如果指定了 *keyColumn*，内存清理是各组内独立进行的。当一个组在内存中的历史数据记录数超出 *garbageSize* 时，会清理该组中本次计算中不需要的历史数据。",
+                            "`garbageSize` 可选参数，是正整数，默认值是50,000（单位为行）。当 *metrics* 中使用了自定义聚合函数，时间序列引擎会保留历史数据。随着订阅的流数据不断积累，进入时间序列引擎，存放在内存中的数据会越来越多，这时需要清理不再需要的历史数据。当内存中历史数据行数超过 *garbageSize* 值时，系统会清理本次计算不需要的历史数据。如果指定了 *keyColumn*，内存清理是各组内独立进行的。当一个组在内存中的历史数据记录数超出 *garbageSize* 时，会清理该组中本次计算中不需要的历史数据。",
                             "",
                             "`updateTime` 可选参数，是正整数，可定义比 *step* 更短的计算的时间间隔。*step* 必须是 *updateTime* 的整数倍。要设置 *updateTime*， *useSystemTime* 必须设为 false。",
                             "",
@@ -13656,7 +14004,7 @@
                             "",
                             "*fill* 可以输入向量，为每个 *metrics* 指定不同的 *fill* 方式。其中，向量中各项只能是 'null', 'ffill' 或一个数值，不能是 'none'。",
                             "",
-                            "`forceTriggerTime` 可选参数，是非负整数，单位为秒。用于强制触发各个分组未计算的窗口进行计算。强制触发计算及输出规则如下：",
+                            "`forceTriggerTime` 可选参数，是非负整数，单位与 *timeColumn* 的时间精度一致。用于强制触发各个分组未计算的窗口进行计算。强制触发计算及输出规则如下：",
                             "",
                             "\\1. 未被触发计算的窗口结束后（窗口结束时刻为 t），若收到了其他分组的数据（时间戳为 t1），且满足 t1-t ≥ *forceTriggerTime*，则该窗口将被触发计算。",
                             "",
@@ -13668,7 +14016,26 @@
                             "",
                             "* 只设置 *updateTime*，计算发生后仍有属于当前窗口的数据到达时，当前窗口计算结果会再次更新；只设置 *forceTriggerTime*，则触发计算之后收到的数据会被丢弃。",
                             "",
-                            "`raftGroup` 是流数据高可用订阅端 raft 组的 ID (大于1的整数，由流数据高可用相关的配置项 *streamingRaftGroups* 指定)。设置该参数表示开启计算引擎高可用。在 leader 节点创建流数据引擎后，会同步在 follower 节点创建该引擎。每次保存的 snapshot 也会同步到 follower。当 raft 组的 leader 节点宕机时，会自动切换新 leader 节点重新订阅流数据表。请注意，若要指定 *raftGroup*，必须同时指定 *snapshotDir*。"
+                            "`raftGroup` 是流数据高可用订阅端 raft 组的 ID (大于1的整数，由流数据高可用相关的配置项 *streamingRaftGroups* 指定)。设置该参数表示开启计算引擎高可用。在 leader 节点创建流数据引擎后，会同步在 follower 节点创建该引擎。每次保存的 snapshot 也会同步到 follower。当 raft 组的 leader 节点宕机时，会自动切换新 leader 节点重新订阅流数据表。请注意，若要指定 *raftGroup*，必须同时指定 *snapshotDir*。",
+                            "",
+                            "`keyPurgeFreqInSec` 正整数，表示清理窗口数据为空的分组的时间间隔，单位为秒。指定该参数后，若当前数据注入时间与上一次清理时间的间隔大于等于 *keyPurgeFreqInSec*，便会对当前窗口数据为空的分组进行清理。",
+                            "",
+                            ".. 若不指定该参数，则表示不对分组数据进行清理。",
+                            "",
+                            "注意：若需指定该参数，必须指定 *forceTriggerTime*，且不能指定 *fill*。",
+                            "",
+                            "若需要查看清理前后的状态，可以通过调用 :doc:`../g/getStreamEngineStat` 函数查看 TimeSeriesEngine 引擎状态的 numGroups 列，来对比响应式状态引擎清理前后分组数的变化。",
+                            "",
+                            "`closed` 字符串，用于确定滑动窗口边界的开闭情况。可选值为 'left' 或 'right'，默认值为 'left'。",
+                            "",
+                            "* closed = 'left'： 窗口左闭右开",
+                            "* closed = 'right'： 窗口左开右闭",
+                            "",
+                            ".. `closed` 字符串，表示对滑动窗口进行计算时需要排除的点，可选值为 'left' 或 'right'，默认值为 'left'。",
+                            "",
+                            ".. * closed = 'left'： 计算中将排除滑动窗口中的最后一个点",
+                            ".. * closed = 'right'： 计算中将排除滑动窗口中的第一个点",
+                            ""
                         ]
                     }
                 ]
@@ -14055,7 +14422,7 @@
                             "",
                             "`useSystemTime` 可选参数，表示 *outputTable* 中第一列（时间列）为系统当前时间（*useSystemTime* = true）或左表的时间列（*useSystemTime* = false）。",
                             "",
-                            "`garbageSize` 可选参数，是正整数，默认值是5,000（单位为字节）。随着订阅的流数据不断积累进入 window join 引擎，存放在内存中的数据会越来越多，这时需要清理不再需要的历史数据。当内存中历史数据行数超过 *garbageSize* 值时，系统会清理本次计算不需要的历史数据。",
+                            "`garbageSize` 可选参数，是正整数，默认值是5,000（单位为行）。随着订阅的流数据不断积累进入 window join 引擎，存放在内存中的数据会越来越多，这时需要清理不再需要的历史数据。当内存中历史数据行数超过 *garbageSize* 值时，系统会清理本次计算不需要的历史数据。",
                             "",
                             "`maxDelayedTime` 可选参数，是正整数,默认值为3，单位为秒。通过设置该参数，帮助触发引擎中长时间未输出的分组数据进行计算。"
                         ]
@@ -14706,7 +15073,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "累计计算 *X* 和 *Y* 的协方差(covariance)。"
+                            "累积计算 *X* 和 *Y* 的协方差(covariance)。"
                         ]
                     }
                 ]
@@ -20881,9 +21248,9 @@
                     {
                         "type": "text",
                         "value": [
-                            "`table` 是一个内存表。",
+                            "`table` 一个内存表。",
                             "",
-                            "`colNames` 是表示列名的标量或向量。"
+                            "`colNames` 表示列名的标量或向量。"
                         ]
                     }
                 ]
@@ -21085,6 +21452,77 @@
             }
         ]
     },
+    "dropDistributedInMemoryTable": {
+        "title": "dropDistributedInMemoryTable",
+        "type": "command",
+        "children": [
+            {
+                "title": "语法",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "dropDistributedInMemoryTable(tableName)"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "参数",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "`tableName` 字符串标量，表示分布式共享内存表的名称。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "详情",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "删除指定的表。该命令只能在数据节点/计算节点上执行。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "例子",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ pt = createDistributedInMemoryTable(`dt, `time`id`value, `DATETIME`INT`LONG, HASH, [INT, 2],`id)",
+                            "    $ time = take(2021.08.20 00:00:00..2021.08.30 00:00:00, 40);",
+                            "    $ id = 0..39;",
+                            "    $ value = rand(100, 40);",
+                            "    $ tmp = table(time, id, value);",
+                            "",
+                            "    $ pt = loadDistributedInMemoryTable(`dt)",
+                            "    $ pt.append!(tmp);",
+                            "    $ dropDistributedInMemoryTable(`dt)",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "相关函数：:doc:`/FunctionsandCommands/FunctionReferences/l/loadDistributedInMemoryTable`, :doc:`/FunctionsandCommands/FunctionReferences/c/createDistributedInMemoryTable`"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "dropFunctionView": {
         "title": "dropFunctionView",
         "type": "command",
@@ -21155,13 +21593,13 @@
                     {
                         "type": "text",
                         "value": [
-                            "`dbHandle` 是分布式数据库的句柄。",
+                            "`dbHandle` 分布式数据库的句柄。",
                             "",
                             "`partitionPaths` 可为以 \"/\" 开头的字符串或这些字符串组成的元组，表示数据库目录下单个或多个分区的路径。请注意对组合分区，路径必须包括所有层次分区。*partitionPaths* 也可以是一个过滤条件或者多个过滤条件组成的元组，其中每个过滤条件是表示一个或多个分区的一个值或向量（向量中每个值代表一个分区）。多个过滤条件组成的元组是针对组合分区，每层分区对应过滤条件元组的一个元素。如果某层分区不需要过滤，那么相应的过滤条件为空。",
                             "",
-                            "`tableName` 是一个字符串，表示表名。若分区粒度为数据库级（:doc:`/FunctionsandCommands/FunctionReferences/d/database`: *chunkGranularity* = 'DATABASE'），可以不指定 *tableName*，否则必须指定该参数。",
+                            "`tableName` 一个字符串，表示表名。若分区粒度为数据库级（:doc:`/FunctionsandCommands/FunctionReferences/d/database`: *chunkGranularity* = 'DATABASE'），可以不指定 *tableName*，否则必须指定该参数。",
                             "",
-                            "`forceDelete` 是一个布尔值。如果 *forceDelete* =true，即使指定的分区正在恢复，系统也会将其强制删除。默认值为 false。"
+                            "`forceDelete` 一个布尔值。如果 *forceDelete* =true，即使指定的分区正在恢复，系统也会将其强制删除。默认值为 false。"
                         ]
                     }
                 ]
@@ -21585,7 +22023,7 @@
                         "value": [
                             "删除流数据表。如果流数据表启用了持久化，该函数也会将磁盘上持久化的数据删除。",
                             "",
-                            "如果要删除高可用流数据表，只需在Raft组中的任意一个/计算节点上执行该函数即可，其他数据节点/计算节点上名称相同的高可用流数据表也会被删除。"
+                            "如果要删除高可用流数据表，只需在Raft组中的任意一个数据节点/计算节点上执行该函数即可，其他数据节点/计算节点上名称相同的高可用流数据表也会被删除。"
                         ]
                     }
                 ]
@@ -21684,7 +22122,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "删除指定的表。该命令只能在/计算节点上执行，不能在控制节点和代理节点上执行。"
+                            "删除指定的表。该命令只能在数据节点/计算节点上执行，不能在控制节点和代理节点上执行。"
                         ]
                     }
                 ]
@@ -22020,6 +22458,372 @@
             }
         ]
     },
+    "dynamicGroupCumcount": {
+        "title": "dynamicGroupCumcount",
+        "type": "function",
+        "children": [
+            {
+                "title": "语法",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "dynamicGroupCumcount(membership, prevMembership, groupCount)"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "参数",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "`membership` 整型向量，其元素必须是 [0, groupCount) 范围内的整数。用于记录事件在每个时间戳上对应的标签。",
+                            "",
+                            "`prevMembership` 整型向量，其元素可以为空值（对应序列的第一条记录）。用于记录事件在前一个时间戳上对应的标签。",
+                            "",
+                            "`groupCount` [2, 8] 之间的一个整数。表示函数返回值（元组）的长度，即需要统计的标签数。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "详情",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "通常一个事件的类别和属性是固定的。但在某些场景下，事件的类别会动态发生变化。如：在实时处理逐笔数据时，进行大小单的统计以对资金流进行分析。用户期望根据某个订单（事件的属性）的累计交易量来判断该订单是大单还是小单（事件的类别）。随着实时数据不断流入，交易量的不断增加，该订单的类别可能从一个小单变成大单。",
+                            "",
+                            "dynamicGroupCumcount 即可应用在这类场景下，用于统计在一个时间序列下，不同类别的累计事件数。",
+                            "",
+                            "具体算法如下：",
+                            "",
+                            "* 若 *membership* = *prevMembership*，统计量不变。",
+                            "* 若 *membership* ≠ *prevMembership*，*membership* 对应组的统计量加1，*prevMembership* 对应的组统计量减1。",
+                            "* 若 *prevMembership* 为空值（对应序列的第一条记录），*membership* 对应组的统计量加1，*prevMembership* 无对应组，无需处理。",
+                            "",
+                            "该函数返回一个长度为 *groupCount* 的元组，其每个元素是一个与 *membership* 等长的向量，依次记录了各标签统计的累积记录数。",
+                            "",
+                            "注意：元组的下标与标签号一一对应，即标签为 0 的统计结果将输出至元组下标为 0 的向量。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "例子",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "数据预处理：",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    // 打标签函数",
+                            "    $ def tag_func(v){",
+                            "        return iif(v <= 5, 0, iif(v <= 10 and v > 5, 1, 2))",
+                            "    }",
+                            "    // 原始数据表",
+                            "    $ time = take(2022.01.01T09:00:00.000 + 1..3, 6)",
+                            "    $ sym=`st0`st0`st0`st1`st1`st1",
+                            "    $ orderNo = `10001`10002`10001`10002`10003`10002",
+                            "    $ volume = 2 4 6 3 2 9",
+                            "    $ t = table(sym, time, orderNo, volume)",
+                            "",
+                            "    // 计算累计和并根据阈值打标签",
+                            "    $ t1 = select *, cumsum(volume) as sumVolume from t context by sym, orderNo",
+                            "    $ t2 = lj(t, t1,`sym`time`orderNo)",
+                            "    $ t3 = select sym, time, orderNo, volume, sumVolume, tag_func(sumVolume) as groupId from t2",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "对于历史数据，可以使用 SQL 语句计算不同组的累计记录数：",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ t4 = select sym, time, orderNo, prev(groupId) as prevGroupId from t3 context by sym,orderNo",
+                            "    $ t5 = lj(t3, t4,`sym`time`orderNo)",
+                            "    $ re = select sym, time, orderNo, dynamicGroupCumcount(groupId, prevGroupId, 3) as `groupId0`groupId1`groupId2 from t5 context by sym",
+                            "    $ re",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "==== ======================= ======== ======== ======== ========",
+                            "sym  time                    orderNo  groupId0 groupId1 groupId2",
+                            "==== ======================= ======== ======== ======== ========",
+                            "st0  2022.01.01T09:00:00.001 10001    1        0        0",
+                            "st0  2022.01.01T09:00:00.002 10002    2        0        0",
+                            "st0  2022.01.01T09:00:00.003 10001    1        1        0",
+                            "st1  2022.01.01T09:00:00.001 10002    1        0        0",
+                            "st1  2022.01.01T09:00:00.002 10003    2        0        0",
+                            "st1  2022.01.01T09:00:00.003 10002    1        0        1",
+                            "==== ======================= ======== ======== ======== ========",
+                            "",
+                            "对于实时数据，可以使用流数据引擎计算不同组的累计记录数：",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ result = table(1000:0, `sym`time`orderNo`groupId0`groupId1`groupId2, [SYMBOL, TIME, SYMBOL,INT,INT,INT])",
+                            "    $ factor0 = [<time>,  <prev(groupId) as prevGroupId>, <groupId>, <volume>]",
+                            "    $ factor1 = [<time>, <orderNo>, <dynamicGroupCumcount(groupId, prevGroupId, 3)>]",
+                            "    $ dm1 = table(1000:0, `sym`time`orderNo`volume`sumVolume`groupId, [SYMBOL, TIME, SYMBOL,INT, INT,INT])",
+                            "    $ dm2 = table(1000:0, `sym`orderNo`time`prevGroupId`groupId`volume, [SYMBOL, SYMBOL, TIME, INT,INT,INT])",
+                            "    $ res1 = createReactiveStateEngine(name=\"reactive_ccnt\", metrics =factor1, dummyTable=dm2, outputTable=result, keyColumn=`sym, keepOrder=true)",
+                            "    $ res0 = createReactiveStateEngine(name=\"reactive_prev\", metrics =factor0, dummyTable=dm1, outputTable=res1, keyColumn=`sym`orderNo, keepOrder=true)",
+                            "    $ res0.append!(t3)",
+                            "",
+                            "    $ select * from result",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "==== ======================= ======== ======== ======== ========",
+                            "sym  time                    orderNo  groupId0 groupId1 groupId2",
+                            "==== ======================= ======== ======== ======== ========",
+                            "st0  2022.01.01T09:00:00.001 10001    1        0        0",
+                            "st0  2022.01.01T09:00:00.002 10002    2        0        0",
+                            "st0  2022.01.01T09:00:00.003 10001    1        1        0",
+                            "st1  2022.01.01T09:00:00.001 10002    1        0        0",
+                            "st1  2022.01.01T09:00:00.002 10003    2        0        0",
+                            "st1  2022.01.01T09:00:00.003 10002    1        0        1",
+                            "==== ======================= ======== ======== ======== ========",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ dropStreamEngine(\"reactive_ccnt\")",
+                            "    $ dropStreamEngine(\"reactive_prev\")",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "相关函数：:doc:`/FunctionsandCommands/FunctionReferences/d/dynamicGroupCumsum`"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
+    "dynamicGroupCumsum": {
+        "title": "dynamicGroupCumsum",
+        "type": "function",
+        "children": [
+            {
+                "title": "语法",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "dynamicGroupCumsum(cumValue, prevCumValue, membership, prevMembership, groupCount)"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "参数",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "`cumValue` 数值型向量，用于记录事件在每个时间戳上对应的累计值。",
+                            "",
+                            "`prevCumValue` 数值型向量，其元素可以为空值（对应序列的第一条记录）。用于记录事件在前一个时间戳上对应的累计值。",
+                            "",
+                            "`membership` 整型向量，其元素必须是 [0, groupCount) 范围内的整数。用于记录事件在每个时间戳上对应的标签。",
+                            "",
+                            "`prevMembership` 整型向量，其元素可以为空值（对应序列的第一条记录）。用于记录事件在前一个时间戳上对应的标签。",
+                            "",
+                            "`groupCount` [2, 8] 之间的一个整数。表示函数返回值（元组）的长度，即需要统计的标签数。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "详情",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "通常一个事件的类别和属性是固定的。但在某些场景下，事件的类别会动态发生变化。如：在实时处理逐笔数据时，进行大小单的统计以对资金流进行分析。用户期望根据某个订单（事件的属性）的累计交易量来判断该订单是大单还是小单（事件的类别）。随着实时数据不断流入，交易量的不断增加，该订单的类别可能从一个小单变成大单。",
+                            "",
+                            "dynamicGroupCumsum 即可应用在这类场景下，用于统计在一个时间序列下，某个事件指标在不同类别下的累计值。",
+                            "",
+                            "具体算法如下：",
+                            "",
+                            "* 若 *membership* = *prevMembership*，统计量不变。",
+                            "* 若 *membership* ≠ *prevMembership*，*membership* 对应组的统计量加 cumValue，*prevMembership* 对应的组统计量减 prevCumValue。",
+                            "* 若 *prevMembership* 为空值（对应序列的第一条记录），*membership* 对应组的统计量加 cumValue，*prevMembership* 无对应组，无需处理。",
+                            "",
+                            "该函数返回一个长度为 *groupCount* 的元组，其每个元素是一个与 *membership* 等长的向量，依次记录了某指标（cumValue 对应的列）在各标签下的累积和。",
+                            "",
+                            "注意：元组的下标与标签号一一对应，即标签为 0 的统计结果将输出至元组下标为 0 的向量。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "例子",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "数据预处理：",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    // 打标签函数",
+                            "    $ def tag_func(v){",
+                            "        return iif(v <= 5, 0, iif(v <= 10 and v > 5, 1, 2))",
+                            "    }",
+                            "    // 原始数据表",
+                            "    $ time = take(2022.01.01T09:00:00.000 + 1..3, 6)",
+                            "    $ sym=`st0`st0`st0`st1`st1`st1",
+                            "    $ orderNo = `10001`10002`10001`10002`10003`10002",
+                            "    $ volume = 2 4 6 3 2 9",
+                            "    $ t = table(sym, time, orderNo, volume)",
+                            "",
+                            "    // 计算累计和并根据阈值打标签",
+                            "    $ t1 = select *, cumsum(volume) as sumVolume from t context by sym, orderNo",
+                            "    $ t2 = lj(t, t1,`sym`time`orderNo)",
+                            "    $ t3 = select sym, time, orderNo, volume, sumVolume, tag_func(sumVolume) as groupId from t2",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "对于历史数据，可以使用 SQL 语句计算不同组的累计成交量：",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ t4 = select sym, time, orderNo, prev(groupId) as prevGroupId, groupId, prev(sumVolume) as prevSumVolume, sumVolume from t3 context by sym,orderNo",
+                            "    $ t5 = lj(t3, t4,`sym`time`orderNo)",
+                            "    $ re = select sym, time, orderNo, dynamicGroupCumsum(sumVolume, prevSumVolume, groupId, prevGroupId, 3) as `groupId0`groupId1`groupId2 from t5 context by sym",
+                            "    $ re",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "==== ======================= ======== ======== ======== ========",
+                            "sym  time                    orderNo  groupId0 groupId1 groupId2",
+                            "==== ======================= ======== ======== ======== ========",
+                            "st0  2022.01.01T09:00:00.001 10001    2        0        0",
+                            "st0  2022.01.01T09:00:00.002 10002    6        0        0",
+                            "st0  2022.01.01T09:00:00.003 10001    4        8        0",
+                            "st1  2022.01.01T09:00:00.001 10002    3        0        0",
+                            "st1  2022.01.01T09:00:00.002 10003    5        0        0",
+                            "st1  2022.01.01T09:00:00.003 10002    2        0        12",
+                            "==== ======================= ======== ======== ======== ========",
+                            "",
+                            "对于实时数据，可以使用流数据引擎计算不同组的累计成交量：",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ result = table(1000:0, `sym`time`orderNo`groupId0`groupId1`groupId2, [SYMBOL, TIME, SYMBOL,INT,INT,INT])",
+                            "    $ factor0 = [ <time>, <prev(groupId) as prevGroupId>, <groupId>, <prev(sumVolume) as prevSumVolume>, <sumVolume>]",
+                            "    $ factor1 = [<time>, <orderNo>, <dynamicGroupCumsum(sumVolume, prevSumVolume, groupId, prevGroupId, 3)>]",
+                            "    $ dm1 = table(1000:0, `sym`time`orderNo`volume`sumVolume`groupId, [SYMBOL, TIME, SYMBOL,INT, INT,INT])",
+                            "    $ dm2 = table(1000:0, `sym`orderNo`time`prevGroupId`groupId`prevSumVolume`sumVolume, [SYMBOL, SYMBOL, TIME, INT, INT, INT, INT])",
+                            "    $ res1 = createReactiveStateEngine(name=\"reactive_csum\", metrics =factor1, dummyTable=dm2, outputTable=result, keyColumn=`sym, keepOrder=true)",
+                            "    $ res0 = createReactiveStateEngine(name=\"reactive_prev\", metrics =factor0, dummyTable=dm1, outputTable=res1, keyColumn=`sym`orderNo, keepOrder=true)",
+                            "    $ res0.append!(t3)",
+                            "",
+                            "    $ select * from result",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "==== ======================= ======== ======== ======== ========",
+                            "sym  time                    orderNo  groupId0 groupId1 groupId2",
+                            "==== ======================= ======== ======== ======== ========",
+                            "st0  2022.01.01T09:00:00.001 10001    2        0        0",
+                            "st0  2022.01.01T09:00:00.002 10002    6        0        0",
+                            "st0  2022.01.01T09:00:00.003 10001    4        8        0",
+                            "st1  2022.01.01T09:00:00.001 10002    3        0        0",
+                            "st1  2022.01.01T09:00:00.002 10003    5        0        0",
+                            "st1  2022.01.01T09:00:00.003 10002    2        0        12",
+                            "==== ======================= ======== ======== ======== ========",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ dropStreamEngine(\"reactive_csum\")",
+                            "    $ dropStreamEngine(\"reactive_prev\")",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "相关函数：:doc:`/FunctionsandCommands/FunctionReferences/d/dynamicGroupCumcount`"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "eig": {
         "title": "eig",
         "type": "function",
@@ -22868,13 +23672,13 @@
                         "value": [
                             "  ",
                             "   $ eqFloat(0.1234567891, 0.123456789);",
-                            "   1",
+                            "   true",
                             "",
                             "   $ eqFloat(0.123456788, 0.123456789);",
-                            "   0",
+                            "   false",
                             "",
                             "   $ eqFloat(0.123456788 0.123456789 0.1234567891, 0.123456789);",
-                            "   [0,1,1]",
+                            "   [false,true,true]",
                             ""
                         ]
                     },
@@ -22926,7 +23730,9 @@
                     {
                         "type": "text",
                         "value": [
-                            "比较两个对象的对象类型和值，看它们是否相同。只有当类型和值都相同时，此函数才会返回true。 如果值相同但类型不同，则此函数仍返回false，这与函数 :doc:`eq` 不同。"
+                            "检验两个对象的类型和值是否相同。只有当类型和值都相同时，此函数才会返回true。 如果值相同但类型不同，则此函数仍返回false，这与函数 :doc:`eq` 不同。",
+                            "",
+                            "注意：使用 eqObj 比较浮点数时，根据 abs(obj1-obj2)<=pow(10,-precision) 的结果来判断 obj1 和 obj2 的值是否相等。"
                         ]
                     }
                 ]
@@ -22941,21 +23747,21 @@
                         "value": [
                             "  ",
                             "   $ eqObj(2, 2.0);",
-                            "   0",
+                            "   false",
                             "",
                             "   $ eq(2, 2.0);",
-                            "   1",
+                            "   true",
                             "",
                             "   $ eqObj(1.1, 1.2, 0);",
-                            "   1",
+                            "   true",
                             "",
                             "   $ eqObj(1.1, 1.2, 1);",
-                            "   0",
+                            "   false",
                             "",
                             "   $ eqObj(1 2 3, 1 2 3);",
-                            "   1",
+                            "   true",
                             "   $ eq(1 2 3, 1 2 3);",
-                            "   [1,1,1]",
+                            "   [true,true,true]",
                             ""
                         ]
                     },
@@ -22978,7 +23784,7 @@
                             "   ([1,2,3],[4,5,6])",
                             "",
                             "   $ each(eqObj, t1.values(), t2.values());",
-                            "   [1,1]"
+                            "   [true,true]"
                         ]
                     }
                 ]
@@ -28143,15 +28949,24 @@
                             "",
                             "* version: 版本号",
                             "",
-                            "* VCLength: 版本链长度",
-                            "",
-                            "* VersionChain: 版本链",
+                            "* vcLength: 版本链长度",
+                            "  ",
+                            "* versionChain: 版本链",
                             "",
                             "* state: chunk 状态。CONSTRUCTING：正在事务中； RECOVERING：正在 recovery 中；COMPLETE：已经处于事务终止状态；",
                             "",
                             "* replicas: 副本的分布信息",
                             "",
-                            "* replicaCount: 副本数"
+                            "* replicaCount: 副本数",
+                            "",
+                            "* permission: CHUNK 的权限。CHUNK 的权限分为 READ_ONLY 以及 READ_WRITE（默认权限）两类。正在进行迁移的分区，或存储在 s3 的分区权限均为 READ_ONLY。",
+                            "",
+                            "对于 READ_ONLY 权限的分区：",
+                            "",
+                            "\\(1) 不能追加或更新数据，并只能通过调用 drop 类函数进行删除，且遵从事务的原则。（注意：存储在 s3 的分区不支持事务）。",
+                            "",
+                            "\\(2) 不能对其进行 recovery 和 rebalance。",
+                            ""
                         ]
                     }
                 ]
@@ -28172,16 +28987,16 @@
                     {
                         "type": "text",
                         "value": [
-                            "=================== =============== ==== ======= ======== =================== ======== ==================== =============",
-                            "chunkId             file            size version vcLength versionChain        state    replicas             replicaCount",
-                            "=================== =============== ==== ======= ======== =================== ======== ==================== =============",
-                            "092d5e12-e595-6f... /testDB/pt2.tbl 49   1       1        2052:49:1 ->        COMPLETE P1-node1:1:0,P2-...  2",
-                            "42936e31-8be0-fa... /testDB/9/i     0    2       2        2053:0:2 -> 2051... COMPLETE P3-node1:2:0,P1-...  2",
-                            "d31e6b47-18f0-37... /testDB/7/i     0    2       2        2053:0:2 -> 2051... COMPLETE P1-node1:2:0,P2-...  2",
-                            "647a5fd6-cd85-3b... /testDB/6/i     0    2       2        2053:0:2 -> 2051... COMPLETE P1-node1:2:0,P3-...  2",
-                            "8bec6445-bc6d-36... /testDB/5/i     0    2       2        2053:0:2 -> 2051... COMPLETE P2-node1:2:0,P3-...  2",
-                            "ca690ba5-be73-a6... /testDB/4/i     0    2       2        2053:0:2 -> 2051... COMPLETE P3-node1:2:0,P1-...  2",
-                            "=================== =============== ==== ======= ======== =================== ======== ==================== ============="
+                            "=================== =============== ==== ======= ======== =================== ======== ==================== ============== ===========",
+                            "chunkId             file            size version vcLength versionChain        state    replicas             replicaCount   permission",
+                            "=================== =============== ==== ======= ======== =================== ======== ==================== ============== ===========",
+                            "092d5e12-e595-6f... /testDB/pt2.tbl 49   1       1        2052:49:1 ->        COMPLETE P1-node1:1:0,P2-...  2              READ_WRITE",
+                            "42936e31-8be0-fa... /testDB/9/i     0    2       2        2053:0:2 -> 2051... COMPLETE P3-node1:2:0,P1-...  2              READ_WRITE",
+                            "d31e6b47-18f0-37... /testDB/7/i     0    2       2        2053:0:2 -> 2051... COMPLETE P1-node1:2:0,P2-...  2              READ_WRITE",
+                            "647a5fd6-cd85-3b... /testDB/6/i     0    2       2        2053:0:2 -> 2051... COMPLETE P1-node1:2:0,P3-...  2              READ_WRITE",
+                            "8bec6445-bc6d-36... /testDB/5/i     0    2       2        2053:0:2 -> 2051... COMPLETE P2-node1:2:0,P3-...  2              READ_WRITE",
+                            "ca690ba5-be73-a6... /testDB/4/i     0    2       2        2053:0:2 -> 2051... COMPLETE P3-node1:2:0,P1-...  2              READ_WRITE",
+                            "=================== =============== ==== ======= ======== =================== ======== ==================== ============== ==========="
                         ]
                     }
                 ]
@@ -28942,7 +29757,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "获取当前 session 的 sessionId 和用户名。返回一个 tuple，第一个元素为 sessionId，第二个元素为 userId。"
+                            "获取当前 session 的 session ID 和用户名。返回一个 tuple，第一个元素为 sessionId，第二个元素为 userId。"
                         ]
                     }
                 ]
@@ -31789,7 +32604,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "获取当前节点所在的流数据Raft组的信息。返回的结果是一个表，第一列表示Raft组的id，第二列表示Raft组包含的/计算节点信息。"
+                            "获取当前节点所在的流数据Raft组的信息。返回的结果是一个表，第一列表示Raft组的id，第二列表示Raft组包含的数据节点/计算节点信息。"
                         ]
                     }
                 ]
@@ -31952,7 +32767,7 @@
                             "lastErrMsg             最后一条错误消息的信息                                                 ",
                             "msgAsTable             布尔值，表示订阅的数据是否为表。true表示订阅的数据为表；false表示订阅的数据是由列组成的元组。                                       ",
                             "batchSize              handler批量处理的消息数                                          ",
-                            "throttle               数值类型，单位为秒。表示继上次handler处理消息之后，若batchSize条件一直未达到，多久后再次处理消息       ",
+                            "throttle               数值类型，单位为毫秒。表示继上次handler处理消息之后，若batchSize条件一直未达到，多久后再次处理消息       ",
                             "hash                   非负整数，指定某个订阅线程处理进来的消息                                     ",
                             "filter                 流数据表指定的过滤列                                             ",
                             "persistOffset          布尔值，表示是否持久化保存最新一条已经处理的订阅数据的偏移量                           ",
@@ -42748,6 +43563,77 @@
             }
         ]
     },
+    "loadDistributedInMemoryTable": {
+        "title": "loadDistributedInMemoryTable",
+        "type": "function",
+        "children": [
+            {
+                "title": "语法",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "loadDistributedInMemoryTable(tableName)"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "参数",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "`tableName` 字符串标量，表示分布式共享内存表的名称。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "详情",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "返回分布式共享内存表的句柄。该函数只能在数据节点/计算节点上执行。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "例子",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ pt = createDistributedInMemoryTable(`dt, `time`id`value, `DATETIME`INT`LONG, HASH, [INT, 2],`id)",
+                            "    $ time = take(2021.08.20 00:00:00..2021.08.30 00:00:00, 40);",
+                            "    $ id = 0..39;",
+                            "    $ value = rand(100, 40);",
+                            "    $ tmp = table(time, id, value);",
+                            "",
+                            "    $ pt = loadDistributedInMemoryTable(`dt)",
+                            "    $ pt.append!(tmp);",
+                            "    $ select * from pt;",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "相关函数：:doc:`/FunctionsandCommands/CommandsReferences/d/dropDistributedInMemoryTable`, :doc:`/FunctionsandCommands/FunctionReferences/c/createDistributedInMemoryTable`"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "loadModel": {
         "title": "loadModel",
         "type": "function",
@@ -44021,7 +44907,7 @@
                         "value": [
                             "",
                             "   $ schematable=table(`sym`permno`date`open`high`close`pre_close`change`vol`amount as name,`SYMBOL`SYMBOL`DATE`DOUBLE`DOUBLE`DOUBLE`DOUBLE`DOUBLE`INT`DOUBLE as type)",
-                            "   $ tt=loadText(\"C:/DolphinDB/Data/stock.csv\",,schema)",
+                            "   $ tt=loadText(\"C:/DolphinDB/Data/stock.csv\",,schematable)",
                             "   $ schema(tt).colDefs;",
                             ""
                         ]
@@ -44755,7 +45641,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "用户可在控制器节点或/计算节点上登录。"
+                            "用户可在控制器节点或数据节点/计算节点上登录。"
                         ]
                     }
                 ]
@@ -44974,7 +45860,7 @@
                             "",
                             "如果 *sessionOnly* 为true，用户只退出登录当前会话。",
                             "",
-                            "如果 *sessionOnly* 为false，用户会退出登录当前会话、所有的/计算节点以及控制节点。",
+                            "如果 *sessionOnly* 为false，用户会退出登录当前会话、所有的数据节点/计算节点以及控制节点。",
                             "",
                             "管理员可以使其他用户退出登录。如果管理员使用户退出登录，用户会退出登录当前会话、所有的数据节点/计算节点以及控制节点。"
                         ]
@@ -48750,6 +49636,82 @@
             }
         ]
     },
+    "memSize": {
+        "title": "memSize",
+        "type": "function",
+        "children": [
+            {
+                "title": "语法",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "memSize(obj)"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "参数",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "`obj` 一个对象。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "详情",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "返回本地对象或共享对象占用内存大小，单位为字节。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "例子",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "   $ $ n=100",
+                            "   $ ID=rand(100, n)",
+                            "   $ date=rand(2017.08.07..2017.08.11, n)",
+                            "   $ x=rand(10.0, n)",
+                            "   $ t=table(ID, date, x);",
+                            "   $ share t as tt",
+                            "   $ memSize(t)",
+                            "   1952",
+                            "   $ memSize(tt)",
+                            "   1952",
+                            "   $ memSize(t[`x])",
+                            "   800",
+                            "   $ memSize(select avg(x) as avgx from t)",
+                            "   280",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "相关函数：:doc:`../o/objs`"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "member": {
         "title": "member",
         "type": "function",
@@ -51596,6 +52558,51 @@
             }
         ]
     },
+    "moveHotDataToColdVolume": {
+        "title": "moveHotDataToColdVolume",
+        "type": "command",
+        "children": [
+            {
+                "title": "语法",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "moveHotDataToColdVolume([checkRange=240])"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "参数",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "`checkRange` 整数，单位为小时，默认值为 10 天，即 240 小时。用于设置需迁移至 *coldVolumes* 的数据的时间范围。设置后，时间范围在 [当前时间 - hoursToColdVolumes - checkRange, 当前时间 - hoursToColdVolumes) 内的数据将会被迁移至 coldVolumes。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "详情",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "用于强制触发将用户指定范围的数据转存至 coldVolumes。",
+                            "",
+                            "该命令设置的转存策略与 :doc:`/FunctionsandCommands/CommandsReferences/s/setRetentionPolicy` 设置的转存策略的有一定区别，详情请参考 :doc:`/DatabaseandDistributedComputing/Database/TieredStorage`。",
+                            ""
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "moveReplicas": {
         "title": "moveReplicas",
         "type": "command",
@@ -58506,7 +59513,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "`function` 调用的本地函数。不能使用引号，必须是无参数的函数。它可以是一个没有定义参数的函数，或者是没有参数的封装了初始函数和参数的部分应用。它可以是内置函数或用户自定义函数。",
+                            "`function` 调用的本地函数（不能使用引号）。它可以是一个没有定义参数的函数，或者是没有参数的封装了初始函数和参数的部分应用。它可以是内置函数或用户自定义函数。",
                             "",
                             "`nodes` 节点的别名。如果没有指定，系统会调用集群中所有活数据节点/计算节点。",
                             "",
@@ -58534,7 +59541,35 @@
                     {
                         "type": "text",
                         "value": [
-                            "在下列例子中，函数 *sum* 和参数1..10被封装成了部分应用 *sum{1..10}*。",
+                            "例1. 函数 `getChunksMeta` 不指定参数。",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ pnodeRun(getChunksMeta,,false);",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "=========  ===================================== ============================================================================= =======================  ===== ===== ===== ======== ====== ==========================",
+                            "site       chunkId                               path                                                                          dfsPath                  type   flag size  version  state  versionList             ",
+                            "=========  ===================================== ============================================================================= =======================  ===== ===== ===== ======== ====== ==========================",
+                            "local8848  bd13090e-7177-01a7-4ac4-840e1b977dcf  D:\\130\\DolphinDB_Win64_V\\server\\local8848\\storage/CHUNKS/compo/20190605/GOOG   /compo/20190605/GOOG    1     0     0     1        0      cid : 40,pt2=>40:6729; # ",
+                            "local8848  b4935730-6372-b2a1-4f24-6c323037e576  e:\\data/CHUNKS/compo/20190605/AAPL                                             /compo/20190605/AAPL    1     0     0     1        0      cid : 40,pt2=>40:6613; # ",
+                            "local8848  f8ee72c9-dad3-f49e-430e-5ddb3c61ae18  D:\\130\\DolphinDB_Win64_V\\server\\local8848\\storage/CHUNKS/compo/20190604/MSFT   /compo/20190604/MSFT    1     0     0     1        0      cid : 40,pt2=>40:6664; # ",
+                            "local8848  08e26b5a-dfac-799f-4979-0dd3902eae6e  D:\\130\\DolphinDB_Win64_V\\server\\local8848\\storage/CHUNKS/compo/20190604/GOOG   /compo/20190604/GOOG    1     0     0     1        0      cid : 40,pt2=>40:6635; # ",
+                            "local8848  f9e53a3d-af3e-018d-4bfa-a2b4980f3561  D:\\130\\DolphinDB_Win64_V\\server\\local8848\\storage/CHUNKS/compo/20190604/AAPL   /compo/20190604/AAPL    1     0     0     1        0      cid : 40,pt2=>40:6783; # ",
+                            "local8848  417e49e9-5c61-cf9e-4b21-4b35f8e57273  D:\\130\\DolphinDB_Win64_V\\server\\local8848\\storage/CHUNKS/compo/20190601/MSFT   /compo/20190601/MSFT    1     0     0     1        0      cid : 40,pt2=>40:6602; # ",
+                            "local8848  3ee64942-1d72-bea7-4bc1-f720132d9288  D:\\130\\DolphinDB_Win64_V\\server\\local8848\\storage/CHUNKS/compo/20190602/AAPL   /compo/20190602/AAPL    1     0     0     1        0      cid : 40,pt2=>40:6749; # ",
+                            "=========  ===================================== ============================================================================= =======================  ===== ===== ===== ======== ====== ==========================",
+                            "",
+                            "例2. 在下例中，函数 `sum` 和参数1..10被封装成了部分应用 `sum{1..10}`。",
                             ""
                         ]
                     },
@@ -58557,7 +59592,7 @@
                             "DFS_NODE3   55",
                             "=========== ======",
                             "",
-                            "*pnodeRun* 对于集群管理非常方便。例如，在一个集群中有4个节点：\"DFS_NODE1\", \"DFS_NODE2\",  \"DFS_NODE3\"和\"DFS_NODE4\"。在每个节点上执行以下脚本：",
+                            "例3. `pnodeRun` 对于集群管理非常方便。例如，在一个集群中有4个节点：\"DFS_NODE1\", \"DFS_NODE2\", \"DFS_NODE3\" 和 \"DFS_NODE4\"。在每个节点上执行以下脚本：",
                             ""
                         ]
                     },
@@ -58645,34 +59680,8 @@
                             "+---------+-------+--------+--------+-----------------------+-----------------------+-----------------------+--------+",
                             "|DFS_NODE4|  root |jobDemo3|job demo|2017.11.16T13:05:16.325|2017.11.16T13:05:16.328|2017.11.16T13:05:34.716|        |",
                             "+---------+-------+--------+--------+-----------------------+-----------------------+-----------------------+--------+",
-                            ""
-                        ]
-                    },
-                    {
-                        "type": "code",
-                        "language": "console",
-                        "value": [
                             "",
-                            "    $ pnodeRun(getChunksMeta,,false);",
-                            ""
-                        ]
-                    },
-                    {
-                        "type": "text",
-                        "value": [
-                            "=========  ===================================== ============================================================================= =======================  ===== ===== ===== ======== ====== ==========================",
-                            "site       chunkId                               path                                                                          dfsPath                  type   flag size  version  state  versionList             ",
-                            "=========  ===================================== ============================================================================= =======================  ===== ===== ===== ======== ====== ==========================",
-                            "local8848  bd13090e-7177-01a7-4ac4-840e1b977dcf  D:\\130\\DolphinDB_Win64_V\\server\\local8848\\storage/CHUNKS/compo/20190605/GOOG   /compo/20190605/GOOG    1     0     0     1        0      cid : 40,pt2=>40:6729; # ",
-                            "local8848  b4935730-6372-b2a1-4f24-6c323037e576  e:\\data/CHUNKS/compo/20190605/AAPL                                             /compo/20190605/AAPL    1     0     0     1        0      cid : 40,pt2=>40:6613; # ",
-                            "local8848  f8ee72c9-dad3-f49e-430e-5ddb3c61ae18  D:\\130\\DolphinDB_Win64_V\\server\\local8848\\storage/CHUNKS/compo/20190604/MSFT   /compo/20190604/MSFT    1     0     0     1        0      cid : 40,pt2=>40:6664; # ",
-                            "local8848  08e26b5a-dfac-799f-4979-0dd3902eae6e  D:\\130\\DolphinDB_Win64_V\\server\\local8848\\storage/CHUNKS/compo/20190604/GOOG   /compo/20190604/GOOG    1     0     0     1        0      cid : 40,pt2=>40:6635; # ",
-                            "local8848  f9e53a3d-af3e-018d-4bfa-a2b4980f3561  D:\\130\\DolphinDB_Win64_V\\server\\local8848\\storage/CHUNKS/compo/20190604/AAPL   /compo/20190604/AAPL    1     0     0     1        0      cid : 40,pt2=>40:6783; # ",
-                            "local8848  417e49e9-5c61-cf9e-4b21-4b35f8e57273  D:\\130\\DolphinDB_Win64_V\\server\\local8848\\storage/CHUNKS/compo/20190601/MSFT   /compo/20190601/MSFT    1     0     0     1        0      cid : 40,pt2=>40:6602; # ",
-                            "local8848  3ee64942-1d72-bea7-4bc1-f720132d9288  D:\\130\\DolphinDB_Win64_V\\server\\local8848\\storage/CHUNKS/compo/20190602/AAPL   /compo/20190602/AAPL    1     0     0     1        0      cid : 40,pt2=>40:6749; # ",
-                            "=========  ===================================== ============================================================================= =======================  ===== ===== ===== ======== ====== ==========================",
-                            "",
-                            "*pnodeRun*  合并多个节点的结果时遵循以下规则：",
+                            "`pnodeRun` 合并多个节点的结果时遵循以下规则：",
                             "",
                             "\\(1) 如果 *function* 返回一个标量：",
                             "",
@@ -60479,7 +61488,7 @@
                         "value": [
                             "`X` 标量或向量；",
                             "",
-                            "`count` 整型标量或数据对。若为标量，表示输出向量的长度；若为数据对，表示输出矩阵的维度。"
+                            "`count` INT 型标量或数据对。若为标量，表示输出向量的长度；若为数据对，表示输出矩阵的维度。"
                         ]
                     }
                 ]
@@ -60766,6 +61775,83 @@
             }
         ]
     },
+    "randDiscrete": {
+        "title": "randDiscrete",
+        "type": "function",
+        "children": [
+            {
+                "title": "语法",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "randDiscrete(v, p, count)"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "参数",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "`v` 向量或元组，表示样本数据。",
+                            "",
+                            "`p` 与 v 等长的浮点型向量，其每个元素必须是正数，对应 v 中采样元素的概率分布。系统会自动将 p 的元素归一化。",
+                            "",
+                            "`count` 正整数，表示输出的随机向量的长度。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "详情",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "根据给定的分布概率 p，生成向量 v 的随机样本。生成样本的长度由 count 指定。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "例子",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ randDiscrete(1..5, [0.1, 0.1, 0.2, 0.2, 0.4], 10)",
+                            "    [2,3,5,2,5,5,2,1,1,2]",
+                            "",
+                            "    //若概率和不为1，系统会自动归一化 ",
+                            "    $ randDiscrete(1..5, [0.1, 0.2, 0.3, 0.4, 0.5], 5)",
+                            "    [5,1,2,3,5]",
+                            "",
+                            "    $ randDiscrete(`A`B`C`E`F, [0.1, 0.2, 0.3, 0.4, 0.5], 5)",
+                            "    [\"C\",\"E\",\"B\",\"C\",\"F\"]",
+                            "",
+                            "    // 输入元组，对元组中的每个元素进行采样",
+                            "    $ randDiscrete([[1,2], [2,3,4], 'S', 'abc'], [0.3, 0.3, 0.2, 0.1], 10)",
+                            "    ('S',[2,3,4],[1,2],[2,3,4],[1,2],'S','S',[2,3,4],[2,3,4],[2,3,4])",
+                            "",
+                            "    // 输入数组向量，对其中的每个向量进行采样",
+                            "    $ a = array(INT[], 0, 10).append!([1 2 3, 4 5,6 7 8, 9 NULL])",
+                            "    $ randDiscrete(a, [0.1, 0.2, 0.3, 0.4], 10)",
+                            "    [[9,00i],[9,00i],[9,00i],[4,5],[9,00i],[1,2,3],[9,00i],[6,7,8],[9,00i],[9,00i]]"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "randExp": {
         "title": "randExp",
         "type": "function",
@@ -62634,10 +63720,203 @@
                     {
                         "type": "text",
                         "value": [
-                            "从句柄中读取给定数量的字符串，并从指定位置开始，把读取结果保存至holder表示的变量中。函数返回实际读取的行数。",
-                            "",
-                            ":doc:`readLines` 函数的每次调用都创建了一个字符串向量并返回。创建字符串向量需要一定的时间开销，所以如果在重复执行函数调用时，能重用相同的向量作为缓冲区的话，可以节约时间。",
-                            "readLines! 就是这样的函数，它接受已存在的缓冲区作为数据容器。下述的两个例子读取相同数量的数据 100 次。readLines! 函数比 readLines 函数更快。"
+                            "从句柄中读取给定数量的字符串，并从指定位置开始，把读取结果保存至holder表示的变量中。函数返回实际读取的行数。",
+                            "",
+                            ":doc:`readLines` 函数的每次调用都创建了一个字符串向量并返回。创建字符串向量需要一定的时间开销，所以如果在重复执行函数调用时，能重用相同的向量作为缓冲区的话，可以节约时间。",
+                            "readLines! 就是这样的函数，它接受已存在的缓冲区作为数据容器。下述的两个例子读取相同数量的数据 100 次。readLines! 函数比 readLines 函数更快。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "例子",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "     $ timer(100){",
+                            "     $ fin = file(\"test.txt\")",
+                            "     $ do{ y=fin.readLines(1024) } while(y.size()==1024)",
+                            "     $ fin.close()",
+                            "     $ };",
+                            "",
+                            "    Time elapsed: 79.511 ms",
+                            "    ",
+                            "     $ timer(100){",
+                            "     $ fin = file(\"test.txt\")",
+                            "     $ y=array(STRING,1024)",
+                            "     $ do{ lines = fin.readLines!(y,0,1024) } while(lines==1024)",
+                            "     $ fin.close()",
+                            "     $ };",
+                            "",
+                            "    Time elapsed: 56.034 ms",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            ".. meta::   ",
+                            "   :keywords: read"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
+    "readObject": {
+        "title": "readObject",
+        "type": "function",
+        "children": [
+            {
+                "title": "语法",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "readObject(handle)"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "参数",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "`handle` 是文件句柄。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "详情",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "可以将所有的数据类型读取到句柄中，包括标量、向量、矩阵、集合、字典和表。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "例子",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "code",
+                        "language": " console",
+                        "value": [
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            " $ a1=10.5",
+                            " $ a2=1..10",
+                            " $ a3=cross(*,1..5,1..10)",
+                            " $ a4=set(`IBM`MSFT`GOOG`YHOO)",
+                            " $ a5=dict(a4.keys(),125.6 53.2 702.3 39.7)",
+                            " $ a6=table(1 2 3 as id, `Jenny`Tom`Jack as name)",
+                            " $ a7=(1 2 3, \"hello world!\", 25.6)",
+                            "",
+                            " $ fout=file(\"test.bin\",\"w\")",
+                            " $ fout.writeObject(a1)",
+                            " $ fout.writeObject(a2)",
+                            " $ fout.writeObject(a3)",
+                            " $ fout.writeObject(a4)",
+                            " $ fout.writeObject(a5)",
+                            " $ fout.writeObject(a6)",
+                            " $ fout.writeObject(a7)",
+                            " $ fout.close();",
+                            "",
+                            "上述的脚本把 7 个不同类型的对象写到一个文件中。下述的脚本将这 7 个对象从文件中读取出来，并为每个对象打印一个简短的描述。",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            " $ fin = file(\"test.bin\")",
+                            " $ for(i in 0:7) print typestr fin.readObject()",
+                            " $ fin.close();",
+                            "",
+                            "    DOUBLE",
+                            "    FAST INT VECTOR",
+                            "    INT MATRIX",
+                            "    STRING SET",
+                            "    STRING->DOUBLE Dictionary",
+                            "    TABLE",
+                            "    ANY VECTOR",
+                            "",
+                            ".. meta::   ",
+                            "   :keywords: read"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
+    "readRecord!": {
+        "title": "readRecord!",
+        "type": "function",
+        "children": [
+            {
+                "title": "语法",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "readRecord!(handle, holder, [offset=0], [length])"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "参数",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "`handle` 是文件句柄。",
+                            "",
+                            "`holder` 是用于保存读取的数据的变量。",
+                            "",
+                            "`offset` 表示数据保存至holder的起始位置。",
+                            "",
+                            "`length` 是从文件中读取的行数。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "详情",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "readRecord! 函数将二进制文件转换为 DolphinDB 数据对象。DolphinDB 也提供了 :doc:`../w/writeRecord`  函数，用于将 DolphinDB 数据对象转换为二进制文件，以供其它程序使用。",
+                            "二进制文件基于行，且每行包含的记录有相同的数据类型和固定的长度。例如，如果一个二进制文件包含了 5 个数据域，分别具有下述数据类型（长度）：char(1), boolean(1), short(2), int(4), long(8), 和 double(8)，",
+                            "那么 readRecord! 函数将把每行视为 24 个字节。类似地，writeRecord 函数把 DolphinDB 对象（例如表或元组）转换为具有上述格式的二进制文件。"
                         ]
                     }
                 ]
@@ -62651,22 +63930,19 @@
                         "language": "console",
                         "value": [
                             "",
-                            "     $ timer(100){",
-                            "     $ fin = file(\"test.txt\")",
-                            "     $ do{ y=fin.readLines(1024) } while(y.size()==1024)",
-                            "     $ fin.close()",
-                            "     $ };",
-                            "",
-                            "    Time elapsed: 79.511 ms",
-                            "    ",
-                            "     $ timer(100){",
-                            "     $ fin = file(\"test.txt\")",
-                            "     $ y=array(STRING,1024)",
-                            "     $ do{ lines = fin.readLines!(y,0,1024) } while(lines==1024)",
-                            "     $ fin.close()",
-                            "     $ };",
+                            "    // 创建一个文件句柄，用于读取记录。二进制文件 a.bin 包含了 1000 条记录。",
+                            "    $ f=file(\"c:/DB/a.bin\")",
+                            "    $ t=table(1000:0, `PERMNO`PRC`VOL`SHROUT, `int`double`int`double)",
+                            "    $ f.readRecord!(t);",
+                            "    1000",
                             "",
-                            "    Time elapsed: 56.034 ms",
+                            "    // 类似地，我们可以将一个二进制文件读入一个 DolphinDB 元组对象",
+                            "    $ f=file(\"c:/DB/a.bin\")",
+                            "    $ t=loop(array, [int, double, int, double], 0, 500)  ",
+                            "    // 创建具有 4 个数组元素的元组 t。每一个数组的长度是 500",
+                            "    $  f.readRecord!(t, 0, 500);                                  ",
+                            "    // 读取前 500 行",
+                            "    500",
                             ""
                         ]
                     },
@@ -62681,8 +63957,8 @@
             }
         ]
     },
-    "readObject": {
-        "title": "readObject",
+    "rebalanceChunksAmongDataNodes": {
+        "title": "rebalanceChunksAmongDataNodes",
         "type": "function",
         "children": [
             {
@@ -62692,7 +63968,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "readObject(handle)"
+                            "rebalanceChunksAmongDataNodes([exec = false])"
                         ]
                     }
                 ]
@@ -62704,7 +63980,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "`handle` 是文件句柄。"
+                            "`exec` 布尔值，表示是否进行节点间的数据平衡。默认值为 false，表示不进行数据平衡。"
                         ]
                     }
                 ]
@@ -62716,7 +63992,19 @@
                     {
                         "type": "text",
                         "value": [
-                            "可以将所有的数据类型读取到句柄中，包括标量、向量、矩阵、集合、字典和表。"
+                            "在所有节点间平衡数据，以保证集群最佳性能。通常用于在集群中增加节点后。只能由管理员在控制节点上执行。",
+                            "",
+                            "返回一个表，包含以下列：",
+                            "",
+                            "================== =================================================",
+                            "列名                含义",
+                            "================== =================================================",
+                            "chunkId               chunk 的唯一标识",
+                            "srcNode               源节点的别名",
+                            "destNode            目标节点的别名",
+                            "================== =================================================",
+                            "",
+                            "调用该函数后，可以在控制节点上执行 :doc:`/FunctionsandCommands/FunctionReferences/g/getRecoveryTaskStatus`  查看任务执行的状态。"
                         ]
                     }
                 ]
@@ -62725,70 +64013,34 @@
                 "title": "例子",
                 "type": "example",
                 "children": [
-                    {
-                        "type": "code",
-                        "language": " console",
-                        "value": [
-                            ""
-                        ]
-                    },
-                    {
-                        "type": "text",
-                        "value": [
-                            " $ a1=10.5",
-                            " $ a2=1..10",
-                            " $ a3=cross(*,1..5,1..10)",
-                            " $ a4=set(`IBM`MSFT`GOOG`YHOO)",
-                            " $ a5=dict(a4.keys(),125.6 53.2 702.3 39.7)",
-                            " $ a6=table(1 2 3 as id, `Jenny`Tom`Jack as name)",
-                            " $ a7=(1 2 3, \"hello world!\", 25.6)",
-                            "",
-                            " $ fout=file(\"test.bin\",\"w\")",
-                            " $ fout.writeObject(a1)",
-                            " $ fout.writeObject(a2)",
-                            " $ fout.writeObject(a3)",
-                            " $ fout.writeObject(a4)",
-                            " $ fout.writeObject(a5)",
-                            " $ fout.writeObject(a6)",
-                            " $ fout.writeObject(a7)",
-                            " $ fout.close();",
-                            "",
-                            "上述的脚本把 7 个不同类型的对象写到一个文件中。下述的脚本将这 7 个对象从文件中读取出来，并为每个对象打印一个简短的描述。",
-                            ""
-                        ]
-                    },
                     {
                         "type": "code",
                         "language": "console",
                         "value": [
+                            "",
+                            "    $ rebalanceChunksAmongDataNodes()",
                             ""
                         ]
                     },
                     {
                         "type": "text",
                         "value": [
-                            " $ fin = file(\"test.bin\")",
-                            " $ for(i in 0:7) print typestr fin.readObject()",
-                            " $ fin.close();",
-                            "",
-                            "    DOUBLE",
-                            "    FAST INT VECTOR",
-                            "    INT MATRIX",
-                            "    STRING SET",
-                            "    STRING->DOUBLE Dictionary",
-                            "    TABLE",
-                            "    ANY VECTOR",
+                            "==================================== ======= ========",
+                            "ChunkId                              srcNode destNode",
+                            "==================================== ======= ========",
+                            "99279094-ca12-3b87-48b6-520cbb986f39 node1   node2",
+                            "45f612b8-42f5-aebd-4cef-e522b6ae1fc8 node1   node2\t",
+                            "==================================== ======= ========",
                             "",
-                            ".. meta::   ",
-                            "   :keywords: read"
+                            " "
                         ]
                     }
                 ]
             }
         ]
     },
-    "readRecord!": {
-        "title": "readRecord!",
+    "rebalanceChunksWithinDataNode": {
+        "title": "rebalanceChunksWithinDataNode",
         "type": "function",
         "children": [
             {
@@ -62798,7 +64050,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "readRecord!(handle, holder, [offset=0], [length])"
+                            "rebalanceChunksWithinDataNode(nodeAlias, [exec=false])"
                         ]
                     }
                 ]
@@ -62810,13 +64062,9 @@
                     {
                         "type": "text",
                         "value": [
-                            "`handle` 是文件句柄。",
-                            "",
-                            "`holder` 是用于保存读取的数据的变量。",
-                            "",
-                            "`offset` 表示数据保存至holder的起始位置。",
+                            "`nodeAlias` 字符串，表示数据节点的别名。",
                             "",
-                            "`length` 是从文件中读取的行数。"
+                            "`exec` 布尔值，表示是否在节点内进行数据平衡。默认值为 false，表示不进行数据平衡。"
                         ]
                     }
                 ]
@@ -62828,9 +64076,20 @@
                     {
                         "type": "text",
                         "value": [
-                            "readRecord! 函数将二进制文件转换为 DolphinDB 数据对象。DolphinDB 也提供了 :doc:`../w/writeRecord`  函数，用于将 DolphinDB 数据对象转换为二进制文件，以供其它程序使用。",
-                            "二进制文件基于行，且每行包含的记录有相同的数据类型和固定的长度。例如，如果一个二进制文件包含了 5 个数据域，分别具有下述数据类型（长度）：char(1), boolean(1), short(2), int(4), long(8), 和 double(8)，",
-                            "那么 readRecord! 函数将把每行视为 24 个字节。类似地，writeRecord 函数把 DolphinDB 对象（例如表或元组）转换为具有上述格式的二进制文件。"
+                            "一个节点内部增加磁盘卷后，需要调整现有磁盘卷上的数据量，使各个磁盘卷上的数据量达到平衡。该函数用于平衡一个数据节点内各磁盘卷间的数据，返回一个表，显示各磁盘卷间数据平衡计划。",
+                            "若 *exec* 为 true，则进行数据平衡；若 *exec* 为 false，则不进行数据平衡。它只能由管理员在控制节点上执行。",
+                            "",
+                            "返回结果包含以下列：",
+                            "",
+                            "================== =================================================",
+                            "列名                含义",
+                            "================== =================================================",
+                            "chunkId               chunk 的唯一标识",
+                            "srcVolume            源磁盘卷",
+                            "destVolume         目标磁盘卷",
+                            "================== =================================================",
+                            "",
+                            "调用该函数进行数据平衡后，可以在控制节点上执行 :doc:`/FunctionsandCommands/FunctionReferences/g/getRecoveryTaskStatus`  查看任务执行的状态。"
                         ]
                     }
                 ]
@@ -62844,27 +64103,18 @@
                         "language": "console",
                         "value": [
                             "",
-                            "    // 创建一个文件句柄，用于读取记录。二进制文件 a.bin 包含了 1000 条记录。",
-                            "    $ f=file(\"c:/DB/a.bin\")",
-                            "    $ t=table(1000:0, `PERMNO`PRC`VOL`SHROUT, `int`double`int`double)",
-                            "    $ f.readRecord!(t);",
-                            "    1000",
-                            "",
-                            "    // 类似地，我们可以将一个二进制文件读入一个 DolphinDB 元组对象",
-                            "    $ f=file(\"c:/DB/a.bin\")",
-                            "    $ t=loop(array, [int, double, int, double], 0, 500)  ",
-                            "    // 创建具有 4 个数组元素的元组 t。每一个数组的长度是 500",
-                            "    $  f.readRecord!(t, 0, 500);                                  ",
-                            "    // 读取前 500 行",
-                            "    500",
+                            "    $ rebalanceChunksWithinDataNode(\"node1\")",
                             ""
                         ]
                     },
                     {
                         "type": "text",
                         "value": [
-                            ".. meta::   ",
-                            "   :keywords: read"
+                            "+-------------------------------------+-------------------+------------------+",
+                            "|ChunkId                              |srcVolume          |destVolume        |",
+                            "+=====================================+===================+==================+",
+                            "|82c6eb6c-36ee-b1b6-4a86-ca24d9faaa25 | /hdd/hdd1/volumes |/hdd/hdd2/volumes |\t",
+                            "+-------------------------------------+-------------------+------------------+"
                         ]
                     }
                 ]
@@ -65007,9 +66257,7 @@
                             "",
                             "`dateColumn` 和 `timeColumn` 是一个字符串，表示SQL查询的表对象的日期列和时间列。dateColumn的每一天会产生一个数据源。dateColumn必须是SQL查询的表对象的分区列之一。如果没有指定 dateColumn与 timeColumn，原数据表的第一列将会作为 dateColumn。",
                             "",
-                            "`timeRepartitionSchema` 是一个TIME或NANOTIME类型的向量。如果指定了 timeColumn，timeRepartitionSchema可用于划分更小粒度的数据源。如果",
-                            "",
-                            "`timeRepartitionSchema` 为[t1, t2, t3]，那么将每天的数据进一步划分为4个数据源：[00:00:00.000,t1), [t1,t2), [t2,t3) 和 [t3,23:59:59.999)。"
+                            "`timeRepartitionSchema` 是一个TIME或NANOTIME类型的向量。如果指定了 timeColumn，timeRepartitionSchema可用于划分更小粒度的数据源。如果为[t1, t2, t3]，那么将每天的数据进一步划分为4个数据源：[00:00:00.000,t1), [t1,t2), [t2,t3) 和 [t3,23:59:59.999)。"
                         ]
                     }
                 ]
@@ -65186,7 +66434,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "resample(X, rule, func)"
+                            "resample(X, rule, func, [closed], [label], [origin='start_day'])"
                         ]
                     }
                 ]
@@ -65224,11 +66472,37 @@
                             "\"BA\"          businessYearEnd",
                             "\"BAS\"         businessYearBegin",
                             "\"D\"           date",
+                            "\"H\"           hourOfDay",
+                            "\"U\"           microsecond",
+                            "\"L\"           millisecond",
+                            "\"min\"         minuteOfHour",
+                            "\"N\"           nanosecond",
+                            "\"S\"           secondOfMinute",
                             "============= ===================",
                             "",
                             "`rule` 字符串亦可配合使用数字，例如 \"2M\" 表示频率为每两个月月末。",
                             "",
-                            "`func` 是一个聚合函数。"
+                            "`func` 一个聚合函数。",
+                            "",
+                            "`closed` 字符串，表示分组区间哪一个边界是闭合的。",
+                            "",
+                            "* *rule* 为 'M', 'A', 'Q', 'BM', 'BA', 'BQ' 和 'W'  时，*closed* 的默认取值为 'right' ，否则，*closed* 的默认取值为 'left'。",
+                            "* *origin* 取 'end' 或者  'end_day' 时，*closed* 的默认值为 'right'。",
+                            "* 1.30.18/2.00.6 版本，当 *rule* 的精度为天以上时，不支持使用默认值以外的选项。",
+                            "",
+                            "`label` 字符串，表示将分组区间的哪一个边界作为 *label* 输出。",
+                            "",
+                            "* *rule* 为 'M', 'A', 'Q', 'BM', 'BA', 'BQ' 和 'W'  时，*label* 的默认取值为 'right' ，否则，*label* 的默认取值为 'left'。",
+                            "* *origin* 取 'end' 或者  'end_day' 时，*label* 的默认值为 'right'。",
+                            "* 1.30.18/2.00.6 版本，当 *rule* 的精度为天以上时，不支持使用默认值以外的选项。",
+                            "",
+                            "`origin` 字符串或与 *X* 具有相同时间类型的标量，表示基于时间戳调整分组。*origin* 的取值为 'epoch', start', 'start_day', 'end', 'end_day' 或自定义的时间对象，默认值为 'start_day'。",
+                            "",
+                            "* 'epoch'：分组起始点为1970-01-01。",
+                            "* 'start'：分组起始点为时间序列的第一个值。",
+                            "* 'start_day'：分组起始点是时间序列的第一个值对应日期的午夜零点。",
+                            "* 'end'：分组起始点是时间序列的最后一个时间戳。",
+                            "* 'end_day'：分组起始点是时间序列的最后一个时间戳对应日期的午夜24点（即下一日的零点）。"
                         ]
                     }
                 ]
@@ -65309,7 +66583,98 @@
                             "|2000.07.31|    |",
                             "+----------+----+",
                             "|2000.09.30|8   |",
-                            "+----------+----+"
+                            "+----------+----+",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ index = temporalAdd(2022.01.01 00:00:00,1..8,`m)",
+                            "    $ s = indexedSeries(index, 1..8)",
+                            "    $ s.resample(rule=`3min, func=sum);",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "=================== ====",
+                            "label\t            col1",
+                            "=================== ====",
+                            "2022.01.01T00:00:00\t3",
+                            "2022.01.01T00:03:00\t12",
+                            "2022.01.01T00:06:00\t21  ",
+                            "=================== ====",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ s.resample(rule=`3min, func=sum, closed=`right);",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "=================== ====",
+                            "label\t            col1",
+                            "=================== ====",
+                            "2022.01.01T00:00:00\t6",
+                            "2022.01.01T00:03:00\t15",
+                            "2022.01.01T00:06:00\t15",
+                            "=================== ====",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ s.resample(rule=`3min, func=sum, closed=`right,origin=`end);",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "=================== ====",
+                            "label\t            col1",
+                            "=================== ====",
+                            "2022.01.01T00:02:00\t1",
+                            "2022.01.01T00:05:00\t9",
+                            "2022.01.01T00:08:00\t18",
+                            "2022.01.01T00:11:00\t8",
+                            "=================== ====",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ s.resample(rule=`3min, func=sum,origin=2022.10.01 00:00:10)",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "=================== ====",
+                            "label               col1",
+                            "=================== ====",
+                            "2022.01.01T00:00:10\t6",
+                            "2022.01.01T00:03:10\t15",
+                            "2022.01.01T00:06:10\t15",
+                            "=================== ===="
                         ]
                     }
                 ]
@@ -65339,9 +66704,9 @@
                     {
                         "type": "text",
                         "value": [
-                            "`userId` 是表示用户名的字符串。",
+                            "`userId` 表示用户名的字符串。",
                             "",
-                            "`newPwd` 是表示新密码的字符串。"
+                            "`newPwd` 表示用户新密码的字符串，长度范围为 6~20 个字符。"
                         ]
                     }
                 ]
@@ -65385,7 +66750,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "resetRecoveryWorkerNum(newWokerNum)"
+                            "resetRecoveryWorkerNum(newWorkerNum)"
                         ]
                     }
                 ]
@@ -65397,7 +66762,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "`newWokerNum` 正整数，指定用于 chunk 恢复的工作线程数。"
+                            "`newWorkerNum` 正整数，指定用于 chunk 恢复的工作线程数。"
                         ]
                     }
                 ]
@@ -69720,7 +71085,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "`Script` 是字符串，表示需要执行的脚本。"
+                            "`script` 是字符串，表示需要执行的脚本。"
                         ]
                     }
                 ]
@@ -72870,7 +74235,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "setRetentionPolicy(dbHanle, retentionHours, [retentionDimension])"
+                            "setRetentionPolicy(dbHanle, retentionHours, [retentionDimension], [hoursToColdVolume])"
                         ]
                     }
                 ]
@@ -72882,11 +74247,15 @@
                     {
                         "type": "text",
                         "value": [
-                            "`dbHandle` 是一个分布式数据库的句柄。数据库的分区方案必须包含DATE类型或DATEHOUR类型。",
+                            "`dbHandle` 分布式数据库的句柄。数据库的分区方案必须包含DATE类型或DATEHOUR类型。",
+                            "",
+                            "`retentionHours` 正整数，表示数据保留时间，单位是小时。",
                             "",
-                            "`retentionHours` 是一个正整数，表示数据保留时间，单位是小时。",
+                            "`retentionDimension` 整数，表示时间分区所在的层次。默认值是0，表示第一层分区是按时间分区。",
                             "",
-                            "`retentionDimension` 是一个整数，表示时间分区所在的层次。默认值是0，表示第一层分区是按时间分区。"
+                            "`hoursToColdVolume` 正整数，表示 volumes 数据的保留时间，单位是小时。存储在 volumes 中的数据，经过 hoursToColdVolume 指定的时间后，将会自动迁移至 coldVolumes（该配置项需在配置文件中预先指定）。",
+                            "",
+                            "注意：必须满足 *retentionHours*  - *hoursToColdVolume* > 7 * 24（即 7 天）"
                         ]
                     }
                 ]
@@ -72898,10 +74267,13 @@
                     {
                         "type": "text",
                         "value": [
-                            "设置数据保留时间，数据库会根据当前系统的机器时间，保留数据时间戳为最近 *retentionHours* 小时的数据。",
+                            "设置数据保留策略以及 :doc:`/DatabaseandDistributedComputing/Database/TieredStorage` 策略。若用户只通过该函数配置分级存储策略，建议将参数 *retentionHours* 指定为一个尽可能大的值。",
+                            "",
+                            "数据库会根据当前系统的机器时间，保留数据时间戳为最近 *retentionHours* 小时的数据。其中最新 *hoursToColdVolume* 小时的数据将继续存储在 volumes 中。在 [当前时间 - hoursToColdVolume - 10天，当前时间 - hoursToColdVolume) 范围内的数据将被迁移到 *coldVolumes*。若 *coldVolumes* 配置了多个路径，则数据将随机分布在各个存储路径下 。",
                             "",
-                            "* 对于保留时间外的数据，只会删除 [当前时间 - 保留期限 - 10 天, 当前时间 - 保留期限 - 1天] 范围的数据。",
-                            "* 若需要删除之前的数据，可以调用 :doc:`../d/dropPartition` 函数实现。注意该函数只能对分布式数据库使用。 ",
+                            "对于保留时间外的数据，只会删除 [当前时间 - retentionHours - 10 天, 当前时间 - retentionHours) 范围的数据。若需要删除之前的数据，可以调用 :doc:`../d/dropPartition` 函数实现。",
+                            "",
+                            "注意：该函数只能对分布式数据库使用。",
                             "",
                             "可以通过 :doc:`../../FunctionReferences/s/schema` 函数查看数据库的数据保留时间。"
                         ]
@@ -72918,15 +74290,22 @@
                         "value": [
                             "",
                             "    $ db=database(\"dfs://db1\",VALUE,2019.06.01..date(now()))",
-                            "    $ retentionHour=7*24",
-                            "    $ setRetentionPolicy(db,retentionHour,0);",
+                            "    $ retentionHour=9*24",
+                            "    $ hoursToColdVolume=1*24",
+                            "    $ setRetentionPolicy(db,retentionHour,0, hoursToColdVolume);",
                             "",
                             "    $ schema(db);",
-                            "    partitionSchema->[2019.07.03,2019.07.02,2019.07.01,2019.06.30,2019.06.29,2019.06.28,2019.06.27,2019.06.26,2019.06.25,2019.06.24,...]",
-                            "    databaseDir->dfs://db1",
+                            "    partitionSchema->[2022.05.05,2022.05.04,2022.05.03,2022.05.02,2022.05.01,2022.04.30,2022.04.29,2022.04.28,2022.04.27,2022.04.26,...]",
                             "    partitionSites->",
+                            "    partitionTypeName->VALUE",
+                            "    hoursToColdVolume->24",
+                            "    atomic->TRANS",
+                            "    databaseDir->dfs://db1",
+                            "    engineType->OLAP",
+                            "    chunkGranularity->TABLE",
                             "    retentionDimension->0",
-                            "    retentionHours->168",
+                            "    partitionType->1",
+                            "    retentionHours->216",
                             ""
                         ]
                     },
@@ -77291,9 +78670,15 @@
                             "",
                             "根据业务场景设计到的计算引擎， *metrics* 的改写规则如下：",
                             "",
+                            "注意：",
+                            "",
+                            "（1）若 metrics 中包含用户自定义函数，则引擎解析器会按下文的分解原则将函数体进行分解，将各分解得到的操作分发给对应引擎进行处理。",
+                            "",
+                            "（2）若用户自定义函数用 @state 进行标识，则引擎解析器会将其分配给响应式状态引擎处理。",
+                            "",
                             "\\1. 引擎分解标识",
                             "",
-                            "* 若指标中的某一步操作需要使用横截面引擎，需改成以 “row开头” 的函数作为标识，若不添加 row 则该操作默认在响应式状态引擎处理。对于的标识函数如下：",
+                            "* 若指标中的某一步操作需要使用横截面引擎，需改成以 “row开头” 的函数作为标识，若不添加 row 则该操作默认在响应式状态引擎处理。横截面引擎的标识函数如下：",
                             "",
                             "::",
                             "",
@@ -77307,7 +78692,7 @@
                             "",
                             "  rolling(func, funcArgs, window, [step=1], [fill='none']) ",
                             "",
-                            "* 分解时由于其他指标中的操作默认在响应式状态引擎中处理，因此不需要标识。",
+                            "* 其他指标中的操作默认在响应式状态引擎中处理。",
                             "  ",
                             "\\2. 中间引擎输入表结构",
                             "",
@@ -77414,7 +78799,7 @@
                             "    //构建计算因子",
                             "    $ metrics=<[sym, rowRank(wqAlpha1TS(close), percent=true)- 0.5]>",
                             "",
-                            "    $ streamEngine=streamEngineParser(name=`alpha1_parser, metrics=metrics, dummyTable=input, outputTable=resultTable, keyColumn=`sym, timeColumn=`time, triggeringPattern='keyCount', triggeringInterval=3)",
+                            "    $ streamEngine=streamEngineParser(name=`alpha1_parser, metrics=metrics, dummyTable=input, outputTable=resultTable, keyColumn=`sym, timeColumn=`time, triggeringPattern='keyCount', triggeringInterval=3000)",
                             "    $ streamEngine.append!(data)",
                             "",
                             "    $ dropStreamEngine(\"alpha1_parser0\")",
@@ -77429,6 +78814,30 @@
         "title": "streamFilter",
         "type": "function",
         "children": [
+            {
+                "title": "详情",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "创建流数据过滤引擎，对输入引擎的数据进行过滤和分发处理，返回一个表对象。",
+                            "",
+                            "该引擎的处理流程包含以下两个步骤：",
+                            "",
+                            "\\1. 根据 *filter* 指定的规则对流表进行过滤。",
+                            "",
+                            "\\2. 过滤后的数据按照时间顺序以表的形式分发到不同的 handler 里进行处理。",
+                            "",
+                            "注意：",
+                            "",
+                            "* 1.30.17 及 2.00.5 版本开始，DolphinDB 支持通过 :doc:`../r/replay` 函数将多个结构不同的流数据表，回放（序列化）到一个流表里，这个流表被称为异构流表。streamFilter 函数用于解析（反序列化）和过滤异构流表的数据并进行分发处理。",
+                            "* 1.30.18 及 2.00.6 版本开始，streamFilter 函数支持过滤普通流表数据，并进行分发处理。",
+                            ""
+                        ]
+                    }
+                ]
+            },
             {
                 "title": "语法",
                 "type": "grammer",
@@ -77436,7 +78845,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "streamFilter(name, dummyTable, filter, msgSchema)"
+                            "streamFilter(name, dummyTable, filter, [msgSchema], [timeColumn], [conditionColumn])"
                         ]
                     }
                 ]
@@ -77456,30 +78865,28 @@
                             "",
                             "字典可选的 key-value 说明如下：",
                             "",
-                            "* 'timeRange'：可选字段，一个数据对或包含多个数据对的 tuple。表示过滤的时间段。",
-                            "* 'condition'：字符串，表示过滤的字段，对应 replay 回放的异构流表的第二列。",
+                            "* 'timeRange'：可选字段，一个数据对或包含多个数据对的 tuple。以指定的 *timeRange* 对 *timeColumn* 进行过滤。注意：若分发普通流表，则 *timeRange* 必须和 *timeColumn* 的数据类型一致；异构流表无该限制。",
+                            "* 'condition'：表示过滤条件。",
+                            "",
+                            "  * 若分发异构流表，则 'condition' 是一个字符串，且必须是 replay 参数 *inputTables* 的键值（表的标识）。用于过滤出异构表中具有 *condition* 标识的数据。",
+                            "  * 若分发普通流表，则 'condition'  是一个字符串标量或向量，且必须是 `conditionColumn` 指定列的元素。用于过滤出表 *conditionColumn* 列中满足 *condition* 的数据。",
+                            "",
                             "* 'handler'：一元函数或表对象（包括流数据引擎返回的表对象）。",
                             "",
                             "  * 如果它是一元函数，它唯一的参数是经过解析和过滤后的数据表。",
                             "  * 如果它是表对象，经过解析和过滤后的数据会直接插入到该表中。",
                             "",
-                            "`msgSchema` 字典，其结构与 replay 回放到异构流表的数据表结构保持一致。引擎将根据 *msgSchema* 指定的结构对注入的数据解析。"
-                        ]
-                    }
-                ]
-            },
-            {
-                "title": "详情",
-                "type": "detail",
-                "children": [
-                    {
-                        "type": "text",
-                        "value": [
-                            "创建流数据过滤引擎，返回一个表对象。1.30.17 及 2.00.5 版本开始，DolphinDB 支持通过 :doc:`../r/replay` 函数将多个结构不同的流数据表，回放（序列化）到一个流表里，这个流表被称为异构流表。replay 回放到异构流表的数据严格按照时间顺序排序。``streamFilter`` 函数用于解析（反序列化）和过滤异构流表的数据并进行处理，包含以下两个步骤：",
+                            "`msgSchema` 可选字段，字典。",
+                            "",
+                            "* 若分发异构流表，其结构与 replay 回放到异构流表的数据表结构保持一致。引擎将根据 *msgSchema* 指定的结构对注入的数据解析;",
+                            "* 若分发普通流表，该参数必须设置为空。",
+                            "",
+                            "以下参数仅在分发普通流表时指定：",
                             "",
-                            "\\1. 根据 *filter* 指定的规则对异构流表进行过滤。",
+                            "`timeColumn`  字符串，指定为 *dummyTable* 中时间列的名称。若不指定，则取 *dummyTable* 第一列的列名。",
                             "",
-                            "\\2. 过滤后的数据按照时间顺序以表的形式分发到不同的 handler 里进行处理。"
+                            "`conditionColumn` 字符串，指定为 *dummyTable* 中的列名。注意 *conditionColumn* 只能指定 STRING 或 SYMBOL 类型的列。若不指定该参数，则 *filter* 的 *condition* 字段将失效。",
+                            ""
                         ]
                     }
                 ]
@@ -77491,6 +78898,8 @@
                     {
                         "type": "text",
                         "value": [
+                            "\\(1) 异构流表分发：",
+                            "",
                             "下例对存放在分布式数据库的订单表和交易表进行回放，按照时间顺序序列化到一个流表里。经过排序后的数据通过 ``streamFilter`` 反序列化后，",
                             "再过滤出订单表和交易表并分发到 asof join 引擎的左、右表里，进行实时双时间连接（两个流表之间的数据会按时间顺序输出）。",
                             ""
@@ -77570,7 +78979,7 @@
                             "  $ filter1['timeRange']=09:30:00.000:09:30:00.005",
                             "",
                             "  $ filter2=dict(STRING,ANY)",
-                            "  $ filter2['condition']=\"trades\"",
+                            "  $ filter2['condition']=`trades",
                             "  $ filter2['timeRange']=09:30:00.000:09:30:00.005",
                             "",
                             "  $ ajEngine=createAsofJoinEngine(name=\"ajEngine\", leftTable=streamOrders, rightTable=streamTrades, outputTable=streamOpt, metrics=<[volume,price,price*volume]>, matchingColumn=`sym, useSystemTime=true)",
@@ -77590,7 +78999,120 @@
                             "  //取消订阅",
                             "  unsubscribeTable(tableName=\"opt\", actionName=\"sub1\")",
                             "  dropStreamEngine(`streamFilter)",
-                            "  dropStreamEngine(`ajEngine)"
+                            "  dropStreamEngine(`ajEngine)",
+                            "",
+                            "",
+                            "\\(2) 普通流表分发：",
+                            "",
+                            "下例，将普通流表（trades）数据注入分发引擎中，根据过滤条件进行分发处理。",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "  $ n=20",
+                            "  $ sym = symbol(rand(`A`B`C,n))",
+                            "  $ name = string(rand(1..10,n))",
+                            "  $ date = temporalAdd(2012.12.06,0..(n-1),'d')",
+                            "  $ time = temporalAdd(09:30:00.000,0..(n-1),'ms')",
+                            "  $ vol = rand(100,n)",
+                            "  $ t = table(date,time,sym,name,vol)",
+                            "",
+                            "  //定义两个流数据引擎，作为分发引擎 handler",
+                            "  $ share streamTable(100:0,`date`time`sym`name`vol,[DATE,TIME,SYMBOL,STRING,INT]) as st1",
+                            "  $ share streamTable(100:0,`date`time`sym`name`vol,[DATE,TIME,SYMBOL,STRING,INT]) as st2",
+                            "  $ share streamTable(100:0,`date`time`sym`name`vol,[DATE,TIME,SYMBOL,STRING,INT]) as st3",
+                            "",
+                            "  //handler为引擎时的输入流表",
+                            "  $ share streamTable(100:0,`time`sym`sum_vol,[TIME,SYMBOL,INT]) as output1",
+                            "  $ share streamTable(100:0,`time`avg_vol,[TIME,INT]) as output2",
+                            "  $ engine1=createTimeSeriesEngine(name=\"timeEngine\", windowSize=3, step=3, metrics=<[sum(vol)]>, dummyTable=st3, outputTable=output1, timeColumn=`time, useSystemTime=false, keyColumn=`sym, garbageSize=50)",
+                            "  $ engine2=createReactiveStateEngine(name=\"reactiveEngine\", metrics=<[mavg(vol, 3)]>, dummyTable=st1, outputTable=output2, keyColumn=`sym)",
+                            "  ",
+                            "  //需要注入分发引擎的流表",
+                            "  $ share streamTable(100:0,`date`time`sym`name`vol,[DATE,TIME,SYMBOL,STRING,INT]) as trades",
+                            "",
+                            "  //设置第一个过滤条件，将 trades表 中 sy m列对应元素为 A 且时间在09:30:00.001:09:30:00.010和09:29:00.000:09:30:00.000的数据输入状态引擎进行处理",
+                            "  $ filter1 = dict(STRING,ANY)",
+                            "  $ filter1['condition']=`A",
+                            "  $ filter1['handler']=engine2",
+                            "  $ filter1['timeRange']=(09:30:00.001:09:30:00.010,09:29:00.000:09:30:00.000)",
+                            "",
+                            "  //设置第二个过滤条件，将 trades 表时间范围在09:30:00.002:09:30:00.005里的数据全部输出到st2表里",
+                            "  $ filter2 = dict(STRING,ANY)",
+                            "  $ filter2['handler']=st2",
+                            "  $ filter2['timeRange']=09:30:00.002:09:30:00.005",
+                            "",
+                            "  //设置第三个过滤条件，将 trades 表中 sym 列对应元素为 A 和 C 的数据输入时序引擎进行处理",
+                            "  $ filter3 = dict(STRING,ANY)",
+                            "  $ filter3['condition']=`C`A",
+                            "  $ filter3['handler']=engine1",
+                            "",
+                            "  //订阅分发引擎，根据以上三个过滤条件，对 trades 表中的数据进行分发处理",
+                            "  $ streamFilter2=streamFilter(name=\"streamFilterDemo\",dummyTable=trades,filter=[filter1,filter2,filter3], timeColumn=`time, conditionColumn=`sym)",
+                            "  $ subscribeTable(tableName=\"trades\", actionName=\"sub1\", offset=0, handler=streamFilter2, msgAsTable=true)",
+                            "  $ trades.append!(t)",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "  $ select * from output1",
+                            "",
+                            "============ ===== ========",
+                            "time         sym   sum_vol",
+                            "============ ===== ========",
+                            "09:30:00.003 A     64",
+                            "09:30:00.003 C     92",
+                            "09:30:00.006 A     22",
+                            "09:30:00.006 C     5",
+                            "09:30:00.009 A     38",
+                            "09:30:00.012 A     38",
+                            "09:30:00.012 C     113",
+                            "09:30:00.015 A     76",
+                            "============ ===== ========",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "  $ select * from output2",
+                            "",
+                            "+-------------+--------+",
+                            "|time         |avg_vol |",
+                            "+=============+========+",
+                            "|00:00:00.001 |        |",
+                            "+-------------+--------+",
+                            "|00:00:00.001 |        |",
+                            "+-------------+--------+",
+                            "|00:00:00.001 | 41     |",
+                            "+-------------+--------+",
+                            "|00:00:00.001 | 33     |",
+                            "+-------------+--------+"
                         ]
                     }
                 ]
@@ -85449,7 +86971,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "transFreq(X, rule)"
+                            "transFreq(X, rule, [closed], [label], [origin='start_day'])"
                         ]
                     }
                 ]
@@ -85495,7 +87017,27 @@
                             "\"N\"                     nanosecond",
                             "================  =======================",
                             "",
-                            "以上字符串亦可配合数字用于rule参数，例如\"2M\"表示频率为每两个月的月末。"
+                            "以上字符串亦可配合数字用于 *rule* 参数，例如\"2M\"表示频率为每两个月的月末。",
+                            "",
+                            "`closed` 字符串，表示分组区间哪一个边界是闭合的。",
+                            "",
+                            "* *rule* 为 'M', 'A', 'Q', 'BM', 'BA', 'BQ' 和 'W'  时，*closed* 的默认取值为 'right' ，否则，*closed* 的默认取值为 'left'。",
+                            "* *origin* 取 'end' 或者  'end_day' 时，*closed* 的默认值为 'right'。",
+                            "* 1.30.18/2.00.6 版本，当 *rule* 的精度为天以上时，不支持使用默认值以外的选项。",
+                            "",
+                            "`label` 字符串，表示将分组区间的哪一个边界作为 *label* 输出。",
+                            "",
+                            "* *rule* 为 'M', 'A', 'Q', 'BM', 'BA', 'BQ' 和 'W'  时，*label* 的默认取值为 'right' ，否则，*label* 的默认取值为 'left'。",
+                            "* *origin* 取 'end' 或者  'end_day' 时，*label* 的默认值为 'right'。",
+                            "* 1.30.18/2.00.6 版本，当 *rule* 的精度为天以上时，不支持使用默认值以外的选项。",
+                            "",
+                            "`origin` 字符串或和 *X* 具有相同时间类型的标量，表示基于时间戳调整分组。取值为 'epoch', start', 'start_day', 'end', 'end_day' 或自定义的时间对象，默认值为 'start_day'。",
+                            "",
+                            "* 'epoch'：分组起始点为1970-01-01。",
+                            "* 'start'：分组起始点为时间序列的第一个值。",
+                            "* 'start_day'：分组起始点是时间序列的第一个值对应日期的午夜零点。",
+                            "* 'end'：分组起始点是时间序列的最后一个时间戳。",
+                            "* 'end_day'：分组起始点是时间序列的最后一个时间戳对应日期的午夜24点（即下一日的零点）。"
                         ]
                     }
                 ]
@@ -85528,7 +87070,25 @@
                             "    [2020.09.30,2020.12.31]",
                             "",
                             "    $ transFreq(2020.08.08 2020.11.18, \"2Q\");",
-                            "    [2020.09.30,2021.03.31]"
+                            "    [2020.09.30,2021.03.31]",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ s = temporalAdd(2022.01.01 00:00:00,1..8,`m);",
+                            "",
+                            "    $ s.transFreq(rule=\"3min\");",
+                            "    [2022.01.01T00:00:00,2022.01.01T00:00:00,2022.01.01T00:03:00,2022.01.01T00:03:00,2022.01.01T00:03:00,2022.01.01T00:06:00,2022.01.01T00:06:00,2022.01.01T00:06:00]",
+                            "",
+                            "    $ s.transFreq(rule=`3min,closed=`right);",
+                            "    [2022.01.01T00:00:00,2022.01.01T00:00:00,2022.01.01T00:00:00,2022.01.01T00:03:00,2022.01.01T00:03:00,2022.01.01T00:03:00,2022.01.01T00:06:00,2022.01.01T00:06:00]",
+                            "    ",
+                            "    $ s.transFreq(rule=`3min,closed=`right,origin=`end);",
+                            "    [2021.12.31T23:59:00,2021.12.31T23:59:00,2022.01.01T00:02:00,2022.01.01T00:02:00,2022.01.01T00:02:00,2022.01.01T00:05:00,2022.01.01T00:05:00,2022.01.01T00:05:00]"
                         ]
                     }
                 ]
@@ -87327,6 +88887,24 @@
                 "title": "例子",
                 "type": "example",
                 "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "在发布节点发布一张表 trades。",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ t=streamTable(100:0,`date`time`sym`qty`price`exch,[DATE,TIME,SYMBOL,INT,DOUBLE,SYMBOL])",
+                            "    $ share t as trades",
+                            "    $ t=NULL",
+                            ""
+                        ]
+                    },
                     {
                         "type": "text",
                         "value": [
@@ -87339,11 +88917,12 @@
                         "language": "console",
                         "value": [
                             "",
-                            "    $ t=streamTable(n:0,`date`time`sym`qty`price`exch,[DATE,TIME,SYMBOL,INT,DOUBLE,SYMBOL])",
+                            "    $ t=streamTable(100:0,`date`time`sym`qty`price`exch,[DATE,TIME,SYMBOL,INT,DOUBLE,SYMBOL])",
                             "    $ share t as trades2",
                             "    $ t=NULL",
-                            "    $ h=xdb(\"localhost\",8080)",
-                            "    $ subscribeTable(h,\"trades\",\"sub1\",trades2);",
+                            "    $ h=xdb(\"localhost\",8902)",
+                            "    $ subscribeTable(server=h, tableName=\"trades\", actionName=\"sub1\", handler=trades2);",
+                            "    localhost:8902:node1/trades/sub1",
                             "",
                             ""
                         ]