dolphindb 2.0.600 → 2.0.603

package/docs.zh.json

@@ -1382,7 +1382,7 @@
                         "value": [
                             "增加数据节点或计算节点。新增加的节点为关闭状态，需要通过Web集群管理器或命令行启动。",
                             "",
-                            "注意，如果要在新的服务器上增加节点，要先部署代理节点。详情请参考教程 `多服务器集群部署 <https://gitee.com/dolphindb/Tutorials_CN/blob/master/multi_machine_cluster_deploy.md>`_ 。"
+                            "注意，如果要在新的服务器上增加节点，要先部署代理节点。详情请参考教程 `多服务器集群部署 <https://gitee.com/dolphindb/Tutorials_CN/blob/master/%E5%AE%89%E8%A3%85%E5%92%8C%E9%83%A8%E7%BD%B2/multi_machine_cluster_deployment.md>`_ 。"
                         ]
                     }
                 ]
@@ -2542,7 +2542,7 @@
                         "value": [
                             "`X` 是有时间类型索引的矩阵（由 :doc:`../s/setIndexedMatrix!` 创建）或序列（由 :doc:`../s/setIndexedSeries!` 创建）。",
                             "",
-                            "`Y` 可以是一个字符串，可取以下值，亦可为一个时间类型的向量。",
+                            "`rule` 可以是一个字符串，可取以下值，亦可为一个时间类型的向量。",
                             "",
                             "============ =================",
                             "Y参数取值    对应DolphinDB函数",
@@ -2561,10 +2561,12 @@
                             "\"QS\"         quarterBegin",
                             "\"BQ\"         businessQuarterEnd",
                             "\"BQS\"        businessQuarterBegin",
+                            "\"REQ\"         FY5253Quarter",
                             "\"A\"          yearEnd",
                             "\"AS\"         yearBegin",
                             "\"BA\"         businessYearEnd",
                             "\"BAS\"        businessYearBegin",
+                            "\"RE\"          FY5253",
                             "\"D\"          date",
                             "\"H\"          hourOfDay",
                             "\"min\"        minuteOfHour",
@@ -2574,7 +2576,7 @@
                             "\"N\"          nanosecond",
                             "============ =================",
                             "",
-                            "参数 *Y* 字符串亦可配合使用数字，例如\"2M\"表示频率为每两个月。",
+                            "参数 *rule* 字符串亦可配合使用数字，例如\"2M\"表示频率为每两个月。",
                             "",
                             "`closed` 字符串，表示分组区间哪一个边界是闭合的。",
                             "",
@@ -6468,7 +6470,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "取消已经提交但尚未完成的批处理作业。"
+                            "取消已经提交但尚未完成的批处理作业。1.30.19 / 2.00.7 版本后，若执行 cancelJob 时，发现某个 jobId 不存在，系统不再抛出异常，而是将包含 jobId 的报错信息输出到日志。"
                         ]
                     }
                 ]
@@ -6502,6 +6504,26 @@
                             "    $ submitJob(myJobId,\"write data to dfs table\",writeData,120);",
                             "    $ cancelJob(myJobId);",
                             "",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "取消集群中所有未完成的 job。",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ def cancelAllBatchJob(){",
+                            "    $    jobids=exec jobid from getRecentJobs() where endTime=NULL",
+                            "    $    cancelJob(jobids)\t",
+                            "    $ }",
+                            "    $ pnodeRun(cancelAllBatchJob)",
                             "",
                             ""
                         ]
@@ -8508,7 +8530,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "`X`  可以是向量、矩阵、集合、字典。"
+                            "`X`  可以是向量、矩阵、集合、字典、内存表。"
                         ]
                     }
                 ]
@@ -8555,7 +8577,10 @@
                             "   3->6",
                             "   1->4",
                             "   2->5",
-                            "   $ z.clear!();"
+                            "   $ z.clear!();",
+                            "",
+                            "   $ t = table(1 2 3 as id, 1.0 2.0 3.0 as value)",
+                            "   $ t.clear!()"
                         ]
                     }
                 ]
@@ -10774,7 +10799,7 @@
                         "value": [
                             "把源节点上的一个或多个chunk的副本复制到目标节点。如果目标节点上已经存在该chunk，那么系统将忽略本次操作。该命令只能由管理员在控制节点上执行。",
                             "",
-                            "通过 *getRecoveryTaskStatus* 函数可以查看任务状态。"
+                            "通过 :doc:`/FunctionsandCommands/FunctionReferences/g/getRecoveryTaskStatus` 函数可以查看任务状态。"
                         ]
                     }
                 ]
@@ -11718,7 +11743,12 @@
                             "",
                             "\\(3) 最后为计算结果列，可为多列。",
                             "",
-                            "`metrics` 必选参数，以元代码的格式表示计算指标。可以是一个或多个表达式、系统内置或用户自定义函数，但不能是聚合函数。*metrics* 内支持调用具有多个返回值的函数，且必须指定列名，例如 <func(price) as \\`col1\\`col2>。有关元代码的更多信息可参考 :doc:`/Objects/Metaprogramming`。",
+                            "`metrics` 以元代码的格式表示计算指标，支持输入元组。有关元代码的更多信息可参考 :doc:`/Objects/Metaprogramming`。",
+                            "",
+                            "* 计算指标可以是一个或多个表达式、系统内置或用户自定义函数，但不能是聚合函数。",
+                            "* *metrics* 内支持调用具有多个返回值的函数，且必须指定列名，例如 <func(price) as \\`col1\\`col2>。",
+                            "",
+                            "请注意，若 *metrics* 中指定了左右表列名相同的时间列或者连接列，默认取左表中的列。如果需要取右表中的列，在列前加上右表名。例如：*matchingColumn* = \\`sym, *timeColumn* = \\`timestamp，则 *metrics* = <[rightTable.sym, rightTable.timestamp, price, val, price*val]> 指定 *metrics* 中输出右表的 sym 列和 timestamp 列。",
                             "",
                             "`matchingColumn` 表示连接列的字符串标量/向量/tuple，支持 Integral, Temproal 或 Literal（UUID 除外）类型。",
                             "",
@@ -12170,7 +12200,7 @@
                             "",
                             "`mergeSessionEnd` 为可选参数，是一个布尔值，表示每一个区间的计算是否包括其结束时刻（规整后的时刻）的数据。默认值为 false。",
                             "",
-                            "`forceTriggerSessionEndTime` 可选参数，是正整数，单位为秒。若 *sessionEnd* 时刻对应的窗口数据未计算输出，通过该参数设置系统经过多少时间后触发计算并输出。若不指定 *fill* ，未包含在该窗口内的分组不会输出结果；若指定了 *fill* ，未包含在该窗口内的分组会按照 *fill* 指定的方式输出结果。",
+                            "`forceTriggerSessionEndTime` 可选参数，是正整数，单位与 *timeColumn* 的时间精度一致。若 *sessionEnd* 时刻对应的窗口数据未计算输出，通过该参数设置系统经过多少时间后触发计算并输出。若不指定 *fill* ，未包含在该窗口内的分组不会输出结果；若指定了 *fill* ，未包含在该窗口内的分组会按照 *fill* 指定的方式输出结果。",
                             "",
                             "注：",
                             "",
@@ -12487,6 +12517,133 @@
             }
         ]
     },
+    "createDualOwnershipReactiveStateEngine": {
+        "title": "createDualOwnershipReactiveStateEngine",
+        "type": "function",
+        "children": [
+            {
+                "title": "语法",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "createDualOwnershipReactiveStateEngine(name, metrics1, metrics2, dummyTable, outputTable, keyColumn1, keyColumn2, [snapshotDir], [snapshotIntervalInMsgCount], [keyPurgeFilter1], [keyPurgeFilter2], [keyPurgeFreqInSecond=0], [raftGroup])"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "参数",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "``createDualOwnershipReactiveStateEngine`` 与 :doc:`createReactiveStateEngine` 参数基本一致，这里仅介绍有区别的参数：",
+                            "",
+                            "对 keyColumn1 分组后的数据按照 metrics1 进行计算，分组数据的清条件则由参数 keyPurgeFilter1 设置。",
+                            "",
+                            "对 keyColumn2 分组后的数据按照 metrics2 进行计算，分组数据的清条件则由参数 keyPurgeFilter2 设置。",
+                            "",
+                            "`outputTable` 结果的输出表，可以是内存表或者分布式表。使用 ``createDualOwnershipReactiveStateEngine`` 函数之前，需要将输出表预先设立为一个空表，并指定各列列名以及数据类型。",
+                            "",
+                            "输出表的各列的顺序为：分组列，计算结果列。",
+                            "",
+                            "其中：",
+                            "",
+                            "(1) 输出表的前几列为 keyColumn1  和 keyColumn2 的公共列，然后依次为 keyColumn1 的非公共列和 keyColumn2 的非公共列。",
+                            "",
+                            "(2) 其后为 metrics1 的计算结果列，metrics2 的计算结果列。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "详情",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "Dual Ownership Reactive State Engine 是对响应式状态引擎的扩展，支持对同一张流数据表指定两种不同的分组方式分别应用不同的指标进行并行计算。与响应式状态级联实现相比，调用该函数进行计算极大地提升了计算性能。",
+                            "",
+                            "注意：该引擎输出和输入顺序保持一致，即内部强制使 keepOrder = True。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "例子",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "    ",
+                            "    $ share streamTable(1:0, `date`time`sym`market`price`qty, [DATE, TIME, SYMBOL, CHAR, DOUBLE, INT]) as trades",
+                            "    $ outputTable = table(100:0, `date`sym`market`factor1`factor2, [DATE, SYMBOL, CHAR, DOUBLE, DOUBLE])",
+                            "    $ dors = createDualOwnershipReactiveStateEngine(name=\"test\", metrics1=<mfirst(price, 3)>, metrics2=<mmax(price, 3)>, dummyTable=trades, outputTable=outputTable, keyColumn1=`date`sym, keyColumn2=`date`market)",
+                            "    $ tmp = table(1:0, `date`time`sym`market`price`qty, [DATE, TIME, SYMBOL, CHAR, DOUBLE, INT]) ",
+                            "    $ subscribeTable(tableName=`trades, actionName=\"test\",msgAsTable=true, handler=tableInsert{dors})",
+                            "    $ insert into tmp values(2012.01.01, 09:00:00.030, `a, 'B', 10.65, 1500)",
+                            "    $ insert into tmp values(2012.01.01, 09:00:00.030, `a, 'B', 10.59, 2500)",
+                            "    $ insert into tmp values(2012.01.01, 09:00:00.031, `b, 'A', 10.59, 2500)",
+                            "    $ insert into tmp values(2012.01.01, 09:00:00.031, `a, 'B', 10.65, 1500)",
+                            "    $ insert into tmp values(2012.01.01, 09:00:00.031, `a, 'A', 10.59, 2500)",
+                            "    $ insert into tmp values(2012.01.01, 09:00:00.033, `b, 'B', 10.59, 2500)",
+                            "    $ insert into tmp values(2012.01.01, 09:00:00.033, `a, 'A', 10.59, 2500)",
+                            "    $ insert into tmp values(2012.01.01, 09:00:00.034, `b, 'A', 10.59, 2500)",
+                            "    $ insert into tmp values(2012.01.01, 09:00:00.034, `b, 'A', 10.22, 1200)",
+                            "    $ insert into tmp values(2012.01.01, 09:00:00.035, `a, 'A', 11.0, 2500)",
+                            "    $ insert into tmp values(2012.01.02, 09:00:00.031, `b, 'A', 10.22, 1200)",
+                            "    $ insert into tmp values(2012.01.02, 09:00:00.032, `a, 'B', 11.0, 2500)",
+                            "    $ insert into tmp values(2012.01.02, 09:00:00.032, `b, 'B', 15.6, 1300)",
+                            "    $ insert into tmp values(2012.01.02, 09:00:00.040, `c, 'B', 13.2, 2000)",
+                            "    $ trades.append!(tmp)",
+                            "    $ select * from outputTable",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "==========  ==== ======= ======== ========",
+                            "date        sym  market  factor1  factor2",
+                            "==========  ==== ======= ======== ========",
+                            "2012.01.01  a    'B'    ",
+                            "2012.01.01  a    'B'    ",
+                            "2012.01.01  b    'A'    ",
+                            "2012.01.01  a    'B'      10.65    10.65",
+                            "2012.01.01  a    'A'      10.59  ",
+                            "2012.01.01  b    'B'               10.65",
+                            "2012.01.01  a    'A'      10.65    10.59",
+                            "2012.01.01  b    'A'      10.59    10.59",
+                            "2012.01.01  b    'A'      10.59    10.59",
+                            "2012.01.01  a    'A'      10.59    11",
+                            "2012.01.02  b    'A'    ",
+                            "2012.01.02  a    'B'    ",
+                            "2012.01.02  b    'B'    ",
+                            "2012.01.02  c    'B'               15.6",
+                            "==========  ==== ======= ======== ========",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ unsubscribeTable(tableName=`trades, actionName=\"dors\")",
+                            "    $ undef(`trades,SHARED)",
+                            "    $ dropStreamEngine(\"dors\")"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "createEqualJoinEngine": {
         "title": "createEqualJoinEngine",
         "type": "function",
@@ -12694,6 +12851,100 @@
             }
         ]
     },
+    "createIPCInMemoryTable": {
+        "title": "createIPCInMemoryTable",
+        "type": "function",
+        "children": [
+            {
+                "title": "语法",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "createIPCInMemoryTable(size, tableName, columnNames, columnTypes)"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "参数",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "`size` 整数，表示 table 能缓存的记录数。该值必须大于 1,000,000，否则系统自动取 1,000,000。",
+                            "",
+                            "`tableName` 字符串，表示跨进程共享内存表的名称。",
+                            "",
+                            "`columnNames` 字符串向量，用于指定表的列名。",
+                            "",
+                            "`columnTypes` 向量，表示每列的数据类型。可使用表示数据类型的系统保留字或相应的字符串。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "详情",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "创建一个跨进程共享内存表的句柄。",
+                            "",
+                            "跨进程共享内存表通过共享内存（由操作系统管理）进行跨进程通信。系统允许不同进程对该内存并发写入（暂不支持并发读），或者不同进程对该内存同时读写。注意：共享内存表仅支持在同一物理机内共享，不支持在集群不同物理节点间进行共享。",
+                            "",
+                            "跨进程共享内存表支持读写，但不支持对跨进程共享内存表的表结构进行修改。向跨进程共享内存表写数据的方法，与普通内存表一致。但对于跨进程共享内存表，既可以通过表的句柄插入数据，亦可通过与表名同名的表对象插入数据。若一次性插入的数据量大于共享内存，系统会抛出异常。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "读写机制：",
+                "children": []
+            },
+            {
+                "title": "场景：",
+                "children": []
+            },
+            {
+                "title": "例子",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "创建一个跨进程共享内存表，并作为流数据订阅的输出表。",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "  ",
+                            "   $ share streamTable(10000:0,`timestamp`temperature, [TIMESTAMP,DOUBLE]) as pubTable",
+                            "   $ ipc_t = createIPCInMemoryTable(1000000, \"ipc_table\", `timestamp`temperature, [TIMESTAMP, DOUBLE])",
+                            "   $ def shm_append(mutable table, msg) {",
+                            "   $ \ttable.append!(msg)",
+                            "   $ }",
+                            "   $ subscribeTable(tableName=\"pubTable\", actionName=\"act3\", offset=0, handler=shm_append{ipc_t}, msgAsTable=true)",
+                            "   // 写入数据",
+                            "",
+                            "   $ n = 200 ",
+                            "   $ timestamp = 2022.01.01T09:00:00.000 + 1..n",
+                            "   $ temp = 30 + rand(5.0,n)",
+                            "   $ tableInsert(shm_test,timestamp,temp)",
+                            "",
+                            "   $ tableInsert(pubTable,timestamp,temp)"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "createLookupJoinEngine": {
         "title": "createLookupJoinEngine",
         "type": "function",
@@ -12753,7 +13004,13 @@
                             "",
                             "\\(2) 最后为计算结果列，可为多列。",
                             "",
-                            "`metrics` 必选参数，以元代码的格式表示计算指标。可以是一个或多个表达式、系统内置或用户自定义函数，但不能是聚合函数。*metrics* 内支持调用具有多个返回值的函数，且必须指定列名，例如 <func(price) as \\`col1\\`col2>。有关元代码的更多信息可参考 :doc:`/Objects/Metaprogramming`。",
+                            "`metrics` 以元代码的格式表示计算指标，支持输入元组。有关元代码的更多信息可参考 :doc:`/Objects/Metaprogramming`。",
+                            "",
+                            "* 计算指标可以是一个或多个表达式、系统内置或用户自定义函数，但不能是聚合函数。",
+                            "* *metrics* 内支持调用具有多个返回值的函数，且必须指定列名，例如 <func(price) as \\`col1\\`col2>。",
+                            "",
+                            "请注意，若 *metrics* 中指定了时间列或者连接列，需要在连接列或时间列前加上表名来指定该列所属的表，若不加表名，则默认取左表的列。例如：*matchingColumn* = \\`sym, *timeColumn* = \\`timestamp，则 *metrics* = <[rightTable.sym, rightTable.timestamp, price, val, price*val]> 指定 *metrics* 中输出右表的 sym 列和 timestamp 列。",
+                            "",
                             "",
                             "`matchingColumn` 表示连接列的字符串标量/向量或字符串向量组成的 tuple，支持 Integral, Temproal 或 Literal(UUID 除外)类型。",
                             "",
@@ -13300,15 +13557,28 @@
                         "value": [
                             "`name`  一个字符串，表示响应式状态引擎的名称，是其在一个数据节点/计算节点上的唯一标识。可包含字母，数字和下划线，但必须以字母开头。",
                             "",
-                            "`metrics` 以元代码的形式表示计算公式。有关元代码的详情可参考 :doc:`/Objects/Metaprogramming`。若需使用用户自定义函数，需在定义前添加声明 \"@state\"。",
+                            "`metrics` 以元代码的形式表示计算公式。有关元代码的详情可参考 :doc:`/Objects/Metaprogramming`。若需使用用户自定义函数，请注意以下两点：",
+                            "",
+                            "1. 需在定义前添加声明 \"@state\"。状态函数只能包含赋值语句和 return 语句。",
+                            "",
+                            "2. 若赋值语句的右值是一个多返回值的函数，则需要将多个返回值同时赋予多个变量。例如：两个返回值的函数 linearTimeTrend 应用于自定义状态函数中，正确写法为：",
+                            "",
+                            ".. code-block:: console",
+                            "",
+                            "   $ @state",
+                            "   $ def forcast2(S, N){",
+                            "   $       linearregIntercept, linearregSlope = linearTimeTrend(S, N)",
+                            "   $       return (N - 1) * linearregSlope + linearregIntercept",
+                            "   $ }",
                             "",
                             "下列状态函数在 DolphinDB 的响应式状态引擎中的实现均得到了优化。目前，状态引擎不允许使用未经优化的状态函数。应避免使用聚合函数。",
                             "",
-                            "* 累计窗口函数：cumavg, cumsum, cumprod, cumcount, cummin, cummax, cumvar, cumvarp, cumstd, cumstdp, cumcorr, cumcovar, cumbeta, cumwsum, cumwavg, cumfirstNot, cumlastNot, cummed, cumpercentile ",
+                            "* 累计窗口函数：cumavg, cumsum, cumprod, cumcount, cummin, cummax, cumvar, cumvarp, cumstd, cumstdp, cumcorr, cumcovar, cumbeta, cumwsum, cumwavg, cumfirstNot, cumlastNot, cummed, cumpercentile, cumPositiveStreak",
                             "* 滑动窗口函数：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",
+                            "* 序列相关函数：deltas, ratios, ffill, move, prev, iterate, ewmMean, ewmVar, ewmStd, ewmCov, ewmCorr, prevState",
                             "* topN相关函数：msumTopN, mavgTopN, mstdpTopN, mstdTopN, mvarpTopN, mvarTopN, mcorrTopN, mbetaTopN, mcovarTopN, mwsumTopN",
-                            "* 其他函数：talibNull, dynamicGroupCumsum, dynamicGroupCumcount",
+                            "* 高阶函数：segmentBy(参数 func 暂支持 cumsum, cummax, cummin, cumcount, cumavg, cumstd, cumvar, cumstdp, cumvarp)",
+                            "* 其他函数：talibNull, dynamicGroupCumsum, dynamicGroupCumcount, topRange, lowRange",
                             "",
                             "注意，:doc:`/Functionalprogramming/TemplateFunctions/talib` 作为状态函数时，第一个参数 `func` 只能是响应式状态引擎支持的状态函数。",
                             "",
@@ -13381,7 +13651,7 @@
                             "",
                             "返回一个表对象，向该表写入数据意味着这些数据进入响应式状态引擎进行计算。",
                             "",
-                            "通常与 :doc:`../s/subscribeTable` 函数一起使用。更多详情请参考教程 `DolphinDB 流聚合引擎 <https://gitee.com/dolphindb/Tutorials_CN/blob/master/stream_aggregator.md>`_。创建的响应式状态引擎可以跨会话调用。",
+                            "通常与 :doc:`../s/subscribeTable` 函数一起使用。更多详情请参考教程 `DolphinDB 流聚合引擎 <https://gitee.com/dolphindb/Tutorials_CN/blob/master/%E6%B5%81%E8%AE%A1%E7%AE%97/stream_aggregator.md>`_。创建的响应式状态引擎可以跨会话调用。",
                             "",
                             "请注意：响应式状态引擎不支持多线程并发写入，必须配置 *subExecutorPooling* = false，使引擎读写任务串行执行。"
                         ]
@@ -13478,7 +13748,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "createSessionWindowEngine(name, sessionGap, metrics, dummyTable, outputTable, [timeColumn], [useSystemTime=false], [keyColumn], [updateTime], [useSessionStartTime=true], [snapshotDir], [snapshotIntervalInMsgCount], [raftGroup])"
+                            "createSessionWindowEngine(name, sessionGap, metrics, dummyTable, outputTable, [timeColumn], [useSystemTime=false], [keyColumn], [updateTime], [useSessionStartTime=true], [snapshotDir], [snapshotIntervalInMsgCount], [raftGroup], [forceTriggerTime])"
                         ]
                     }
                 ]
@@ -13494,13 +13764,9 @@
                             "",
                             "`sessionGap` 必选参数，是一个正整数，表示会话窗口之间的时间间隔。此参数的时间单位由 *useSystemTime* 参数决定。",
                             "",
-                            "`useSystemTime`: 可选参数，表示窗口以何种方式确定。",
-                            "",
-                            "* 当 *useSystemTime* = true时，按照数据进入引擎的时刻（毫秒精度的本地系统时间，与数据中的时间列无关）确定窗口。",
+                            "`useSessionStartTime`: 可选参数，是一个布尔值，默认值为 true，表示输出表中的时刻是否为数据窗口起始时刻，即每个窗口中第一条数据的时刻。若设置为 false，则表示输出表中的时刻为数据窗口结束时刻，即每个窗口中最后一条数据的时刻+ *sessionGap*。如果指定 *updateTime*，*useSessionStartTime* 必须为 true。",
                             "",
-                            "* 当 *useSystemTime* = false（缺省值）时，根据 *timeColumn* 列中数据来决定数据窗口。",
-                            "",
-                            "`useSessionStartTime`: 可选参数，是一个布尔值，默认值为 true，表示输出表中的时刻是否为数据窗口起始时刻，即每个窗口中第一条数据的时刻。若设置为 false，则表示输出表中的时刻为数据窗口结束时刻，即每个窗口中最后一条数据的时刻+ *sessionGap*。如果指定 *updateTime*，*useSessionStartTime* 必须为 true。"
+                            "`forceTriggerTime` 可选参数，非负整数，单位与 *timeColumn* 的时间精度一致。该参数仅在设置 *useSystemTime* = false 时起效。当系统收到最后一条数据后，经过 *forceTriggerTime* 时间，将强制触发未计算的窗口进行计算。请注意，若设置了 *keyColumn*，则各分组内进行上述操作。"
                         ]
                     }
                 ]
@@ -13528,77 +13794,84 @@
                         "language": "console",
                         "value": [
                             "  ",
-                            "   $ share streamTable(1000:0, `time`volume, [TIMESTAMP, INT]) as trades",
-                            "   $ output1 = keyedTable(`time,10000:0, `time`sumVolume, [TIMESTAMP, INT])",
-                            "   $ engine_sw = createSessionWindowEngine(name = \"engine_sw\", sessionGap = 5, metrics = <sum(volume)>, dummyTable = trades, outputTable = output1, timeColumn = `time)",
+                            "   $ share streamTable(1000:0, `time`sym`volume, [TIMESTAMP, SYMBOL, INT]) as trades",
+                            "   $ output1 = table(10000:0, `time`sym`sumVolume, [TIMESTAMP, SYMBOL, INT])",
+                            "   $ engine_sw = createSessionWindowEngine(name = \"engine_sw\", sessionGap = 5, metrics = <sum(volume)>, dummyTable = trades, outputTable = output1, timeColumn = `time, keyColumn=`sym)",
                             "   $ subscribeTable(tableName=\"trades\", actionName=\"append_engine_sw\", offset=0, handler=append!{engine_sw}, msgAsTable=true)",
-                            "   ",
+                            "",
                             "   $ n = 5",
                             "   $ timev = 2018.10.12T10:01:00.000 + (1..n)",
+                            "   $ symv=take(`A`B`C,n)",
                             "   $ volumev = (1..n)%1000",
-                            "   $ insert into trades values(timev, volumev)",
+                            "   $ insert into trades values(timev, symv, volumev)",
                             "   ",
                             "   $ n = 5",
                             "   $ timev = 2018.10.12T10:01:00.010 + (1..n)",
                             "   $ volumev = (1..n)%1000",
-                            "   $ insert into trades values(timev, volumev)",
+                            "   $ symv=take(`A`B`C,n)",
+                            "   $ insert into trades values(timev, symv, volumev)",
                             "   ",
-                            "   $ n = 3",
-                            "   $ timev = 2018.10.12T10:01:00.020 + (1..n)",
+                            "   $ n = 6",
+                            "   $ timev = 2018.10.12T10:01:00.020 + 1 2 3 8 14 20",
                             "   $ volumev = (1..n)%1000",
-                            "   $ timev.append!(2018.10.12T10:01:00.027 + (1..n))",
-                            "   $ volumev.append!((1..n)%1000)",
-                            "   $ insert into trades values(timev, volumev)",
+                            "   $ symv=take(`A`B`C,n)",
+                            "   $ insert into trades values(timev, symv, volumev)",
                             "",
-                            "   $ select * from trades;",
+                            "   $ select * from output1;",
                             ""
                         ]
                     },
                     {
                         "type": "text",
                         "value": [
-                            "======================== ========",
-                            "time                     volume",
-                            "======================== ========",
-                            "2018.10.12T10:01:00.001  1",
-                            "2018.10.12T10:01:00.002  2",
-                            "2018.10.12T10:01:00.003  3",
-                            "2018.10.12T10:01:00.004  4",
-                            "2018.10.12T10:01:00.005  5",
-                            "2018.10.12T10:01:00.011  1",
-                            "2018.10.12T10:01:00.012  2",
-                            "2018.10.12T10:01:00.013  3",
-                            "2018.10.12T10:01:00.014  4",
-                            "2018.10.12T10:01:00.015  5",
-                            "2018.10.12T10:01:00.021  1",
-                            "2018.10.12T10:01:00.022  2",
-                            "2018.10.12T10:01:00.023  3",
-                            "2018.10.12T10:01:00.028  1",
-                            "2018.10.12T10:01:00.029  2",
-                            "2018.10.12T10:01:00.030  3",
-                            "======================== ========",
+                            "======================== ==== ========",
+                            "time                     sym  volume",
+                            "======================== ==== ========",
+                            "2018.10.12T10:01:00.001   A   5",
+                            "2018.10.12T10:01:00.002   B   7",
+                            "2018.10.12T10:01:00.003   C   3",
+                            "2018.10.12T10:01:00.011   A   5",
+                            "2018.10.12T10:01:00.012   B   7",
+                            "2018.10.12T10:01:00.013   C   3",
+                            "2018.10.12T10:01:00.021   A   1",
+                            "2018.10.12T10:01:00.022   B   2",
+                            "2018.10.12T10:01:00.023   C   3",
+                            "======================== ==== ========",
+                            "",
+                            "指定 forceTriggerTime 为1000ms，收到最后一条消息后，经过1000ms，触发所有分组数据计算输出。用以下代码替换上述引擎创建部分的代码。",
                             ""
                         ]
                     },
                     {
                         "type": "code",
-                        "language": "sql",
+                        "language": "console",
                         "value": [
-                            "  ",
-                            "   select * from output1;",
+                            "",
+                            "   $ engine_sw = createSessionWindowEngine(name = \"engine_sw\", sessionGap = 5, metrics = <sum(volume)>, dummyTable = trades, outputTable = output1, timeColumn = `time, keyColumn=`sym, forceTriggerTime=1000)",
                             ""
                         ]
                     },
                     {
                         "type": "text",
                         "value": [
-                            "======================== ==========",
-                            "time                     sumVolume",
-                            "======================== ==========",
-                            "2018.10.12T10:01:00.001  15",
-                            "2018.10.12T10:01:00.011  15",
-                            "2018.10.12T10:01:00.021  6",
-                            "======================== =========="
+                            "再次查询输出表，可以得到以下结果：",
+                            "",
+                            "======================== ==== ========",
+                            "time                     sym  volume",
+                            "======================== ==== ========",
+                            "2018.10.12T10:01:00.001   A   5",
+                            "2018.10.12T10:01:00.002   B   7",
+                            "2018.10.12T10:01:00.003   C   3",
+                            "2018.10.12T10:01:00.011   A   5",
+                            "2018.10.12T10:01:00.012   B   7",
+                            "2018.10.12T10:01:00.013   C   3",
+                            "2018.10.12T10:01:00.021   A   1",
+                            "2018.10.12T10:01:00.022   B   2",
+                            "2018.10.12T10:01:00.023   C   3",
+                            "2018.10.12T10:01:00.028   A   4",
+                            "2018.10.12T10:01:00.034   B   5",
+                            "2018.10.12T10:01:00.040   C   6",
+                            "======================== ==== ========"
                         ]
                     }
                 ]
@@ -13769,7 +14042,7 @@
                             "",
                             "否则，时间乱序的数据在计算中会被直接丢弃。",
                             "",
-                            "该函数通常与 :doc:`../s/subscribeTable` 函数一起使用。更多详情请参考教程 `DolphinDB 流数据引擎 <https://gitee.com/dolphindb/Tutorials_CN/blob/master/stream_aggregator.md>`_。创建时间序列引擎可以跨会话调用。"
+                            "该函数通常与 :doc:`../s/subscribeTable` 函数一起使用。更多详情请参考教程 `DolphinDB 流数据引擎 <https://gitee.com/dolphindb/Tutorials_CN/blob/master/%E6%B5%81%E8%AE%A1%E7%AE%97/stream_aggregator.md>`_。创建时间序列引擎可以跨会话调用。"
                         ]
                     }
                 ]
@@ -14406,7 +14679,12 @@
                             "",
                             "`window` 必选参数，表示滑动窗口区间的整型或 DURATION 数据对，其中左右边界都包含在内。",
                             "",
-                            "`metrics` 必选参数，以元代码的格式表示计算指标。该参数可以是一个或多个表达式、系统内置或用户自定义函数，可以是聚合函数或非聚合函数。*metrics* 内支持调用具有多个返回值的函数，且必须指定列名，例如 <func(price) as \\`col1\\`col2>。有关元代码的更多信息可参考 :doc:`/Objects/Metaprogramming`。",
+                            "`metrics` 以元代码的格式表示计算指标，支持输入元组。有关元代码的更多信息可参考 :doc:`/Objects/Metaprogramming`。",
+                            "",
+                            "* 计算指标可以是一个或多个表达式、系统内置或用户自定义函数，但不能是聚合函数。",
+                            "* *metrics* 内支持调用具有多个返回值的函数，且必须指定列名，例如 <func(price) as \\`col1\\`col2>。",
+                            "",
+                            "请注意，若 *metrics* 中指定了时间列或者连接列，需要在连接列或时间列前加上表名来指定该列所属的表，若不加表名，则默认取左表的列。例如：*matchingColumn* = \\`sym, *timeColumn* = \\`timestamp，则 *metrics* = <[rightTable.sym, rightTable.timestamp, price, val, price*val]> 指定 *metrics* 中输出右表的 sym 列和 timestamp 列。",
                             "",
                             "当以下函数只计算 *rightTable* 中的数据列时，window join 引擎对它们进行了优化：sum, sum2, avg, std, var, corr, covar, wavg, wsum, beta, max, min, last, first, med, percentile。",
                             "",
@@ -15133,7 +15411,13 @@
                     {
                         "type": "text",
                         "value": [
-                            "计算 *X* 中第一个不为 *k* 的元素；若 *k* 未指定，则返回第一个不为 NULL 的元素。"
+                            "若 *X* 是向量：",
+                            "",
+                            "如果没有指定 *k*，对 *X* 内的每个元素，返回其之前所有元素中第一个不为 NULL 的元素。",
+                            "",
+                            "如果指定 *k*，对 *X* 内的每个元素，返回其之前所有元素中第一个不为 *k* 的元素。",
+                            "",
+                            "若 *X* 是矩阵，在每列内进行上述计算，返回一个与 *X* 维度相同的矩阵。"
                         ]
                     }
                 ]
@@ -15236,7 +15520,13 @@
                     {
                         "type": "text",
                         "value": [
-                            "计算 *X* 中最后一个不为 *k* 的元素；若 *k* 未指定，则返回最后一个不为 NULL 的元素。"
+                            "若 *X* 是向量：",
+                            "",
+                            "如果没有指定 *k*，对 *X* 内的每个元素，返回其之前所有元素中最后一个不为 NULL 的元素。",
+                            "",
+                            "如果指定 *k*，对 *X* 内的每个元素，返回其之前所有元素中最后一个不为 *k* 的元素。",
+                            "",
+                            "若 *X* 是矩阵，在每列内进行上述计算，返回一个与 *X* 维度相同的矩阵。"
                         ]
                     }
                 ]
@@ -17434,7 +17724,7 @@
                             "   $ ID=rand(10, n)",
                             "   $ x=rand(1.0, n)",
                             "   $ t=table(ID, x);",
-                            "   $ db=database(directory=\"C:/DolphinDB/Data/rangedb\", partitionType=RANGE, partitionScheme=0 5 10)",
+                            "   $ db=database(directory=\"dfs://rangedb\", partitionType=RANGE, partitionScheme=0 5 10)",
                             "   $ pt = db.createPartitionedTable(t, `pt, `ID);",
                             "   $ pt.append!(t);",
                             "",
@@ -17472,7 +17762,7 @@
                             "   $ t=table(ID, x);",
                             "   $ saveText(t, \"C:/DolphinDB/Data/t.txt\");",
                             "   ",
-                            "   $ db=database(directory=\"C:/DolphinDB/Data/rangedb\", partitionType=RANGE, partitionScheme=0 5 10)",
+                            "   $ db=database(directory=\"dfs://rangedb\", partitionType=RANGE, partitionScheme=0 5 10)",
                             "   $ pt = loadTextEx(db, `pt, `ID, \"C:/DolphinDB/Data/t.txt\");",
                             ""
                         ]
@@ -17553,7 +17843,7 @@
                             "   $ x=rand(1.0, n);",
                             "   $ t=table(month, x);",
                             "   ",
-                            "   $ db=database(directory=\"C:/DolphinDB/Data/valuedb\", partitionType=VALUE, partitionScheme=2000.01M..2016.12M)",
+                            "   $ db=database(directory=\"dfs://valuedb\", partitionType=VALUE, partitionScheme=2000.01M..2016.12M)",
                             "   $ pt = db.createPartitionedTable(t, `pt, `month);",
                             "   $ pt.append!(t);",
                             "   ",
@@ -17589,7 +17879,7 @@
                             "   $ x=rand(1.0, n);",
                             "   $ t=table(ticker, x);",
                             "   ",
-                            "   $ db=database(directory=\"C:/DolphinDB/Data/listdb\", partitionType=LIST, partitionScheme=[`IBM`ORCL`MSFT, `GOOG`FB])",
+                            "   $ db=database(directory=\"dfs://listdb\", partitionType=LIST, partitionScheme=[`IBM`ORCL`MSFT, `GOOG`FB])",
                             "   $ pt = db.createPartitionedTable(t, `pt, `ticker)",
                             "   $ pt.append!(t);",
                             "   ",
@@ -17735,7 +18025,7 @@
                             "   $ x=rand(1.0, n)",
                             "   $ t=table(ID, x);",
                             "   ",
-                            "   $ db=database(directory=\"C:/DolphinDB/Data/rangedb5\", partitionType=RANGE, partitionScheme=0 5 10, locations=[`node1`node2, `node3])",
+                            "   $ db=database(directory=\"dfs://rangedb5\", partitionType=RANGE, partitionScheme=0 5 10, locations=[`node1`node2, `node3])",
                             "   $ pt = db.createPartitionedTable(t, `pt, `ID);",
                             "   $ pt.append!(t);",
                             ""
@@ -17771,7 +18061,7 @@
                         "language": "console",
                         "value": [
                             "  ",
-                            "   $ db=database(directory=\"C:/DolphinDB/Data/rangedb6\", partitionType=RANGE, partitionScheme=0 5 10, locations=[[\"111.222.3.4:8080\", \"111.222.3.5:8080\"], \"111.222.3.6:8080\"])",
+                            "   $ db=database(directory=\"dfs://rangedb6\", partitionType=RANGE, partitionScheme=0 5 10, locations=[[\"111.222.3.4:8080\", \"111.222.3.5:8080\"], \"111.222.3.6:8080\"])",
                             ""
                         ]
                     },
@@ -20350,6 +20640,52 @@
             }
         ]
     },
+    "disableQueryMonitor": {
+        "title": "disableQueryMonitor",
+        "type": "command",
+        "children": [
+            {
+                "title": "语法",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "disableQueryMonitor()"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "参数",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "无"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "详情",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "关闭监控查询任务状态的功能。",
+                            "",
+                            "由于监控查询任务状态具有一定的内存开销，内存资源紧张时，可以关闭该功能。注意：调用该命令后，用户将无法调用 :doc:`/FunctionsandCommands/FunctionReferences/g/getQueryStatus` 函数获取查询任务的状态。",
+                            "",
+                            "相关函数： :doc:`../e/enableQueryMonitor`"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "disableTablePersistence": {
         "title": "disableTablePersistence",
         "type": "command",
@@ -21570,6 +21906,72 @@
             }
         ]
     },
+    "dropIPCInMemoryTable": {
+        "title": "dropIPCInMemoryTable",
+        "type": "function",
+        "children": [
+            {
+                "title": "语法",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "dropIPCInMemoryTable(tableName)"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "参数",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "`tableName` 字符串，表示跨进程共享内存表的名称。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "详情",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "删除跨进程共享内存表。",
+                            "",
+                            "注意：server 关机并不能删除跨进程共享内存表，仍然需要通过 ``dropIPCInMemoryTable`` 进行删除。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "例子",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "删除函数 ``createIPCInMemoryTable`` 例子中创建的表 ipc_table。",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "  ",
+                            "    $ dropIPCInMemoryTable(`ipc_table)",
+                            "    ipc_table"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "dropPartition": {
         "title": "dropPartition",
         "type": "command",
@@ -21903,7 +22305,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "`name` 是一个字符串，表示一个流数据引擎的名称。",
+                            "`name` 字符串，表示一个流数据引擎的名称。需指定为已创建的引擎名称，否则会抛出异常。通过 :doc:`../../FunctionReferences/g/getStreamEngineStat` 可查看已创建的引擎名称。",
                             "",
                             "详情",
                             "",
@@ -23147,6 +23549,50 @@
             }
         ]
     },
+    "enableQueryMonitor": {
+        "title": "enableQueryMonitor",
+        "type": "command",
+        "children": [
+            {
+                "title": "语法",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "enableQueryMonitor()"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "参数",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "无"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "详情",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "启用监控查询任务状态的功能。系统默认会开启该功能。",
+                            "",
+                            "相关函数： :doc:`../d/disableQueryMonitor`"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "enableTablePersistence": {
         "title": "enableTablePersistence",
         "type": "command",
@@ -24933,7 +25379,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "existsPartition(path)"
+                            "existsPartition(path, [tableName])"
                         ]
                     }
                 ]
@@ -24945,7 +25391,15 @@
                     {
                         "type": "text",
                         "value": [
-                            "`path` 是分区文件夹的路径，它是一个字符串。"
+                            "`path` 字符串，表示分区文件夹的路径。",
+                            "",
+                            "`tableName` 字符串，表示表名。",
+                            "",
+                            "* 若分区粒度为数据库级（ :doc:`../d/database` : *chunkGranularity* = 'DATABASE'），可以不指定该参数。",
+                            "* 若分区粒度为表级（ :doc:`../d/database` :  *chunkGranularity* = 'TABLE'）",
+                            "",
+                            "    * *path* 指定的路径包含了物理索引（通过函数 :doc:`../l/listTables` 获取），可以不指定该参数。",
+                            "    * 否则，必须指定该参数。"
                         ]
                     }
                 ]
@@ -25012,6 +25466,10 @@
                             "   $ existsPartition(\"dfs://valueDB/20170807/s\");",
                             "   true",
                             "",
+                            "   //表级分区时，path 不包含物理索引，检查分区时需指定表名，否则查找不到分区信息",
+                            "   $ existsPartition(\"dfs://valueDB/20170807\", `pt) ",
+                            "   true",
+                            "",
                             "   $ existsPartition(\"dfs://valueDB/20170807\");",
                             "   false",
                             "",
@@ -28593,6 +29051,8 @@
                             "",
                             "`partition` 是字符串，表示分区在数据库内的路径，例如 \"/20190101/GOOG\"。",
                             "",
+                            "请注意：若使用 1.30.16/2.00.4 ~ 1.30.18/2.00.6 版本 server，对表级分区数据进行备份和恢复时，该参数必须指定路径到物理索引（可通过函数 :doc:`/FunctionsandCommands/FunctionReferences/l/listTables` 获取），例如分区 \"/compoDB/20170807/0_50\" 下表的物理索引为8，则 partition 需指定为 \"/compoDB/20170807/0_50/8\"。",
+                            "",
                             "`tableName` 是字符串，表示数据库中表的名称。"
                         ]
                     }
@@ -28735,6 +29195,84 @@
             }
         ]
     },
+    "getCacheEngineStat": {
+        "title": "getCacheEngineStat",
+        "type": "function",
+        "children": [
+            {
+                "title": "语法",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "getCacheEngineStat()"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "参数",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "无"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "详情",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "获取当前节点下 OLAP 引擎 cache engine 的状态信息。该函数只能在数据节点调用。",
+                            "",
+                            "返回一个表对象，包含以下几列: ",
+                            "",
+                            "* chunkId: chunk 的唯一标识。",
+                            "* physicalName: chunk 所属表的物理表名。",
+                            "* timeSinceLastWrite: 距离最后一次写入经过的时间，单位为毫秒。",
+                            "* cachedRowsOfCompletedTxn: 当前缓存的已完成事务的记录数。",
+                            "* cachedRowsOfUncompletedTxn: 当前缓存的未完成事务的记录数。注意: 每个 chunk 最多只有最后一个事务是未完成的。",
+                            "* cachedMemOfCompletedTxn: cachedRowsOfCompletedTxn 占用的内存，单位为字节。",
+                            "* cachedMemOfUncompletedTxn: cachedRowsOfUncompletedTxn 占用的内存，单位为字节。",
+                            "* cachedTids: 当前缓存的事务 id 列表。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "例子",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ getCacheEngineStat()",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "======================================== ============= =================== ========================== =========================== ======================== =========================== ==============",
+                            "chunkId                                  physicalName  timeSinceLastWrite   cachedRowsOfCompletedTxn   cachedRowsOfUncompletedTxn  cachedMemOfCompletedTxn  cachedMemOfUncompletedTxn  cachedTids",
+                            "======================================== ============= =================== ========================== =========================== ======================== =========================== ==============",
+                            "e4558d3c-fa41-52b5-418b-94e26cb70a75     pt_2          1056                222,386                    0                            3,558,176               0                           2052",
+                            "======================================== ============= =================== ========================== =========================== ======================== =========================== =============="
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "getChunkPath": {
         "title": "getChunkPath",
         "type": "function",
@@ -29157,9 +29695,51 @@
                     {
                         "type": "text",
                         "value": [
-                            "返回每个节点的多个配置和性能监控度量值。它只能在控制节点上执行。 ",
+                            "获取每个节点的多个配置和性能监控度量值。它只能在控制节点上执行。 注意：代理节点的 `connectionNum` 是一个随机值，可以忽略。",
+                            "",
+                            "返回一个表对象，包含以下几列：",
                             "",
-                            "注意：代理节点的 `connectionNum` 是一个随机值，可以忽略。",
+                            "* host：节点的主机名。",
+                            "* port：节点的端口号。",
+                            "* site：节点的局域网信息。",
+                            "* mode：节点的类型。0 表示集群的数据节点，1 表示集群的代理节点，2 表示集群的控制节点，3 表示 single mode 的节点。",
+                            "* state：节点是否存活。",
+                            "* agentSite：当前节点的代理节点信息。",
+                            "* maxConnections：最多可以从多少个外部 GUI ，API 或其它节点连接到本地节点。",
+                            "* maxMemSize：当前节点的内存空间上限（单位：GB）。",
+                            "* workerNum：常规作业的工作线程的数量。默认值是 CPU 的内核数。",
+                            "* executorNum：本地执行线程的数量。默认值是 CPU 内核数减1。",
+                            "* connectionNum：连接到本地节点的连接数。",
+                            "* name：节点别名。",
+                            "* memoryUsed：节点的内存占用量（单位：字节）。",
+                            "* memoryAlloc：系统已分配给当前节点的内存（单位：字节）。",
+                            "* cpuUsage：CPU 使用率。",
+                            "* avgLoad：CPU 平均负载。",
+                            "* medLast10QueryTime：前 10 个完成的查询执行所耗费时间的中间值（单位：毫秒）。",
+                            "* maxLast10QueryTime：前 10 个完成的查询执行所耗费时间的最大值（单位：毫秒）。",
+                            "* medLast100QueryTime：前 100 个完成的查询执行所耗费时间的中间值（单位：毫秒）。",
+                            "* maxLast100QueryTime：前100个完成的查询执行所耗费时间的最大值（单位：毫秒）。",
+                            "* maxRunningQueryTime：当前正在执行的查询的耗费时间的最大值（单位：毫秒）。",
+                            "* runningJobs：正在执行中的 Job 个数。",
+                            "* queuedJobs：队列中的 Job 个数。",
+                            "* runningTasks：正在执行中的 Task 个数。",
+                            "* queuedTasks：队列中的 Task 个数。",
+                            "* jobLoad：作业负载。",
+                            "* diskCapacity：磁盘容量（单位：字节）。",
+                            "* diskFreeSpace：磁盘剩余空间（单位：字节）。",
+                            "* diskFreeSpaceRatio：磁盘可用空间占比。",
+                            "* diskWriteRate：磁盘写速率 （单位：字节/秒）。",
+                            "* diskReadRate：磁盘读速率（单位：字节/秒）。",
+                            "* lastMinuteWriteVolume：前一分钟写磁盘容量（单位：字节）。",
+                            "* lastMinuteReadVolume：前一分钟读磁盘容量（单位：字节）。",
+                            "* networkSendRate：网络发送速率（单位：字节/秒）。",
+                            "* networkRecvRate：网络接收速率（单位：字节/秒）。",
+                            "* lastMinuteNetworkSend：前一分钟网络发送字节数（单位：字节）。",
+                            "* lastMinuteNetworkRecv：前一分钟网络接收字节数 （单位：字节）。",
+                            "* publicName：若为控制节点，且配置了 publicName，则显示 publicName；否则显示控制节点所在服务器的 网卡地址。若为数据节点或代理节点，则显示数据节点或代理节点所在服务器的网卡地址。",
+                            "* lastMsgLatency：前一批消息的延时（单位：毫秒）。",
+                            "* cumMsgLatency：所有消息的平均延时（单位：毫秒）。",
+                            "* isLeader：是否是 raft 组的 leader，该字段仅在配置了控制节点高可用时才生效。请注意，若 raft 组存在宕机的节点，则该节点的 isLeader 将返回空值。",
                             ""
                         ]
                     }
@@ -29202,8 +29782,41 @@
                             "   $ rpc(getControllerAlias(), getClusterPerf).keys()",
                             "   [\"host\",\"port\",\"site\",\"mode\",\"state\",\"agentSite\",\"maxConnections\",\"maxMemSize\",\"workerNum\",\"executorNum\",\"connectionNum\",\"name\",\"memoryUsed\",\"memoryAlloc\",\"cpuUsage\",\"avgLoad\",\"medLast10QueryTime\",\"maxLast10QueryTime\",\"medLast100QueryTime\",\"maxLast100QueryTime\",\"maxRunningQueryTime\",\"runningJobs\",\"queuedJobs\",\"runningTasks\",\"queuedTasks\",\"jobLoad\",\"diskCapacity\",\"diskFreeSpace\",\"diskFreeSpaceRatio\",\"diskWriteRate\",\"diskReadRate\",\"lastMinuteWriteVolume\",\"lastMinuteReadVolume\",\"networkSendRate\",\"networkRecvRate\",\"lastMinuteNetworkSend\",\"lastMinuteNetworkRecv\",\"publicName\",\"lastMsgLatency\",\"cumMsgLatency\"]",
                             "",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "集群高可用环境下执行：",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
                             "",
-                            "   "
+                            "   $ rpc(getControllerAlias(true), getClusterPerf)",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "===================  ===========  ==========================================  ======  =======  =====================================  ================  ============  ===========  =============  ===============  =====================  ============  =============  ==========  =========  ====================  ====================  =====================  =====================  =====================  =============  ============  ==============  =============  =========  =====================  =======================  ====================  ===============  ==============  =======================  ======================  =================  =================  =======================  =======================  ===============================================  ================  =============== ================",
+                            "host                 port         site                                         mode    state    agentSite                             maxConnections    maxMemSize    workerNum    executorNum    connectionNum    name                   memoryUsed    memoryAlloc    cpuUsage    avgLoad    medLast10QueryTime    maxLast10QueryTime    medLast100QueryTime    maxLast100QueryTime    maxRunningQueryTime    runningJobs    queuedJobs    runningTasks    queuedTasks    jobLoad    diskCapacity           diskFreeSpace            diskFreeSpaceRatio    diskWriteRate    diskReadRate    lastMinuteWriteVolume    lastMinuteReadVolume    networkSendRate    networkRecvRate    lastMinuteNetworkSend    lastMinuteNetworkRecv    publicName                                       lastMsgLatency    cumMsgLatency   isLeader",
+                            "===================  ===========  ==========================================  ======  =======  =====================================  ================  ============  ===========  =============  ===============  =====================  ============  =============  ==========  =========  ====================  ====================  =====================  =====================  =====================  =============  ============  ==============  =============  =========  =====================  =======================  ====================  ===============  ==============  =======================  ======================  =================  =================  =======================  =======================  ===============================================  ================  =============== ================",
+                            "192.168.100.10        17,000       192.168.100.10:17000:master3                 2        1                                                  512             16            64            3              1            master3                23,449,272   24,133,632      0.7788      0.0037        0                   0                       0                       0                       0                       0          0            0                 0            0           0                       0                     0                     0               4,658           2,736                    102,468                  59,193            78,351             8,012,182                2,378,846                192.198.1.10;172.17.0.1;10.244.5.0;10.244.5.1        0             0                false",
+                            "192.168.100.11        17,000       192.168.100.11:17000:master2                 2        1                                                  512             16            64            3              2            master2                23,527,872   24,133,632      11.5625     0.3219        0                   0                       0                       0                       0                       0          0            0                 0            0           0                       0                     0                     0               4,670           2,785                    116,733                  62,402            56,160             1,366,293                1,398,238                192.198.1.11;172.17.0.1;10.244.4.0;10.244.4.1        0             0                false",
+                            "192.168.100.12        17,000       192.168.100.12:17000:master1                 2        1                                                  512             16            64            3              20           master1                25,002,792   46,538,752      14.0406     0.1136        0                   0                       0                       0                       0                       0          0            0                 0            0           0                       0                     0                     0               4,671           13,546,528               19,964,606               53,206            56,891             22,543,771               8,226,278                192.198.1.12;172.17.0.1;10.244.3.0;10.244.3.1        0             0                true",
+                            "192.168.100.12        17,102       192.168.100.12:17102:server19-datanode1      0        1      192.168.100.12:17101:server19-agent1        254             120           5             31             1            server19-datanode1     23,118,960   24,133,632      13.928      0.1136        0                   0                       0                       0                       0                       0          0            0                 0            0           17,790,585,659,392      16,826,060,464,128    0.9458                0               4,687           1,289                    23,477                   44,197            55,104             352,258                  6,163,159                192.198.1.12;172.17.0.1;10.244.3.0;10.244.3.1        0             0                ",
+                            "192.168.100.11        17,102       192.168.100.11:17102:server18-datanode1      0        1      192.168.100.11:17101:server18-agent1        254             120           5             31             1            server18-datanode1     23,111,912   24,133,632      14.1066     0.3219        0                   0                       0                       0                       0                       0          0            0                 0            0           17,790,585,659,392      16,714,392,956,928    0.9395                0               4,698           1,989                    23,530                   40,896            50,706             243,008                  250,727                  192.198.1.11;172.17.0.1;10.244.4.0;10.244.4.1        0             0                   ",
+                            "192.168.100.11        17,101       192.168.100.11:17101:server18-agent1         1        1      192.168.100.11:17101:server18-agent1        304             4             4             63             0            server18-agent1        0            0               0           0             0                   0                       0                       0                       0                       0          0            0                 0            0           0                       0                     0                     0               0               0                        0                        0                 0                  0                        0                        192.198.1.11;172.17.0.1;10.244.4.0;10.244.4.1        0             0",
+                            "192.168.100.10        17,102       192.168.100.10:17102:server17-datanode1      0        1      192.168.100.10:17101:server17-agent1        254             120           5             31             1            server17-datanode1     40,872,496   52,445,184      0.7788      0.0037        0                   0                       0                       0                       0                       0          0            0                 0            0           53,783,736,754,176      50,336,934,432,768    0.9359                0               4,699           13,900,218               18,835                   118,935           109,862            6,170,512                408,018                  192.198.1.10;172.17.0.1;10.244.5.0;10.244.5.1        0             0",
+                            "192.168.100.12        17,101       192.168.100.12:17101:server19-agent1         1        1      192.168.100.12:17101:server19-agent1        304             4             4             63             0            server19-agent1        0            0               0           0             0                   0                       0                       0                       0                       0          0            0                 0            0           0                       0                     0                     0               0               0                        0                        0                 0                  0                        0                        192.198.1.12;172.17.0.1;10.244.3.0;10.244.3.1        0             0",
+                            "192.168.100.10        17,101       192.168.100.10:17101:server17-agent1         1        1      192.168.100.10:17101:server17-agent1        304             4             4             63             0            server17-agent1        0            0               0           0             0                   0                       0                       0                       0                       0          0            0                 0            0           0                       0                     0                     0               0               0                        0                        0                 0                  0                        0                        192.198.1.10;172.17.0.1;10.244.5.0;10.244.5.1        0             0",
+                            "===================  ===========  ==========================================  ======  =======  =====================================  ================  ============  ===========  =============  ===============  =====================  ============  =============  ==========  =========  ====================  ====================  =====================  =====================  =====================  =============  ============  ==============  =============  =========  =====================  =======================  ====================  ===============  ==============  =======================  ======================  =================  =================  =======================  =======================  ===============================================  ================  =============== ================"
                         ]
                     }
                 ]
@@ -30924,8 +31537,8 @@
             }
         ]
     },
-    "getMemoryStat": {
-        "title": "getMemoryStat",
+    "getMemLimitOfQueryResult": {
+        "title": "getMemLimitOfQueryResult",
         "type": "function",
         "children": [
             {
@@ -30935,7 +31548,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "getMemoryStat()"
+                            "getMemLimitOfQueryResult()"
                         ]
                     }
                 ]
@@ -30959,7 +31572,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "返回当前节点已分配的内存和未使用的内存。"
+                            "获取单次查询结果占用的内存上限（单位为字节），返回一个 DOUBLE 类型数据。"
                         ]
                     }
                 ]
@@ -30973,76 +31586,24 @@
                         "language": "console",
                         "value": [
                             "  ",
-                            "    $ getMemoryStat();",
-                            "",
-                            "    freeBytes->6430128",
-                            "    allocatedBytes->35463168"
-                        ]
-                    }
-                ]
-            }
-        ]
-    },
-    "getNodeAlias": {
-        "title": "getNodeAlias",
-        "type": "function",
-        "children": [
-            {
-                "title": "语法",
-                "type": "grammer",
-                "children": [
-                    {
-                        "type": "text",
-                        "value": [
-                            "getNodeAlias()"
-                        ]
-                    }
-                ]
-            },
-            {
-                "title": "参数",
-                "type": "parameters",
-                "children": [
-                    {
-                        "type": "text",
-                        "value": [
-                            "无"
+                            "    $ setMemLimitOfQueryResult(0.2)",
+                            "    $ getMemLimitOfQueryResult() / 1024 / 1024 / 1024",
+                            "    0.2",
+                            ""
                         ]
-                    }
-                ]
-            },
-            {
-                "title": "详情",
-                "type": "detail",
-                "children": [
+                    },
                     {
                         "type": "text",
                         "value": [
-                            "获取本地节点的别名。该别名定义在配置文件 dolphindb.cfg 中。"
-                        ]
-                    }
-                ]
-            },
-            {
-                "title": "例子",
-                "type": "example",
-                "children": [
-                    {
-                        "type": "code",
-                        "language": "console",
-                        "value": [
-                            "  ",
-                            "    $ getNodeAlias();",
-                            "",
-                            "    controller2"
+                            "相关函数：:doc:`/FunctionsandCommands/CommandsReferences/s/setMemLimitOfQueryResult`"
                         ]
                     }
                 ]
             }
         ]
     },
-    "getNodeHost": {
-        "title": "getNodeHost",
+    "getMemLimitOfTaskGroupResult": {
+        "title": "getMemLimitOfTaskGroupResult",
         "type": "function",
         "children": [
             {
@@ -31052,7 +31613,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "getNodeHost()"
+                            "getMemLimitOfTaskGroupResult()"
                         ]
                     }
                 ]
@@ -31076,7 +31637,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "获取本地节点的主机名。该名称定义在配置文件 dolphindb.cfg 中。"
+                            "获取当前节点发送的批量子查询占用的内存上限（单位为字节），返回一个 DOUBLE 类型数据。"
                         ]
                     }
                 ]
@@ -31090,17 +31651,24 @@
                         "language": "console",
                         "value": [
                             "  ",
-                            "    $ getNodeHost();",
-                            "",
-                            "    10.6.0.6"
+                            "    $ setMemLimitOfTaskGroupResult(10)",
+                            "    $ getMemLimitOfTaskGroupResult() / 1024 / 1024 / 1024",
+                            "    10",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "相关函数：:doc:`/FunctionsandCommands/CommandsReferences/s/setMemLimitOfTaskGroupResult`"
                         ]
                     }
                 ]
             }
         ]
     },
-    "getNodePort": {
-        "title": "getNodePort",
+    "getMemoryStat": {
+        "title": "getMemoryStat",
         "type": "function",
         "children": [
             {
@@ -31110,7 +31678,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "getNodePort()"
+                            "getMemoryStat()"
                         ]
                     }
                 ]
@@ -31134,7 +31702,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "获取节点使用的端口号。该端口号定义在配置文件dolphindb.cfg 中。"
+                            "返回当前节点已分配的内存和未使用的内存。"
                         ]
                     }
                 ]
@@ -31148,17 +31716,18 @@
                         "language": "console",
                         "value": [
                             "  ",
-                            "    $ getNodePort();",
+                            "    $ getMemoryStat();",
                             "",
-                            "    8888"
+                            "    freeBytes->6430128",
+                            "    allocatedBytes->35463168"
                         ]
                     }
                 ]
             }
         ]
     },
-    "getNodeType": {
-        "title": "getNodeType",
+    "getNodeAlias": {
+        "title": "getNodeAlias",
         "type": "function",
         "children": [
             {
@@ -31168,7 +31737,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "getNodeType()"
+                            "getNodeAlias()"
                         ]
                     }
                 ]
@@ -31192,7 +31761,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "返回节点的类型。0表示数据节点；1表示代理节点；2表示控制器节点；3表示单节点模式；4表示计算节点。"
+                            "获取本地节点的别名。该别名定义在配置文件 dolphindb.cfg 中。"
                         ]
                     }
                 ]
@@ -31206,17 +31775,17 @@
                         "language": "console",
                         "value": [
                             "  ",
-                            "    $ getNodeType();",
+                            "    $ getNodeAlias();",
                             "",
-                            "    2"
+                            "    controller2"
                         ]
                     }
                 ]
             }
         ]
     },
-    "getOS": {
-        "title": "getOS",
+    "getNodeHost": {
+        "title": "getNodeHost",
         "type": "function",
         "children": [
             {
@@ -31226,7 +31795,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "getOS()"
+                            "getNodeHost()"
                         ]
                     }
                 ]
@@ -31250,7 +31819,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "返回DolphinDB server所在操作系统的类型。"
+                            "获取本地节点的主机名。该名称定义在配置文件 dolphindb.cfg 中。"
                         ]
                     }
                 ]
@@ -31264,17 +31833,17 @@
                         "language": "console",
                         "value": [
                             "  ",
-                            "    $ getOS();",
+                            "    $ getNodeHost();",
                             "",
-                            "    linux"
+                            "    10.6.0.6"
                         ]
                     }
                 ]
             }
         ]
     },
-    "getOSBit": {
-        "title": "getOSBit",
+    "getNodePort": {
+        "title": "getNodePort",
         "type": "function",
         "children": [
             {
@@ -31284,7 +31853,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "getOSBit()"
+                            "getNodePort()"
                         ]
                     }
                 ]
@@ -31308,7 +31877,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "返回DolphinDB server所在操作系统的位数。"
+                            "获取节点使用的端口号。该端口号定义在配置文件dolphindb.cfg 中。"
                         ]
                     }
                 ]
@@ -31322,17 +31891,17 @@
                         "language": "console",
                         "value": [
                             "  ",
-                            "    $ getOSBit();",
+                            "    $ getNodePort();",
                             "",
-                            "    64"
+                            "    8888"
                         ]
                     }
                 ]
             }
         ]
     },
-    "getPerf": {
-        "title": "getPerf",
+    "getNodeType": {
+        "title": "getNodeType",
         "type": "function",
         "children": [
             {
@@ -31342,7 +31911,181 @@
                     {
                         "type": "text",
                         "value": [
-                            "getPerf()"
+                            "getNodeType()"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "参数",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "无"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "详情",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "返回节点的类型。0表示数据节点；1表示代理节点；2表示控制器节点；3表示单节点模式；4表示计算节点。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "例子",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "  ",
+                            "    $ getNodeType();",
+                            "",
+                            "    2"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
+    "getOS": {
+        "title": "getOS",
+        "type": "function",
+        "children": [
+            {
+                "title": "语法",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "getOS()"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "参数",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "无"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "详情",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "返回DolphinDB server所在操作系统的类型。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "例子",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "  ",
+                            "    $ getOS();",
+                            "",
+                            "    linux"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
+    "getOSBit": {
+        "title": "getOSBit",
+        "type": "function",
+        "children": [
+            {
+                "title": "语法",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "getOSBit()"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "参数",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "无"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "详情",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "返回DolphinDB server所在操作系统的位数。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "例子",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "  ",
+                            "    $ getOSBit();",
+                            "",
+                            "    64"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
+    "getPerf": {
+        "title": "getPerf",
+        "type": "function",
+        "children": [
+            {
+                "title": "语法",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "getPerf()"
                         ]
                     }
                 ]
@@ -31510,6 +32253,86 @@
             }
         ]
     },
+    "getQueryStatus": {
+        "title": "getQueryStatus",
+        "type": "function",
+        "children": [
+            {
+                "title": "语法",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "getQueryStatus()"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "参数",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "无"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "详情",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "获取由当前节点发起且正在执行的查询任务状态，返回一个表对象，包含以下几列：",
+                            "",
+                            "* id：表示到该查询任务为止，系统已执行的查询任务总数。",
+                            "* sessionId：任务发起会话的 id。请注意，无法获取通过 submitJob 提交的查询任务的 sessionId。",
+                            "* userId：任务发起会话的用户名。",
+                            "* query：原始查询语句中主要的查询信息。",
+                            "* startTime：查询任务开始的时间戳。",
+                            "* elapsedTimeInMs：查询任务已经经过的时间，单位为毫秒。",
+                            "* memoryUsage：查询过程中变量和结果所占用的内存空间，单位为字节。",
+                            "* totalTaskCount：查询子任务总数。",
+                            "* completedTaskCount：已完成的查询子任务数。",
+                            "* percentComplete：已完成的查询子任务占比。",
+                            "",
+                            "该函数只能在任务发起节点上调用。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "例子",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    getQueryStatus();",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "=== ========== ======== =============================== ========================= ================ ============ =============== =================== ================",
+                            "id  sessionId  userId   query                           startTime                 elapsedTimeInMs  memoryUsage  totalTaskCount  completedTaskCount  percentComplete",
+                            "=== ========== ======== =============================== ========================= ================ ============ =============== =================== ================",
+                            "2   1166953221 admin    select ticker, id, x from pt    2022.06.14  08:15:00.606  1052              184550000    4                1                  0.25",
+                            "=== ========== ======== =============================== ========================= ================ ============ =============== =================== ================"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "getRaftElectionTick": {
         "title": "getRaftElectionTick",
         "type": "function",
@@ -31694,11 +32517,13 @@
                             "* DeleteSource: 是否删除源节点的数据。当 TaskType 是 ChunkRecovery 时，只能返回 false；当 TaskType 是 LoadRebalance 时，可以返回 true 或 false。",
                             "* StartTime: 创建恢复任务的时间。",
                             "* LastDequeueTime: 任务最后一次从任务队列出队的时间。",
-                            "* LastStartTime：最后一次开始执行任务的时间。",
+                            "* LastStartTime: 最后一次开始执行任务的时间。",
                             "* FinishTime: 任务结束的时间。",
                             "* IsIncrementalRecovery: 是否启用增量复制。",
-                            "* IsAsyncRecovery：是否启用异步复制。",
-                            "* ChangeFromIncrementalToFull: 是否成功从增量恢复转为全量复制。"
+                            "* IsAsyncRecovery: 是否启用异步复制。",
+                            "* ChangeFromIncrementalToFull: 是否从增量恢复转为全量恢复。系统多次尝试增量恢复失败会自动转换成全量恢复。",
+                            "* ChangeToSyncTime: 节点在线恢复时，从异步恢复阶段转为同步恢复阶段的时刻。",
+                            "* FailureReason：recovery 任务失败的原因。"
                         ]
                     }
                 ]
@@ -31721,7 +32546,7 @@
     },
     "getRecoveryWorkerNum": {
         "title": "getRecoveryWorkerNum",
-        "type": "command",
+        "type": "function",
         "children": [
             {
                 "title": "语法",
@@ -31777,7 +32602,82 @@
                     {
                         "type": "text",
                         "value": [
-                            "相关函数：:doc:`../r/resetRecoveryWorkerNum`"
+                            "相关函数：:doc:`/FunctionsandCommands/CommandsReferences/r/resetRecoveryWorkerNum`"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
+    "getRedoLogGCStat": {
+        "title": "getRedoLogGCStat",
+        "type": "function",
+        "children": [
+            {
+                "title": "语法",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "getRedoLogGCStat()"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "参数",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "无"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "详情",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "获取 redo log 垃圾回收的状态。返回一个表对象，包含以下几列：",
+                            "",
+                            "* physicalName：物理表名，格式为 \"/数据库名/物理表名\"",
+                            "* txnCount：redo log 尚未回收的事务数。",
+                            "* numOfTxnPendingGC：等待回收的事务数。",
+                            "* minTidPendingGC：等待回收的事务的最小 tid。",
+                            "* numOfTxnPendingFlush：等待刷盘的事务数。",
+                            "* minTidPendingFlush：等待刷盘的事务的最小 tid。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "例子",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "  ",
+                            "    $ getRedoLogGCStat();",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "============== ============ ==================== ================== ===================== ====================",
+                            "physicalName   txnCount     numOfTxnPendingGC     minTidPendingGC   numOfTxnPendingFlush   minTidPendingFlush",
+                            "============== ============ ==================== ================== ===================== ====================",
+                            "/test/pt_2      2            0                                       2                     1031",
+                            "/listdb/pt_2    1            1                    1033               0",
+                            "============== ============ ==================== ================== ===================== ===================="
                         ]
                     }
                 ]
@@ -32683,7 +33583,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "监控流计算的状态。返回的结果是一个字典，包含以下4个表：",
+                            "监控流计算的状态。返回的结果是一个字典，包含以下5个表：",
                             "",
                             "* 表pubConns监控本地发布节点和它的所有订阅节点之间的连接状态。每一行表示一个订阅节点。它包含以下列：",
                             "",
@@ -32796,6 +33696,7 @@
                         "value": [
                             "  $ getStreamingStat().pubConns;",
                             "  $ getStreamingStat().subConns;",
+                            "  $ getStreamingStat().pubTables;",
                             "  $ getStreamingStat().persistWorkers;",
                             "  $ getStreamingStat().subWorkers;"
                         ]
@@ -32878,6 +33779,102 @@
             }
         ]
     },
+    "getSupportBundle": {
+        "title": "getSupportBundle",
+        "type": "function",
+        "children": [
+            {
+                "title": "语法",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "getSupportBundle([dir])"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "参数",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "`dir` 可选参数，用于指定存储路径。若不指定该参数，单节点环境下默认存储至 <HomeDir>（可通过 :doc:`getHomeDir` 查看 <HomeDir>）；集群环境下默认存储至 <HomeDir> 同级目录。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "详情",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "生成一个包含所有配置信息的文件，并返回文件路径。该函数只能在数据节点/计算节点调用。",
+                            "",
+                            "配置文件包含以下信息：",
+                            "",
+                            "",
+                            "+----------------------+--------------------------------------------------------------------------------+-----------------------------------------+",
+                            "| 模块名               | 含义                                                                           | 信息来源                                |",
+                            "+======================+================================================================================+=========================================+",
+                            "| VERSION              | server 的版本信息。                                                            | ``version()``                           |",
+                            "+----------------------+--------------------------------------------------------------------------------+-----------------------------------------+",
+                            "| CONFIGS              | 配置信息。单机环境下，返回单节点的配置信息；集群环境下，包含集群、控制节点、   | 单机: dolphindb.cfg                     |",
+                            "|                      | 和数据节点/计算节点的配置。                                                    | 集群: cluster.cfg,                      |",
+                            "|                      |                                                                                | cluster.nodes, controller.cfg           |",
+                            "+----------------------+--------------------------------------------------------------------------------+-----------------------------------------+",
+                            "| DB AND TABLE SCHEMA  | 所有数据库和表的结构。                                                         | ``schema``                              |",
+                            "+----------------------+--------------------------------------------------------------------------------+-----------------------------------------+",
+                            "| LICENSE AND MACHINE  | license、机器核数和内存信息。                                                  | 许可证: dolphindb.lic                   |",
+                            "| INFO                 |                                                                                |                                         |",
+                            "+----------------------+--------------------------------------------------------------------------------+-----------------------------------------+",
+                            "| OLAP CACHE ENGINE    | OLAP 引擎 cache Engine 的状态信息，包含各节点的内存信息以及当前节点的状态表。  | ``pnodeRun(getCacheEngineMemSize)``     |",
+                            "| STATUS               |                                                                                | ``pnodeRun(getCacheEngineStat)``        |",
+                            "+----------------------+--------------------------------------------------------------------------------+-----------------------------------------+",
+                            "| TSDB META            | 获取 TSDB 引擎下所有 chunk 的元数据。                                          | ``pnodeRun(getTSDBMetaData)``           |",
+                            "+----------------------+--------------------------------------------------------------------------------+-----------------------------------------+",
+                            "| REDO LOG GC STATUS   | 获取事务 redo log 回收的状态。                                                 | ``pnodeRun(getRedoLogGCStat)``          |",
+                            "+----------------------+--------------------------------------------------------------------------------+-----------------------------------------+",
+                            "| TRANSACTION STATUS   | 获取事务的状态。                                                               | ``pnodeRun(getTransactionStatus)``      |",
+                            "+----------------------+--------------------------------------------------------------------------------+-----------------------------------------+",
+                            "| TABLETS META         | 返回集群中行数最多的前100个 chunk 的元数据信息。                               | select top 100 \\* from pnodeRun(getTable|",
+                            "|                      |                                                                                | tsMeta{\"%\",\"%\",false,-1}) order by      |",
+                            "|                      |                                                                                | rowNum desc                             |",
+                            "+----------------------+--------------------------------------------------------------------------------+-----------------------------------------+",
+                            "|ANOMALOUS CHUNK STATUS| 获取处于异常状态的 chunk 信息。异常状态包含处于 recovery 状态，版本号不一致，  | ``getClusterChunksStatus()``            |",
+                            "|(only in cluster mode)| 副本数不一致等。                                                               |                                         |",
+                            "+----------------------+--------------------------------------------------------------------------------+-----------------------------------------+",
+                            ""
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "例子",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ getSupportBundle()",
+                            "    /home/dolphindb/server/getSupportBundle.1655869793424",
+                            "",
+                            "    $ getSupportBundle(\"/home/dolphindb/sup\")",
+                            "    /home/dolphindb/sup/getSupportBundle.1655869853178",
+                            " "
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "getSystemCpuUsage": {
         "title": "getSystemCpuUsage",
         "type": "function",
@@ -33376,6 +34373,82 @@
             }
         ]
     },
+    "getTransactionStatus": {
+        "title": "getTransactionStatus",
+        "type": "function",
+        "children": [
+            {
+                "title": "语法",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "getTransactionStatus()"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "参数",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "无"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "详情",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "获取事务的状态，该函数只能在数据节点/计算节点执行。返回一个表，包含以下列：",
+                            "",
+                            "* tid ：事务的 id。",
+                            "* startTime：事务开始的时间。",
+                            "* type：事务涉及到的操作类型，包括 APPEND, DROP, SQLUPDATE, SQLUPSERT, SQLDELETE, FILEOPERATE 和 UNKNOWN。",
+                            "* status：事务当前的状态，包括 BEGIN, COMMIT, COMPLETE, ROLLBACK。",
+                            "* partitionCount：事务涉及到的分区数量。",
+                            "* endTime：事务结束的时间。",
+                            "* elapsedTime：事务持续的时间。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "例子",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    getTransactionStatus() ",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "============= ========================== ======= ====== ============== ============================ ============",
+                            "tid           startTime                  type    status partitionCount endTime                      elapsedTime",
+                            "============= ========================== ======= ====== ============== ============================ ============",
+                            "3135          2022.06.07 16:19:48.477    APPEND  BEGIN  4                                           584",
+                            "3143          2022.06.07 16:11:27.489    APPEND  COMMIT 4              \t2022.06.07 16:11:33.100     484",
+                            "============= ========================== ======= ====== ============== ============================ ============"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "getUserAccess": {
         "title": "getUserAccess",
         "type": "function",
@@ -33746,6 +34819,107 @@
             }
         ]
     },
+    "gmm": {
+        "title": "gmm",
+        "type": "function",
+        "children": [
+            {
+                "title": "语法",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "gmm(X, k, [maxIter=300], [tolerance=1e-4], [randomSeed], [mean], [sigma])"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "参数",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "`X` 训练数据集。若为一元数据，则 *X* 是一个向量；若为多元数据，则 *X* 是一个矩阵或表，矩阵的每列代表一个样本数据。",
+                            "",
+                            "`k` 正整数。表示混合模型中子模型的数量。",
+                            "",
+                            "`maxlter` 正整数，表示最大的迭代次数。默认为 300。",
+                            "",
+                            "`tolerance` 浮点数，表示 EM 迭代中止的边界差值。如果相邻两次迭代的对数似然函数值的差值小于 *tolerance*，则停止迭代。默认为 1e-4。",
+                            "",
+                            "`randomSeed` 随机数种子。",
+                            "",
+                            "`mean` 可选参数，向量/矩阵。表示模型初始化的均值。若 *X* 为一元数据，则 *mean* 是元素个数为 *k* 的向量；若 *X* 为多元数据，则 *mean* 是列数为 *k*，行数与 *X* 的元数相同的矩阵。若不指定，系统随机从 *X* 中选择 *k* 个值作为模型的初始化均值。",
+                            "",
+                            "`sigma` 可选参数，向量/元组，元素个数为 *k*。若 *X* 为一元数据，表示每个子模型初始化的方差；若 *X* 为多元数据，表示每个子模型初始化的协方差矩阵。若不指定，系统使用元素值为 1 的向量或单位矩阵。",
+                            ""
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "详情",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "通过数据集训练 GMM（高斯混合模型）。返回一个字典，包含以下键值：",
+                            "",
+                            "* modelName：字符串 \"Gaussian Mixture Model\"",
+                            "* prior：观测数据属于各子模型的先验概率。",
+                            "* mean：训练获得的每个子模型的期望。",
+                            "* sigma：若 *X* 为 一元数据，表示训练获得的每个子模型的方差；若 *X* 为多元数据，表示训练获得的每个子模型的协方差矩阵。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "例子",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ dataT = 6.8 7.2 5.3 9.4 6.5 11.2 25.6 0.6 8.9 4.3 2.2 1.9 8.7 0.2 1.5",
+                            "    $ mean = [2, 2]",
+                            "    $ re = gmm(dataT, 2, 300, 1e-4, 42, mean)",
+                            "    $ re",
+                            "",
+                            "    sigma->[36.759822,36.759822]",
+                            "    modelName->Gaussian Mixture Model",
+                            "    prior->[0.5,0.5]",
+                            "    mean->[6.686667,6.686667]",
+                            "",
+                            "    $ dataT = transpose(matrix(3.2 1.5 2.6 7.8 6.3 4.2 5.1 8.9 11.2 25.8, 25.6 4.6 8.9 4.3 2.2 1.9 8.7 0.2 1.5 9.3))",
+                            "    $ mean = transpose(matrix([1, 0], [0, 1]))",
+                            "    $ re = gmm(dataT, 2, 300, 1e-4, 42, mean)",
+                            "    $ re",
+                            "",
+                            "    sigma->(#0        #1       ",
+                            "    51.001369 18.273032",
+                            "    18.273032 9.34789  ",
+                            "    ,#0       #1       ",
+                            "    1.718475 0.629584 ",
+                            "    0.629584 67.713701",
+                            "    )",
+                            "    modelName->Gaussian Mixture Model",
+                            "    prior->[0.558683,0.441317]",
+                            "    mean->",
+                            "    #0        #1       ",
+                            "    11.152841 3.238262 ",
+                            "    3.341493  10.996997"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "gmtime": {
         "title": "gmtime",
         "type": "function",
@@ -39468,6 +40642,128 @@
             }
         ]
     },
+    "isPeak": {
+        "title": "isPeak",
+        "type": "function",
+        "children": [
+            {
+                "title": "语法",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "isPeak(X, [strict=true])"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "参数",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "`X` 数值型向量/矩阵/表。",
+                            "",
+                            "`strict` 布尔值，表示是否取严格的峰值点。默认值为 true。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "详情",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "若 *X* 为向量，计算 *X* 中的每个元素是否为峰值点，若是则返回 true，否则返回 false。",
+                            "",
+                            "判断规则为：",
+                            "",
+                            "* 若 *strict* = true，相邻元素不为空且严格小于该元素；",
+                            "* 若 *strict* = false，相邻元素不为空且小于等于该元素；",
+                            "",
+                            "若 *X* 为矩阵，在每列进行上述计算，返回值一个同 X 维度相同的矩阵。若 *X* 为表，则只对数值型的列进行上述计算。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "例子",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ v = [1, 2.2, 2.2, 2.2, 2.3, 1, 1.2]",
+                            "    $ isPeak(v)",
+                            "    [0,0,0,0,1,0,0]",
+                            "",
+                            "    $ v = [1, 2.2, 2.2, 2.2, 1.6, 1, 1.2]",
+                            "    $ isPeak(v)",
+                            "    [0,0,0,0,0,0,0]",
+                            "    $ isPeak(v, false)",
+                            "    [0,1,1,1,0,0,0]",
+                            "",
+                            "    // 矩阵在每列单独计算",
+                            "    $ m = matrix(3.3 2.8 5.6 NULL 2.5 1.2, 4.5 3.5 4.6 2.8 3.9 NULL)",
+                            "    $ isPeak(m)",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "== ==",
+                            "#0 #1",
+                            "== ==",
+                            "0  0 ",
+                            "0  0 ",
+                            "0  1 ",
+                            "0  0 ",
+                            "0  0 ",
+                            "0  0 ",
+                            "== ==",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    // 表只在数值列进行计算",
+                            "    $ t = table(`01`01`00`01`02`00 as id, 2022.01.01 + 1..6 as date, 388.3 390.6 390.8 390.6 390.3 391.5 as price)",
+                            "    $ isPeak(t)",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "== ========== =====",
+                            "id date       price",
+                            "== ========== =====",
+                            "01 2022.01.02 0    ",
+                            "01 2022.01.03 0    ",
+                            "00 2022.01.04 1    ",
+                            "01 2022.01.05 0    ",
+                            "02 2022.01.06 0    ",
+                            "00 2022.01.07 0",
+                            "== ========== =====",
+                            "",
+                            "相关函数：:doc:`isValley`"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "isQuarterEnd": {
         "title": "isQuarterEnd",
         "type": "function",
@@ -39944,6 +41240,128 @@
             }
         ]
     },
+    "isValley": {
+        "title": "isValley",
+        "type": "function",
+        "children": [
+            {
+                "title": "语法",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "isValley(X, [strict=true])"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "参数",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "`X` 数值型向量/矩阵/表。",
+                            "",
+                            "`strict` 布尔值，表示是否取严格的谷值点。默认值为 true。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "详情",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "若 *X* 为向量，计算 *X* 中的每个元素是否为谷值点，若是则返回 true，否则返回 false。",
+                            "",
+                            "判断规则为：",
+                            "",
+                            "* 若 *strict* = true，相邻元素不为空且严格大于该元素；",
+                            "* 若 *strict* = false，相邻元素不为空且大于等于该元素；",
+                            "",
+                            "若 *X* 为矩阵，在每列进行上述计算，返回值一个同 X 维度相同的矩阵。若 *X* 为表，则只对数值型的列进行上述计算。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "例子",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ v = [3.1, 2.2, 2.2, 2.2, 1.3, 2.1, 1.2]",
+                            "    $ isValley(v)",
+                            "    [0,0,0,0,1,0,0]",
+                            "",
+                            "    $ v = [3.1, 2.2, 2.2, 2.2, 2.6, 1, 1.2]",
+                            "    $ isValley(v)",
+                            "    [0,0,0,0,0,1,0]",
+                            "    $ isValley(v, false)",
+                            "    [0,1,1,1,0,1,0]",
+                            "",
+                            "    // 矩阵在每列单独计算",
+                            "    $ m = matrix(5.3 5.8 5.6 NULL 5.7 1.2, 4.5 3.5 4.6 2.8 3.9 NULL)",
+                            "    $ isValley(m)",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "== ==",
+                            "#0 #1",
+                            "== ==",
+                            "0  0 ",
+                            "0  1 ",
+                            "0  0 ",
+                            "0  1 ",
+                            "0  0 ",
+                            "0  0 ",
+                            "== ==",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    // 表只在数值列进行计算",
+                            "    $ t = table(`01`01`00`01`02`00 as id, 2022.01.01 + 1..6 as date, 388.3 390.6 390.8 390.6 390.3 391.5 as price)",
+                            "    $ isValley(t)",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "== ========== =====",
+                            "id date       price",
+                            "== ========== =====",
+                            "01 2022.01.02 0    ",
+                            "01 2022.01.03 0    ",
+                            "00 2022.01.04 0    ",
+                            "01 2022.01.05 0    ",
+                            "02 2022.01.06 1    ",
+                            "00 2022.01.07 0",
+                            "== ========== =====",
+                            "",
+                            "相关函数：:doc:`isPeak`"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "isVoid": {
         "title": "isVoid",
         "type": "function",
@@ -43429,7 +44847,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "`dbUrl` 是一个字符串，表示本地磁盘数据库或分布式数据库的路径。"
+                            "`dbUrl` 是一个字符串，表示分布式数据库的路径。"
                         ]
                     }
                 ]
@@ -43515,6 +44933,8 @@
                             "",
                             "`partition` 是字符串，表示分区在数据库内的路径，例如 \"/20190101/GOOG\"。",
                             "",
+                            "请注意：若使用 1.30.16/2.00.4 ~ 1.30.18/2.00.6 版本 server，对表级分区数据进行备份和恢复时，该参数必须指定路径到物理索引（可通过函数 :doc:`/FunctionsandCommands/FunctionReferences/l/listTables` 获取），例如分区 \"/compoDB/20170807/0_50\" 下表的物理索引为8，则 partition 需指定为 \"/compoDB/20170807/0_50/8\"。",
+                            "",
                             "`tableName` 是字符串，表示分布式表的名称。"
                         ]
                     }
@@ -43634,6 +45054,71 @@
             }
         ]
     },
+    "loadIPCInMemoryTable": {
+        "title": "loadIPCInMemoryTable",
+        "type": "function",
+        "children": [
+            {
+                "title": "语法",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "loadIPCInMemoryTable(tableName)"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "参数",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "`tableName` 字符串，表示跨进程共享内存表的名称。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "详情",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "加载跨进程共享内存表，并返回该表的句柄。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "例子",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "加载函数 ``createIPCInMemoryTable`` 例子中创建的表 ipc_table。",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "  ",
+                            "    $ ipc_t = loadIPCInMemoryTable(\"ipc_table\")",
+                            "    $ ipc_t",
+                            "    timestamp temperature"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "loadModel": {
         "title": "loadModel",
         "type": "function",
@@ -46025,6 +47510,117 @@
             }
         ]
     },
+    "lowRange": {
+        "title": "lowRange",
+        "type": "function",
+        "children": [
+            {
+                "title": "语法",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "lowRange(X)"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "参数",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "`X` 向量/元组/矩阵/表。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "详情",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "对于 *X* 中的每个元素 *Xi*，统计 *Xi* 左侧相邻且连续小于它的元素个数。",
+                            "",
+                            "该函数常用于统计一个序列的当前值是前多少周期（日或分钟等）内的最小值。例如某只股票创几日新低等。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "例子",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ lowRange([13.5, 13.6, 13.4, 13.3, 13.5, 13.9, 13.1, 20.1, 20.2, 20.3])",
+                            "    [0,0,2,3,0,0,6,0,0,0]",
+                            "",
+                            "    $ m = matrix(1.5 2.6 3.2 1.4 2.5 2.2 3.7 2.0, 1.6 2.3 4.2 5.6 4.1 3.2 4.4 6.9)",
+                            "    $ lowRange(m)",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "== ==",
+                            "#0 #1",
+                            "== ==",
+                            "0  0 ",
+                            "0  0 ",
+                            "0  0 ",
+                            "3  0 ",
+                            "0  2 ",
+                            "1  3 ",
+                            "0  0 ",
+                            "3  0 ",
+                            "== ==",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    //模拟股票 A 8天的股价,使用 topRange 计算股票 A 每日股价创几日新高",
+                            "    $ trades = table(take(`A, 8) as sym,  2022.01.01 + 1..8 as date, 39.70 39.72 39.80 39.78 39.83 39.92 40.00 40.03 as price)",
+                            "    $ select *, lowRange(price) from trades",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "=== ========== ======== ===============",
+                            "id  date        price   lowRange_price",
+                            "=== ========== ======== ===============",
+                            "A   2022.01.02 39.7     0",
+                            "A   2022.01.03 39.72    0",
+                            "A   2022.01.04 39.8     0",
+                            "A   2022.01.05 39.78    1",
+                            "A   2022.01.06 39.83    0",
+                            "A   2022.01.07 39.92    0",
+                            "A   2022.01.08 40       0",
+                            "A   2022.01.09 40.03    0",
+                            "=== ========== ======== ===============",
+                            "",
+                            "相关函数：:doc:`../t/topRange`"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "lower": {
         "title": "lower",
         "type": "function",
@@ -52730,9 +54326,7 @@
                             "* 'nearest': :math:`X_i` 和 :math:`X_{i+1}` 之中最接近分位点的数据",
                             "* 'midpoint': :math:`(X_i+X_{i+1})/2`",
                             "",
-                            "如果没有指定 *interpolation*，默认采用 'linear'。",
-                            "",
-                            "如果没有指定 *interpolation*，默认采用 linear。"
+                            "如果没有指定 *interpolation*，默认采用 'linear'。"
                         ]
                     }
                 ]
@@ -54252,6 +55846,89 @@
             }
         ]
     },
+    "msum2": {
+        "title": "msum2",
+        "type": "function",
+        "children": [
+            {
+                "title": "语法",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "msum2(X, window, [minPeriods])",
+                            "",
+                            "参数说明和窗口计算规则请参考: :doc:`/FunctionsandCommands/SeriesOfFunctions/mFunctions`"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "详情",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "在给定长度（以元素个数或时间长度衡量）的滑动窗口内计算 *X* 元素的平方和。请注意，该函数的返回值是 DOUBLE 类型。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "例子",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ X = 2 1 3 7 6 5 4",
+                            "    $ Y = 2 1 3 NULL 6 5 4",
+                            "",
+                            "    $ msum2(X, 3)",
+                            "    [,,14,59,94,110,77]",
+                            "",
+                            "    $ msum2(Y, 3)",
+                            "    [,,14,10,45,61,77]",
+                            "",
+                            "    $ msum2(Y, 3, minPeriods=1)",
+                            "    [4,5,14,10,45,61,77]",
+                            "",
+                            "    $ m = matrix(1 NULL 4 NULL 8 6 , 9 NULL NULL 10 NULL 2)",
+                            "    $ m.rename!(date(2021.08.16)+1..6, `col1`col2)",
+                            "    $ m.setIndexedMatrix!()",
+                            "    $ msum2(m, 3d)  // 等价于 msum2(m, 3)",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "========== ===== =====",
+                            "label      col1  col2",
+                            "========== ===== =====",
+                            "2021.08.17   1   81",
+                            "2021.08.18   1   81",
+                            "2021.08.19   17  81",
+                            "2021.08.20   16  100",
+                            "2021.08.21   80  100",
+                            "2021.08.22   100 104",
+                            "========== ===== =====",
+                            "",
+                            "",
+                            "相关函数：:doc:`../s/sum2`",
+                            "",
+                            ".. meta::   ",
+                            "   :keywords: sum"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "msumTopN": {
         "title": "msumTopN",
         "type": "function",
@@ -56563,6 +58240,101 @@
             }
         ]
     },
+    "nextState": {
+        "title": "nextState",
+        "type": "function",
+        "children": [
+            {
+                "title": "语法",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "nextState(X)"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "参数",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "`X` 时间类型，布尔类型或者数值型的向量/矩阵。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "详情",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "*X* 中连续且值相同的元素具有相同的状态，该函数返回与当前元素状态不同的后一个临近元素值。",
+                            "",
+                            "*X* 是向量时：",
+                            "",
+                            "* 若当前元素为空值，返回后项最邻近的一个非空值。",
+                            "* 若当前元素为非空值，寻找后项最邻近且状态不同的元素 N：",
+                            "  ",
+                            "   * 若 N 为非空值，则返回 N。",
+                            "   * 若 N 为空值，则返回 N 之后最邻近的一个非空值。",
+                            "  ",
+                            "* 若找不到符合上述条件的值，则返回空值。",
+                            "",
+                            "*X* 是矩阵时，则在矩阵每一列进行上述计算。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "例子",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ X = [1, 2.2, NULL, 2.2, 2.3, 1, 1.2]",
+                            "    $ next(X)",
+                            "    [2.2,,2.2,2.3,1,1.2,]",
+                            "    ",
+                            "    $ nextState(X)",
+                            "    [2.2,2.2,2.2,2.3,1,1.2,]",
+                            "",
+                            "    $ X = matrix([1.0, 1.1, 1.0, 0.9], [NULL, 1.3, 2.5, 5.5], [5.5, 4.2, 1.6, 1.8])",
+                            "    $ nextState(X)",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "+---+---+---+",
+                            "|#0 |#1 |#2 |",
+                            "+===+===+===+",
+                            "|1.1|1.3|4.2|",
+                            "+---+---+---+",
+                            "|1  |2.5|1.6|  ",
+                            "+---+---+---+            ",
+                            "|0.9|5.5|1.8|",
+                            "+---+---+---+",
+                            "|   |   |   |",
+                            "+---+---+---+",
+                            "",
+                            "相关函数： :doc:`../p/prevState`"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "norm": {
         "title": "norm",
         "type": "function",
@@ -57418,7 +59190,10 @@
                     {
                         "type": "text",
                         "value": [
-                            "`shared` 是一个布尔值变量。当它为false时，函数返回内存中变量的表；当它为true时，函数还会返回在其他会话共享的表。默认值为false。"
+                            "`shared` 布尔值，默认为 false。",
+                            "",
+                            "* false：返回当前会话中所有变量的信息；",
+                            "* true：返回当前会话中所有变量的信息以及所有会话共享的变量信息；"
                         ]
                     }
                 ]
@@ -57430,7 +59205,26 @@
                     {
                         "type": "text",
                         "value": [
-                            "返回内存中的变量的表。注意该函数不返回函数定义。我们应该用 :doc:`../d/defs` 检查函数定义。"
+                            "用于获取内存中缓存的各变量的内存占用情况等信息。返回一个表，它具有以下几列：",
+                            "",
+                            "* name: 变量名。",
+                            "* type: 变量的数据类型。",
+                            "* form: 变量的数据形式。",
+                            "* rows:",
+                            "",
+                            "    * 若 form 为向量/字典/集合，则返回所有元素（包含NULL）的个数",
+                            "    * 若 form 为矩阵/表，则返回它们的行数",
+                            "",
+                            "* columns:",
+                            "",
+                            "    * 若 form 为向量/字典/集合，则返回 1",
+                            "    * 若 form 为矩阵/表，则返回它们的列数",
+                            "",
+                            "* bytes: 变量占用的内存大小，单位为字节",
+                            "* shared: 是否为共享变量",
+                            "* extra: 分布式表的逻辑路径，格式为 \"dfs://dbName/tableName\"",
+                            "",
+                            "注意，该函数不返回函数定义。我们应该用 defs 检查函数定义，或通过 :doc:`../m/memSize` 查看函数定义的内存占用。"
                         ]
                     }
                 ]
@@ -57444,19 +59238,39 @@
                         "language": "console",
                         "value": [
                             "",
-                            "    $ objs();",
-                            ""
-                        ]
-                    },
-                    {
-                        "type": "text",
-                        "value": [
-                            "===== ====== ====== ===== ======== ====== ======= ======= ",
-                            "name  type   form   rows  columns  bytes  shared  extra",
-                            "===== ====== ====== ===== ======== ====== ======= ======= ",
-                            "t     BASIC  TABLE  10    4         618   0",
-                            "===== ====== ====== ===== ======== ====== ======= ======= ",
+                            "    //创建分布式数据库",
+                            "    $ if(existsDatabase(\"dfs://listdb\")){",
+                            "    $         dropDatabase(\"dfs://listdb\")",
+                            "    $ }",
+                            "    $ n=1000000",
+                            "    $ ticker = rand(`MSFT`GOOG`FB`ORCL`IBM,n);",
+                            "    $ ticker[0..5]",
+                            "    $ x=rand(1.0, n)",
+                            "    $ t=table(ticker, x)",
+                            "    $ db=database(directory=\"dfs://listdb\", partitionType=HASH, partitionScheme=[STRING, 5])",
+                            "    $ pt=db.createPartitionedTable(t, `pt, `ticker)",
+                            "    $ pt.append!(t)",
+                            "",
+                            "    // 共享内存表",
+                            "    $ 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);",
+                            "    $ share tmp as st",
+                            "",
+                            "    // 创建 set",
+                            "    $ s = set([1,2,3,4,5])",
+                            "",
+                            "    // 创建 dict",
+                            "    $ x=1 2 3",
+                            "    $ y=4.5 7.8 4.3",
+                            "    $ z=dict(x,y);",
+                            "",
+                            "    // 创建 matrix",
+                            "    $ m = matrix(1 2 3, 4 5 6)",
                             "",
+                            "    // 创建 pair",
+                            "    $ p = 1:2",
                             ""
                         ]
                     },
@@ -57465,21 +59279,33 @@
                         "language": "console",
                         "value": [
                             "",
-                            "    $ share t as st;",
-                            "    $ objs(true);",
+                            "    $ objs(true)",
                             ""
                         ]
                     },
                     {
                         "type": "text",
                         "value": [
-                            "+------+----------+------+------+----------+------+------+----------+",
-                            "| name |   type   | form | rows |columns   |bytes |shared|extra     |",
-                            "+======+==========+======+======+==========+======+======+==========+",
-                            "| t    |  BASIC   | TABLE|10    |    4     | 618  |   0  |          |",
-                            "+------+----------+------+------+----------+------+------+----------+",
-                            "| st   |  BASIC   | TABLE|10    |    4     | 618  |   1  |          |",
-                            "+------+----------+------+------+----------+------+------+----------+"
+                            "======= ======== ============ ========== ======= ========== ======= =================",
+                            "name    type     form         rows       columns bytes      shared    extra",
+                            "======= ======== ============ ========== ======= ========== ======= =================",
+                            "n       INT      SCALAR       1          1       16         false    ",
+                            "ticker  SYMBOL   VECTOR       1,000,000  1       4,000,000  false    ",
+                            "x       INT      VECTOR       3          1       12         false    ",
+                            "t       BASIC    TABLE        1,000,000  2       12,000,312 false    ",
+                            "db      HANDLE   SCALAR       1          1       24         false    ",
+                            "pt      ALIAS    TABLE        0          2       12,000,000 false    dfs://listdb/pt",
+                            "time    DATETIME VECTOR       40         1       160        false    ",
+                            "id      INT      VECTOR       40         1       160        false    ",
+                            "value   INT      VECTOR       40         1       160        false    ",
+                            "tmp     BASIC    TABLE        40         3       832        false    ",
+                            "s       INT      SET          5          1       28         false    ",
+                            "y       DOUBLE   VECTOR       3          1       24         false    ",
+                            "z       DOUBLE   DICTIONARY   3          1       199        false    ",
+                            "m       INT      MATRIX       3          2       24         false    ",
+                            "p       INT      PAIR         2          1       8          false    ",
+                            "st      BASIC    TABLE        40         3       832        true",
+                            "======= ======== ============ ========== ======= ========== ======= ================="
                         ]
                     }
                 ]
@@ -58137,7 +59963,7 @@
                             "",
                             "panel 函数同 :doc:`/SQLStatements/pivotBy` 语句类似，将数据表中的数据按照两个维度重新排列。两者的不同之处在于，SQL 中，exec... pivot by... 只能指定一个指标列，",
                             "生成一个矩阵，而 panel 函数可以指定一个或多个指标列，生成一个或多个矩阵。",
-                            "更多面板数据的处理，请参考 `DolphinDB教程：面板数据的处理 <https://gitee.com/dolphindb/Tutorials_CN/blob/master/panel_data.md>`_。"
+                            "更多面板数据的处理，请参考 `DolphinDB教程：面板数据的处理 <https://gitee.com/dolphindb/Tutorials_CN/blob/master/%E5%BA%94%E7%94%A8%E5%9C%BA%E6%99%AF%E7%A4%BA%E4%BE%8B/panel_data.md>`_。"
                         ]
                     }
                 ]
@@ -60177,6 +62003,102 @@
             }
         ]
     },
+    "prevState": {
+        "title": "prevState",
+        "type": "function",
+        "children": [
+            {
+                "title": "语法",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "prevState(X)"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "参数",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "`X` 时间类型，布尔类型或者数值型的向量/矩阵。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "详情",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "*X* 中连续且值相同的元素具有相同的状态，该函数返回与当前元素状态不同的前一个临近元素值。",
+                            "",
+                            "*X* 是向量时：",
+                            "",
+                            "* 若当前元素为空值，返回前项最邻近的一个非空值。",
+                            "* 若当前元素为非空值，寻找前项最邻近且状态不同的元素 P：",
+                            "  ",
+                            "   * 若 P 为非空值，则返回 P。",
+                            "   * 若 P 为空值，则返回 P 之前最邻近的一个非空值。",
+                            "  ",
+                            "* 若找不到符合上述条件的值，则返回空值。",
+                            "",
+                            "*X* 是矩阵时，则在矩阵每一列进行上述计算。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "例子",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ X = [1, 2.2, NULL, 2.2, 2.3, 1, 1.2]",
+                            "    $ prev(X)",
+                            "    [,1,2.2,,2.2,2.3,1]",
+                            "    ",
+                            "    $ prevState(X)",
+                            "    [,1,2.2,2.2,2.2,2.3,1]",
+                            "",
+                            "    $ X = matrix([1.0, 1.1, 1.0, 0.9], [NULL, 1.3, 2.5, 5.5], [5.5, 4.2, 1.6, 1.8])",
+                            "    $ prevState(X)",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "+---+---+---+",
+                            "|#0 |#1 |#2 |",
+                            "+===+===+===+",
+                            "|   |   |   |",
+                            "+---+---+---+",
+                            "|1  |   |5.5|",
+                            "+---+---+---+",
+                            "|1.1|1.3|4.2|",
+                            "+---+---+---+",
+                            "|1  |2.5|1.6|",
+                            "+---+---+---+  ",
+                            "",
+                            "",
+                            "相关函数： :doc:`../n/nextState`"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "print": {
         "title": "print",
         "type": "command",
@@ -62867,7 +64789,8 @@
                 ]
             },
             {
-                "title": " 参数 ",
+                "title": "参数",
+                "type": "parameters",
                 "children": [
                     {
                         "type": "text",
@@ -62900,6 +64823,7 @@
                             "* 如果指定了 *groupNum*，则将排序后的 *X* 分成 *groupNum* 个组。返回 *X* 中每个元素对应的组编号（从0开始编号）。",
                             "",
                             "    请注意：",
+                            "    ",
                             "    * 若 *X* 不能被均分，多余元素优先存入编号较小的组内。",
                             "    * 若 *X* 中相同元素分别属于不同的组，则所有相同元素返回最小的组号。",
                             "* 如果 *ignoreNA* = true，则 NULL 值不参与排序，结果中 NULL 值的排名为空。",
@@ -66180,50 +68104,59 @@
                             "",
                             "",
                             "例3. 异构回放",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "  $ n=1000",
+                            "  $ sym = take(take(`IBM,n).join(take(`GS,n)), n)",
+                            "  $ myDate=take(2021.01.02..2021.01.06, n).sort!()",
+                            "  $ myTime=take(09:30:00..15:59:59,n)",
+                            "  $ vol = rand(100, n)",
+                            "  $ t=table(sym,myDate,myTime,vol)",
                             "",
-                            ".. code-block:: console",
-                            "   :emphasize-lines: 40",
-                            "",
-                            "    $ n=1000",
-                            "    $ sym = take(take(`IBM,n).join(take(`GS,n)), n)",
-                            "    $ myDate=take(2021.01.02..2021.01.06, n).sort!()",
-                            "    $ myTime=take(09:30:00..15:59:59,n)",
-                            "    $ vol = rand(100, n)",
-                            "    $ t=table(sym,myDate,myTime,vol)",
-                            "",
-                            "",
-                            "    $ n=1000",
-                            "    $ sym = take(take(`IBM,n).join(take(`GS,n)), n)",
-                            "    $ date=take(2021.01.02..2021.01.06, n).sort!()",
-                            "    $ time=take(09:30:00..15:59:59,n)",
-                            "    $ vol = rand(100, n)",
-                            "    $ t1=table(sym, date,time,vol)",
                             "",
-                            "    $ if(existsDatabase(\"dfs://test_stock\")){",
-                            "      dropDatabase(\"dfs://test_stock\")",
-                            "    }",
-                            "    $ db1=database(\"\",RANGE, 2021.01.01..2021.01.12)",
-                            "    $ db2=database(\"\",VALUE,`IBM`GS)",
-                            "    $ db=database(\"dfs://test_stock\",COMPO,[db1, db2])",
-                            "    $ trades=db.createPartitionedTable(t,`trades,`myDate`sym)",
-                            "    $ trades.append!(t);",
-                            "    $ trades1=db.createPartitionedTable(t1,`trades1,`date`sym)",
-                            "    $ trades1.append!(t1);",
+                            "  $ n=1000",
+                            "  $ sym = take(take(`IBM,n).join(take(`GS,n)), n)",
+                            "  $ date=take(2021.01.02..2021.01.06, n).sort!()",
+                            "  $ time=take(09:30:00..15:59:59,n)",
+                            "  $ vol = rand(100, n)",
+                            "  $ t1=table(sym, date,time,vol)",
+                            "",
+                            "  $ if(existsDatabase(\"dfs://test_stock\")){",
+                            "  $    dropDatabase(\"dfs://test_stock\")",
+                            "  $  }",
+                            "  $ db1=database(\"\",RANGE, 2021.01.01..2021.01.12)",
+                            "  $ db2=database(\"\",VALUE,`IBM`GS)",
+                            "  $ db=database(\"dfs://test_stock\",COMPO,[db1, db2])",
+                            "  $ trades=db.createPartitionedTable(t,`trades,`myDate`sym)",
+                            "  $ trades.append!(t);",
+                            "  $ trades1=db.createPartitionedTable(t1,`trades1,`date`sym)",
+                            "  $ trades1.append!(t1);",
                             "",
-                            "    //获取数据源",
+                            "  //获取数据源",
                             "",
-                            "    $ ds = replayDS(sqlObj=<select * from loadTable(db, `trades)>, dateColumn=`myDate, timeColumn=`myTime)",
-                            "    $ ds.size();",
+                            "  $ ds = replayDS(sqlObj=<select * from loadTable(db, `trades)>, dateColumn=`myDate, timeColumn=`myTime)",
+                            "  $ ds.size();",
                             "",
-                            "    $ ds1 = replayDS(sqlObj=<select * from loadTable(db, `trades1)>, dateColumn=`date, timeColumn=`time)",
-                            "    $ ds1.size();",
+                            "  $ ds1 = replayDS(sqlObj=<select * from loadTable(db, `trades1)>, dateColumn=`date, timeColumn=`time)",
+                            "  $ ds1.size();",
                             "",
-                            "    $ input_dict  = dict([\"msg1\", \"msg2\"], [ds, ds1])",
-                            "    $ date_dict = dict([\"msg1\", \"msg2\"], [`myDate, `date])",
-                            "    $ time_dict = dict([\"msg1\", \"msg2\"], [`myTime, `time])",
-                            "    $ opt = streamTable(100:0,`timestamp`sym`blob`vol, [DATETIME,SYMBOL, BLOB, INT])",
-                            "    $ replay(inputTables=input_dict, outputTables=opt, dateColumn = date_dict, timeColumn=time_dict,  replayRate=1000, absoluteRate=false);",
-                            "    $ select top 10 * from opt;"
+                            "  $ input_dict  = dict([\"msg1\", \"msg2\"], [ds, ds1])",
+                            "  $ date_dict = dict([\"msg1\", \"msg2\"], [`myDate, `date])",
+                            "  $ time_dict = dict([\"msg1\", \"msg2\"], [`myTime, `time])",
+                            "  $ opt = streamTable(100:0,`timestamp`sym`blob`vol, [DATETIME,SYMBOL, BLOB, INT])",
+                            "  $ replay(inputTables=input_dict, outputTables=opt, dateColumn = date_dict, timeColumn=time_dict,  replayRate=1000, absoluteRate=false);",
+                            "  $ select top 10 * from opt;"
                         ]
                     }
                 ]
@@ -66466,11 +68399,13 @@
                             "\"Q\"           quarterEnd",
                             "\"QS\"          quarterBegin",
                             "\"BQ\"          businessQuarterEnd",
-                            "\"BQS\"         businessQuarterBegin",
+                            "\"BQS\"         businessQuarterBegin       ",
+                            "\"REQ\"         FY5253Quarter",
                             "\"A\"           yearEnd",
                             "\"AS\"          yearBegin",
                             "\"BA\"          businessYearEnd",
                             "\"BAS\"         businessYearBegin",
+                            "\"RE\"          FY5253 ",
                             "\"D\"           date",
                             "\"H\"           hourOfDay",
                             "\"U\"           microsecond",
@@ -66790,7 +68725,14 @@
                         "language": "console",
                         "value": [
                             "",
-                            "    $ resetRecoveryWorkerNum(2)"
+                            "    $ resetRecoveryWorkerNum(2)",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "相关函数：:doc:`/FunctionsandCommands/FunctionReferences/g/getRecoveryWorkerNum`"
                         ]
                     }
                 ]
@@ -67045,6 +68987,9 @@
                             "`partition` 是字符串，表示要恢复的分区的相对路径。分区路径可以包含通配符(\"%\"和\"?\"), \"?\"表示单个字符，\"%\"表示0，1或多个字符。",
                             "",
                             "* 若仅备份某个分区，输入分区的相对路径或者\"%/\"+”分区名称”。举例：要恢复\"dfs://compoDB\"下的分区”20170810/50_100”,输入\"/compoDB/20170807/0_50\"或者\"%/20170807/0_50\"。",
+                            "  ",
+                            "  请注意：若使用 1.30.16/2.00.4 ~ 1.30.18/2.00.6 版本 server，对表级分区数据进行备份和恢复时，该参数必须指定路径到物理索引（可通过函数 :doc:`/FunctionsandCommands/FunctionReferences/l/listTables` 获取），例如分区 \"/compoDB/20170807/0_50\" 下表的物理索引为8，则 partition 需指定为 \"/compoDB/20170807/0_50/8\"。",
+                            "  ",
                             "* 若需要备份所有分区，直接输入\"%\"。",
                             "",
                             "`force` 是布尔值，表示是否强制恢复。默认值为false，表示只有元数据与备份数据元数据不一致的分区，才会恢复。",
@@ -67186,6 +69131,86 @@
             }
         ]
     },
+    "restoreDislocatedTablet": {
+        "title": "restoreDislocatedTablet",
+        "type": "function",
+        "children": [
+            {
+                "title": "语法",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "restoreDislocatedTablet()"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "参数",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "无"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "详情",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "当配置分区粒度为表级分区时（详见 :doc:`/DatabaseandDistributedComputing/Configuration/StandaloneMode` *enableChunkGranularityConfig* 参数），同一个分区的所有表将分布在相同的节点下。当调用函数 :doc:`/FunctionsandCommands/FunctionReferences/r/rebalanceChunksAmongDataNodes` 进行数据平衡时，若出现节点宕机或离线，可能出现同一个分区里部分表的数据转移成功，部分表的数据转移失败的情况，即同一个分区下的不同表会分布在不同的节点。该函数可以修复此问题，将同一个分区里的表转移到同一个节点下。",
+                            "",
+                            "返回一个表，包含以下列：",
+                            "",
+                            "================== =================================================",
+                            "列名                含义",
+                            "================== =================================================",
+                            "chunkId               chunk 的唯一标识",
+                            "srcNode               源节点的别名",
+                            "destNode            目标节点的别名",
+                            "================== =================================================",
+                            "",
+                            "调用该函数后，可以在进行数据平衡的数据节点上执行 :doc:`/FunctionsandCommands/FunctionReferences/g/getRecoveryTaskStatus`  查看任务执行的状态。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "例子",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ restoreDislocatedTablet()",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "==================================== ======= ========",
+                            "ChunkId                              srcNode destNode",
+                            "==================================== ======= ========",
+                            "99279094-ca12-3b87-48b6-520cbb986f39 node1   node2",
+                            "45f612b8-42f5-aebd-4cef-e522b6ae1fc8 node1   node2\t",
+                            "==================================== ======= ========"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "resumeRecovery": {
         "title": "resumeRecovery",
         "type": "command",
@@ -68293,6 +70318,80 @@
             }
         ]
     },
+    "rowAt": {
+        "title": "rowAt",
+        "type": "function",
+        "children": [
+            {
+                "title": "语法",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "rowAt(X, Y)",
+                            "",
+                            "row 系列函数通用参数说明和计算规则请参考: :doc:`/FunctionsandCommands/SeriesOfFunctions/rowFunctions`"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "详情",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "以 *Y* 的元素为 *X* 每行的列索引，逐行取出 *X* 中对应索引的元素，返回一个长度与输入参数行数相同的向量。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "例子",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ m = matrix(3.1 4.5 2.2, 4.2 4.3 5.1, 6.2 7.1 2.2, 1.8 6.1 5.3, 7.1 8.4 3.5)",
+                            "    $ index = 4 0 2",
+                            "    $ rowAt(m, index)",
+                            "    [7.1,4.5,2.2]",
+                            "",
+                            "    $ trades = table(10:0,`time`sym`p1`p2`p3`p4`p5`vol1`vol2`vol3`vol4`vol5,[TIMESTAMP,SYMBOL,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,INT,INT,INT,INT,INT])",
+                            "    $ insert into trades values(2022.01.01T09:00:00, `A, 33.2, 33.8, 33.6, 33.3, 33.1, 200, 180, 180, 220, 200)",
+                            "    $ insert into trades values(2022.01.01T09:00:00, `A, 33.1, 32.8, 33.2, 34.3, 32.3, 150, 280, 190, 100, 220)",
+                            "    $ insert into trades values(2022.01.01T09:00:00, `A, 31.2, 32.6, 33.6, 35.3, 34.5, 220, 160, 130, 100, 110)",
+                            "    $ insert into trades values(2022.01.01T09:00:00, `A, 30.2, 32.5, 33.6, 35.3, 34.1, 200, 180, 150, 140, 120)",
+                            "    $ insert into trades values(2022.01.01T09:00:00, `A, 33.2, 33.8, 33.6, 33.3, 33.1, 180, 160, 160, 180, 200)",
+                            "    $ select rowAt(matrix(p1, p2, p3, p4, p5), rowImin(vol1, vol2, vol3, vol4, vol5)) as price1, rowAt(matrix(p1, p2, p3, p4, p5), rowImax(vol1, vol2, vol3, vol4, vol5)) as price2 from trades",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "====== =======",
+                            "price1\tprice2",
+                            "====== =======",
+                            "33.8\t33.3",
+                            "34.3\t32.8",
+                            "35.3\t31.2",
+                            "34.1\t30.2",
+                            "33.8\t33.1",
+                            "====== =======",
+                            "",
+                            "相关函数: :doc:`../a/at`"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "rowAvg": {
         "title": "rowAvg",
         "type": "function",
@@ -68797,6 +70896,171 @@
             }
         ]
     },
+    "rowImax": {
+        "title": "rowImax",
+        "type": "function",
+        "children": [
+            {
+                "title": "语法",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "rowImax(args...)",
+                            "",
+                            "row 系列函数通用参数说明和计算规则请参考: :doc:`/FunctionsandCommands/SeriesOfFunctions/rowFunctions`",
+                            ""
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "详情",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "返回每行元素中最大元素的索引。如果有多个相同的最大值，返回左起第一个最大值的索引。结果为一个长度与输入参数行数相同的向量。",
+                            ""
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "例子",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ m=matrix([4.5 2.6 1.5 3.2, 1.5 4.8 5.9 1.7, 4.9 2.0 NULL 5.5])",
+                            "    $ print rowImax(m)",
+                            "    [2,1,1,2]",
+                            "",
+                            "    $ trades = table(10:0,`time`sym`p1`p2`p3`p4`p5`vol1`vol2`vol3`vol4`vol5,[TIMESTAMP,SYMBOL,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,INT,INT,INT,INT,INT])",
+                            "    $ insert into trades values(2022.01.01T09:00:00, `A, 33.2, 33.8, 33.6, 33.3, 33.1, 200, 180, 180, 220, 200)",
+                            "    $ insert into trades values(2022.01.01T09:00:00, `A, 33.1, 32.8, 33.2, 34.3, 32.3, 150, 280, 190, 100, 220)",
+                            "    $ insert into trades values(2022.01.01T09:00:00, `A, 31.2, 32.6, 33.6, 35.3, 34.5, 220, 160, 130, 100, 110)",
+                            "    $ insert into trades values(2022.01.01T09:00:00, `A, 30.2, 32.5, 33.6, 35.3, 34.1, 200, 180, 150, 140, 120)",
+                            "    $ insert into trades values(2022.01.01T09:00:00, `A, 33.2, 33.8, 33.6, 33.3, 33.1, 180, 160, 160, 180, 200)",
+                            "    $ select rowAt(matrix(p1, p2, p3, p4, p5), rowImin(vol1, vol2, vol3, vol4, vol5)) as price from trades",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "+-----+",
+                            "|price|",
+                            "+=====+",
+                            "|33.3 |",
+                            "+-----+",
+                            "|32.8 |",
+                            "+-----+",
+                            "|31.2 |",
+                            "+-----+",
+                            "|30.2 |",
+                            "+-----+",
+                            "|33.1 |",
+                            "+-----+",
+                            "",
+                            "相关函数：:doc:`../i/imax`",
+                            "",
+                            ".. meta::   ",
+                            "   :keywords: row"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
+    "rowImin": {
+        "title": "rowImin",
+        "type": "function",
+        "children": [
+            {
+                "title": "语法",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "rowImin(args...)",
+                            "",
+                            "row 系列函数通用参数说明和计算规则请参考: :doc:`/FunctionsandCommands/SeriesOfFunctions/rowFunctions`",
+                            ""
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "详情",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "返回每行元素中最小元素的索引。如果有多个相同的最小值，返回左起第一个最小值的索引。结果为一个长度与输入参数行数相同的向量。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "例子",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ m=matrix([4.5 2.6 1.5 3.2, 1.5 4.8 5.9 1.7, 4.9 2.0 NULL 5.5])",
+                            "    $ rowImin(m)",
+                            "    [1,2,0,1]",
+                            "    ",
+                            "    ",
+                            "    $ trades = table(10:0,`time`sym`p1`p2`p3`p4`p5`vol1`vol2`vol3`vol4`vol5,[TIMESTAMP,SYMBOL,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,INT,INT,INT,INT,INT])",
+                            "    $ insert into trades values(2022.01.01T09:00:00, `A, 33.2, 33.8, 33.6, 33.3, 33.1, 200, 180, 180, 220, 200)",
+                            "    $ insert into trades values(2022.01.01T09:00:00, `A, 33.1, 32.8, 33.2, 34.3, 32.3, 150, 280, 190, 100, 220)",
+                            "    $ insert into trades values(2022.01.01T09:00:00, `A, 31.2, 32.6, 33.6, 35.3, 34.5, 220, 160, 130, 100, 110)",
+                            "    $ insert into trades values(2022.01.01T09:00:00, `A, 30.2, 32.5, 33.6, 35.3, 34.1, 200, 180, 150, 140, 120)",
+                            "    $ insert into trades values(2022.01.01T09:00:00, `A, 33.2, 33.8, 33.6, 33.3, 33.1, 180, 160, 160, 180, 200)",
+                            "",
+                            "    $ select rowAt(matrix(p1, p2, p3, p4, p5), rowImin(vol1, vol2, vol3, vol4, vol5)) as price from trades",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "+-----+",
+                            "|price|",
+                            "+=====+",
+                            "|33.8 |",
+                            "+-----+",
+                            "|34.3 |",
+                            "+-----+",
+                            "|35.3 |",
+                            "+-----+",
+                            "|34.1 |",
+                            "+-----+",
+                            "|33.8 |",
+                            "+-----+",
+                            "",
+                            "相关函数：:doc:`../i/imin`",
+                            "",
+                            ".. meta::   ",
+                            "   :keywords: row"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "rowKurtosis": {
         "title": "rowKurtosis",
         "type": "function",
@@ -73782,6 +76046,48 @@
             }
         ]
     },
+    "setLogLevel": {
+        "title": "setLogLevel",
+        "type": "command",
+        "children": [
+            {
+                "title": "语法",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "setLogLevel(logLevel)"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "参数",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "`logLevel` 日志等级，从低到高可选值为：DEBUG, INFO, WARNING, ERROR。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "详情",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "在线设置当前节点的日志文件的等级。设置后，系统只打印当前 logLevel 及以上级别的日志。该命令只能由管理员调用。"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "setMaxBlockSizeForReservedMemory": {
         "title": "setMaxBlockSizeForReservedMemory",
         "type": "command",
@@ -74030,6 +76336,94 @@
             }
         ]
     },
+    "setMemLimitOfQueryResult": {
+        "title": "setMemLimitOfQueryResult",
+        "type": "command",
+        "children": [
+            {
+                "title": "语法",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "setMemLimitOfQueryResult(memLimit)"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "参数",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "`memLimit` 数值类型标量，表示内存上限，单位为 GB。该值必须小于 80% * maxMemSize。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "详情",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "在线修改单次查询结果占用的最大内存上限。该命令只能由管理员在数据节点/计算节点执行。",
+                            "",
+                            "相关函数： :doc:`/FunctionsandCommands/FunctionReferences/g/getMemLimitOfTaskGroupResult`"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
+    "setMemLimitOfTaskGroupResult": {
+        "title": "setMemLimitOfTaskGroupResult",
+        "type": "command",
+        "children": [
+            {
+                "title": "语法",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "setMemLimitOfTaskGroupResult(memLimit)"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "参数",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "`memLimit` 数值类型标量，表示内存上限。单位为 GB。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "详情",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "在线修改当前节点发送的批量子查询占用的内存上限。该命令只能由管理员在数据节点/计算节点执行。",
+                            "",
+                            "相关函数： :doc:`/FunctionsandCommands/FunctionReferences/g/getMemLimitOfQueryResult`"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "setRaftElectionTick": {
         "title": "setRaftElectionTick",
         "type": "command",
@@ -78869,7 +81263,7 @@
                             "* 'condition'：表示过滤条件。",
                             "",
                             "  * 若分发异构流表，则 'condition' 是一个字符串，且必须是 replay 参数 *inputTables* 的键值（表的标识）。用于过滤出异构表中具有 *condition* 标识的数据。",
-                            "  * 若分发普通流表，则 'condition'  是一个字符串标量或向量，且必须是 `conditionColumn` 指定列的元素。用于过滤出表 *conditionColumn* 列中满足 *condition* 的数据。",
+                            "  * 若分发普通流表，则 'condition'  可以是一个表示列名的字符串标量或/向量，或者是包含一个或多个布尔表达式的元代码，且表达式中不能调用函数。请注意，若 'condition' 指定为字符串标量/向量，必须为 *conditionColumn* 指定列的元素。",
                             "",
                             "* 'handler'：一元函数或表对象（包括流数据引擎返回的表对象）。",
                             "",
@@ -79019,11 +81413,11 @@
                         "type": "text",
                         "value": [
                             "  $ n=20",
-                            "  $ sym = symbol(rand(`A`B`C,n))",
+                            "  $ sym = symbol(take(`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)",
+                            "  $ vol = 100+take(1..8,20)",
                             "  $ t = table(date,time,sym,name,vol)",
                             "",
                             "  //定义两个流数据引擎，作为分发引擎 handler",
@@ -79036,11 +81430,11 @@
                             "  $ 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的数据输入状态引擎进行处理",
+                            "  //设置第一个过滤条件，将 trades 表中 sym 列对应元素为 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",
@@ -79078,14 +81472,17 @@
                             "============ ===== ========",
                             "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",
+                            "09:30:00.003   A   101",
+                            "09:30:00.003   C   103",
+                            "09:30:00.006   A   104",
+                            "09:30:00.006   C   106",
+                            "09:30:00.009   A   107",
+                            "09:30:00.009   C   101",
+                            "09:30:00.012   A   102",
+                            "09:30:00.012   C   104",
+                            "09:30:00.015   A   105",
+                            "09:30:00.015   C   107",
+                            "09:30:00.018   A   108",
                             "============ ===== ========",
                             ""
                         ]
@@ -79109,10 +81506,65 @@
                             "+-------------+--------+",
                             "|00:00:00.001 |        |",
                             "+-------------+--------+",
-                            "|00:00:00.001 | 41     |",
+                            "|00:00:00.001 | 104    |",
+                            "+-------------+--------+",
+                            "|00:00:00.001 | 104    |",
                             "+-------------+--------+",
-                            "|00:00:00.001 | 33     |",
-                            "+-------------+--------+"
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "  $ select * from st2",
+                            "",
+                            "============ ============= === ==== ====",
+                            "date         time          sym name vol",
+                            "============ ============= === ==== ====",
+                            "2012.12.08   09:30:00.002   C   6   103",
+                            "2012.12.09   09:30:00.003   A   8   104",
+                            "2012.12.10   09:30:00.004   B   10  105",
+                            "2012.12.11   09:30:00.005   C   10  106",
+                            "2012.12.12   09:30:00.006   A   10  107",
+                            "2012.12.13   09:30:00.007   B   1   108",
+                            "2012.12.14   09:30:00.008   C   3   101",
+                            "2012.12.15   09:30:00.009   A   4   102",
+                            "2012.12.16   09:30:00.010   B   9   103",
+                            "============ ============= === ==== ====",
+                            "",
+                            "可以为 condition 指定表达式，以支持更复杂的过滤逻辑，将上例中 filter2 的 *condition* 指定为条件表达式，同时对 vol 和 date 列进行过滤。",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "  $ filter2 = dict(STRING,ANY)",
+                            "  $ filter2['condition'] = <sym==`A and 101<vol<105 and date<2012.12.15>",
+                            "  $ filter2['handler'] = st2",
+                            "  $ filter2['timeRange'] = 09:30:00.002:09:30:00.010",
+                            "  ",
+                            "  $ select * from st2",
+                            "",
+                            "=========== ============ === ==== ====",
+                            "date        time         sym name\tvol",
+                            "=========== ============ === ==== ====",
+                            "2012.12.09  09:30:00.003  A  7    104",
+                            "=========== ============ === ==== ===="
                         ]
                     }
                 ]
@@ -79198,6 +81650,88 @@
             }
         ]
     },
+    "stretch": {
+        "title": "stretch",
+        "type": "function",
+        "children": [
+            {
+                "title": "语法",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "stretch(X, n)"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "参数",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "`X` 向量/元组。",
+                            "",
+                            "`n` 非负整数。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "详情",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "将 *X* 均匀拉伸为长度为 n 的向量。",
+                            "",
+                            "该函数与 :doc:`../t/take` 的区别为：",
+                            "",
+                            "* take 是对向量整体进行循环拼接，而 stretch 则是对向量的每一个元素进行复制达到拉伸的效果。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "例子",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ X = 1 NULL 2 3",
+                            "    $ print stretch(X, 11)",
+                            "    [1,1,1,,,,2,2,3,3]",
+                            "",
+                            "    $ print stretch(X, 11)",
+                            "    [1,1,1,,,,2,2,2,3,3]",
+                            "",
+                            "    $ print stretch(X, 12)",
+                            "    [1,1,1,,,,2,2,2,3,3,3]",
+                            "",
+                            "    $ print take(X, 10)",
+                            "    [1,,2,3,1,,2,3,1,]",
+                            "",
+                            "",
+                            "",
+                            "",
+                            "",
+                            "",
+                            "",
+                            "",
+                            ""
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "string": {
         "title": "string",
         "type": "function",
@@ -85972,6 +88506,68 @@
             }
         ]
     },
+    "tmsum2": {
+        "title": "tmsum2",
+        "type": "function",
+        "children": [
+            {
+                "title": "语法",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "tmsum2(T, X, window)",
+                            "",
+                            "参数说明和窗口计算规则请参考: :doc:`/FunctionsandCommands/SeriesOfFunctions/tmFunctions`"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "详情",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "在给定长度（以时间 *T* 衡量）的滑动窗口内计算 *X* 元素的平方和。请注意，该函数的返回值是 DOUBLE 类型。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "例子",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ tmsum2(1 1 3 5 8 15 15 20, 5 2 4 1 2 8 9 10, 3)",
+                            "    [25,29,45,17,4,64,145,100]",
+                            "",
+                            "    $ index = take(datehour(2019.06.13 13:30:10),4) join (datehour(2019.06.13 13:30:10)+1..6)",
+                            "    $ data = 1 NULL 3 4 5 NULL 3 NULL 5 3",
+                            "    $ tmsum2(index, data, 4h)",
+                            "    [1,1,10,26,51,51,60,34,34,43]",
+                            "",
+                            "    $ tmsum2(index, data, 1d)",
+                            "    [1,1,10,26,51,51,60,60,85,94]",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "相关函数：:doc:`../m/msum2`, :doc:`../s/sum2`"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "tmvar": {
         "title": "tmvar",
         "type": "function",
@@ -86871,6 +89467,117 @@
             }
         ]
     },
+    "topRange": {
+        "title": "topRange",
+        "type": "function",
+        "children": [
+            {
+                "title": "语法",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "topRange(X)"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "参数",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "`X` 向量/元组/矩阵/表。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "详情",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "对于 *X* 中的每个元素 *Xi*，统计 *Xi* 左侧相邻且连续大于它的元素个数。",
+                            "",
+                            "该函数常用于统计一个序列的当前值是前多少周期（日或分钟等）内的最大值。例如某只股票创几日新高等。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "例子",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ topRange([13.5, 13.6, 13.4, 13.3, 13.5, 13.9, 13.1, 20.1, 20.2, 20.3])",
+                            "    [0,1,0,0,2,5,0,7,8,9]",
+                            "",
+                            "    $ m = matrix(1.5 2.6 3.2 1.4 2.5 2.2 3.7 2.0, 1.6 2.3 4.2 5.6 4.1 3.2 4.4 6.9)",
+                            "    $ topRange(m)",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "== ==",
+                            "#0 #1",
+                            "== ==",
+                            "0  0 ",
+                            "1  1 ",
+                            "2  2 ",
+                            "0  3 ",
+                            "1  0 ",
+                            "0  0 ",
+                            "6  2 ",
+                            "0  7 ",
+                            "== ==",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    //模拟股票 A 8天的股价,使用 topRange 计算股票 A 每日股价创几日新高",
+                            "    $ trades = table(take(`A, 8) as sym,  2022.01.01 + 1..8 as date, 39.70 39.72 39.80 39.78 39.83 39.92 40.00 40.03 as price)",
+                            "    $ select *, topRange(price) from trades",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "=== ========== ======== ===============",
+                            "id  date        price   topRange_price",
+                            "=== ========== ======== ===============",
+                            "A   2022.01.02 39.7     0",
+                            "A   2022.01.03 39.72    1",
+                            "A   2022.01.04 39.8     2",
+                            "A   2022.01.05 39.78    0",
+                            "A   2022.01.06 39.83    4",
+                            "A   2022.01.07 39.92    5",
+                            "A   2022.01.08 40       6",
+                            "A   2022.01.09 40.03    7",
+                            "=== ========== ======== ===============",
+                            "",
+                            "相关函数：:doc:`../l/lowRange`"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "transDS!": {
         "title": "transDS!",
         "type": "function",
@@ -88061,7 +90768,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "从内存中释放变量和函数定义。另一种从内存中释放变量的做法是使用 \"= NULL\"。"
+                            "从内存中释放变量和函数定义。VAR（本地变量）亦可通过 \"= NULL\" 释放变量。"
                         ]
                     }
                 ]
@@ -89668,6 +92375,136 @@
             }
         ]
     },
+    "valueChanged": {
+        "title": "valueChanged",
+        "type": "function",
+        "children": [
+            {
+                "title": "语法",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "valueChanged(X, [mode=”prev“])"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "参数",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "`X` 字符串、布尔、时间或数值类型的向量/矩阵/表/元组。",
+                            "",
+                            "`mode` 字符串，可选值为：\"prev\", \"next\", \"any\" 和 \"all\"，默认值为 \"prev\"。",
+                            "",
+                            "* \"prev\": 前一个元素。",
+                            "* \"next\": 后一个元素。",
+                            "* \"any\": 前一个元素或后一个元素。",
+                            "* \"all\": 前一个元素和后一个元素值。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "详情",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "*X* 中每个元素较 *mode* 是否发生变化，若当前元素值发生变化，则返回 true，否则返回 false。若比较对象不存在，则返回 false。例如：valueChanged(X, [mode=”prev“]) 的第一个元素返回 false；valueChanged(X, [mode=”next“]) 的最后一个元素返回 false。",
+                            "",
+                            "若 *X* 为矩阵/表，在每列内进行上述操作，返回一个矩阵/表。"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "例子",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ x= 1 2 2 2 2 3 NULL 3 4 8",
+                            "    $ valueChanged(x)",
+                            "    [false,true,false,false,false,true,true,true,true,true]",
+                            "    ",
+                            "    $ valueChanged(x,\"next\")",
+                            "    [true,false,false,false,true,true,true,true,true,false]",
+                            "    ",
+                            "    $ valueChanged(x,\"any\")",
+                            "    [true,true,false,false,true,true,true,true,true,true]",
+                            "    ",
+                            "    $ valueChanged(x,\"all\")",
+                            "    [false,false,false,false,false,true,true,true,true,false]",
+                            "",
+                            "    $ tup=(1 2 3, `A`A`B`C, 2021.10.12+1 2 2)",
+                            "    $ valueChanged(tup)",
+                            "    ([false,true,true],[false,false,true,true],[false,true,false])",
+                            "",
+                            "    $ m=matrix(1 2 3, 1 2 3, 1 3 3)",
+                            "    $ valueChanged(m)",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "====== ======= =======",
+                            "col1\tcol2\tcol3",
+                            "====== ======= =======",
+                            "false\tfalse\tfalse",
+                            "true\ttrue\ttrue",
+                            "true\ttrue\tfalse",
+                            "====== ======= =======",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ id= 1 2 2 2 2 3 3 4 8",
+                            "    $ sym=`A + string(1 2 2 2 2 3 3 4 8)",
+                            "    $ val=83.8 92.8 8.1 61.4 40.7 67.2 15.2 20.6 96.5",
+                            "    $ t=table(id, sym, val)",
+                            "    $ valueChanged(t)",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "======= ====== =======",
+                            "id      sym    val",
+                            "======= ====== =======",
+                            "false\tfalse\tfalse",
+                            "true\ttrue\ttrue",
+                            "false\tfalse\ttrue",
+                            "false\tfalse\ttrue",
+                            "false\tfalse\ttrue",
+                            "true\ttrue\ttrue",
+                            "false\tfalse\ttrue",
+                            "true\ttrue\ttrue",
+                            "true\ttrue\ttrue",
+                            "======= ====== =======",
+                            "",
+                            "相关函数：:doc:`../k/keys`"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "values": {
         "title": "values",
         "type": "function",