dolphindb 2.0.527 → 2.0.530

package/docs.en.json

@@ -704,6 +704,134 @@
             }
         ]
     },
+    "addAccessControl": {
+        "title": "addAccessControl",
+        "type": "command",
+        "children": [
+            {
+                "title": "Syntax",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "addAccessControl(table)"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Arguments",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "`table` is a shared table or a streaming engine."
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Details",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "The current user can add access control to the table created by herself. Other users can access this table only after the administrator grants the privilege.",
+                            "",
+                            "Please note:",
+                            "",
+                            "1. It can only be executed by the user who created the table or administrators.",
+                            "",
+                            "2. If the administrator has set access privileges to the table for other users by grant/deny/revoke, access control will be automatically added without calling addAccessControl. Users that are not granted privileges by the administrator cannot access the table."
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Examples",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "Create a user group for access management.",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ login(`admin, `123456)",
+                            "    $ createUser(`u1, \"111111\");",
+                            "    $ createUser(`u2, \"222222\");",
+                            "    $ createUser(`u3, \"333333\");",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "streaming engine",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    // user u1 create streaming engine agg1",
+                            "    $ login(`u1, \"111111\")",
+                            "    $ share streamTable(1000:0, `time`sym`volume, [TIMESTAMP, SYMBOL, INT]) as trades",
+                            "    $ output1 = table(10000:0, `time`sym`sumVolume, [TIMESTAMP, SYMBOL, INT])",
+                            "    $ agg1 = createTimeSeriesEngine(name=\"agg1\", windowSize=60000, step=60000, metrics=<[sum(volume)]>, dummyTable=trades, outputTable=output1, timeColumn=`time, useSystemTime=false, keyColumn=`sym, garbageSize=50, useWindowStartTime=false)",
+                            "    $ subscribeTable(tableName=\"trades\", actionName=\"agg1\", offset=0, handler=append!{agg1}, msgAsTable=true);",
+                            "    // add access control for agg1",
+                            "    $ addAccessControl(agg1)",
+                            "",
+                            "    // user u2 logs in",
+                            "    $ login(`u2, \"222222\")",
+                            "",
+                            "    // insert data",
+                            "    $ insert into trades values(2018.10.08T01:01:01.785,`A,10) // OK!",
+                            "    $ insert into agg1 values(2018.10.08T01:01:01.785,`A,10) // ERROR: No access to table [agg1]",
+                            "    ",
+                            "    // drop stream engine",
+                            "    $ dropStreamEngine(\"agg1\") // No access to drop stream engine agg1",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "shared in-memory table",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ login(`u1, \"111111\")",
+                            "    $ t = table(take(`a`b`c`, 10) as sym, 1..10 as val)",
+                            "    $ share t as st;",
+                            "    $ addAccessControl(`st)",
+                            "",
+                            "    $ login(`u3, \"333333\")",
+                            "    $ select * from st // ERROR: No access to shared table [st]",
+                            "    $ insert into st values(`a, 4) // ERROR: No access to shared table [st]"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "addColumn": {
         "title": "addColumn",
         "type": "command",
@@ -2194,7 +2322,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "`engine` is a streaming engine, which is the abstract table object returned by functions such as :doc:`../c/createAsofJoinEngine`. Currently, streaming asof join engine and streaming equal join engine are supported.",
+                            "`engine`  is a streaming join engine, which is the abstract table object returned by functions ``createAsofJoinEngine``, ``createEqualJoinEngine``, ``createWindowJoinEngine``, or ``createLookupJoinEngine``.",
                             "",
                             "`isLeftTable` is a Boolean value indicating whether to insert a left table or right table. ",
                             "",
@@ -2212,7 +2340,7 @@
                         "value": [
                             "Insert data into a streaming join engine.",
                             "",
-                            "Please note that the parameter *handler* of function :doc:`../s/subscribeTable` must be function ``appendForJoin`` while subscribing to a stream table for the streaming join engine."
+                            "Please note that the parameter *handler* of function :doc:`../s/subscribeTable` must be function ``appendForJoin``, :doc:`/FunctionsandCommands/FunctionReferences/g/getLeftStream` or :doc:`/FunctionsandCommands/FunctionReferences/g/getRightStream` while subscribing to a stream table for the streaming join engine."
                         ]
                     }
                 ]
@@ -3034,7 +3162,9 @@
                     {
                         "type": "text",
                         "value": [
-                            "Find the position of the element with the largest value in parameter *location*, and return the value of the element in the same position in parameter *value*.",
+                            "Find the position of the element with the largest value in parameter *location*, and return the value of the element in the same position in parameter *value*. If there are multiple identical maximums in *location*, return the position of the first maximum.",
+                            "",
+                            "If *location* and *value* are matrices, conduct the aforementioned calculation with each column of *location* and the corresponding column of *value*.",
                             "",
                             "atImax(location, value) = value[imax(location)]. "
                         ]
@@ -3103,7 +3233,9 @@
                     {
                         "type": "text",
                         "value": [
-                            "Find the position of the element with the smallest value in parameter *location*, and return the value of the element in the same position in parameter *value*.",
+                            "Find the position of the element with the smallest value in parameter *location*, and return the value of the element in the same position in parameter *value*. If there are multiple identical minimums in *location*, return the position of the first minimum.",
+                            "",
+                            "If *location* and *value* are matrices, conduct the aforementioned calculation with each column of *location* and the corresponding column of *value*.",
                             "",
                             "atImin(location, value) = value[imin(location)]. ",
                             ""
@@ -3550,7 +3682,9 @@
                     {
                         "type": "text",
                         "value": [
-                            "bar(X, Y)"
+                            "bar(X, interval, [closed='left'])",
+                            "",
+                            "Related function: :doc:`../d/dailyAlignedBar`"
                         ]
                     }
                 ]
@@ -3562,11 +3696,19 @@
                     {
                         "type": "text",
                         "value": [
-                            "`X` and `Y` is a scalar or a vector. If X and Y are both vectors, they must be of the same length.",
+                            "`X` is an integral/temporal scalar or vector.",
+                            "",
+                            "`interval` is an integral/DURATION type scalar greater than 0 or a vector of the same length as X.",
                             "",
-                            "If Y is a DURATION , the following units of time are supported: w, d, H, m, s, ms, us, ns.",
+                            "When *interval* is of type DURATION, the following time units are supported: w, d, H, m, s, ms, us, ns.",
                             "",
-                            "Note: As the units of time *M* and *y* are not supported by *duration*, to group *X* by month or year in your calculation, convert the data type of *X* with function :doc:/FunctionsandCommands/FunctionReferences/m/month or :doc:/FunctionsandCommands/FunctionReferences/y/year."
+                            "Note: As time units *y* and *M* are not supported in interval, to group X by year or month, convert the data format of X with function :doc:`/FunctionsandCommands/FunctionReferences/m/month` or :doc:`/FunctionsandCommands/FunctionReferences/y/year`. Specify the interval as an integer for calculation. You can refer to Example 2.",
+                            "",
+                            "`closed` is a string. This optional parameter can specified as 'left' or 'right', indicating whether an element of X that is divisible by interval is the left boundary (the first element of the group) or the right boundary(the last element of the group) of a group. The default value is 'left'.",
+                            "",
+                            "* *closed* = 'left': X-(X % interval), indicating that the value with a remainder of 0 is specified as the left boundary of a group.",
+                            "",
+                            "* *closed* = 'right': iif((X % interval) == 0, X, X + (interval-(X % interval))), indicating that the value with a remainder of 0 is specified as the right boundary of a group."
                         ]
                     }
                 ]
@@ -3578,7 +3720,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "Perform the calculation X-(X%Y). Return a vector with the same length as X."
+                            "``bar`` can group *X* based on the length specified by *interval*. Return a vector with the same length as X."
                         ]
                     }
                 ]
@@ -3643,7 +3785,137 @@
                             "======== ======",
                             "2018.01M 0.9868",
                             "2018.04M 0.9243",
-                            "======== ======"
+                            "======== ======",
+                            "",
+                            "The following example groups data by week and calculates the maximum values for each week. Depending on parameter *closed*, the results are different.",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ t=table(2022.01.01 + 1..20  as time, rand(100, 20) as x)",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "+------------+----+",
+                            "| time       | x  |",
+                            "+============+====+",
+                            "| 2022.01.02 | 6  |",
+                            "+------------+----+",
+                            "| 2022.01.03 | 29 |",
+                            "+------------+----+",
+                            "| 2022.01.04 | 71 |",
+                            "+------------+----+",
+                            "| 2022.01.05 | 56 |",
+                            "+------------+----+",
+                            "| 2022.01.06 | 93 |",
+                            "+------------+----+",
+                            "| 2022.01.07 | 34 |",
+                            "+------------+----+",
+                            "| 2022.01.08 | 77 |",
+                            "+------------+----+",
+                            "| 2022.01.09 | 18 |",
+                            "+------------+----+",
+                            "| 2022.01.10 | 62 |",
+                            "+------------+----+",
+                            "| 2022.01.11 | 33 |",
+                            "+------------+----+",
+                            "| 2022.01.12 | 34 |",
+                            "+------------+----+",
+                            "| 2022.01.13 | 64 |",
+                            "+------------+----+",
+                            "| 2022.01.14 | 80 |",
+                            "+------------+----+",
+                            "| 2022.01.15 | 63 |",
+                            "+------------+----+",
+                            "| 2022.01.16 | 17 |",
+                            "+------------+----+",
+                            "| 2022.01.17 | 66 |",
+                            "+------------+----+",
+                            "| 2022.01.18 | 85 |",
+                            "+------------+----+",
+                            "| 2022.01.19 | 27 |",
+                            "+------------+----+",
+                            "| 2022.01.20 | 77 |",
+                            "+------------+----+",
+                            "| 2022.01.21 | 27 |",
+                            "+------------+----+",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "    ",
+                            "    $ select max(x) from t group by bar(time, 7d);",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "+------------+-------+",
+                            "| bar_time   | max_x |",
+                            "+============+=======+",
+                            "| 2021.12.30 | 71    |",
+                            "+------------+-------+",
+                            "| 2022.01.06 | 93    |",
+                            "+------------+-------+",
+                            "| 2022.01.13 | 85    |",
+                            "+------------+-------+",
+                            "| 2022.01.20 | 77    |",
+                            "+------------+-------+",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ print  select max(x) from t group by bar(time, 7d, closed='right');",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "+------------+-------+",
+                            "| bar_time   | max_x |",
+                            "+============+=======+",
+                            "| 2021.01.06 | 93    |",
+                            "+------------+-------+",
+                            "| 2022.01.13 | 77    |",
+                            "+------------+-------+",
+                            "| 2022.01.20 | 85    |",
+                            "+------------+-------+",
+                            "| 2022.01.27 | 27    |",
+                            "+------------+-------+",
+                            "",
+                            "When calculating 1-minute OHLC bars, the data type needs to be converted to LONG if n needs to be converted to NANOTIMESTAMP, otherwise an integer overflow will occur.",
+                            "",
+                            ".. code-block:: console",
+                            "   :linenos:",
+                            "   :emphasize-lines: 9, 11",
+                            "   ",
+                            "   $ n = 1000000",
+                            "   $ nano = (09:30:00.000000000 + rand(long(6.5*60*60*1000000000), n)).sort!() ",
+                            "   $ price = 100+cumsum(rand(0.02, n)-0.01)",
+                            "   $ volume = rand(1000, n)",
+                            "   $ symbol = rand(`600519`000001`600000`601766, n)",
+                            "   $ tradeNano = table(symbol, nano, price, volume).sortBy!(`symbol`nano)",
+                            "   $ undef(`nano`price`volume`symbol)",
+                            "   $ barMinutes = 7",
+                            "   $ itv = barMinutes*60*long(1000000000)",
+                            "",
+                            "   $ OHLC_nano=select first(price) as open, max(price) as high, min(price) as low, last(price) as close, sum(volume) as volume from tradeNano group by symbol, bar(nano, itv) as barStart"
                         ]
                     }
                 ]
@@ -4338,6 +4610,67 @@
             }
         ]
     },
+    "bitNot": {
+        "title": "bitNot",
+        "type": "function",
+        "children": [
+            {
+                "title": "Syntax",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "bitNot(X)"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Arguments",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "`X` is a numeric scalar/vector/matrix/table."
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Details",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "Return the result of a bitwise logical NOT operation."
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Examples",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ bitNot(3)",
+                            "    -4",
+                            "",
+                            "    $ av = array(INT[], 0, 10).append!([1 2 3, 4 5])",
+                            "    $ bitNot(av)",
+                            "    [[-2,-3,-4],[-5,-6]]"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "bitOr": {
         "title": "bitOr",
         "type": "function",
@@ -7423,6 +7756,95 @@
             }
         ]
     },
+    "cells": {
+        "title": "cells",
+        "type": "function",
+        "children": [
+            {
+                "title": "Syntax",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "cells(obj, row, col)"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Arguments",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "`obj` is a matrix.",
+                            "",
+                            "`row` is a vector of integral type, indicating indices of rows. ",
+                            "",
+                            "`col` is a vector of integral type of the same length as row, indicating indices of columns."
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Details",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "Return a vector of cells in a matrix by the specified row and column index."
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Examples",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ m=(1..15).reshape(3:5)",
+                            "    $ m;",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "===== ===== ===== ===== =====",
+                            "col1  col2  col3  col4  col5",
+                            "===== ===== ===== ===== =====",
+                            "1     4     7     10    13",
+                            "2     5     8     11    14",
+                            "3     6     9     12    15",
+                            "===== ===== ===== ===== =====",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    // obtain the two elements at [0,1] and [0,2]",
+                            "    $ cells(m, 0 0, 1 2)",
+                            "    [4,7]",
+                            "    // obtain the elements on the diagonal of the matrix",
+                            "    $ index = 0..2",
+                            "    $ cells(m, v, v)",
+                            "    [1, 5, 9]"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "changePwd": {
         "title": "changePwd",
         "type": "command",
@@ -9390,6 +9812,111 @@
             }
         ]
     },
+    "concatMatrix": {
+        "title": "concatMatrix",
+        "type": "function",
+        "children": [
+            {
+                "title": "Syntax",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "concatMatrix(X, [horizontal=true]) "
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Arguments",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "`X` is a tuple of multiple matrices.",
+                            "",
+                            "`horizontal` is a boolean value indicating whether the matrices are contatenated horizontally. The default value is true. If it is false, the matrices are contatenated vertically."
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Details",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "Concatenate the matrices vertically or horizontally.",
+                            "",
+                            "When you concatenate matrices horizontally, they must have the same number of rows. When you concatenate them vertically, they must have the same number of columns. "
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Examples",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "  ",
+                            "   $ m1 = matrix(4 0 5, 2 1 8);",
+                            "   $ m2 = matrix(2 9 8, 3 7 -3, 6 4 2, 0 5 8);",
+                            "   $ m3 = matrix(1 -1 6 2, 1 -3 1 9, 5 3 0 -4, 1 NULL 3 4);",
+                            "   $ concatMatrix([m1, m2]);",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "==== ==== ==== ==== ==== ====",
+                            "col1 col2 col3 col4 col5 col6",
+                            "==== ==== ==== ==== ==== ====",
+                            "4    2    2    3    6    0",
+                            "0    1    9    7    4    5",
+                            "5    8    8    -3   2    8",
+                            "==== ==== ==== ==== ==== ====",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "   $ print concatMatrix([m2, m3], false);",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "==== ==== ==== ====",
+                            "col1 col2 col3 col4",
+                            "==== ==== ==== ====",
+                            "2    3    6    0",
+                            "9    7    4    5",
+                            "8    -3   2    8",
+                            "1    1    5    1",
+                            "-1   -3   3 ",
+                            "6    1    0    3",
+                            "2    9    4    4",
+                            "==== ==== ==== ====",
+                            "",
+                            ".. meta::   ",
+                            "   :keywords: concat"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "conditionalFilter": {
         "title": "conditionalFilter",
         "type": "function",
@@ -11044,9 +11571,13 @@
                             "",
                             "`outputTable` is a table object indicating the output table for the results. We need to set the output table as an empty table and specify the names and data types of the columns before using function createAsofJoinEngine. By default, the first two columns are the `timeColumn` and `matchingColumn` of the leftTable which do not need to be specified in metrics.",
                             "",
-                            "`metrics` is metacode specifying the calculation formulas. For more information about metacode please refer to :doc:/Objects/Metaprogramming. It can use one or more expressions, built-in or user-defined functions, but not aggregate functions.",
+                            "`metrics` is metacode specifying the calculation formulas. It can use one or more expressions, built-in or user-defined functions, but not aggregate functions. You can specify functions that return multiple values for metrics, such as <func(price) as \\`col1\\`col2> (it's not necessary to specify the column names). For more information about metacode please refer to :doc:`/Objects/Metaprogramming`.",
                             "",
-                            "`matchingCols` is a string indicating the matching columns. It supports integral, temporal or literal (except UUID) types. Currently, only one matching column is supported. If the matching column of the left table is the same as that of the right table, `matchingCols` can be a string scalar. Otherwise, it should be a string vector of length 2 (the matching column names in the two tables).",
+                            "`matchingColumn` is a STRING scaler/vector/tuple indicating the column(s) on which the tables are joined. It supports integral, temporal or literal (except UUID) types.",
+                            "",
+                            "\\1. When there is only 1 matching column - If the names of the matching column are the same in both tables, *matchingColumn* should be specified as a STRING scalar; otherwise it's a tuple of two elements. For example, if the matching column is named “sym“ in the left table and “sym1“ in the right table, then matchingColumn = [[\\`sym],[\\`sym1]]. ",
+                            "",
+                            "\\2. When there are multiple matching columns - If the names of the matching columns are all the same in both tables, specify *matchingColumn* as a STRING vector; otherwise it's a tuple of two elements. For example, if the matching columns are named “timestamp“ and “sym“ in the left table and “timestamp“ and “sym1“ in the right table, then matchingColumn = [[\\`timestamp, \\`sym], [\\`timestamp,\\`sym1]].",
                             "",
                             "`timeColumn` is an optional parameter indicating the name of the time column in the two input tables when `useSystemTime` = false. If the time column of the left table is the same as that of the right table, `timeColumn` can be a string scalar. Otherwise, specify a string vector of length 2 (the time column names in the two tables).",
                             "",
@@ -11057,7 +11588,9 @@
                             "",
                             "`useSessionStartTime` is a Boolean scalar. It is optional and indicates whether the time in the output table is the start time of data window. The default value is false, which means that the time in the output table is the end time of the data window, that is, the timestamp of the last data in each window + sessionGap. It must be set to true if parameter `updateTime` is specified.",
                             "",
-                            "`delayedTime` is a positive integer. When delayedTime is specified, if the time difference between the timestamp of the latest record t2 in the left table and the timestamp of uncalculated records is greater than the delayedTime, a calculation will be triggered by the record t2. If max(2*updateTime, 2 seconds) after a record of leftTable arrives at the aggregator, the arriving record still has not participated in a calculation, a calculation will be triggered too. We need to set parameter `useSystemTime` to false before specifying `delayedTime`.",
+                            "`delayedTime` is a positive integer. We need to set parameter `useSystemTime` to false before specifying `delayedTime`.",
+                            "",
+                            "When delayedTime is specified, if the time difference between the timestamp of the latest record t2 in the left table and the timestamp of uncalculated records is greater than the delayedTime, a calculation will be triggered by the record t2. If max(2*updateTime, 2 seconds) after a record of leftTable arrives at the aggregator, the arriving record still has not participated in a calculation, a calculation will be triggered too.",
                             "",
                             "`garbageSize` is a positive integer. It is optional and the default value is 5,000. As the subscribed data is ingested into the streaming engine, it occupies an increasing amount of memory. When the number of rows in memory exceeds *garbageSize*, the system will clear the data that is not needed for the current calculation."
                         ]
@@ -11071,15 +11604,15 @@
                     {
                         "type": "text",
                         "value": [
-                            "Create asof join engine for streaming data. Return a table object. Generally it is used in conjunction with subscribeTable.",
+                            "Create asof join engine for streaming data. Return a table that is the asof join result of a left table and a right table. Generally it is used in conjunction with subscribeTable.",
                             "",
-                            "* If delayedTime is not specified, then a calculation is triggered when the timestamp of the latest record in the right table is later than the timestamp of the latest record in the left table.",
-                            "* If delayedTime is specified, then a calculation is trigger when either of the following 2 conditions is met:",
+                            "* If *delayedTime* is not specified, then a calculation is triggered when the timestamp of the latest record in the right table is later than the timestamp of the latest record in the left table.",
+                            "* If *delayedTime* is specified, then a calculation is trigger when either of the following 2 conditions is met:",
                             "",
                             "   * the time difference between the latest time in left table and the time of uncalculated data is greater than the delayedTime.",
                             "   * max(2*updateTime, 2 seconds) after a record is ingested into the left table, it still has not been used in a calculation.",
                             "",
-                            "Please note that we can only use function :doc:`/FunctionsandCommands/FunctionReferences/a/appendForJoin` to ingest data into the asof join engine. "
+                            "Starting from version 1.30.17, 2.00.5, DolphinDB supports other stream engines to ingest data into streaming join engines to realize cascade between engines through :doc:`/FunctionsandCommands/FunctionReferences/g/getLeftStream` and :doc:`/FunctionsandCommands/FunctionReferences/g/getRightStream`."
                         ]
                     }
                 ]
@@ -11148,7 +11681,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "createCrossSectionalEngine(name, [metrics], dummyTable, [outputTable], keyColumn, [triggeringPattern='perBatch'], [triggeringInterval=1000], [useSystemTime=true], [timeColumn], [lastBatchOnly=false])",
+                            "createCrossSectionalEngine(name, [metrics], dummyTable, [outputTable], keyColumn, [triggeringPattern='perBatch'], [triggeringInterval=1000], [useSystemTime=true], [timeColumn], [lastBatchOnly=false], [contextByColumn], [snapshotDir], [snapshotIntervalInMsgCount], [raftGroup=-1])",
                             "",
                             "Alias: createCrossSectionalAggregator"
                         ]
@@ -11164,38 +11697,65 @@
                         "value": [
                             "`name` is a string indicating the name of the engine. It is the only identifier of an engine. It can have letter, number and \"_\". It must start with a letter.",
                             "",
-                            "`metrics`  is a piece of metacode or a tuple specifying the formula for calculation. It can use built-in or user-defined aggregate functions or expressions such as <[sum(qty), avg(price)]>, <[avg(price1)-avg(price2)]> or <[std(price1-price2)]>. The arguments for metrics must be columns in the subscribed data or their expressions. For more information about metacode please refer to :doc:`/Objects/Metaprogramming`. If we only need the latest row for each unique value of keyColumn, we can leave metrics unspecified. In this case outputTable will be empty. ",
+                            "`metrics`  is a piece of metacode or a tuple specifying the formula for calculation. It can use built-in or user-defined aggregate functions or expressions such as <[sum(qty), avg(price)]>, <[avg(price1)-avg(price2)]> or <[std(price1-price2)]>. You can specify functions that return multiple values for metrics, such as <func(price) as \\`col1\\`col2> (it's not necessary to specify the column names). For more information about metacode please refer to :doc:`/Objects/Metaprogramming`. ",
+                            "",
+                            "`dummyTable`  is a TABLE indicating the schema of the subscribed stream table. It doesn't matter whether *dummyTable* contains data or not. ",
                             "",
-                            "`dummyTable`  is a table object whose schema must be the same as the subscribed streaming table. The system uses the schema of dummyTable to determine the data type of each column in the messages. Whether dummyTable contains data does not affect the aggregation result.",
+                            "`outputTable` is a TABLE containing calculation results. It can be an in-memory table or a distributed table. ",
                             "",
-                            "`outputTable` is the output table of aggregation results. The number of columns in outputTable is the number of metrics +1. The first column is of TIMESTAMP data type and stores the timestamp when each calculation happens. Starting from the second column, the data type of each column must be the same as the result of each metric.",
+                            "* If *contextByColumn* is not specified, the number of columns in the output table should be the number of metrics + 1. The first column is of TIMESTAMP type indicating the starting time of each calculation in system time (If *timeColumn* is specified, the values in *timeColumn* will be used instead). The remaining columns are calculation results - make sure to keep the data types of columns consistent with the results.",
+                            "* If *contextByColumn* is specified, the number of columns in the output table should be the number of metrics + 2. The first column is of TIMESTAMP type indicating the starting time of each calculation in system time (If *timeColumn* is specified, the values in *timeColumn* will be used instead). The second column is the column specified by *contextByColumn*. The remaining columns are calculation results - make sure to keep the data types of columns consistent with the results.",
                             "",
                             "`keyColumn` is a string scalar or vector that specifies one or more columns in the stream table as the key columns of the cross-sectional streaming engine. For each unique value in the *keyColumn*, only the lastest row is used in the calculation.",
                             "",
-                            "`triggeringPattern` is a string indicating how calculation is triggered. It can take the following values:",
+                            "`triggeringPattern` is a STRING indicating how calculation is triggered. Each calculation adds 1 record to the output table. This parameter can take the following values:",
                             "",
-                            "* 'perBatch':  calculation is triggered by each batch of data that is inserted. It is the default value for `triggeringPattern`.",
-                            "* 'perRow': calculation is triggered by each row of data that is inserted.",
-                            "* 'interval': calculation is triggered at predetermined intervals (in terms of milliseconds).",
-                            "* 'keyCount':  If data with the same timestamp arrive in batches, calculation is triggered if either the number of keys with the latest timestamp reaches triggeringInterval or data that is to be calculated contains 2 different timestamps (i.e., data with newer timestamp arrives before some data with old timestamp is used for calculation). To set `triggeringPattern` to 'keyCount', timeColumn must be specified.  ",
+                            "* 'perBatch': Default value. Calculation is triggered by each batch of data that is inserted.",
+                            "* 'perRow': Calculation is triggered by each row of data that is inserted.",
+                            "* 'interval': Calculation is triggered at predetermined intervals (using system time).",
+                            "* 'keyCount': If data with the same timestamp arrive in batches, calculation is triggered if either a) the number of keys with the latest timestamp reaches *triggeringInterval*, or b) data that is to be calculated contains 2 different timestamps (i.e., data with newer timestamp arrives before some data with old timestamp is used for calculation). To set *triggeringPattern* to 'keyCount', *timeColumn* must be specified and *useSystemTime* must be set to false.",
                             "",
-                            "`triggeringInterval` is a positive integer. ",
+                            "Note: If *triggeringPattern* is specified as keyCount, out-of-order data will not participate in the calculation. ",
                             "",
-                            "* If `triggeringPattern`\\='interval': `triggeringInterval` indicates the duration in milliseconds between 2 adjacent calculations. The default value is 1000.",
-                            "* If `triggeringPattern`\\='keyCount': `triggeringInterval` indicates the threshold of the number of keys in the unused data to trigger a calculation.",
+                            "`triggeringInterval` is an INTEGER or a tuple. Below explains its available values and triggering rules: ",
+                            "",
+                            "*If *triggeringPattern*='interval': *triggeringInterval* indicates the duration in milliseconds between 2 adjacent calculations. The default value is 1000.",
+                            "*If *triggeringPattern*='keyCount': *triggeringInterval* indicates the threshold of the number of keys in the unused data to trigger a calculation. It can also be a tuple of 2 elements, with the first being an integer indicating the threshold of the number of keys in the unused data to trigger a calculation, and the second being an INTEGER or DURATION value. In this example, the value of *triggeringPattern* is a tuple.",
+                            "",
+                            "   Suppose *triggeringPattern* =(c1, c2):",
+                            "",
+                            "   * When c2 is an integer, if the number of keys with the latest timestamp t1 doesn't reach c1, calculation will not be triggered and the system will go on to save data with newer timestamp t2 (t2>t1). Data with t1 will be calculated when either of the events happens: the number of keys with timestamp t2 reaches c2, or data with newer timestamp t3 (t3>t2) starts to come in. Note that c2 must be smaller than c1.",
+                            "   * When c2 is a duration, if the number of keys with the latest timestamp t1 doesn't reach c1, calculation will not be triggered and the system will go on to save data with newer timestamp t2 (t2>t1) . Once data with t2 starts to come in, data with t1 will not be calculated until any of the events happens: the number of keys with timestamp t1 reaches c1, or data with newer timestamp t3 (t3>t2) starts to come in, or the duration c2 comes to an end.",
                             "",
                             "`useSystemTime` is a Boolean value indicating whether the first column of outputTable is system time (`useSystemTime`\\=true) or `timeColumn` in the stream table (`useSystemTime`\\=false). ",
                             "",
                             "`timeColumn`  is a string. If `useSystemTime`\\=false, timeColumn is the name of the temporal column in the stream table. The column only supports TIMESTAMP type. ",
                             "",
-                            ".. `lastBatchOnly` :可选参数。是否只计算最新时间戳上的数据。当 *lastBatchOnly* =true时，横截面引擎表只保存最新时间戳上key的数据，进行计算；否则，横截面引擎表更新并保留所有key的数据，进行计算。",
+                            "`lastBatchOnly` is an optional BOOLEAN indicating whether to keep the latest data only in the cross-sectional engine. When *lastBatchOnly* = true, *triggeringPattern* must take the value 'keyCount' and the the cross-sectional engine only saves the unique value with the latest timestamp for calculation. When *lastBatchOnly* = false, the engine updates and retains all unique values for calculation.",
+                            "",
+                            "`contextByColumn` is an optional STRING scalar indicating the grouping column,  based on which data will be calculated in groups.",
                             "",
-                            "`lastBatchOnly` is a optional parameter indicating whether to calculate latest data only. When `lastBatchOnly` = true, the cross sectional engine only saves the unique value with the latest timestamp for calculation; otherwise, the cross sectional engine updates and retains all unique values for calculation. ",
+                            "* To specify this parameter, *metrics* and *outputTable* must be specified accordingly.",
+                            "* If *metrics* only contains aggregate functions, the calculation results would be the same as using function ``groupby`` to conduct calculation in groups. Otherwise, the results would be the same as using function ``contextby``.",
                             "",
-                            "`contextByColumn` is a string. The data in this engine will be calculated in groups which are grouped by the set value.",
+                            "To enable snapshot, *snapshotDir* and *snapshotIntervalInMsgCount* must be specified.",
                             "",
-                            "* The metrics and outputTable must be specified before setting this parameter.",
-                            "* If the functions set metric are all aggregate functions, the result is consistent with the one grouped by \"groupby\". Otherwise, it is consistent with the result grouped by \"contextby\"."
+                            "With snapshot enabled, if an exception occurs, the stream engine can be recovered to the latest snapshot.",
+                            "",
+                            "`snapshotDir` is an optional STRING indicating the directory where the snapshot of the engine is stored.",
+                            "",
+                            "* Make sure the specified directory actually exists. Otherwise the system reports an error.",
+                            "* If *snapshotDir* is specified when creating the engine, the system will check if a snapshot exists in this directory. If it exists, the system will load the snapshot and restore the state of the engine (intermediate calculation results).",
+                            "* Multiple engines may share a single directory, using the name of the engine to distinguish the snapshot files.",
+                            "* A snapshot file of an engine may take 3 file extensions over different stages:",
+                            "",
+                            "  * <engineName>.*tmp* for temporary stroage of snapshot data",
+                            "  * <engineName>.*snapshot* for a generated snapshot file synced to disk",
+                            "  * If a new snapshot file is created, the existing snapshot with the same name will be renamed to <engineName>.*old*",
+                            "",
+                            "`snapshotIntervalInMsgCount` is an optional INTEGER indicating how many messages are processed before a new snapshot is generated.",
+                            "",
+                            "`raftGroup` is the ID of the raft group on the high-availability streaming subscriber specified by the configuration parameter *streamingRaftGroups*. It is an integer greater than 1. Specify *raftGroup* to enable high availability on the streaming engine. When a streaming engine is created on the leader, it is also created on each follower. Once a snapshot is generated, it will also be synced to all followers. When a leader is down, the raft group automatically switches to a new leader to resubscribe to the stream table. Note that *SnapShotDir* must also be specified when specifying a raft group."
                         ]
                     }
                 ]
@@ -11207,10 +11767,11 @@
                     {
                         "type": "text",
                         "value": [
-                            "Create a cross sectionnal engine. It returns a table containing the latest records (for each group). Each value in keyColumn corresponds to only one specified row in table. If the keyColumn value of the arriving record already exists, the record will be updated by the new one. Otherwise, a new record will be inserted at the end of the table.",
+                            "Create a cross-sectional engine. Return a keyed table with *keyColumn* values as the keys.",
                             "",
-                            "* If metrics and outputTable are not specified, The engine won't do any calculation and output, but only update the records.",
-                            "* If metrics and outputTable are specified, the engine will update the records first, then calculate and output the result into the outputTable."
+                            "If *metrics* or *outputTable* is not specified, the engine only updates table records but will not calculate or output any data.",
+                            "",
+                            "If *metrics* and *outputTable* are specified, the engine will update table records, conduct calculation using the latest records, and output results to the *outputTable*. "
                         ]
                     }
                 ]
@@ -11222,8 +11783,6 @@
                     {
                         "type": "text",
                         "value": [
-                            "`Example 1`",
-                            "",
                             "Use function ``createCrossSectionalEngine`` to create a table `csEngine1` that subscribes to the stream table `trades1`.",
                             "",
                             "In this example, `triggeringPattern`\\=\"perRow\". Therefore each row that is inserted into table `csEngine1` triggers a computation. ",
@@ -11284,7 +11843,6 @@
                             "2020.08.12T09:30:00.901  15.2      60      1012          2",
                             "======================== ========= ======= ============= ======",
                             "",
-                            "`Example 2`",
                             "",
                             "In this example, `triggeringPattern`\\=\"perBatch\". Insert 2 batches of data and the result has 2 rows. ",
                             ""
@@ -11317,8 +11875,6 @@
                             "2020.08.12T09:30:00.901  15.2      60      1012          2",
                             "======================== ========= ======= ============= ======",
                             "",
-                            "`Example 3`",
-                            "",
                             "In this example, `triggeringPattern` = \"keyCount\" and `lastBatchOnly` = true. Only the data with the latest timestamp will participate in calculation. Because there are both aggregator and non-aggregator functions set in metrics, the number of rows in the result table will be the same as that in the input table.",
                             ""
                         ]
@@ -11376,8 +11932,6 @@
                             "2018.01.01T09:30:01.000  10.1      40",
                             "======================= ========  ======== ",
                             "",
-                            "`Example 4`",
-                            "",
                             "In this example, `triggeringPattern`\\=\"interval\" and  triggeringInterval=500 (milliseconds). ",
                             ""
                         ]
@@ -11456,7 +12010,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "createDailyTimeSeriesEngine(name, windowSize, step, metrics, dummyTable, outputTable, [timeColumn], [useSystemTime=false], [keyColumn], [garbageSize], [updateTime], [useWindowStartTime], [roundTime=true], [snapshotDir], [snapshotIntervalInMsgCount], [fill=’none’], [sessionBegin], [sessionEnd], [mergeSessionEnd=false], [forceTriggerTime], [raftGroup])"
+                            "createDailyTimeSeriesEngine(name, windowSize, step, metrics, dummyTable, outputTable, [timeColumn], [useSystemTime=false], [keyColumn], [garbageSize], [updateTime], [useWindowStartTime], [roundTime=true], [snapshotDir], [snapshotIntervalInMsgCount], [fill='none'], [sessionBegin], [sessionEnd], [mergeSessionEnd=false], [forceTriggerTime], [raftGroup], [forceTriggerSessionEndTime])"
                         ]
                     }
                 ]
@@ -11476,9 +12030,15 @@
                             "",
                             "`mergeSessionEnd` is a Boolean scalar indicating whether to include the data at the ending time of the session in the calculation of each session. It is optional and the default value is false.",
                             "",
+                            "`forceTriggerSessionEndTime` is an optional parameter. It is a positive integer in unit of seconds. It indicates the waiting time to force trigger calculation in the window containing the sessionEnd, if it ends without calculation.",
+                            "",
+                            "- If *fill* is not specified, the window returns no result.",
+                            "",
+                            "- If *fill* is specified, the result of the window will be filled using the specified filling method.",
+                            "",
                             "Note: ",
                             "",
-                            "* The aggregator automatically adjusts the starting point of the window for `sessionBegin` and `sessionEnd` according to the value of alignmentSize.",
+                            "* The engine automatically adjusts the starting point of the window for `sessionBegin` and `sessionEnd` according to the value of alignmentSize.",
                             "* To set these three parameters, `useSystemTime` must be set to false. `mergeSessionEnd` can be set only when `updateTime` or `forceTriggerTime` is specified."
                         ]
                     }
@@ -11509,8 +12069,8 @@
                             "  ",
                             "   $ share streamTable(1000:0, `date`second`sym`volume, [DATE, SECOND, SYMBOL, INT]) as trades",
                             "   $ output1 = keyedTable(`time`sym, 10000:0, `time`sym`sumVolume, [DATETIME, SYMBOL, INT])",
-                            "   $ agg1 = createDailyTimeSeriesEngine(name=\"agg1\", windowSize=60, step=60, metrics=<[sum(volume)]>, dummyTable=trades, outputTable=output1, timeColumn=`date`second, useSystemTime=false, keyColumn=`sym, garbageSize=50, updateTime=2, useWindowStartTime=false, sessionBegin=09:30:00 13:00:00, sessionEnd=11:30:00 15:00:00,mergeSessionEnd=true)",
-                            "   $ subscribeTable(tableName=\"trades\", actionName=\"agg1\", offset=0, handler=append!{agg1}, msgAsTable=true);",
+                            "   $ engine1 = createDailyTimeSeriesEngine(name=\"engine1\", windowSize=60, step=60, metrics=<[sum(volume)]>, dummyTable=trades, outputTable=output1, timeColumn=`date`second, useSystemTime=false, keyColumn=`sym, garbageSize=50, updateTime=2, useWindowStartTime=false, sessionBegin=09:30:00 13:00:00, sessionEnd=11:30:00 15:00:00,mergeSessionEnd=true)",
+                            "   $ subscribeTable(tableName=\"trades\", actionName=\"engine1\", offset=0, handler=append!{engine1}, msgAsTable=true);",
                             "",
                             "   $ insert into trades values(2018.10.08,09:25:31,`A,8)",
                             "   $ insert into trades values(2018.10.08,09:26:01,`B,10)",
@@ -11535,18 +12095,262 @@
                     {
                         "type": "text",
                         "value": [
-                            "=================== ========== ==========",
-                            "time                sym        sumVolume",
-                            "=================== ========== ==========",
-                            "2018.10.08T09:31:00  A         34",
-                            "2018.10.08T09:31:00  B         24",
-                            "2018.10.08T11:30:00  A         44",
-                            "2018.10.08T11:30:00  B         15",
-                            "2018.10.08T13:01:00  A         16",
-                            "2018.10.08T13:01:00  B         9",
-                            "2018.10.08T15:00:00  A         30",
-                            "2018.10.08T15:00:00  B         49",
-                            "=================== ========== =========="
+                            "=================== === =========",
+                            "time                sym sumVolume",
+                            "=================== === =========",
+                            "2018.10.08T09:31:00  A  34",
+                            "2018.10.08T09:31:00  B  24",
+                            "2018.10.08T11:30:00  A  44",
+                            "2018.10.08T11:30:00  B  15",
+                            "2018.10.08T13:01:00  A  16",
+                            "2018.10.08T13:01:00  B  9",
+                            "2018.10.08T15:00:00  A  30",
+                            "2018.10.08T15:00:00  B  49",
+                            "=================== === =========",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "   $ share streamTable(1000:0, `date`second`sym`volume, [DATE, SECOND, SYMBOL, INT]) as trades",
+                            "   $ output1 = keyedTable(`time`sym, 10000:0, `time`sym`sumVolume, [DATETIME, SYMBOL, INT])",
+                            "   $ engine1 = createDailyTimeSeriesEngine(name=\"engine1\", windowSize=60, step=60, metrics=<[sum(volume)]>, dummyTable=trades, outputTable=output1, timeColumn=`date`second, useSystemTime=false, keyColumn=`sym, garbageSize=50, useWindowStartTime=false, sessionBegin=09:30:00 13:00:00, sessionEnd=11:30:00 15:00:00,mergeSessionEnd=true,forceTriggerSessionEndTime=10)",
+                            "   $ subscribeTable(tableName=\"trades\", actionName=\"engine1\", offset=0, handler=append!{engine1}, msgAsTable=true);",
+                            "",
+                            "   $ insert into trades values(date(now()),09:25:31,`A,8)",
+                            "   $ insert into trades values(date(now()),09:26:01,`B,10)",
+                            "   $ insert into trades values(date(now()),09:30:02,`A,26)",
+                            "   $ insert into trades values(date(now()),09:30:10,`B,14)",
+                            "   $ insert into trades values(date(now()),11:29:46,`A,30)",
+                            "   $ insert into trades values(date(now()),11:29:50,`B,11)",
+                            "   $ insert into trades values(date(now()),11:30:00,`B,14)",
+                            "   $ insert into trades values(date(now()),11:30:01,`A,4)",
+                            "",
+                            "   $ select * from output1",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "=================== === =========",
+                            "time                sym sumVolume",
+                            "=================== === =========",
+                            "2022.03.24T09:31:00 A   34",
+                            "2022.03.24T09:31:00 B   24",
+                            "2022.03.24T11:30:00 A   30",
+                            "=================== === =========",
+                            "",
+                            "",
+                            "Set *forceTriggerSessionEndTime* = 10. Calculation on the window with the right boundary at 11:30:00 will be triggered 10 seconds after the system time reaches 11:30:00.",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "   $ sleep(10000)",
+                            "   $ select * from output1",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "=================== === =========",
+                            "time                sym sumVolume",
+                            "=================== === =========",
+                            "2022.03.24T09:31:00 A   34",
+                            "2022.03.24T09:31:00 B   24",
+                            "2022.03.24T11:30:00 A   30",
+                            "2022.03.03T11:30:00 B   25",
+                            "=================== === ========="
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
+    "createDistributedInMemoryTable": {
+        "title": "createDistributedInMemoryTable",
+        "type": "function",
+        "children": [
+            {
+                "title": "Syntax",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "createDistributedInMemoryTable(tableName, colNames, colTypes, globalPartitionType, globalPartitionScheme, globalPartitionColumn, [localPartitionType], [localPartitionScheme], [localPartitionColumn])",
+                            "  "
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Details",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "Create a distributed in-memory table and store it on different nodes based on the specified partitioning scheme. This function can only be executed on a data node or compute node.",
+                            "",
+                            "The distributed in-memory table is stored on different nodes (data nodes/compute nodes) based on the global partitioning scheme. Each node can only hold one partition. Concurrent reads and writes are supported in a distributed in-memory table. Therefore, it is suitable for scenarios that require distributed computing on in-memory tables.",
+                            "",
+                            "A distributed in-memory table can be partitioned on 2 different levels:",
+                            "",
+                            "- global (between nodes): a distributed in-memory table is partitioned and the partitions are stored on different nodes. ",
+                            "",
+                            "- local (within node): data within each node can be partitioned again.",
+                            "",
+                            "If both global and local partitioning is adopted, the partitioning scheme of the distributed in-memory table is equivalent to a composite domain.",
+                            "",
+                            "Note:",
+                            "",
+                            "\\(1) Distributed in-memory tables can only be created in cluster mode.",
+                            "",
+                            "\\(2) The number of global partitions must be greater or equal to 2 and less than the total number of data nodes and compute nodes.",
+                            "",
+                            "\\(3) Before accessing the distributed  in-memory table from other nodes, use function :doc:`../l/loadDistributedInMemoryTable` first to load the table.",
+                            "",
+                            "\\(4) Drop the distributed in-memory table with command :doc:`/FunctionsandCommands/CommandsReferences/d/dropDistributedInMemoryTable`.",
+                            "",
+                            "\\(5) Transactions are not supported currently for distributed in-memory tables. "
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Arguments",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "`tableName` is a STRING scalar indicating the name of a distributed in-memory table.",
+                            "",
+                            "`colNames` is a STRING vector of column names. ",
+                            "",
+                            "`colTypes` is a vector indicating data types of columns specified by *colNames*.",
+                            "",
+                            "`globalPartitionType` is a required parameter indicating the partition type for a table in a cluster, which only supports RANGE, HASG, VALUE, and LIST.",
+                            "",
+                            "`globalPartitionScheme` is a required parameter indicating the partitioning scheme that describes how the partitions are created in a cluster.",
+                            "",
+                            "The partition type and partitioning scheme are shown as follows:",
+                            "",
+                            "+----------------+-----------------------+-------------------------------------------------------------------------------------+",
+                            "| Partition Type | Partition Type Symbol | Partitioning Scheme                                                                 |",
+                            "+================+=======================+=====================================================================================+",
+                            "| range domain   | RANGE                 | A vector. Any two adjacent elements of the vector define the range for a partition. |",
+                            "+----------------+-----------------------+-------------------------------------------------------------------------------------+",
+                            "| hash domain    | HASH                  | A tuple. The first element is the data type of partitioning column. The second      |",
+                            "|                |                       | element is the number of partitions.                                                |",
+                            "+----------------+-----------------------+-------------------------------------------------------------------------------------+",
+                            "| value domain   | VALUE                 | A vector. Each element of the vector defines a partition.                           |",
+                            "+----------------+-----------------------+-------------------------------------------------------------------------------------+",
+                            "| list domain    | LIST                  | A vector. Each element of the vector defines a partition.                           |",
+                            "+----------------+-----------------------+-------------------------------------------------------------------------------------+",
+                            "",
+                            "`globalPartitionColumn` is a required parameter. It is a STRING scalar indicating the partitioning column for a table in a cluster.",
+                            "",
+                            "The above parameters are specified for a cluster. The distributed in-memory table is partitioned and the partitions are stored on each node based on the above partitioning schemes. ",
+                            "",
+                            "The data within each node can be partitioned again through the following parameters.",
+                            "",
+                            "`localPartitionType` is an optional parameter indicating the partition type within a node, which only supports RANGE, HASG, VALUE, and LIST.",
+                            "",
+                            "`localPartitionScheme` is an optional parameter indicating the partitioning scheme that describes how the partitions are created within a node.",
+                            "",
+                            "`localPartitionColumn` is an optional parameter. It is a STRING scalar indicating the partitioning column within a node."
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Examples",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "* Create a distributed in-memory table",
+                            "",
+                            "The cluster in this example has two data nodes: node1 and node2. Create a distributed in-memory table on node1. The number of partitions should be less than the total number of data nodes and compute nodes, thus HASH partitioning is recommended.",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ pt = createDistributedInMemoryTable(`dt, `time`id`value, `DATETIME`INT`LONG, HASH, [INT, 2],`id)",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "* Load a distributed in-memory table",
+                            "",
+                            "Load a distributed in-memory table on node2 and insert data into it.",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ time = take(2021.08.20 00:00:00..2021.08.30 00:00:00, 40);",
+                            "    $ id = 0..39;",
+                            "    $ value = rand(100, 40);",
+                            "    $ tmp = table(time, id, value);",
+                            "",
+                            "    $ pt = loadDistributedInMemoryTable(`dt)",
+                            "    $ pt.append!(tmp);",
+                            "",
+                            "    $ select * from pt;",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "* Check whether a distributed in-memory table exists",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ objs(true)",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "* Delete a distributed in-memory table",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ dropDistributedInMemoryTable(`dt)"
                         ]
                     }
                 ]
@@ -11758,6 +12562,305 @@
             }
         ]
     },
+    "createLookupJoinEngine": {
+        "title": "createLookupJoinEngine",
+        "type": "function",
+        "children": [
+            {
+                "title": "Syntax",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "createLookupJoinEngine(name, leftTable, rightTable, outputTable, metrics, matchingColumn, [rightTimeColumn], [checkTimes])"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Details",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "Create a lookup join streaming engine to perform left join on stream tables. It conducts a real-time left join on two stream tables, or on a stream table and a non-stream table (where the non-stream table needs to be refreshed regularly).",
+                            "",
+                            "Note:",
+                            "",
+                            "\\1. A left join is triggered only when new data is ingested to the left table.",
+                            "",
+                            "\\2. Data in the right table is grouped based on *matchingColumn* and only the latest record in each group is kept. ",
+                            "",
+                            "- If the right table is a subscribed stream table, the records will be updated when new data is ingested to the right table. ",
+                            "",
+                            "- If the right table is an in-memory table or a DFS table (currently only dimension table is supported), the system refreshes the right table at specified *checkTimes* intervals.",
+                            "",
+                            "Starting from version 1.30.17, 2.00.5, DolphinDB supports using streaming engines to ingest data into streaming join engines to realize cascade of engines with :doc:`/FunctionsandCommands/FunctionReferences/g/getLeftStream` and :doc:`/FunctionsandCommands/FunctionReferences/g/getRightStream`."
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Arguments",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "`name` is a STRING indicating the name of the lookup join streaming engine.",
+                            "",
+                            "`leftTable` is a table object. Its schema must be the same as the subscribed stream table.",
+                            "",
+                            "`rightTable` is a table object. It is an empty in-memory table, stream table or dimension table. Note that if the *rightTable* is not subscribed, *checkTimes* must be specified for timed data refreshing.",
+                            "",
+                            "`outputTable` is a required table object to hold the calculation results. Before using function ``createLookupJoinEngine``, set up an empty table as the *outputTable*, and specify the column names and data types.",
+                            "",
+                            "The columns of the *outputTable* are in the following order: the matching columns, the result columns. Specifically:",
+                            "",
+                            "\\(1) The first few columns must be arranged in the same order as specified in *matchingColumn*.",
+                            "",
+                            "\\(2) The last few columns are the results of the *metrics*.",
+                            "",
+                            "`metrics` is metacode specifying the calculation formulas. It can use one or more expressions, built-in or user-defined functions, but not aggregate functions. You can specify functions that return multiple values for metrics, such as <func(price) as \\`col1\\`col2> (it's not necessary to specify the column names). For more information about metacode, please refer to :doc:`/Objects/Metaprogramming`.",
+                            "",
+                            "`matchingColumn` is a STRING scalar/vector, or a tuple of STRING vectors indicating the matching column(s). It can be integral, temporal or literal (excluding UUID) types.",
+                            "",
+                            "Specify *matchingColumn* following the rules below:",
+                            "",
+                            "\\1. When there is only 1 matching column - If the names of the matching column are the same in both tables, *matchingColumn* should be specified as a STRING scalar; otherwise it's a tuple of two elements. For example, if the matching column is named \"sym\" in the left table and \"sym1\" in the right table, then *matchingColumn* = [[\\`sym],[\\`sym1]].",
+                            "",
+                            "\\2. When there are multiple matching columns - If the names of the matching columns are all the same in both tables, specify *matchingColumn* as a STRING vector; otherwise it's a tuple of two elements. For example, if the matching columns are named \"timestamp\" and \"sym\" in the left table, whereas in the right table they're named \"timestamp\" and \"sym1\", then *matchingColumn* = [[\\`timestamp, \\`sym], [\\`timestamp,\\`sym1]].",
+                            "",
+                            "`rightTimeColumn` is a STRING scalar, indicating the time column in the right table. If the parameter is specified, the right table will keep the record with the latest timestamp. If there are multiple records with identical timestamp, only the latest is retained. If the parameter is not specified, the latest ingested record based on the system time will be kept.",
+                            "",
+                            "`checkTimes` is a temporal vector or DURATION scalar. If it is specified, the system will regularly update the data set in the right table (with only the latest record kept).",
+                            "",
+                            "- If *checkTimes* is a temporal vector, it is of SECOND, TIME or NANOTIME type. The lookup join engine updates the right table on a daily basis according to the time specified by each element in the vector.",
+                            "",
+                            "- If *checkTimes* is a DURATION scalar, it indicates the interval to update the right table."
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "First Release",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "1.30.16/2.00.4"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Examples",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "Ex. 1",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "  ",
+                            "   $ login(`admin, `123456)",
+                            "   $ share streamTable(1000:0, `timestamps`sym`price, [TIMESTAMP, SYMBOL, DOUBLE]) as trades",
+                            "   $ share streamTable(1000:0, `timestamps`sym`val`id, [TIMESTAMP, SYMBOL, DOUBLE, INT]) as prices",
+                            "   $ output = table(100:0, `sym`factor1`factor2`factor3, [SYMBOL, DOUBLE, DOUBLE, DOUBLE])",
+                            "",
+                            "   $ LjEngine = createLookupJoinEngine(name=\"test1\", leftTable=trades, rightTable=prices, outputTable=output, metrics=<[price,val,price*val]>, matchingColumn=`sym)",
+                            "   $ subscribeTable(tableName=\"trades\", actionName=\"append_leftTable\", offset=0, handler=appendForJoin{LjEngine, true}, msgAsTable=true) ",
+                            "   $ subscribeTable(tableName=\"prices\", actionName=\"append_rightTable\", offset=0, handler=appendForJoin{LjEngine, false}, msgAsTable=true)  ",
+                            "",
+                            "   $ n = 15",
+                            "   $ tem1 = table( (2018.10.08T01:01:01.001 + 1..12) join (2018.10.08T01:01:01.001 + 1..3)as timestamps,take(`A`B`C, n) as sym,take(1..15,n) as val,1..15 as id)",
+                            "   $ prices.append!(tem1)",
+                            "   $ sleep(2000)",
+                            "   $ n  = 10",
+                            "   $ tem2 = table( 2019.10.08T01:01:01.001 + 1..n as timestamps,take(`A`B`C, n) as sym,take(0.1+10..20,n) as price)",
+                            "   $ trades.append!(tem2)",
+                            "   $ sleep(100)",
+                            "   $ select * from output",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "=== ======= ======= =======",
+                            "sym factor1 factor2 factor3",
+                            "=== ======= ======= =======",
+                            "A   10.1    13      131.3",
+                            "B   11.1    14      155.4",
+                            "C   12.1    15      181.5",
+                            "A   13.1    13      170.3",
+                            "B   14.1    14      197.4",
+                            "C   15.1    15      226.5",
+                            "A   16.1    13      209.3",
+                            "B   17.1    14      239.4",
+                            "C   8.1     15      271.5",
+                            "A   19.1    13      248.3",
+                            "=== ======= ======= =======",
+                            "",
+                            "Ex. 2",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "  ",
+                            "   $ share streamTable(1000:0, `timestamps`sym`price, [TIMESTAMP, SYMBOL, DOUBLE]) as trades",
+                            "   $ share streamTable(1000:0, `timestamps`sym`val`id, [TIMESTAMP, SYMBOL, DOUBLE, INT]) as prices",
+                            "   $ output = table(100:0, `sym`factor1`factor2`factor3, [SYMBOL, DOUBLE, DOUBLE, DOUBLE])",
+                            "   $ LjEngine = createLookupJoinEngine(name=\"test1\", leftTable=trades, rightTable=prices, outputTable=output, metrics=<[price,val,price*val]>, matchingColumn=`sym, rightTimeColumn=`timestamps)",
+                            "   $ subscribeTable(tableName=\"trades\", actionName=\"append_leftTable\", offset=0, handler=appendForJoin{LjEngine, true}, msgAsTable=true) ",
+                            "   $ subscribeTable(tableName=\"prices\", actionName=\"append_rightTable\", offset=0, handler=appendForJoin{LjEngine, false}, msgAsTable=true) ",
+                            "",
+                            "   $ n = 15",
+                            "   $ tem1 = table( (2018.10.08T01:01:01.001 + 1..12) join (2018.10.08T01:01:01.001 + 1..3)as timestamps,take(`A`B`C, n) as sym,take(1..15,n) as val,1..15 as id)",
+                            "   $ prices.append!(tem1)",
+                            "   $ sleep(2000)",
+                            "   $ n  = 10",
+                            "   $ tem2 = table( 2019.10.08T01:01:01.001 + 1..n as timestamps,take(`A`B`C, n) as sym,take(0.1+10..20,n) as price)",
+                            "   $ trades.append!(tem2)",
+                            "   $ sleep(100)",
+                            "   $ select * from output",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "=== ======= ======= =======",
+                            "sym factor1 factor2 factor3",
+                            "=== ======= ======= =======",
+                            "A   10.1    10      101",
+                            "B   11.1    11      122.1",
+                            "C   12.1    12      145.2",
+                            "A   13.1    10      131",
+                            "B   14.1    11      155.1",
+                            "C   15.1    12      181.2",
+                            "A   16.1    10      161",
+                            "B   17.1    11      188.1",
+                            "C   18.1    12      217.2",
+                            "A   19.1    10      191",
+                            "=== ======= ======= =======",
+                            "",
+                            "Ex. 3:",
+                            "The right table is an in-memory table, so *checkTimes* must be set.",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "  ",
+                            "   $ share streamTable(1000:0, `timestamps`sym`price, [TIMESTAMP, SYMBOL, DOUBLE]) as trades",
+                            "   $ output = table(100:0, `sym`factor1`factor2`factor3, [SYMBOL, DOUBLE, DOUBLE, DOUBLE])",
+                            "   $ prices=table(1000:0, `timestamps`sym`val`id, [TIMESTAMP, SYMBOL, DOUBLE, INT])",
+                            "   $ LjEngine = createLookupJoinEngine(name=\"test1\", leftTable=trades, rightTable=prices, outputTable=output, metrics=<[price,val,price*val]>, matchingColumn=`sym, rightTimeColumn=`timestamps, checkTimes=1s)",
+                            "   $ subscribeTable(tableName=\"trades\", actionName=\"append_leftTable\", offset=0, handler=appendForJoin{LjEngine, true}, msgAsTable=true) ",
+                            "",
+                            "   $ n = 15",
+                            "   $ tem1 = table( (2018.10.08T01:01:01.001 + 1..12) join (2018.10.08T01:01:01.001 + 1..3)as timestamps,take(`A`B`C, n) as sym,take(1..15,n) as val,1..15 as id)",
+                            "   $ prices.append!(tem1)",
+                            "   $ sleep(2000)",
+                            "   $ n  = 10",
+                            "   $ tem2 = table( 2019.10.08T01:01:01.001 + 1..n as timestamps,take(`A`B`C, n) as sym,take(0.1+10..20,n) as price)",
+                            "   $ trades.append!(tem2)",
+                            "   $ sleep(100)",
+                            "   $ select * from output",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "=== ======= ======= =======",
+                            "sym factor1 factor2 factor3",
+                            "=== ======= ======= =======",
+                            "A   10.1    10      101",
+                            "B   11.1    11      122.1",
+                            "C   12.1    12      145.2",
+                            "A   13.1    10      131",
+                            "B   14.1    11      155.1",
+                            "C   15.1    12      181.2",
+                            "A   16.1    10      161",
+                            "B   17.1    11      188.1",
+                            "C   18.1    12      217.2",
+                            "A   19.1    10      191",
+                            "=== ======= ======= =======",
+                            "",
+                            "Ex 4:",
+                            "Join the left table \"trades\" (a real-time stream table) and the right table \"prices\" (a dimension table with relatively infrequent updates) to look up the matched records in column \"id\" from the right table.",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "     ",
+                            "   $ share streamTable(1000:0, `time`volume`id, [TIMESTAMP, INT,INT]) as trades",
+                            "   $ dbPath=\"dfs://testlj\"",
+                            "   $ if(existsDatabase(dbPath)){",
+                            "   $ \tdropDatabase(dbPath)",
+                            "   $ }",
+                            "   $ rt=table(1000:0, `time`price`id, [TIMESTAMP, DOUBLE, INT])",
+                            "   $ db=database(dbPath, VALUE, `A`B`C)",
+                            "   $ prices=db.createTable(rt,`rightTable)",
+                            "   $ outputTable = table(10000:0, `id`volume`price`prod, [INT,INT,DOUBLE,DOUBLE])",
+                            "",
+                            "   $ tradesLookupJoin = createLookupJoinEngine(name=\"streamLookup1\", leftTable=trades, rightTable=prices, outputTable=outputTable, metrics=<[volume,price,volume*price]>, matchingColumn=`id, rightTimeColumn=`time,checkTimes=1s)",
+                            "   $ subscribeTable(tableName=\"trades\", actionName=\"append_trades\", offset=0, handler=appendForJoin{tradesLookupJoin, true}, msgAsTable=true) ",
+                            "",
+                            "   $ def writeData(t,n){",
+                            "   $     timev = 2021.10.08T01:01:01.001 + timestamp(1..n)",
+                            "   $     volumev = take(1..n, n)",
+                            "   $     id = take(1 2 3, n)",
+                            "   $     insert into t values(timev, volumev, id)",
+                            "   $ }",
+                            "   $ //n=7",
+                            "   $ writeData(rt, 10)",
+                            "   $ prices.append!(rt)",
+                            "   $ sleep(2000)",
+                            "   $ writeData(trades, 6)",
+                            "   $ sleep(2)",
+                            "",
+                            "   $ select * from outputTable",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "== ====== ===== ====",
+                            "id volume price prod",
+                            "== ====== ===== ====",
+                            "1  1      10    10",
+                            "2  2      8     16",
+                            "3  3      9     27",
+                            "1  4      10    40",
+                            "2  5      8     40",
+                            "3  6      9     54",
+                            "== ====== ===== ===="
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "createPartitionedTable": {
         "title": "createPartitionedTable",
         "type": "function",
@@ -12048,7 +13151,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "createReactiveStateEngine(name, metrics, dummyTable, outputTable, keyColumn, [filter], [snapshotDir], [snapshotIntervalInMsgCount], [keepOrder], [raftGroup])"
+                            "createReactiveStateEngine(name, metrics, dummyTable, outputTable, keyColumn, [filter], [snapshotDir], [snapshotIntervalInMsgCount], [keepOrder], [keyPurgeFilter], [keyPurgeFreqInSecond=0], [raftGroup])"
                         ]
                     }
                 ]
@@ -12062,20 +13165,17 @@
                         "value": [
                             "`name` is a string indicating the name of the reactive state engine. It is the only identifier of the reactive state engine. It can have letter, number and \"_\". It must start with a letter.",
                             "",
-                            "`metrics` is metacode specifying the formulas for calculation. The formulas should use vector functions instead of aggregate functions. For more information about metacode please refer to  :doc:`/Objects/Metaprogramming`.",
-                            "",
-                            ".. 下列状态函数在DolphinDB的响应式状态引擎中的实现均得到了优化。目前，状态引擎不允许使用未经优化的状态函数。应避免使用聚合函数。",
-                            "",
-                            ".. * 累计窗口函数: cumavg, cumsum, cumprod, cumcount, cummin, cummax, cumvar, cumvarp, cumstd, cumstdp, cumcorr, cumcovar, cumbeta, cumwsum, cumwavg",
-                            ".. * 滑动窗口函数: ema, mavg, msum, mcount, mprod, mvar, mvarp, mstd, mstdp, mskew, mkurtosis, mmin, mmax, mimin, mimax, mmed, mpercentile, mrank, mcorr, mcovar, mbeta, mwsum, mwavg, mslr",
-                            ".. * 序列相关函数: deltas, ratios, ffill, move, prev, iterate, ewmMean, ewmVar, ewmStd, ewmCovar, ewmCorr",
+                            "`metrics` is metacode specifying the formulas for calculation. The formulas should use vector functions instead of aggregate functions. For more information about metacode please refer to  :doc:`/Objects/Metaprogramming`. To use a user-defined function in the reactive state engine, please add \"@state\" to declare it before the definition.",
                             "",
                             "The following state functions in DolphinDB's reactive state engine has been optimized. Currently, unoptimized state functions are not supported by this engine. And aggregate functions should be avoid.",
                             "",
                             "* cumulative function: cumavg, cumsum, cumprod, cumcount, cummin, cummax, cumvar, cumvarp, cumstd, cumstdp, cumcorr, cumcovar, cumbeta, cumwsum, cumwavg, cumfirstNot, cumlastNot",
-                            "* moving function: ema, mavg, msum, mcount, mprod, mvar, mvarp, mstd, mstdp, mskew, mkurtosis, mmin, mmax, mimin, mimax, mmed, mpercentile, mrank, mcorr, mcovar, mbeta, mwsum, mwavg, 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, mmad, mfirst, mlast",
-                            "* Sequence-related function: deltas, ratios, ffill, move, prev, iterate, ewmMean, ewmVar, ewmStd, ewmCovar, ewmCorr",
-                            "* topN-related functions: msumTopN, mavgTopN, mstdpTopN, mstdTopN, mvarpTopN, mvarTopN, mcorrTopN, mbetaTopN, mcovarTopN, mwsumTopN",
+                            "* moving function: 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",
+                            "* order-sensitive function: deltas, ratios, ffill, move, prev, iterate, ewmMean, ewmVar, ewmStd, ewmCov, ewmCorr",
+                            "* topN functions: msumTopN, mavgTopN, mstdpTopN, mstdTopN, mvarpTopN, mvarTopN, mcorrTopN, mbetaTopN, mcovarTopN, mwsumTopN",
+                            "* other: talibNull",
+                            "",
+                            "Note: The parameter *func* in the state function ``talib`` can only be a state function supported by the reactive state engine.",
                             "",
                             "`dummyTable` is a table object whose schema must be the same as the subscribed stream table. The system uses the schema of dummyTable to determine the data type of each column in the messages. Whether dummyTable contains data does not matter.",
                             "",
@@ -12490,6 +13590,33 @@
                     }
                 ]
             },
+            {
+                "title": "Details",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "Create a time-series engine to conduct real-time time-series aggregate calculations with streaming data.",
+                            "",
+                            "Return a table object that subscribes to a stream table. Ingesting data to this table means that data enters the engine for windowed aggregations. The left boundary of the sliding window is inclusive and the right bounday is exclusive. ",
+                            "",
+                            "If *keyColumn* is specified to group the records that have the same key, the window calculation will be performed in each group.",
+                            "",
+                            "Rules for *timeColumn*:",
+                            "",
+                            "\\1. If keyColumn is not specified, the values in timeColumn must be incremental.",
+                            "",
+                            "\\2. If keyColumn is specified, the values from the same group in the timeColumn must be incremental.",
+                            "",
+                            "Otherwise, out-of-order data will will be discarded.",
+                            "",
+                            "Generally it is used in conjunction with :doc:`../s/subscribeTable`. Refer to `Time-Series Stream Engine of DolphinDB <https://github.com/dolphindb/Tutorials_EN/blob/master/stream_aggregator.md>`_ for more information. The engine it creates can be called across sessions.",
+                            ""
+                        ]
+                    }
+                ]
+            },
             {
                 "title": "Arguments",
                 "type": "parameters",
@@ -12499,16 +13626,11 @@
                         "value": [
                             "`name` is a string indicating the name of the engine. It is the only identifier of an engine. It can have letter, number and \"_\". It must start with a letter.",
                             "",
-                            "`useSystemTime` is a Boolean scalar. It is optional and the default value is false, which means that calculation for a window is triggered by the ingestion of the first record after the window if the window is not empty. If useSystemTime=true, fixed-length windows are determined based on the time when each record is ingested into the engine (with millisecond precision) instead of timeColumn. If a window is not empty, a calculation is triggered immediately after the window ends.",
-                            "",
-                            ".. * 当useSystemTime=true时，时间序列引擎会按照数据进入时间序列引擎的时刻（毫秒精度的本地系统时间，与数据中的时间列无关），每隔固定时间截取固定长度窗口的流数据进行计算。只要一个数据窗口中含有数据，数据窗口结束后就会自动进行计算。结果中的第一列为计算发生的时间戳，与数据中的时间无关。",
-                            "",
-                            ".. * 当useSystemTime=false（缺省值）时，时间序列引擎根据流数据中的timeColumn列来截取数据窗口。一个数据窗口结束后的第一条新数据才会触发该数据窗口的计算。请注意，触发计算的数据并不会参与该次计算。",
+                            "`useSystemTime` is an optional BOOLEAN indicating whether the calculations are performed based on the system time when data is ingested into the engine.",
                             "",
-                            ".. 例如，一个数据窗口从10:10:10到10:10:19。若useSystemTime=true, 则只要该窗口中至少有一条数据，该窗口的计算会在窗口结束后的10:10:20触发。若useSystemTime=false, 且10:10:19后的第一条数据为10:10:25，则该窗口的计算会在10:10:25触发。",
+                            "- *useSystemTime* = true: the engine will regularly window the streaming data at fixed time intervals for calculations according to the ingestion time (local system time with millisecond precision, independent of any temporal columns in the streaming table) of each record. As long as a window contains data, the calculation will be performed automatically when the window ends. The first column in output table indicates the timestamp when the calculation occurred.",
                             "",
-                            "* useSystemTime=true: the engine will regularly intercept the streaming data in a length-fixed window for calculations according to the time (local system time with millisecond precision). As long as a window contains data, the calculation will be performed automatically after the end of the window. The first column in output table indicates the timestamp when the calculation occurred.",
-                            "* useSystemTime=false: the engine will intercept the window according to the timeColumn in the streaming table. The calculation for a window is triggered by the first record after the previous window. Please note that the record which triggers the calculation will not participate in this calculation. ",
+                            "- *useSystemTime* = false (default): the engine will window the streaming data according to the timeColumn in the stream table. The calculation for a window is triggered by the first record after the previous window. Please note that the record which triggers the calculation will not participate in this calculation.",
                             "",
                             "For example, there is a window ranges from 10:10:10 to 10:10:19. If useSystemTime=true and the window is not empty, the calculation will be triggered at 10:10:20. If useSystemTime=false and the first record after 10:10:19 is at 10:10:25, the calculation will be triggered at 10:10:25.",
                             "",
@@ -12652,9 +13774,7 @@
                             "",
                             "* It can use one or more built-in or user-defined aggregate functions such as <[sum(volume), avg(price)]>, or expressions of aggregate functions such as as <[avg(price1)-avg(price2)]>, or aggregate functions on operations involving multiple columns such as <[std(price1-price2)]>. ",
                             "",
-                            ".. 支持输入元组。",
-                            "",
-                            "* A function used in metrics can return multiple results, such as <func(price) as \\`col1\\`col2>.",
+                            "* You can specify functions that return multiple values for metrics, such as <func(price) as \\`col1\\`col2> (it's not necessary to specify the column names).",
                             "",
                             "* If windowSize is a vector, each element of windowSize can correspond to multiple formulas in metrics. For example, if windowSize=[10,20], metrics can be  (<[min(volume), max(volume)]>,  <sum(volume)>). Metrics can also input nested tuple vectors, such as [[<[min(volume), max(volume)]>,  <sum(volume)>],[<avg(volume)>]].",
                             "",
@@ -12732,19 +13852,24 @@
                             "",
                             ".. fill可以输入向量，为每个metrics指定不同的fill方式。其中，向量中各项只能是'null', 'ffill'或一个数值，不能是'none'.",
                             "",
-                            "`fill` is a vector/scalar indicating the method to deal with an empty window.It could be:",
+                            "`fill` is a vector/scalar indicating the filling method to deal with an empty window (in a group). It could be:",
+                            "",
+                            "- 'none': no result",
+                            "- 'null': result is NULL.",
+                            "- 'ffill': output the result in the last window.",
+                            "- 'specific value': Specify a value. Its type should be the same as metrics output's type.",
+                            "",
+                            "*fill* could be a vector to specify different fill method for each metric. The element in vector can't be 'none'.",
                             "",
-                            "* 'none': no result",
-                            "* 'null': result is NULL.",
-                            "* 'ffill': output the result in the last window.",
-                            "* 'specific value': the type should be the same as metrics output's type.",
+                            "`forceTriggerTime` is an optional parameter. It is a non-negative integer indicating the waiting time (in seconds) to force trigger calculation in the uncalculated windows for each group. The rules are as follow:",
                             "",
-                            "fill could be a vector to specify different fill method for each metric. The element in vector can't be 'none'.",
+                            "\\1. Suppose the end time of the uncalculated window is t, and an incoming record of another group arrives at t1: when t1-t>=forceTriggerTime, calculation of the window will be triggered.",
                             "",
-                            "`forceTriggerTime` is a positive integer. It is optional. Calculation will be triggered if one of the following conditions are met.",
+                            "\\2. When a window doesn't contain any records:",
                             "",
-                            "* The difference between the time of the latest records and end time of the current window exceeds the forceTriggerTime. ",
-                            "* After a period of max(2*forceTriggerTime, 2 seconds).",
+                            "- If *fill* is not specified, the window returns no result.",
+                            "",
+                            "- If *fill* is specified, the result of the window will be filled using the specified filling method.",
                             "",
                             "Note: useSystemTime must be false and updateTime cannot be specified if forceTriggerTime is set. If the data belonging to the current window is still be injected into the engine after the calculation is forced to be triggered, the data will be calculated in the next window. It is recommended not to set the a small value to forceTriggerTime.",
                             "",
@@ -12753,23 +13878,23 @@
                             "* If updateTime is set, the output table must be a keyedTable; If forceTriggerTime is set, output table can be an in-memory table or a distributed table.",
                             "* If the data belonging to the current window is still reached after the calculation is forced to be triggered, the data will be calculated in the next window.",
                             "",
-                            "`raftGroup` is an integer greater than 1 indicating Raft group ID. Setting this parameter to enable high availability in the computing engine. The calculation engines will be created on other Followers, and the snapshot will be synchronized to other Followers as well. Enable high availability on subscriber with function subscribeTable. The raftGroup ID of subscribeTable must be the same as that of the stream engine. When the leader is down, it will automatically switch to a new leader and re-subscribe. Please note that SnapShotDir must be specified if raftGroup is specified."
-                        ]
-                    }
-                ]
-            },
-            {
-                "title": "Details",
-                "type": "detail",
-                "children": [
-                    {
-                        "type": "text",
-                        "value": [
-                            "Create a time-series engine to conduct real-time time-series aggregate calculations with streaming data.",
+                            "`raftGroup` is an integer greater than 1 indicating Raft group ID. Setting this parameter to enable high availability in the computing engine. The calculation engines will be created on other Followers, and the snapshot will be synchronized to other Followers as well. Enable high availability on subscriber with function subscribeTable. The raftGroup ID of subscribeTable must be the same as that of the stream engine. When the leader is down, it will automatically switch to a new leader and re-subscribe. Please note that SnapShotDir must be specified if raftGroup is specified.",
+                            "",
+                            "`keyPurgeFreqInSec` is a positive integer indicating the interval (in seconds) to remove groups with no incoming data for a long time. If a group has no incoming data for at least *keyPurgeFreqInSec* seconds after the last time of data purging, it will be removed. ",
+                            "",
+                            "Note: To specify this parameter, parameter *forceTriggerTime* must be specified and parameter *fill* cannot be specified. ",
+                            "",
+                            "You can check the number of groups in a time-series streaming engine based on the column numGroups returned by :doc:`../g/getStreamEngineStat`.",
                             "",
-                            "Return a table object that subscribes to a stream table. Writing data to this table means that data enters the engine for calculation.",
+                            "`closed` is a STRING indicating whether the left or the right boundary is included.",
                             "",
-                            "Generally it is used in conjunction with :doc:`../s/subscribeTable`. Refer to `Time-Series Stream Engine of DolphinDB <https://github.com/dolphindb/Tutorials_EN/blob/master/stream_aggregator.md>`_ for more information. The engine it creates can be called across sessions."
+                            "* closed = 'left': left-closed, right-open",
+                            "* closed = 'right': left-open, right-closed",
+                            "",
+                            ".. `closed`` is a STRING indicating the point in the moving window that need to be excluded from calculation. This optional parameter can specified as ‘left’ or ‘right’. The default value is `left`.",
+                            "",
+                            ".. * closed = 'left': the last point in the window is excluded from calculations.",
+                            ".. * closed = 'right': the first point in the window is excluded from calculations."
                         ]
                     }
                 ]
@@ -12792,8 +13917,8 @@
                             "  ",
                             "   $ share streamTable(1000:0, `time`sym`volume, [TIMESTAMP, SYMBOL, INT]) as trades",
                             "   $ output1 = table(10000:0, `time`sym`sumVolume, [TIMESTAMP, SYMBOL, INT])",
-                            "   $ agg1 = createTimeSeriesEngine(name=\"agg1\", windowSize=60000, step=60000, metrics=<[sum(volume)]>, dummyTable=trades, outputTable=output1, timeColumn=`time, useSystemTime=false, keyColumn=`sym, garbageSize=50, useWindowStartTime=false)",
-                            "   $ subscribeTable(tableName=\"trades\", actionName=\"agg1\", offset=0, handler=append!{agg1}, msgAsTable=true);",
+                            "   $ engine1 = createTimeSeriesEngine(name=\"engine1\", windowSize=60000, step=60000, metrics=<[sum(volume)]>, dummyTable=trades, outputTable=output1, timeColumn=`time, useSystemTime=false, keyColumn=`sym, garbageSize=50, useWindowStartTime=false)",
+                            "   $ subscribeTable(tableName=\"trades\", actionName=\"engine1\", offset=0, handler=append!{engine1}, msgAsTable=true);",
                             "   ",
                             "   $ insert into trades values(2018.10.08T01:01:01.785,`A,10)",
                             "   $ insert into trades values(2018.10.08T01:01:02.125,`B,26)",
@@ -12833,7 +13958,6 @@
                             "As there are no records since 01:05:00.000, no calculations are triggers for the window of [01:04:00.000, 01:05:00.000).",
                             "",
                             "The table output1 stores the calculation results of the time-series engine. As useWindowStartTime=false, the timestamps in the output table are the starting time of the windows + windowSize. If useWindowStartTime=true, then the timestamps in the output table are the starting time of the windows, as illustrated in the following example:",
-                            "",
                             ""
                         ]
                     },
@@ -12843,8 +13967,8 @@
                         "value": [
                             "  ",
                             "   $ output2 = table(10000:0, `time`sym`sumVolume, [TIMESTAMP, SYMBOL, INT])",
-                            "   $ agg2 = createTimeSeriesEngine(name=\"agg2\", windowSize=60000, step=60000, metrics=<[sum(volume)]>, dummyTable=trades, outputTable=output2, timeColumn=`time, useSystemTime=false, keyColumn=`sym, garbageSize=50, useWindowStartTime=true)",
-                            "   $ subscribeTable(tableName=\"trades\", actionName=\"agg2\", offset=0, handler=append!{agg2}, msgAsTable=true)",
+                            "   $ engine2 = createTimeSeriesEngine(name=\"engine2\", windowSize=60000, step=60000, metrics=<[sum(volume)]>, dummyTable=trades, outputTable=output2, timeColumn=`time, useSystemTime=false, keyColumn=`sym, garbageSize=50, useWindowStartTime=true)",
+                            "   $ subscribeTable(tableName=\"trades\", actionName=\"engine2\", offset=0, handler=append!{engine2}, msgAsTable=true)",
                             "   ",
                             "   $ sleep(10)",
                             "   $ select * from output2;",
@@ -12873,8 +13997,8 @@
                         "value": [
                             "  ",
                             "   $ output3 = keyedTable(`time`sym,10000:0, `time`sym`sumVolume, [TIMESTAMP, SYMBOL, INT])",
-                            "   $ agg3 = createTimeSeriesEngine(name=\"agg3\", windowSize=60000, step=60000, metrics=<[sum(volume)]>, dummyTable=trades, outputTable=output3, timeColumn=`time, useSystemTime=false, keyColumn=`sym, garbageSize=50, updateTime=1000, useWindowStartTime=false)",
-                            "   $ subscribeTable(tableName=\"trades\", actionName=\"agg3\", offset=0, handler=append!{agg3}, msgAsTable=true)",
+                            "   $ engine3 = createTimeSeriesEngine(name=\"engine3\", windowSize=60000, step=60000, metrics=<[sum(volume)]>, dummyTable=trades, outputTable=output3, timeColumn=`time, useSystemTime=false, keyColumn=`sym, garbageSize=50, updateTime=1000, useWindowStartTime=false)",
+                            "   $ subscribeTable(tableName=\"trades\", actionName=\"engine3\", offset=0, handler=append!{engine3}, msgAsTable=true)",
                             "   ",
                             "   $ sleep(2001)",
                             "   $ select * from output3;",
@@ -12983,24 +14107,46 @@
                             "",
                             "    $ share streamTable(1000:0, `time`sym`qty, [DATETIME, SYMBOL, INT]) as trades",
                             "    $ output3 = table(10000:0, `time`sym`sumQty, [DATETIME, SYMBOL, INT])",
-                            "    $ agg3 = createTimeSeriesEngine(name=\"agg3\", windowSize=6, step=6, metrics=<sum(qty)>, dummyTable=trades, outputTable=output3, timeColumn=`time,keyColumn=`sym, forceTriggerTime=7)",
-                            "    $ subscribeTable(tableName=\"trades\", actionName=\"agg3\", offset=0, handler=append!{agg3}, msgAsTable=true)",
-                            "    $ sleep(1000)",
-                            "    $ insert into agg3 values(2018.08.01T14:05:43,`A,1)",
-                            "    $ sleep(1000)",
-                            "    $ insert into agg3 values(2018.08.01T14:05:44,`B,1)",
-                            "    $ sleep(8000)",
-                            "    $ insert into agg3 values(2018.08.01T14:05:52,`B,3)",
-                            "    $ sleep(2000)",
-                            "    $ insert into agg3 values(2018.08.01T14:05:54,`A,3)",
+                            "",
+                            "    $ engine = createTimeSeriesEngine(name=\"engine\", windowSize=6, step=6, metrics=<sum(qty)>, dummyTable=trades, outputTable=output3, timeColumn=`time,keyColumn=`sym, forceTriggerTime=7,fill=1000)",
+                            "    $ subscribeTable(tableName=\"trades\", actionName=\"engine\", offset=0, handler=append!{engine}, msgAsTable=true)",
                             "    $ sleep(1000)",
-                            "    $ insert into agg3 values(2018.08.01T14:05:55,`A,5)",
-                            "    $ sleep(2000)",
-                            "    $ insert into agg3 values(2018.08.01T14:05:57,`B,5)",
-                            "    $ sleep(5000)",
-                            "    $ insert into agg3 values(2018.08.01T14:06:12,`A,1)",
-                            "    $ sleep(3000)",
-                            "    $ select * from output3 order by time,sym"
+                            "    $ insert into engine values(2018.08.01T14:05:43,`A,1)",
+                            "    $ insert into engine values(2018.08.01T14:05:43,`C,3)",
+                            "    $ sleep(10)",
+                            "    $ insert into engine values(2018.08.01T14:05:44,`B,1)",
+                            "    $ sleep(80)",
+                            "    $ insert into engine values(2018.08.01T14:05:52,`B,3)",
+                            "    $ sleep(20)",
+                            "    $ insert into engine values(2018.08.01T14:05:54,`A,3)",
+                            "    $ sleep(10)",
+                            "    $ insert into engine values(2018.08.01T14:05:55,`A,5)",
+                            "    $ sleep(20)",
+                            "    $ insert into engine values(2018.08.01T14:05:57,`B,5)",
+                            "    $ sleep(50)",
+                            "    $ insert into engine values(2018.08.01T14:06:12,`A,1)",
+                            "    $ sleep(50)",
+                            "    $ select * from output3 order by sym",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "=================== === ======",
+                            "time                sum  Qty",
+                            "=================== === ======",
+                            "2018.08.01T14:05:46 A\t1",
+                            "2018.08.01T14:05:52 A\t1,000",
+                            "2018.08.01T14:05:58 A\t8",
+                            "2018.08.01T14:06:04 A\t1,000",
+                            "2018.08.01T14:06:10 A\t1,000",
+                            "2018.08.01T14:05:46 B\t1",
+                            "2018.08.01T14:05:52 B\t1,000",
+                            "2018.08.01T14:05:58 B\t8",
+                            "2018.08.01T14:05:46 C\t3",
+                            "2018.08.01T14:05:52 C\t1,000",
+                            "=================== === ======"
                         ]
                     }
                 ]
@@ -13121,7 +14267,7 @@
                             "",
                             "`window` is a pair of integers or duration values, indicating the range of the sliding window, including both left and right bounds.",
                             "",
-                            "`metrics` is a required parameter indicating calculation metrics in the form of metacode. It can use one or more expressions, and built-in or user-defined functions. For details about metacode, see :doc:`/Objects/Metaprogramming`。",
+                            "`metrics` is a required parameter indicating calculation metrics in the form of metacode. It can use one or more expressions, and built-in or user-defined functions. You can specify functions that return multiple values for metrics, such as <func(price) as \\`col1\\`col2> (it’s not necessary to specify the column names). For details about metacode, see :doc:`/Objects/Metaprogramming`。",
                             "",
                             "When only the columns in the *rightTable* are involved in calculation, the window join engine optimizes the performance of the following functions: sum, sum2, avg, std, var, corr, covar, wavg, wsum, beta, max, min, last, first, med, percentile。",
                             "",
@@ -13157,6 +14303,8 @@
                         "value": [
                             "Create the window join streaming engine. Return a table that is the :doc:`/SQLStatements/TableJoiners/windowjoin` result of a left table and a right table. This function is usually used in conjunction with :doc:`../s/subscribeTable`.",
                             "",
+                            "Note: Only function :doc:`../a/appendForJoin`、:doc:`/FunctionsandCommands/FunctionReferences/g/getLeftStream` or :doc:`/FunctionsandCommands/FunctionReferences/g/getRightStream` can be used to ingest data into the window join engine.",
+                            "",
                             "Calculation rules of the engine:",
                             "",
                             "\\1. With data grouped based on the *matchingColumn*, the timestamp of each record from the left table determines a time window in the right table. The calculation of each window is triggered by the arrival of the first record after the current window ends.",
@@ -15623,7 +16771,9 @@
                     {
                         "type": "text",
                         "value": [
-                            "dailyAlignedBar(X, timeOffset, n, [timeEnd], [mergeSessionEnd=false])"
+                            "dailyAlignedBar(X, timeOffset, n, [timeEnd], [mergeSessionEnd=false])",
+                            "",
+                            "Related function: :doc:`../b/bar`"
                         ]
                     }
                 ]
@@ -15635,15 +16785,15 @@
                     {
                         "type": "text",
                         "value": [
-                            "`X`  is a scalar/vector of type DATETIME, TIMESTAMP or NANOTIMESTAMP.",
+                            "`X` is a temporal vector of type SECOND, TIME, NANOTIME, DATETIME, TIMESTAMP or NANOTIMESTAMP.",
                             "",
-                            "`timeOffset` is a scalar/vector of type SECOND, TIME or NANOTIME (corresponding to type DATETIME, TIMESTAMP or NANOTIMESTAMP of X) indicating the left boundary of session(s). If it is a vector, it must be increasing.",
+                            "`timeOffset` is a scalar/vector of type SECOND, TIME or NANOTIME with the same accuracy of *X* indicating the left boundary of session(s). If it is a vector, it must be increasing.",
                             "",
-                            "`n`  is a positive integer indicating the length of a window. If n is a positive integer, its unit is the minimum precision of timeOffset.",
+                            "`n` is a positive integer or DURATION type data indicating the window length. If n is a positive integer, its unit is the minimum accuracy of timeOffset. If n is a DURATION type data, its unit cannot be y, M, w, d, B.",
                             "",
-                            "`timeEnd`   is a scalar/vector of type SECOND, TIME or NANOTIME (corresponding to type DATETIME, TIMESTAMP or NANOTIMESTAMP of X) indicating the right boundary of session(s).",
+                            "`timeEnd` is an optional parameter of the same type and length of *timeOffset* indicating the right boundary of session(s).",
                             "",
-                            "`mergeSessionEnd`  is a Boolean value. When the right boundary of a session (as specified in timeEnd) is also the right boundary of a window, if mergeSessionEnd=true, the right boundary of the session is merged into the previous window."
+                            "`mergeSessionEnd` is a Boolean value. When the right boundary of a session (as specified in timeEnd) is also the right boundary of a window, if mergeSessionEnd=true, the right boundary of the session is merged into the previous window."
                         ]
                     }
                 ]
@@ -15751,7 +16901,24 @@
                     {
                         "type": "text",
                         "value": [
-                            "Related function: :doc:`../b/bar`"
+                            "Ex 3. When calculating 1-minute OHLC bars, the data type needs to be converted to LONG if n needs to be converted to NANOTIMESTAMP, otherwise an integer overflow will occur.",
+                            "",
+                            ".. code-block:: console",
+                            "   :linenos:",
+                            "   :emphasize-lines: 10, 12",
+                            "   ",
+                            "   $ n = 1000000",
+                            "   $ nano=(09:30:00.000000000 + rand(long(6.5*60*60*1000000000), n)).sort!() ",
+                            "   $ sessionStartNano=09:30:00.000000000 ",
+                            "   $ price = 100+cumsum(rand(0.02, n)-0.01)",
+                            "   $ volume = rand(1000, n)",
+                            "   $ symbol = rand(`600519`000001`600000`601766, n)",
+                            "   $ tradeNano=table(symbol, nano, price, volume).sortBy!(`symbol`nano)",
+                            "   $ undef(`nano`price`volume`symbol)",
+                            "   $ barMinutes=7",
+                            "   $ itv = barMinutes*60*long(1000000000)",
+                            "",
+                            "   $ OHLC_nano=select first(price) as open, max(price) as high, min(price) as low, last(price) as close, sum(volume) as volume from tradeNano group by symbol, dailyAlignedBar(nano, sessionStartNano, itv) as barStart"
                         ]
                     }
                 ]
@@ -15769,7 +16936,11 @@
                     {
                         "type": "text",
                         "value": [
-                            "database(directory, [partitionType], [partitionScheme], [locations])"
+                            "database(directory, [partitionType], [partitionScheme], [locations], [engine='OLAP'], [atomic='TRANS'])",
+                            "",
+                            "Starting from 1.30.16/2.00.4, if the configuration paramter *enableChunkGranularityConfig* = true, use the following syntax:",
+                            "",
+                            "database(directory, [partitionType], [partitionScheme], [locations], [engine='OLAP'], [atomic='TRANS'], [chunkGranularity='TABLE'])"
                         ]
                     }
                 ]
@@ -15803,7 +16974,24 @@
                             "|composite domain |COMPO                |A vector. Each element of the vector is a database handle.                                                          |",
                             "+-----------------+---------------------+--------------------------------------------------------------------------------------------------------------------+",
                             "",
-                            "`locations` a tuple indicating the locations of each partition. The number of elements in the tuple should be the same as that of partitions determined by *partitionType* and *partitionScheme*. When saving partitions on multiple nodes, we can specify the location for each partition by using the DFS (Distributed File System) or the *locations* parameter. If the *locations* parameter is not specified, all partitions reside in the current node. We cannot specify partition locations for composite partitions."
+                            "`locations` a tuple indicating the locations of each partition. The number of elements in the tuple should be the same as that of partitions determined by *partitionType* and *partitionScheme*. When saving partitions on multiple nodes, we can specify the location for each partition by using the DFS (Distributed File System) or the *locations* parameter. If the *locations* parameter is not specified, all partitions reside in the current node. We cannot specify partition locations for composite partitions.",
+                            "",
+                            "`engine = 'OLAP'` is a parameter with fixed value. Only version 2.00 supports modifying the parameter.",
+                            "",
+                            "`atomic` indicates at which level the atomicity is guaranteed for a write transaction, thus determining whether concurrent writes to the same chunk are allowed. It can be 'TRANS' or 'CHUNK' and the default value is 'TRANS'.",
+                            "",
+                            "- 'TRANS' indicates that the atomicity is guaranteed at the transaction level. If a transaction attempts to write to multiple chunks and one of the chunks is locked by another transaction, a write-write conflict occurs, and all writes of the transaction fail. Therefore, setting *atomic* ='TRANS' means concurrent writes to a chunk are not allowed.",
+                            "",
+                            "- 'CHUNK' indicates that the atomicity is guaranteed at the chunk level. If a transaction tries to write to multiple chunks and a write-write conflict occurs as a chunk is locked by another transaction, instead of aborting the writes, the transaction will keep writing to the non-locked chunks and keep attempting to write to the chunk in conflict until it is still locked after a few minutes. Therefore, setting *atomic* ='CHUNK' means concurrent writes to a chunk are allowed. As the atomicity at the transaction level is not guaranteed, the write operation may succeed in some chunks but fail in other chunks. Please also note that the write speed may be impacted by the repeated attempts to write to the chunks that are locked.",
+                            "",
+                            "`chunkGranularity` is a string indicating the chunk granularity. It determines whether concurrent writes to different tables in the same chunk are allowed. It is only enabled when *enableChunkGranularityConfig* = true is configured. The value can be 'TABLE' or 'DATABASE':",
+                            "",
+                            "- 'TABLE': the chunk granularity is at the TABLE level. In this case, concurrent writes to different tables in the same partition are allowed.",
+                            "",
+                            "- 'DATABASE': the chunk granularity is at the DATABASE level. In this case, concurrent writes to different tables in the same partition are not allowed.",
+                            "",
+                            "The chunk granularity determines where a DolphinDB transaction locates the lock. Before version 1.30.16/2.00.4, the chunk granularity is at the DATABASE level, i.e., each partition of the database is a chunk. Starting from version 1.30.16/2.00.4, the default chunk granularity is at the TABLE level and each table of the partition is a chunk.",
+                            ""
                         ]
                     }
                 ]
@@ -16208,7 +17396,37 @@
                         "language": "console",
                         "value": [
                             "  ",
-                            "   $ db=database(\"C:/DolphinDB/Data/rangedb6\", RANGE, 0 5 10, [[\"111.222.3.4:8080\", \"111.222.3.5:8080\"], \"111.222.3.6:8080\"])"
+                            "   $ db=database(\"C:/DolphinDB/Data/rangedb6\", RANGE, 0 5 10, [[\"111.222.3.4:8080\", \"111.222.3.5:8080\"], \"111.222.3.6:8080\"])",
+                            "",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "\\5. Examples regarding the parameter *atomic*:",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "   $ if(existsDatabase(\"dfs://test\"))",
+                            "   $ dropDB(\"dfs://test\")",
+                            "   $ db = database(directory=\"dfs://test\", partitionType=VALUE, partitionScheme=1..20, atomic='CHUNK')",
+                            "   $ dummy = table(take(1..20, 100000) as id, rand(1.0, 100000) as value)",
+                            "   $ pt = db.createPartitionedTable(dummy, \"pt\", `id)",
+                            "",
+                            "   $ dummy1 = table(take(1..15, 1000000) as id, rand(1.0, 1000000) as value)",
+                            "   $ dummy2 = table(take(11..20, 1000000) as id, rand(1.0, 1000000) as value)",
+                            "   $ submitJob(\"write1\", \"writer1\", append!{pt, dummy1})",
+                            "   $ submitJob(\"write2\", \"writer2\", append!{pt, dummy2})",
+                            "   $ submitJob(\"write3\", \"writer3\", append!{pt, dummy1})",
+                            "   $ submitJob(\"write4\", \"writer4\", append!{pt, dummy2})",
+                            "   $ select count(*) from pt",
+                            "   4,000,000"
                         ]
                     }
                 ]
@@ -17306,7 +18524,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "Delete a group of users. This can only be executed by an administrator on the controller."
+                            "Delete a group. This can only be executed by an administrator on the controller."
                         ]
                     }
                 ]
@@ -19698,6 +20916,78 @@
             }
         ]
     },
+    "dropDistributedInMemoryTable": {
+        "title": "dropDistributedInMemoryTable",
+        "type": "command",
+        "children": [
+            {
+                "title": "Syntax",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "dropDistributedInMemoryTable(tableName)"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Arguments",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "`tableName` is a STRING scalar indicating column names of a distributed in-memory table. "
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Details",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "Delete the specified distributed in-memory table. This function can only be executed on a data node or compute node."
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Examples",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ pt = createDistributedInMemoryTable(`dt, `time`id`value, `DATETIME`INT`LONG, HASH, [INT, 2],`id)",
+                            "    $ time = take(2021.08.20 00:00:00..2021.08.30 00:00:00, 40);",
+                            "    $ id = 0..39;",
+                            "    $ value = rand(100, 40);",
+                            "    $ tmp = table(time, id, value);",
+                            "",
+                            "    $ pt = loadDistributedInMemoryTable(`dt)",
+                            "    $ pt.append!(tmp);",
+                            "    $ dropDistributedInMemoryTable(`dt)",
+                            "",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "Related functions: :doc:`/FunctionsandCommands/FunctionReferences/l/loadDistributedInMemoryTable`, :doc:`/FunctionsandCommands/FunctionReferences/c/createDistributedInMemoryTable`"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "dropFunctionView": {
         "title": "dropFunctionView",
         "type": "command",
@@ -21568,9 +22858,9 @@
                     {
                         "type": "text",
                         "value": [
-                            "Compare the object types and values of two objects to see if they are identical. Return true only if both types and values are identical.",
+                            "Check if the data types and values of two objects are identical. Return true only if both data types and values are identical. Please note that ``eqObj`` returns false if values are identical but object types are different. This is different from fuction :doc:`eq`.",
                             "",
-                            "Please note that ``eqObj`` returns false if values are identical but object types are different. This is different from fuction :doc:`eq`."
+                            "Note: When comparing floating point numbers, function eqObj determines whether the values of obj1 and obj2 are equal based on the result of abs(obj1-obj2)<=pow(10,-precision)."
                         ]
                     }
                 ]
@@ -21585,21 +22875,21 @@
                         "value": [
                             "  ",
                             "   $ eqObj(2, 2.0);",
-                            "   0",
+                            "   false",
                             "",
                             "   $ eq(2, 2.0);",
-                            "   1",
+                            "   true",
                             "",
                             "   $ eqObj(1.1, 1.2, 0);",
-                            "   1",
+                            "   true",
                             "",
                             "   $ eqObj(1.1, 1.2, 1);",
-                            "   0",
+                            "   false",
                             "",
                             "   $ eqObj(1 2 3, 1 2 3);",
-                            "   1",
+                            "   true",
                             "   $ eq(1 2 3, 1 2 3);",
-                            "   [1,1,1]",
+                            "   [true,true,true]",
                             ""
                         ]
                     },
@@ -21622,7 +22912,7 @@
                             "   ([1,2,3],[4,5,6])",
                             "",
                             "   $ each(eqObj, t1.values(), t2.values());",
-                            "   [1,1]"
+                            "   [true,true]"
                         ]
                     }
                 ]
@@ -26794,6 +28084,63 @@
             }
         ]
     },
+    "getCurrentSessionAndUser": {
+        "title": "getCurrentSessionAndUser",
+        "type": "function",
+        "children": [
+            {
+                "title": "Syntax",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "getCurrentSessionAndUser()"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Arguments",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "None"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Details",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "Get the sessionId and username of the current session. Return a tuple with sessionId as the first element and userId as the second element."
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Examples",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ getCurrentSessionAndUser()",
+                            "    (1166953221,\"admin\")"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "getDFSTablesByDatabase": {
         "title": "getDFSTablesByDatabase",
         "type": "function",
@@ -27659,6 +29006,106 @@
             }
         ]
     },
+    "getLeftStream": {
+        "title": "getLeftStream",
+        "type": "function",
+        "children": [
+            {
+                "title": "Arguments",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "`joinEngine` is a table object returned by creating a join engine. The join engines currently supported by DolphinDB are:",
+                            "",
+                            "* createAsofJoinEngine",
+                            "",
+                            "* createEqualJoinEngine",
+                            "",
+                            "* createLookupJoinEngine",
+                            "",
+                            "* createWindowJoinEngine"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Details",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "Return the schema of the left table of the join engine. The data ingested into this schema will be ingested into *joinEngine*.",
+                            "",
+                            "The result of an engine can be ingested into the join engine to realize the cascade between engines."
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Examples",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "  ",
+                            "    $ share streamTable(1000:0, `time`sym`price, [TIMESTAMP, SYMBOL, DOUBLE]) as trades",
+                            "",
+                            "    $ output=table(100:0, `timestamp`sym`price1`price2, [TIMESTAMP, SYMBOL, DOUBLE, DOUBLE])",
+                            "",
+                            "    $ leftTable=table(1:0, `sym`timestamp`price, [SYMBOL, TIMESTAMP, DOUBLE])",
+                            "    $ rightTable=table(1:0, `sym`timestamp`price, [SYMBOL, TIMESTAMP, DOUBLE])",
+                            "",
+                            "    $ ajEngine = createAsofJoinEngine(\"asofjoin_engine\", leftTable, rightTable, output, <[leftTable.price, rightTable.price]>, `sym, `timestamp)",
+                            "",
+                            "    $ leftEngine = createReactiveStateEngine(name=`left_reactive_engine, metrics=<[time,msum(price,3)]>, dummyTable=trades, outputTable=getLeftStream(ajEngine), keyColumn=\"sym\")",
+                            "    $ rightEngine = createReactiveStateEngine(name=`right_reactive_engine, metrics=<[time,mfirst(price,3)]>, dummyTable=trades, outputTable=getRightStream(ajEngine), keyColumn=\"sym\")",
+                            "",
+                            "    $ subscribeTable(, \"trades\", \"left_reactive_engine\", 0, append!{leftEngine}, true)   ",
+                            "    $ subscribeTable(, \"trades\", \"right_reactive_engine\", 0, append!{rightEngine}, true) ",
+                            "",
+                            "    $ t = table(2022.01.01 + 1..20 as time, take(`AMZN`IBM`APPL, 20) as sym, rand(100.0, 20) as price)",
+                            "    $ trades.append!(t)  ",
+                            "    $ select * from output order by timestamp,sym",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "======================= ==== ======== ======",
+                            "timestamp               sym  price1   price2",
+                            "======================= ==== ======== ======",
+                            "2022.01.02T00:00:00.000 AMZN ",
+                            "2022.01.03T00:00:00.000 IBM ",
+                            "2022.01.04T00:00:00.000 APPL ",
+                            "2022.01.05T00:00:00.000 AMZN ",
+                            "2022.01.06T00:00:00.000 IBM ",
+                            "2022.01.07T00:00:00.000 APPL ",
+                            "2022.01.08T00:00:00.000 AMZN 102.192   26.2273",
+                            "2022.01.09T00:00:00.000 IBM  152.2704  43.6296",
+                            "2022.01.10T00:00:00.000 APPL 126.1056  74.929",
+                            "2022.01.11T00:00:00.000 AMZN 137.4656  57.6015",
+                            "2022.01.12T00:00:00.000 IBM  116.7775  54.2854",
+                            "2022.01.13T00:00:00.000 APPL 58.8909   49.3149",
+                            "2022.01.14T00:00:00.000 AMZN 148.5405  18.3633",
+                            "2022.01.15T00:00:00.000 IBM  141.0848  54.3554",
+                            "2022.01.16T00:00:00.000 APPL 93.9003   1.8618",
+                            "2022.01.17T00:00:00.000 AMZN 210.4329  61.5008",
+                            "2022.01.18T00:00:00.000 IBM  88.7772   8.1367",
+                            "======================= ==== ======== ======",
+                            "",
+                            "Related function: :doc:`/FunctionsandCommands/FunctionReferences/g/getRightStream`."
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "getLicenseExpiration": {
         "title": "getLicenseExpiration",
         "type": "function",
@@ -28668,6 +30115,113 @@
             }
         ]
     },
+    "getRecoveryWorkerNum": {
+        "title": "getRecoveryWorkerNum",
+        "type": "command",
+        "children": [
+            {
+                "title": "Arguments",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "None"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Details",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "Get the number of worker threads used by the current node for chunk recovery."
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Examples",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ resetRecoveryWorkerNum(2)",
+                            "    $ getRecoveryWorkerNum()",
+                            "    2",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "Related function: :doc:`../r/resetRecoveryWorkerNum`"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
+    "getRightStream": {
+        "title": "getRightStream",
+        "type": "function",
+        "children": [
+            {
+                "title": "Syntax",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "getRightStream(joinEngine)"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Arguments",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "`joinEngine` is a table object returned by creating a join engine. The join engines currently supported by DolphinDB are:",
+                            "",
+                            "* createAsofJoinEngine",
+                            "",
+                            "* createEqualJoinEngine",
+                            "",
+                            "* createLookupJoinEngine",
+                            "",
+                            "* createWindowJoinEngine"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Details",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "Return the schema of the right table of the join engine. The data ingested into this schema will be inserted into *joinEngine*.",
+                            "",
+                            "The result of an engine can be directly ingested into the join engine to realize the cascade between engines.",
+                            "",
+                            "Please refer to :doc:`/FunctionsandCommands/FunctionReferences/g/getLeftStream` for specific examples."
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "getRunningQueries": {
         "title": "getRunningQueries",
         "type": "function",
@@ -40032,6 +41586,86 @@
             }
         ]
     },
+    "listTables": {
+        "title": "listTables",
+        "type": "function",
+        "children": [
+            {
+                "title": "Syntax",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "listTables(dbUrl)"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Arguments",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "`dbUrl` is a string indicating the local path or dfs path of a database."
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Details",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "Return a table of two columns, tableName and physicalIndex. Please note that only the database with chunks of the table level can have physical indices."
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "First Release",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "1.30.16/2.00.4"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Examples",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "    ",
+                            "    $ listTables(dbPath)",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "+----------+-------------+",
+                            "|tableName |physicalIndex|",
+                            "+==========+=============+",
+                            "|pt1       |1By          |",
+                            "+----------+-------------+",
+                            "|pt        |1Bw          |",
+                            "+----------+-------------+"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "loadBackup": {
         "title": "loadBackup",
         "type": "function",
@@ -40114,6 +41748,78 @@
             }
         ]
     },
+    "loadDistributedInMemoryTable": {
+        "title": "loadDistributedInMemoryTable",
+        "type": "function",
+        "children": [
+            {
+                "title": "Syntax",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "loadDistributedInMemoryTable(tableName)"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Arguments",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "`tableName` is a STRING scalar indicating column names of a distributed in-memory table."
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Details",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "Delete the specified distributed in-memory table. This function can only be executed on a data node or compute node."
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Examples",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "",
+                            "    $ pt = createDistributedInMemoryTable(`dt, `time`id`value, `DATETIME`INT`LONG, HASH, [INT, 2],`id)",
+                            "    $ time = take(2021.08.20 00:00:00..2021.08.30 00:00:00, 40);",
+                            "    $ id = 0..39;",
+                            "    $ value = rand(100, 40);",
+                            "    $ tmp = table(time, id, value);",
+                            "",
+                            "    $ pt = loadDistributedInMemoryTable(`dt)",
+                            "    $ pt.append!(tmp);",
+                            "    $ select * from pt;",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "Related functions: :doc:`/FunctionsandCommands/CommandsReferences/d/dropDistributedInMemoryTable`, :doc:`/FunctionsandCommands/FunctionReferences/c/createDistributedInMemoryTable`"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "loadModel": {
         "title": "loadModel",
         "type": "function",
@@ -41190,13 +42896,10 @@
                     {
                         "type": "text",
                         "value": [
-                            "Load a text file into memory as a table. In comparison, the function :doc:`../l/loadTable` loads binary tables into memory. *loadText* is more time consuming than *loadTable*.",
-                            "",
-                            "*loadText* loads data in single thread. To load data in multiple threads, use :doc:`../p/ploadText` .",
+                            "Load a text file into memory as a table. *loadText* loads data in single thread. To load data in multiple threads, use :doc:`../p/ploadText` .",
                             "",
-                            "When loading a text file, the system determines the data type of each column based on a random sample of rows. This convenient feature may not always accurately determine the data type of all columns. We recommend users check the data type of each column with the :doc:`../e/extractTextSchema` function after loading. If a column does not have the expected data type, then we need to enter the correct data type of the column in the schema table. Users can also specify data types for all columns. For a temporal column, if it does not have the expected data type, we also need to specify a format such as \"MM/dd/yyyy\" in the schema table. For details about temporal formats please refer to :doc:`/DataManipulation/TemporalObjects/ParsingandFormatofTemporalVariables`.",
-                            "",
-                            "If none of the columns in the first row of the file starts with a number, the first row is treated as the header with column names of the text file. Otherwise the system uses *col0*, *col1*, ..... as the column names.",
+                            "* When loading a text file, the first row of data is read in string format, and the column names are parsed from that data. Please note that the upper limit for the first row is 256 KB. If none of the columns in the first row of the file starts with a number, the first row is treated as the header with column names of the text file. If at least one of the columns in the first row of the file starts with a number, the system uses col0, col1, ... as the column names.",
+                            "* When loading a text file, the system determines the data type of each column based on a random sample of rows. This convenient feature may not always accurately determine the data type of all columns. We recommend users check the data type of each column with the :doc:`../e/extractTextSchema` function after loading. If a column does not have the expected data type, then we need to enter the correct data type of the column in the schema table. Users can also specify data types for all columns. For a temporal column, if it does not have the expected data type, we also need to specify a format such as \"MM/dd/yyyy\" in the schema table. For details about temporal formats please refer to :doc:`/DataManipulation/TemporalObjects/ParsingandFormatofTemporalVariables`.",
                             "",
                             "As string in DolphinDB is encoded in UTF-8, we require input text files be encoded in UTF-8.",
                             "",
@@ -45139,6 +46842,82 @@
             }
         ]
     },
+    "memSize": {
+        "title": "memSize",
+        "type": "function",
+        "children": [
+            {
+                "title": "Syntax",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "memSize(obj)"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Arguments",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "`obj` is an object."
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Details",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "Return the memory usage (in units of bytes) of a local or shared object."
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Examples",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "   $ $ n=100",
+                            "   $ ID=rand(100, n)",
+                            "   $ date=rand(2017.08.07..2017.08.11, n)",
+                            "   $ x=rand(10.0, n)",
+                            "   $ t=table(ID, date, x);",
+                            "   $ share t as tt",
+                            "   $ memSize(t)",
+                            "   1952",
+                            "   $ memSize(tt)",
+                            "   1952",
+                            "   $ memSize(t[`x])",
+                            "   800",
+                            "   $ memSize(select avg(x) as avgx from t)",
+                            "   280",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "Related functions: :doc:`../o/objs`"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "member": {
         "title": "member",
         "type": "function",
@@ -47712,7 +49491,7 @@
                             "",
                             "`destNode` is a string indicating the alias of destination node.",
                             "",
-                            "`chunkId` is a string or a string vector indicating ID of chunks. "
+                            "`chunkId` is a string/UUID scalar or vector indicating ID of chunks. "
                         ]
                     }
                 ]
@@ -47724,7 +49503,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "Move replicas of one or multiple chunks from a node to another node. If the destination node already has the chunk, the command is skipped.",
+                            "Move replicas of one or multiple chunks from the source node to the destination node. If the destination node already has the chunk, the command is skipped.",
                             "",
                             "This command can only be executed by an administrator on a controller node.",
                             "",
@@ -50483,11 +52262,11 @@
                     {
                         "type": "text",
                         "value": [
-                            "`mean` is the mean (center) of a normal distribution.",
+                            "`mean` is a numeric scalar indicating the mean of a normal distribution.",
                             "",
-                            "`std` is the standard deviation (spread or width) of a normal distribution. ",
+                            "`std` is a numeric scalar indicating standard deviation of a normal distribution. ",
                             "",
-                            "`count` is a positive integer indicating the output vector size."
+                            "`count` is an integral scalar/pair. A scalar indicates the length of the output vector. A pair indicates the dimension of the output matrix."
                         ]
                     }
                 ]
@@ -50499,7 +52278,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "Return a vector of size `count` that follows a normal distribution with mean of mean and standard deviation of `std`. "
+                            "Return a vector(matrix) that follows a normal distribution. "
                         ]
                     }
                 ]
@@ -50521,7 +52300,25 @@
                             "",
                             "",
                             "    $ std norm(10000);",
-                            "    0.995806"
+                            "    0.995806",
+                            "",
+                            "    //生成随机矩阵",
+                            "    $ norm(0, 1, 3:2)",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "+---------+---------+ ",
+                            "|col1     |col2     |",
+                            "+=========+=========+",
+                            "|(0.5399) |(0.8475) |",
+                            "+---------+---------+ ",
+                            "|(1.0029) |1.811    |",
+                            "+---------+---------+ ",
+                            "|(0.0485) |(0.4339) |",
+                            "+---------+---------+ "
                         ]
                     }
                 ]
@@ -51220,6 +53017,78 @@
             }
         ]
     },
+    "objectChecksum": {
+        "title": "objectChecksum",
+        "type": "function",
+        "children": [
+            {
+                "title": "Syntax",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "objectChecksum(vector, [prev])"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Arguments",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "`vector` is a vector that is used for calculating checksums.",
+                            "",
+                            "`prev` is an integer. If the vector is too long, the checksum can be computed iteratively by specifying prev which represents the checksum of the previous segment of data during iteration."
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Details",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "Calculate the checksum of a vector. The result is an integer. It is often used to verify data integrity."
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Examples",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ print objectChecksum(take(`A`B`C, 10))",
+                            "    -268298654",
+                            "    ",
+                            "    $ print objectChecksum(2.3 6.5 7.8)",
+                            "    -430996932",
+                            "",
+                            "    //calculate checksum section by section",
+                            "    $ print objectChecksum(1..15)",
+                            "    -1877567753",
+                            "",
+                            "    $ t0 = objectChecksum(1..5)",
+                            "    $ t1 = objectChecksum(6..10, t0)",
+                            "    $ t2 = objectChecksum(11..15, t1)",
+                            "    $ print t2 ",
+                            "    -1877567753"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "objs": {
         "title": "objs",
         "type": "function",
@@ -53328,11 +55197,11 @@
                     {
                         "type": "text",
                         "value": [
-                            "`function` the local function to call. It must not be quoted. It must have no parameters. It can be a function with no parameters by definition, or a partial application that wraps the orginal function and its parameters to a function with no parameters. It can be a built-in function or a user-defined function.",
+                            "`function` the local function to call. It must not be quoted. It can be a function with no parameters by definition, or a partial application that wraps the orginal function and its parameters to a function with no parameters. It can be a built-in function or a user-defined function.",
                             "",
-                            "`nodes` aliases of nodes. It is an optional parameter. If it is not specified, the system will call the function on all live data nodes in the cluster.",
+                            "`nodes` aliases of nodes. It is an optional parameter. If it is not specified, the system will call the function on all live data nodes and compute nodes in the cluster.",
                             "",
-                            "`addNodeAlias` whether to add aliases of nodes to results. It is an optional parameter. The default value is true. If the returned result from each node already contains the node alias, we can set it to false. "
+                            "`addNodeAlias` whether to add aliases of nodes to results. It is an optional parameter. The default value is true. You can set it to false if the result from each node already contains the node alias. "
                         ]
                     }
                 ]
@@ -53344,7 +55213,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "Call a local function on all data nodes in a cluster in parallel and then merge the results. "
+                            "Call a local function on all data nodes and compute nodes in a cluster in parallel and then merge the results. "
                         ]
                     }
                 ]
@@ -53356,7 +55225,35 @@
                     {
                         "type": "text",
                         "value": [
-                            "In the following simple example, we wrap the function ``sum`` and arguments 1..10 to a partial application `sum{1..10}`. ",
+                            "Ex. 1 Call function ``getChunksMeta`` without specifying parameters",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ pnodeRun(getChunksMeta,,false);",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "=========  ===================================== ============================================================================= =======================  ===== ===== ===== ======== ====== ==========================",
+                            "site       chunkId                               path                                                                          dfsPath                  type   flag size  version  state  versionList             ",
+                            "=========  ===================================== ============================================================================= =======================  ===== ===== ===== ======== ====== ==========================",
+                            "local8848  bd13090e-7177-01a7-4ac4-840e1b977dcf  D:\\130\\DolphinDB_Win64_V\\server\\local8848\\storage/CHUNKS/compo/20190605/GOOG   /compo/20190605/GOOG    1     0     0     1        0      cid : 40,pt2=>40:6729; # ",
+                            "local8848  b4935730-6372-b2a1-4f24-6c323037e576  e:\\data/CHUNKS/compo/20190605/AAPL                                             /compo/20190605/AAPL    1     0     0     1        0      cid : 40,pt2=>40:6613; # ",
+                            "local8848  f8ee72c9-dad3-f49e-430e-5ddb3c61ae18  D:\\130\\DolphinDB_Win64_V\\server\\local8848\\storage/CHUNKS/compo/20190604/MSFT   /compo/20190604/MSFT    1     0     0     1        0      cid : 40,pt2=>40:6664; # ",
+                            "local8848  08e26b5a-dfac-799f-4979-0dd3902eae6e  D:\\130\\DolphinDB_Win64_V\\server\\local8848\\storage/CHUNKS/compo/20190604/GOOG   /compo/20190604/GOOG    1     0     0     1        0      cid : 40,pt2=>40:6635; # ",
+                            "local8848  f9e53a3d-af3e-018d-4bfa-a2b4980f3561  D:\\130\\DolphinDB_Win64_V\\server\\local8848\\storage/CHUNKS/compo/20190604/AAPL   /compo/20190604/AAPL    1     0     0     1        0      cid : 40,pt2=>40:6783; # ",
+                            "local8848  417e49e9-5c61-cf9e-4b21-4b35f8e57273  D:\\130\\DolphinDB_Win64_V\\server\\local8848\\storage/CHUNKS/compo/20190601/MSFT   /compo/20190601/MSFT    1     0     0     1        0      cid : 40,pt2=>40:6602; # ",
+                            "local8848  3ee64942-1d72-bea7-4bc1-f720132d9288  D:\\130\\DolphinDB_Win64_V\\server\\local8848\\storage/CHUNKS/compo/20190602/AAPL   /compo/20190602/AAPL    1     0     0     1        0      cid : 40,pt2=>40:6749; # ",
+                            "=========  ===================================== ============================================================================= =======================  ===== ===== ===== ======== ====== ==========================",
+                            "",
+                            "Ex. 2 In the following example, the function ``sum`` and arguments 1..10 are wrapped into a partial application ``sum{1..10}``. ",
                             ""
                         ]
                     },
@@ -53379,7 +55276,7 @@
                             "DFS_NODE3   55",
                             "=========== ======",
                             "",
-                            "``pnodeRun`` is a very convenient tool for cluster management. For example, in a cluster of 4 nodes: \"DFS_NODE1\", \"DFS_NODE2\", \"DFS_NODE3\", and \"DFS_NODE4\", run the following script on each of the node:",
+                            "Ex. 3 ``pnodeRun`` is a very convenient tool for cluster management. For example, in a cluster of 4 nodes: \"DFS_NODE1\", \"DFS_NODE2\", \"DFS_NODE3\", and \"DFS_NODE4\", run the following script on each of the node:",
                             ""
                         ]
                     },
@@ -53467,32 +55364,7 @@
                             "+---------+-------+--------+--------+-----------------------+-----------------------+-----------------------+--------+",
                             "|DFS_NODE4|  root |jobDemo3|job demo|2017.11.16T13:05:16.325|2017.11.16T13:05:16.328|2017.11.16T13:05:34.716|        |",
                             "+---------+-------+--------+--------+-----------------------+-----------------------+-----------------------+--------+",
-                            ""
-                        ]
-                    },
-                    {
-                        "type": "code",
-                        "language": "console",
-                        "value": [
                             "",
-                            "    $ pnodeRun(getAllChunks,,false);",
-                            ""
-                        ]
-                    },
-                    {
-                        "type": "text",
-                        "value": [
-                            "=========  ===================================== ============================================================================= =======================  ===== ===== ===== ======== ====== ==========================",
-                            "site       chunkId                               path                                                                          dfsPath                  type   flag size  version  state  versionList             ",
-                            "=========  ===================================== ============================================================================= =======================  ===== ===== ===== ======== ====== ==========================",
-                            "local8848  bd13090e-7177-01a7-4ac4-840e1b977dcf  D:\\130\\DolphinDB_Win64_V\\server\\local8848\\storage/CHUNKS/compo/20190605/GOOG   /compo/20190605/GOOG    1     0     0     1        0      cid : 40,pt2=>40:6729; # ",
-                            "local8848  b4935730-6372-b2a1-4f24-6c323037e576  e:\\data/CHUNKS/compo/20190605/AAPL                                             /compo/20190605/AAPL    1     0     0     1        0      cid : 40,pt2=>40:6613; # ",
-                            "local8848  f8ee72c9-dad3-f49e-430e-5ddb3c61ae18  D:\\130\\DolphinDB_Win64_V\\server\\local8848\\storage/CHUNKS/compo/20190604/MSFT   /compo/20190604/MSFT    1     0     0     1        0      cid : 40,pt2=>40:6664; # ",
-                            "local8848  08e26b5a-dfac-799f-4979-0dd3902eae6e  D:\\130\\DolphinDB_Win64_V\\server\\local8848\\storage/CHUNKS/compo/20190604/GOOG   /compo/20190604/GOOG    1     0     0     1        0      cid : 40,pt2=>40:6635; # ",
-                            "local8848  f9e53a3d-af3e-018d-4bfa-a2b4980f3561  D:\\130\\DolphinDB_Win64_V\\server\\local8848\\storage/CHUNKS/compo/20190604/AAPL   /compo/20190604/AAPL    1     0     0     1        0      cid : 40,pt2=>40:6783; # ",
-                            "local8848  417e49e9-5c61-cf9e-4b21-4b35f8e57273  D:\\130\\DolphinDB_Win64_V\\server\\local8848\\storage/CHUNKS/compo/20190601/MSFT   /compo/20190601/MSFT    1     0     0     1        0      cid : 40,pt2=>40:6602; # ",
-                            "local8848  3ee64942-1d72-bea7-4bc1-f720132d9288  D:\\130\\DolphinDB_Win64_V\\server\\local8848\\storage/CHUNKS/compo/20190602/AAPL   /compo/20190602/AAPL    1     0     0     1        0      cid : 40,pt2=>40:6749; # ",
-                            "=========  ===================================== ============================================================================= =======================  ===== ===== ===== ======== ====== ==========================",
                             "",
                             "How does ``pnodeRun`` merge the results from multiple nodes:",
                             "",
@@ -53537,8 +55409,6 @@
                             "",
                             "Return a table which is the union of individual tables from multiple nodes.",
                             "",
-                            "Please see the aforementioned example of `pnodeRun(getRecentJobs{2})`.",
-                            "",
                             "\\(5) If `function` is a command (a command returns nothing):",
                             "",
                             "Return nothing",
@@ -54163,43 +56033,46 @@
                 ]
             },
             {
-                "title": "Arguments",
-                "type": "parameters",
+                "title": "Details",
+                "type": "detail",
                 "children": [
                     {
                         "type": "text",
                         "value": [
-                            "`host` the host name of the client node.",
+                            "This function is executed on the server where the stream table is located. It instructs the server to publish data from a stream table to a client. The client may or may not be a DolphinDB data node or API. In comparison, when we use function :doc:`../s/subscribeTable`, the client must be a DolphinDB data node.",
                             "",
-                            "`port` the subscription port number of the client node specified by the parameter `subPort`. ",
-                            "",
-                            "`tableName` a string indicating the name of the shared stream table on the local server.",
-                            "",
-                            "`actionName` a string indicating the name assigned to the subscription task. It can have letters, digits and underscores.",
+                            "This function returns a string vector, including the list of column names of the stream table.",
                             "",
-                            "`offset` the position of the first message to subscribe. A message is row of the stream table. If offset is unspecified, or negative, or above the number of rows of the stream table, the subscription starts from the first row of the stream table. The offset is relative to the first row of the stream table when it is created. If some rows were cleared from memory due to cache size limit, they are still considered in determining where the subscription starts.",
-                            "",
-                            "`filter`  a vector of selected values in the filtering column. Only the messages with specified filtering column values are published. The filtering column is set with function :doc:`/FunctionsandCommands/CommandsReferences/s/setStreamTableFilterColumn`. filter does not support Boolean types.",
+                            "The function throws an exception if the specified table doesn't exist or it is not a stream table, or if the subscription already exists on the client and allowExists=false.",
                             "",
-                            "`allowExists` is a Boolean value. When `allowExists`\\=true, if the subscription already exists before function ``publishTable`` is executed, the system will not throw an exception.  "
+                            "Use command :doc:`/FunctionsandCommands/CommandsReferences/s/stopPublishTable` to stop publishing data. ",
+                            ""
                         ]
                     }
                 ]
             },
             {
-                "title": "Details",
-                "type": "detail",
+                "title": "Arguments",
+                "type": "parameters",
                 "children": [
                     {
                         "type": "text",
                         "value": [
-                            "This function is executed on the server where the stream table is located. It instructs the server to publish data from a stream table to a client. The client may or may not be a DolphinDB node. In comparison, when we use function :doc:`../s/subscribeTable`, the client must be a DolphinDB node.",
+                            "`host` the host name of the client node.",
                             "",
-                            "This function returns the list of column names of the stream table.",
+                            "`port` the subscription port number of the client. If the client is the DolphinDB data node, *port* is specified by the parameter *subPort*. If the client is an API, *port* is subscription port number enabled by the client.",
                             "",
-                            "The function throws an exception if the specified table doesn't exist or it is not a stream table, or if the subscription already exists on the client and allowExists=false.",
+                            "`tableName` a string indicating the name of the shared stream table on the local server.",
+                            "",
+                            "`actionName` a string indicating the name assigned to the subscription task. It can have letters, digits and underscores.",
+                            "",
+                            "`offset` the position of the first message to subscribe. A message is row of the stream table. If offset is unspecified, or negative, or above the number of rows of the stream table, the subscription starts from the next incoming record. The offset is relative to the first row of the stream table when it is created. If some rows were cleared from memory due to cache size limit, they are still considered in determining where the subscription starts.",
                             "",
-                            "Use command :doc:`/FunctionsandCommands/CommandsReferences/s/stopPublishTable` to stop publishing data. "
+                            "`filter` a vector of selected values in the filtering column. Only the messages with specified filtering column values are published. The filtering column is set with function :doc:`/FunctionsandCommands/CommandsReferences/s/setStreamTableFilterColumn`. filter does not support Boolean types.",
+                            "",
+                            "`allowExists` a Boolean value. When `allowExists`\\=true, if the subscription already exists before function ``publishTable`` is executed, the system will not throw an exception.  ",
+                            "",
+                            "`resetOffset` a Boolean value indicating whether to reset the *offset* to -1, the default value is false. When resetOffset = true, the *offset* will be reset if the row specified by the *offset* in the stream table has no data and the subscription will start from the next incoming record."
                         ]
                     }
                 ]
@@ -54225,6 +56098,59 @@
             }
         ]
     },
+    "purgeCacheEngine": {
+        "title": "purgeCacheEngine",
+        "type": "command",
+        "children": [
+            {
+                "title": "Syntax",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "purgeCacheEngine()"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Arguments",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "None"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Details",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "Forcibly flush the data of completed transactions cached in the OLAP cache engine to the database. Specify the configuration parameter *chunkCacheEngineMemSize* and set *dataSync* = 1 before execution."
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "First Release",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "1.30.16/2.00.4"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "push!": {
         "title": "push!",
         "type": "function",
@@ -55235,7 +57161,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "rand(X, n)"
+                            "rand(X, count)"
                         ]
                     }
                 ]
@@ -55249,7 +57175,7 @@
                         "value": [
                             "`X` is a scalar/vector. ",
                             "",
-                            "`n` is the number of random values to be generated."
+                            "`count` is an INT scalar/pair. As a scalar, it indicates the length of the output vector; As a pair, it indicates the dimension of the output matrix."
                         ]
                     }
                 ]
@@ -55261,9 +57187,11 @@
                     {
                         "type": "text",
                         "value": [
-                            "If `X` is a scalar, return a vector of random values that follows a uniform distribution on [0, `X`). The range includes 0 but excludes `X`. For example, if `X` is an integer, then the range is from 0 to `X`-1, inclusive on both ends.",
+                            "Return a vector/matrix of random values.",
+                            "",
+                            "* If `X` is a scalar, return a vector of random values that follows a uniform distribution on [0, `X`).",
                             "",
-                            "If `X` is a vector, return a vector of random values drawn from the elements of `X`.",
+                            "* If `X` is a vector, return a vector of random values drawn from the elements of `X`.",
                             "",
                             "The data type of the result is the same as the data type of `X`. "
                         ]
@@ -55280,18 +57208,41 @@
                         "value": [
                             "",
                             "    $ x=rand(10, 20); ",
-                            "    $ // generate 20 random nonnegative integers less than 10  ",
+                            "",
+                            "    // generate 20 random nonnegative integers less than 10  ",
                             "    $ x;                                              ",
                             "    [9,9,8,1,1,0,8,3,2,6,4,6,9,6,8,9,3,2,1,5]      ",
                             "",
+                            "    // generate 10 random nonnegative double values less than 9.8",
                             "    $ rand(9.8, 10);          ",
                             "    [3.653754,1.750518,0.055747,5.219222,2.473778,6.337576,7.797493,1.392241,0.149499,5.697612]",
-                            "    $ // generate 10 random nonnegative double values less than 9.8",
                             "",
+                            "    // generate 3 random values drawn from vector x",
                             "    $ x=3 5 4 6 9;",
                             "    $ rand(x, 3);                ",
                             "    [9,3,6]",
-                            "    $ // generate 3 random values drawn from vector x",
+                            "",
+                            "    $ rand(10.0, 2:2) // generate a 2*2 random matrix less than 10",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "+-------+-------+",
+                            "|col1   |col2   |",
+                            "+=======+=======+",
+                            "|0.8233 |1.0052 |",
+                            "+-------+-------+",
+                            "|7.1127 |9.7578 |",
+                            "+-------+-------+",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
                             "",
                             "    $ 12:35:06 + rand(100, 10);  ",
                             "    [12:35:44,12:35:16,12:35:50,12:35:44,12:35:46,12:35:09,12:35:50,12:36:35,12:35:09,12:36:44]",
@@ -55510,6 +57461,83 @@
             }
         ]
     },
+    "randDiscrete": {
+        "title": "randDiscrete",
+        "type": "function",
+        "children": [
+            {
+                "title": "Syntax",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "randDiscrete(v, p, count)"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Arguments",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "`v` is a vector/tuple indicating the sample data.",
+                            "",
+                            "`p` is a vector of floating point type of the same length as v. Each element in p must be a positive number, indicating the probability distribution of v.",
+                            "",
+                            "`count` is a positive integer indicating the length of the output vector."
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Details",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "Generate a sample of size count with random values sampling from v based on the specified probability distribution p."
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Examples",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ randDiscrete(1..5, [0.1, 0.1, 0.2, 0.2, 0.4], 10)",
+                            "    [2,3,5,2,5,5,2,1,1,2]",
+                            "",
+                            "    //If the sum of p is not 1, it will be normalized automatically.",
+                            "    $ randDiscrete(1..5, [0.1, 0.2, 0.3, 0.4, 0.5], 5)",
+                            "    [5,1,2,3,5]",
+                            "",
+                            "    $ randDiscrete(`A`B`C`E`F, [0.1, 0.2, 0.3, 0.4, 0.5], 5)",
+                            "    [\"C\",\"E\",\"B\",\"C\",\"F\"]",
+                            "",
+                            "    // Sample from each element in a tuple.",
+                            "    $ randDiscrete([[1,2], [2,3,4], 'S', 'abc'], [0.3, 0.3, 0.2, 0.1], 10)",
+                            "    ('S',[2,3,4],[1,2],[2,3,4],[1,2],'S','S',[2,3,4],[2,3,4],[2,3,4])",
+                            "",
+                            "    // Sample from each vector in an array vector.",
+                            "    $ a = array(INT[], 0, 10).append!([1 2 3, 4 5,6 7 8, 9 NULL])",
+                            "    $ randDiscrete(a, [0.1, 0.2, 0.3, 0.4], 10)",
+                            "    [[9,00i],[9,00i],[9,00i],[4,5],[9,00i],[1,2,3],[9,00i],[6,7,8],[9,00i],[9,00i]]"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "randExp": {
         "title": "randExp",
         "type": "function",
@@ -57616,6 +59644,166 @@
             }
         ]
     },
+    "rebalanceChunksAmongDataNodes": {
+        "title": "rebalanceChunksAmongDataNodes",
+        "type": "function",
+        "children": [
+            {
+                "title": "Syntax",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "rebalanceChunksAmongDataNodes([exec = false])"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Arguments",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "`exec` is a Boolean value indicating whether to initiate data rebalancing among data nodes. The default value is false indicating that data rebalancing will not be initiated."
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Details",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "This function is used to rebalance data among data nodes for optimal performance after one or more data nodes are added to a DolphinDB cluster. It can only be executed on a controller by an administrator.",
+                            "",
+                            "Return a table containing the following columns:",
+                            "",
+                            "================== =================================================",
+                            "name                meaning",
+                            "================== =================================================",
+                            "chunkId               the chunk ID",
+                            "srcNode               alias of source node",
+                            "destNode              alias of destination node",
+                            "================== =================================================",
+                            "",
+                            "You can get the status of recovery tasks by :doc:`/FunctionsandCommands/FunctionReferences/g/getRecoveryTaskStatus` on a controller."
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Example",
+                "children": [
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ rebalanceChunksAmongDataNodes()",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "==================================== ======= ========",
+                            "ChunkId                              srcNode destNode",
+                            "==================================== ======= ========",
+                            "99279094-ca12-3b87-48b6-520cbb986f39 node1   node2",
+                            "45f612b8-42f5-aebd-4cef-e522b6ae1fc8 node1   node2\t",
+                            "==================================== ======= ========"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
+    "rebalanceChunksWithinDataNode": {
+        "title": "rebalanceChunksWithinDataNode",
+        "type": "function",
+        "children": [
+            {
+                "title": "Syntax",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "rebalanceChunksWithinDataNode(nodeAlias, [exec=false])"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Arguments",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "`nodeAlias` is a string indicating the alias of a node.",
+                            "",
+                            "`exec` is a Boolean value indicating whether to initiate data rebalancing within a data node. The default value is false indicating that data rebalancing will not be initiated."
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Details",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "After volumes are added in a data node, partitions on the other volumes need to be rebalanced for optimal performance. This function is used to rebalance data among volumes within a data node. It can only be executed on a controller by an administrator.",
+                            "",
+                            "Return a table containing the following columns:",
+                            "",
+                            "================== =================================================",
+                            "name               meaning",
+                            "================== =================================================",
+                            "chunkId              the chunk ID",
+                            "srcVolume            source volume",
+                            "destVolume           destination volume",
+                            "================== =================================================",
+                            "",
+                            "You can get the status of recovery tasks by :doc:`/FunctionsandCommands/FunctionReferences/g/getRecoveryTaskStatus` on a controller."
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Examples",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ rebalanceChunksWithinDataNode(\"node1\")",
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "+-------------------------------------+-------------------+------------------+",
+                            "|ChunkId                              |srcVolume          |destVolume        |",
+                            "+=====================================+===================+==================+",
+                            "|82c6eb6c-36ee-b1b6-4a86-ca24d9faaa25 | /hdd/hdd1/volumes |/hdd/hdd2/volumes |\t",
+                            "+-------------------------------------+-------------------+------------------+"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "reciprocal": {
         "title": "reciprocal",
         "type": "function",
@@ -59973,7 +62161,7 @@
                         "value": [
                             "`userId` a string indicating a user name.",
                             "",
-                            "`newPwd` a string indicating the new password for the user."
+                            "`newPwd` a string with 6-20 characters indicating the new password for the user."
                         ]
                     }
                 ]
@@ -60006,6 +62194,52 @@
             }
         ]
     },
+    "resetRecoveryWorkerNum": {
+        "title": "resetRecoveryWorkerNum",
+        "type": "command",
+        "children": [
+            {
+                "title": "Arguments",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "`newWokerNum` is a positive integer that specifies the number of worker threads used for chunk recovery."
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Details",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "Modify the number of worker threads used by the current node for chunk recovery online. This command can only be executed by the administrator on the data node.",
+                            "",
+                            "Note that this command modifies the configuration parameter 'recoveryWorkers' during the current session only. To permanently modify 'recoveryWorkers', change it in the configuration file (the default value is 1)."
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Examples",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            "",
+                            "    $ resetRecoveryWorkerNum(2)"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "reshape": {
         "title": "reshape",
         "type": "function",
@@ -60395,6 +62629,63 @@
             }
         ]
     },
+    "resumeRecovery": {
+        "title": "resumeRecovery",
+        "type": "command",
+        "children": [
+            {
+                "title": "Syntax",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "resumeRecovery()"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Arguments",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "None"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Details",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "Resume suspended recovery processes in \"Waiting\" status. This command can only be executed by the administrator on the controller.",
+                            "",
+                            "Note: For high-availability clusters, this command must be executed on every node in the raft group. "
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "First Release",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "1.30.16、2.00.4",
+                            "",
+                            "Related command: :doc:`../s/suspendRecovery`"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "reverse": {
         "title": "reverse",
         "type": "function",
@@ -64654,8 +66945,11 @@
                             "",
                             "  partitionSchema->[0,5,10]",
                             "  partitionSites->",
-                            "  partitionTypeName->RANGE",
                             "  partitionColumnType->4",
+                            "  partitionTypeName->RANGE",
+                            "  chunkGranularity->TABLE",
+                            "  keepDuplicates->ALL",
+                            "  engineType->OLAP",
                             "  chunkPath->",
                             "  partitionColumnIndex->0",
                             "  colDefs->",
@@ -64666,7 +66960,7 @@
                             "",
                             "  partitionType->2",
                             "  partitionColumnName->ID",
-                            ""
+                            "   "
                         ]
                     },
                     {
@@ -64681,11 +66975,14 @@
                         "value": [
                             "  $ schema(db);",
                             "",
-                            "  databaseDir->dfs://rangedb101",
-                            "  partitionType->2",
-                            "  partitionTypeName->RANGE",
                             "  partitionSchema->[0,5,10]",
-                            "  partitionSites->"
+                            "  partitionSites->",
+                            "  partitionTypeName->RANGE",
+                            "  atomic->TRANS",
+                            "  databaseDir->dfs://rangedb101",
+                            "  chunkGranularity->TABLE",
+                            "  engineType->OLAP",
+                            "  partitionType->2"
                         ]
                     }
                 ]
@@ -65836,6 +68133,92 @@
             }
         ]
     },
+    "setAtomicLevel": {
+        "title": "setAtomicLevel",
+        "type": "command",
+        "children": [
+            {
+                "title": "Syntax",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "setAtomicLevel(dbHandle, atomic)"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Arguments",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "`dbHandle`  is a distributed database handle returned by function :doc:`/FunctionsandCommands/FunctionReferences/d/database`.",
+                            "",
+                            "`atomic` indicates at which level the atomicity is guaranteed for a write transaction, thus determining whether concurrent writes to the same chunk are allowed. It can be 'TRANS' or 'CHUNK' and the default value is 'TRANS'.",
+                            "",
+                            "- 'TRANS' indicates that the atomicity is guaranteed at the transaction level. If a transaction attempts to write to multiple chunks and one of the chunks is locked by another transaction, a write-write conflict occurs, and all writes of the transaction fail. Therefore, setting *atomic* ='TRANS' means concurrent writes to a chunk are not allowed.",
+                            "",
+                            "- 'CHUNK' indicates that the atomicity is guaranteed at the chunk level. If a transaction tries to write to multiple chunks and a write-write conflict occurs as a chunk is locked by another transaction, instead of aborting the writes, the transaction will keep writing to the non-locked chunks and keep attempting to write to the chunk in conflict until it is still locked after a few minutes. Therefore, setting *atomic* ='CHUNK' means concurrent writes to a chunk are allowed. As the atomicity at the transaction level is not guaranteed, the write operation may succeed in some chunks but fail in other chunks. Please also note that the write speed may be impacted by the repeated attempts to write to the chunks that are locked."
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Details",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "To manually specify at which level concurrent writes are allowed in a distributed database."
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Examples",
+                "type": "example",
+                "children": [
+                    {
+                        "type": "code",
+                        "language": "console",
+                        "value": [
+                            ""
+                        ]
+                    },
+                    {
+                        "type": "text",
+                        "value": [
+                            "\t$ dbPath=\"dfs://test\"",
+                            "\t$ mydb=database(dbPath, VALUE, ['AMZN','NFLX', 'NVDA'])",
+                            "\t$ mydb.schema()",
+                            "",
+                            "\tdatabaseDir->dfs://test",
+                            "\tpartitionSchema->[NVDA,AMZN,NFLX]",
+                            "\tpartitionSites->",
+                            "\tpartitionTypeName->VALUE",
+                            "\tpartitionType->1",
+                            "\tatomic->TRANS",
+                            "",
+                            "\t$ setAtomicLevel(mydb, `CHUNK)",
+                            "\t$ mydb.schema()",
+                            "",
+                            "\tdatabaseDir->dfs://test",
+                            "\tpartitionSchema->[NVDA,AMZN,NFLX]",
+                            "\tpartitionSites->",
+                            "\tpartitionTypeName->VALUE",
+                            "\tpartitionType->1",
+                            "\tatomic->CHUNK"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "setCacheEngineMemSize": {
         "title": "setCacheEngineMemSize",
         "type": "command",
@@ -66016,7 +68399,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "setIndexedMatrix!(X) "
+                            "setIndexedMatrix!(X, [on=true])"
                         ]
                     }
                 ]
@@ -66028,7 +68411,9 @@
                     {
                         "type": "text",
                         "value": [
-                            "`X`  is a matrix with row labels and column labels. Row labels and column labels must be monotonically increasing with no duplicate values."
+                            "`X`  is a matrix with row labels and column labels. Row labels and column labels must be monotonically increasing with no duplicate values.",
+                            "",
+                            "`on` is a boolean value indicating the conversion between a matrix and an indexed matrix. The default value is true, indicating the conversion from a matrix to an indexed matrix. Set to false for the opposite conversion."
                         ]
                     }
                 ]
@@ -66040,9 +68425,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "Set the labels of the rows and columns of a matrix as the indexes.",
-                            "",
-                            "The function was released in version 1.30.0."
+                            "Set the labels of the rows and columns of a matrix as the indexes."
                         ]
                     }
                 ]
@@ -66079,7 +68462,8 @@
                             "|2020.01.05|5  |15 |",
                             "+----------+---+---+  ",
                             "",
-                            "",
+                            ".. meta::   ",
+                            "   :keywords: set",
                             "",
                             "",
                             ""
@@ -66100,7 +68484,7 @@
                     {
                         "type": "text",
                         "value": [
-                            "setIndexedSeries!(X)"
+                            "setIndexedSeries!(X, [on=true])"
                         ]
                     }
                 ]
@@ -66112,7 +68496,9 @@
                     {
                         "type": "text",
                         "value": [
-                            "`X` is a matrix with row labels and only one column. The row labels must be monotonically increasing with no duplicate values."
+                            "`X` is a matrix with row labels and only one column. The row labels must be monotonically increasing with no duplicate values.",
+                            "",
+                            "`on` is a boolean value indicating the conversion between a matrix and an indexed series. The default value is true, indicating the conversion from a matrix to an indexed series. Set to false for the opposite conversion."
                         ]
                     }
                 ]
@@ -66169,7 +68555,10 @@
                             "|2012.01.09|9     |",
                             "+----------+------+",
                             "|2012.01.10|10    |",
-                            "+----------+------+"
+                            "+----------+------+",
+                            "",
+                            ".. meta::   ",
+                            "   :keywords: set"
                         ]
                     }
                 ]
@@ -71721,6 +74110,28 @@
         "title": "subscribeTable",
         "type": "function",
         "children": [
+            {
+                "title": "Details",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "Subscribe to a stream table on a local or remote server from a client node. We can also specify a function to process the subscribed data.",
+                            "",
+                            "Return the subscription topic, which is a combination of the alias of the node where the stream table is located, stream table name, and the subscription task name (if actionName is specified) separated by \"_\". If the subscription topic already exists, the function throws an exception.",
+                            "",
+                            "* If *batchSize* is specified, *handler* will be triggered if either the number of unprocessed messages reaches *batchSize* or the duration of time since the last time handler was triggered reaches *throttle* seconds.",
+                            "",
+                            "* If the subscribed table is overwritten, to keep the subscription we need to cancel the subscription with command :doc:`/FunctionsandCommands/CommandsReferences/u/unsubscribeTable` and then subscribe to the new table.",
+                            "",
+                            "* With the high availability subscription enabled, a leader switch or cluster restart in the raft group of subscribers may log off a user. Since guests have no privilege to write to a DFS table, the writing will be interrupted (the current user can be identified by function :doc:`../g/getCurrentSessionAndUser`). If parameters userId and password are specified, the system will attempt to log in after the user is logged out accidentally to make sure the subscribed data can be written to a DFS table.",
+                            "",
+                            "Please note that the parameter handler of function subscribeTable should be function appendForJoin, :doc:`/FunctionsandCommands/FunctionReferences/g/getLeftStream` or :doc:`/FunctionsandCommands/FunctionReferences/g/getRightStream` while subscribing to a stream table for the streaming join engine."
+                        ]
+                    }
+                ]
+            },
             {
                 "title": "Syntax",
                 "type": "grammer",
@@ -71756,7 +74167,7 @@
                             "",
                             "`batchSize` an integer indicating the number of unprocessed messages to trigger the handler. If it is positive, the handler does not process messages until the number of unprocessed messages reaches batchSize. If it is unspecified or non-positive, the handler processes incoming messages as soon as they come in.",
                             "",
-                            "`throttle` a numeric scalar indicating the maximum waiting time (in seconds) before the handler processes the incoming messages. The default value is 1. This optional parameter has no effect if batchSize is not specified.",
+                            "`throttle` is a floating point number in seconds,  indicating the maximum waiting time before the handler processes the incoming messages if the batchSize condition has not been reached. The default value is 1. This optional parameter has no effect if batchSize is not specified. To set If throttle is less than 1 second, you need to modify the configuration parameter subThrottle first.",
                             "",
                             "`hash` a hash value (a nonnegative integer) indicating which subscription executor will process the incoming messages for this subscription. If it is unspecified, the system automatically assigns an executor. When we need to keep the messages synchronized from multiple subscriptions, we can set hash of all these subscriptions to be the same, so that the same executor is used to synchronize multiple data sources.",
                             "",
@@ -71792,29 +74203,13 @@
                             "",
                             "`handlerNeedMsgId` a Boolean value. If it is true, the parameter handler must support 2 parameters: msgBody and msgId; if it is false, the parameter handler must support just 1 parameter: msgBody. The default value is false.",
                             "",
-                            "`raftGroup` is the ID of raft group used to enable high availability on the subscriber. If the leader node of a raft group is changed after setting the parameter *raftGroup*, the new leader will resubscribe to the stream table.",
-                            "",
-                            "Note: The function ``subscribeTable`` can only be executed on a leader node if the parameter *raftGroup* is set. If handlerNeedMsgId is also set to true while *raftGroup* = true, then the handler must be the handler of a stream engine (you can obtain the handler when you create the engine or obtain it with the function “getStreamEngine(engineName)”."
-                        ]
-                    }
-                ]
-            },
-            {
-                "title": "Details",
-                "type": "detail",
-                "children": [
-                    {
-                        "type": "text",
-                        "value": [
-                            "Subscribe to a stream table on a local or remote server from a client node. We can also specify a function to process the subscribed data.",
-                            "",
-                            "Return the subscription topic, which is a combination of the alias of the node where the stream table is located, stream table name, and the subscription task name (if actionName is specified) separated by \"_\". If the subscription topic already exists, the function throws an exception.",
+                            "`raftGroup` the ID of raft group used to enable high availability on the subscriber. If the leader node of a raft group is changed after setting the parameter *raftGroup*, the new leader will resubscribe to the stream table.",
                             "",
-                            "If batchSize is specified, handler will be triggered if either the number of unprocessed messages reaches batchSize or the duration of time since the last time handler was triggered reaches throttle seconds.",
+                            "Note: The function ``subscribeTable`` can only be executed on a leader node if the parameter *raftGroup* is set. If handlerNeedMsgId is also set to true while *raftGroup* = true, then the handler must be the handler of a stream engine (you can obtain the handler when you create the engine or obtain it with the function “getStreamEngine(engineName)”.",
                             "",
-                            "Please note that all the tables involved in streaming are either DFS tables or shared streaming tables.",
+                            "`userId` a string indicating a user name.",
                             "",
-                            "If the subscribed table is overwritten, to keep the subscription we need to cancel the subscription with command :doc:`/FunctionsandCommands/CommandsReferences/u/unsubscribeTable` and then subscribe to the new table."
+                            "`password` a string indicating the password."
                         ]
                     }
                 ]
@@ -72764,6 +75159,63 @@
             }
         ]
     },
+    "suspendRecovery": {
+        "title": "suspendRecovery",
+        "type": "command",
+        "children": [
+            {
+                "title": "Syntax",
+                "type": "grammer",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "suspendRecovery()"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Arguments",
+                "type": "parameters",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "None"
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Details",
+                "type": "detail",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "Suspend online node recovery processes. When this command is executed, tasks in \"In-Progress\" status will continue to recover and processes in \"Waiting\" status will be suspended. Once suspended, the source node can continue to receive new data. This command can only be executed by the administrator on the controller.",
+                            "",
+                            "Note: For high-availability clusters, this command must be executed on every node in the raft group."
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "First Release",
+                "children": [
+                    {
+                        "type": "text",
+                        "value": [
+                            "1.30.16、2.00.4",
+                            "",
+                            "Related command: :doc:`../r/resumeRecovery`"
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
     "svd": {
         "title": "svd",
         "type": "function",
@@ -77639,15 +80091,15 @@
                             "",
                             "`ignoreNull` is a Boolean value. If set to true, for the NULL values in newData, the correponding elements in obj are not updated. The default value is false.",
                             "",
-                            "`keyColNames` is a STRING scalar/vector indicating the key columns in a DFS table.",
+                            "`keyColNames` is a STRING scalar/vector.  When *obj* is a DFS table, *keyColNames* are considered as the key columns.",
                             "",
                             "`sortColumns` is a STRING scalar or vector. The updated partitions will be sorted on sortColumns (only within each partition, not across partitions).",
                             "",
                             "Please note:",
                             "",
-                            "\\1. To specify sortColumns, obj must be a DFS table.",
+                            "\\1. To specify *sortColumns*, obj must be a DFS table.",
                             "",
-                            "\\2. When *obj* is an empty table, setting sortColumns has no effect. That is, the system will not sort the inserted data."
+                            "\\2. When *obj* is an empty table, setting *sortColumns* has no effect. That is, the system will not sort the inserted data."
                         ]
                     }
                 ]
@@ -77659,7 +80111,12 @@
                     {
                         "type": "text",
                         "value": [
-                            "Insert rows into a keyed table or indexed table if the values of the primary key do not already exist, or update them if they do. Please note that if there are duplicated values in the key columns of a DFS table, ``upsert!`` on duplicated key values only updates the row of the first duplicate key value. The rows of the other duplicate key values are not updated."
+                            "Insert rows into a keyed table or indexed table if the values of the primary key do not already exist, or update them if they do. ",
+                            "",
+                            "Note:",
+                            "",
+                            "- When using this function, please make sure the corresponding columns in table *newData* and *obj* are arranged in the same order, or the system may generate the wrong result or throw an error. ",
+                            "- If obj is a DFS table with duplicated \"keys\" (as specified by keyColNames), ``upsert!`` on rows with duplicated keys only updates the first row."
                         ]
                     }
                 ]
@@ -77749,7 +80206,7 @@
                             "======= ========== === ====",
                             "",
                             "",
-                            "The example above is for the case when *ignoreNull* =true. Compare it with the following example where *ignoreNull* =true (by default).",
+                            "The example above is for the case when *ignoreNull* = true. Compare it with the following example where *ignoreNull* = false (by default).",
                             ""
                         ]
                     },
@@ -80735,22 +83192,20 @@
                     {
                         "type": "text",
                         "value": [
-                            "`HL` is a numeric vector or a numeric matrix contains two columns.",
+                            "`HL` is a numeric vector or a numeric matrix with two columns.",
                             "",
-                            "`change` is the minimum price change, in dollars or percentages.",
+                            "`change` is the minimum threshold for extreme value movement.",
                             "",
-                            "`percent` is a boolean value. If it is set to true, the result is displayed as a percentage, If it set to false, it is displayed in US dollars. The default value is true.",
+                            "`percent` is a Boolean value indicating whether *change* is used as a percentage.",
                             "",
-                            "`retrace` is a boolean value and the default value is false.",
+                            "`retrace` is a Boolean value. The default value is false.",
                             "",
-                            "    * true: The parameter change represents the change compared with the previous point.",
-                            "    * false: The parameter change represents the change between the extreme points.",
+                            "    * true: *change* represents a retracement of the previous move.",
+                            "    * false: *change* represents the change between the extreme points.",
                             "",
-                            "`lastExtreme` is a boolean value indicating whether to select the first point or the last point if multiple consecutive points have the same value. And the default value is true.",
+                            "Note: If *percent*=false, *retrace* can only take “false”. Setting it to true has no effect.",
                             "",
-                            "    * true: select the last point",
-                            "    * false: select the first point",
-                            ""
+                            "`lastExtreme` is a boolean value indicating whether to output the last point if multiple consecutive points have the same value. The default value is true."
                         ]
                     }
                 ]
@@ -80762,8 +83217,9 @@
                     {
                         "type": "text",
                         "value": [
-                            "Calculate the indicator zigzag of a set of data, and return a double vector whose length is the same as the length of the vector HL or the row number of the matrix. The non-NULL elements in the vector represent the extreme points of the input data.",
-                            ""
+                            "``zigzag`` is mainly used to filter values with smaller movements in *HL*. Only extreme points that satisfy the conditions will be output.",
+                            "",
+                            "If *HL* is a vector, return a vector with the same length as *HL*; if *HL* is a matrix, return a vector with the same number of rows as *HL*."
                         ]
                     }
                 ]