{
    "abs": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/abs.html",
        "signatures": [
            {
                "full": "abs(X)",
                "name": "abs",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [abs](https://docs.dolphindb.cn/zh/funcs/a/abs.html)\n\n\n\n#### 语法\n\nabs(X)\n\n#### 详情\n\n对 *X* 内每个元素求绝对值并返回。\n\n与 Python/NumPy/scipy.stats 的 `abs` 函数功能相同，区别在于：Python/NumPy/scipy.stats 的 `abs` 函数支持计算复数的绝对值；而 DolphinDB 的 `abs` 函数不支持计算复数绝对值，可通过DolphinDB signal 插件中的 [abs](https://docs.dolphindb.cn/zh/plugins/signal/sipui2.html) 函数计算复数绝对值（见例子）。\n\n#### 参数\n\n**X** 是可以标量、数据对、向量、矩阵、字典或表。\n\n#### 返回值\n\n返回结果的数据形式和数据类型与输入 *X* 保持一致。若 *X* 为标量，返回标量；若为向量、矩阵或表，返回相同维度的向量、矩阵或表。\n\n#### 例子\n\n```\nabs(-2.0);\n// output: 2\n\nabs(-2 -3 4);\n// output: [2, 3, 4]\n```\n\n通过 signal 插件，计算复数的绝对值。\n\n```\n// 查看插件市场是否存在 signal 插件\nlistRemotePlugins()\n// 从插件市场下载 signal 插件\ninstallPlugin(\"signal\")\n// 加载 signal 插件\nloadPlugin(\"signal\")\n// 创建复数\nz = complex(3, 4)  // 3.0+4.0i\n// 计算复数绝对值\nabs = signal::abs(z) \nabs\n// output: 5\n\n```\n"
    },
    "acf": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/acf.html",
        "signatures": [
            {
                "full": "acf(X, maxLag)",
                "name": "acf",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "maxLag",
                        "name": "maxLag"
                    }
                ]
            }
        ],
        "markdown": "### [acf](https://docs.dolphindb.cn/zh/funcs/a/acf.html)\n\n\n\n#### 语法\n\nacf(X, maxLag)\n\n#### 详情\n\n计算 *X* 的1阶至 *maxLag* 阶的自相关系数。\n\n该函数 与 [statsmodels.tsa.stattools.acf](https://www.statsmodels.org/stable/generated/statsmodels.tsa.stattools.acf.html) 在自相关系数计算方面功能基本一致，具体实现差异如下：\n\n| 维度     | DolphinDB `acf`       | Python `statsmodels.tsa.acf`                        |\n| ------ | --------------------- | --------------------------------------------------- |\n| lag 参数 | 必须指定 *`maxLag`*       | 可选，默认 `min(10 * np.log10(nobs), nobs - 1)`          |\n| 计算方法   | 去均值+归一化               | 去均值 + 归一化（默认）；支持通过 *adjusted* 参数调整归一化方式             |\n| FFT 加速 | 支持（不可修改）              | 支持（*fft* 参数）                                        |\n| 置信区间   | 不支持                   | 支持设置置信区间（*alpha* 参数）和置信区间方法（*bartlett\\_confint* 参数） |\n| 显著性检验  | 不支持                   | 支持（*qstat* 参数）                                      |\n| 缺失值处理  | 不支持（报错）               | 支持（*missing* 参数）                                    |\n| 返回结果   | 1 至 *maxLag* 阶自相关系数向量 | 自相关系数数组 + 可选置信区间                                    |\n\n#### 参数\n\n**X** 是一个向量。\n\n**maxLag** 是一个非负整数，指定计算自相关系数的最大滞后阶数。\n\n#### 返回值\n\n长度为 *maxLag* + 1 的向量。\n\n#### 例子\n\n```\nn=10000\nx=array(DOUBLE, n, n, NULL)\nx[0]=1\nr=rand(0.05, n)-0.025\nfor(i in 0:(n-1)){\n   x[i+1]=-0.8*x[i]+r[i]\n}\n\nacf = acf(x, 20)\nplot(acf,chartType=BAR)\n```\n\n相关函数： [autocorr](https://docs.dolphindb.cn/zh/funcs/a/autocorr.html)\n"
    },
    "acos": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/acos.html",
        "signatures": [
            {
                "full": "acos(X)",
                "name": "acos",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [acos](https://docs.dolphindb.cn/zh/funcs/a/acos.html)\n\n\n\n#### 语法\n\nacos(X)\n\n#### 详情\n\n返回 *X* 的反余弦。\n\nDolphinDB `acos` 函数与 TA-Lib `ACOS` 函数在数学语义上完全一致。区别在于：TA-Lib 的 `ACOS` 是 Math Transform 函数，输入和输出主要为一维数组；DolphinDB 的 `acos` 可用于标量、向量、矩阵或表，并保持输入的数据形式。\n\n#### 参数\n\n**X** 可以是标量、向量、矩阵或表。\n\n#### 返回值\n\n返回结果的数据形式与输入保持一致：若输入为标量，返回标量；若输入为向量、矩阵或表，返回相同维度的结果。\n\n#### 例子\n\n```\nacos(1.000000 0.540302 -0.416147);\n// output: [0,1,2]\n```\n\n相关函数：[asin](https://docs.dolphindb.cn/zh/funcs/a/asin.html), [atan](https://docs.dolphindb.cn/zh/funcs/a/atan.html), [sin](https://docs.dolphindb.cn/zh/funcs/s/sin.html), [cos](https://docs.dolphindb.cn/zh/funcs/c/cos.html), [tan](https://docs.dolphindb.cn/zh/funcs/t/tan.html), [asinh](https://docs.dolphindb.cn/zh/funcs/a/asinh.html), [acosh](https://docs.dolphindb.cn/zh/funcs/a/acosh.html), [atanh](https://docs.dolphindb.cn/zh/funcs/a/atanh.html), [sinh](https://docs.dolphindb.cn/zh/funcs/s/sinh.html), [cosh](https://docs.dolphindb.cn/zh/funcs/c/cosh.html), [tanh](https://docs.dolphindb.cn/zh/funcs/t/tanh.html)\n"
    },
    "acosh": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/acosh.html",
        "signatures": [
            {
                "full": "acosh(X)",
                "name": "acosh",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [acosh](https://docs.dolphindb.cn/zh/funcs/a/acosh.html)\n\n\n\n#### 语法\n\nacosh(X)\n\n#### 详情\n\n返回 *X* 的反双曲余弦。\n\n#### 参数\n\n**X** 可以是标量、向量、矩阵或表。\n\n#### 返回值\n\n返回结果的数据形式与输入保持一致：若输入为标量，返回标量；若输入为向量、矩阵或表，返回相同维度的结果。\n\n#### 例子\n\n```\nacosh(1 2 3);\n// output: [0,1.316958,1.762747]\n```\n\n相关函数：[asin](https://docs.dolphindb.cn/zh/funcs/a/asin.html), [acos](https://docs.dolphindb.cn/zh/funcs/a/acos.html), [atan](https://docs.dolphindb.cn/zh/funcs/a/atan.html), [sin](https://docs.dolphindb.cn/zh/funcs/s/sin.html), [cos](https://docs.dolphindb.cn/zh/funcs/c/cos.html), [tan](https://docs.dolphindb.cn/zh/funcs/t/tan.html), [asinh](https://docs.dolphindb.cn/zh/funcs/a/asinh.html), [atanh](https://docs.dolphindb.cn/zh/funcs/a/atanh.html), [sinh](https://docs.dolphindb.cn/zh/funcs/s/sinh.html), [cosh](https://docs.dolphindb.cn/zh/funcs/c/cosh.html), [tanh](https://docs.dolphindb.cn/zh/funcs/t/tanh.html)\n"
    },
    "adaBoostClassifier": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/adaBoostClassifier.html",
        "signatures": [
            {
                "full": "adaBoostClassifier(ds, yColName, xColNames, numClasses, [maxFeatures=0], [numTrees=10], [numBins=32], [maxDepth=10], [minImpurityDecrease=0.0], [learningRate=0.1], [algorithm='SAMME.R'], [randomSeed])",
                "name": "adaBoostClassifier",
                "parameters": [
                    {
                        "full": "ds",
                        "name": "ds"
                    },
                    {
                        "full": "yColName",
                        "name": "yColName"
                    },
                    {
                        "full": "xColNames",
                        "name": "xColNames"
                    },
                    {
                        "full": "numClasses",
                        "name": "numClasses"
                    },
                    {
                        "full": "[maxFeatures=0]",
                        "name": "maxFeatures",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[numTrees=10]",
                        "name": "numTrees",
                        "optional": true,
                        "default": "10"
                    },
                    {
                        "full": "[numBins=32]",
                        "name": "numBins",
                        "optional": true,
                        "default": "32"
                    },
                    {
                        "full": "[maxDepth=10]",
                        "name": "maxDepth",
                        "optional": true,
                        "default": "10"
                    },
                    {
                        "full": "[minImpurityDecrease=0.0]",
                        "name": "minImpurityDecrease",
                        "optional": true,
                        "default": "0.0"
                    },
                    {
                        "full": "[learningRate=0.1]",
                        "name": "learningRate",
                        "optional": true,
                        "default": "0.1"
                    },
                    {
                        "full": "[algorithm='SAMME.R']",
                        "name": "algorithm",
                        "optional": true,
                        "default": "'SAMME.R'"
                    },
                    {
                        "full": "[randomSeed]",
                        "name": "randomSeed",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [adaBoostClassifier](https://docs.dolphindb.cn/zh/funcs/a/adaBoostClassifier.html)\n\n\n\n#### 语法\n\nadaBoostClassifier(ds, yColName, xColNames, numClasses, \\[maxFeatures=0], \\[numTrees=10], \\[numBins=32], \\[maxDepth=10], \\[minImpurityDecrease=0.0], \\[learningRate=0.1], \\[algorithm='SAMME.R'], \\[randomSeed])\n\n#### 详情\n\n进行 AdaBoost 分类。\n\n生成的模型可以作为 `predict` 函数的输入。\n\n#### 参数\n\n**ds** 是数据源，通常用 `sqlDS` 函数生成。\n\n**yColName** 是字符串，表示数据源中作为因变量（所属分类）的列名。\n\n**xColNames** 是字符串标量或向量，表示数据源中作为自变量的列名。\n\n**numClasses** 是正整数，表示分类数目。y 列的取值必须是\\[0, numClasses)之间的整数。\n\n**maxFeatures** 是一个整数或浮点数，表示一次分裂节点选取的特征个数或比例。默认值是0。\n\n* 如果 *maxFeatures* 为正整数，则在一次分裂时选取 *maxFeatures* 个特征。\n* 如果 *maxFeatures* =0，则在一次分裂时选取全部特征。\n* 如果 *maxFeatures* 是一个0和1之间的浮点数，则在一次分裂时选取 int(特征列数量 \\* *maxFeatures*)个特征。\n\n**numTrees** 是正整数，表示产生树的最大个数，即停止提升时的最大迭代次数。如果能够完美训练，学习会提前中止。默认值为10。\n\n**numBins** 是正整数，表示离散化连续特征时的桶数。默认值为32。增加 *numBins* 会使算法考虑更多的分裂节点的决策值，产生更好的分裂结果，但也会提高计算量和通讯量。\n\n**maxDepth** 是正整数，表示树的最大深度。默认值为10。\n\n**minImpurityDecrease** 是浮点数，如果分裂产生的基尼指数纯度减少值大于或等于这个值，节点会继续分裂。\n\n**learningRate** 是正浮点数，表示迭代过程中的每个分类器对下一个分类器的样本权重的影响。\n\n**algorithm** 是一个字符串，表示所使用的算法，可以取值 \"SAMME.R\" 或 \"SAMME\"。默认值为 \"SAMME.R\"。\n\n**randomSeed** 是随机数生成器使用的种子。\n\n#### 返回值\n\n返回一个字典，包含以下 key：numClasses, minImpurityDecrease, maxDepth, numBins, numTrees, maxFeatures, model, modelName, xColNames, learningRate, algorithm, predict。其中 model 是一个元组，保存了训练生成的树；modelName 为 \"AdaBoost Classifier\"。\n\n#### 例子\n\n用模拟数据训练一个 AdaBoost 分类模型\n\n```\nt = table(100:0, `cls`x0`x1, [INT,DOUBLE,DOUBLE])\nn=5\ncls = take(0, n)\nx0 = norm(0, 10, n)\nx1 = norm(0, 10, n)\ninsert into t values (cls, x0, x1)\ncls = take(1, n)\nx0 = norm(1, 10, n)\nx1 = norm(1, 10, n)\ninsert into t values (cls, x0, x1)\nmodel = adaBoostClassifier(sqlDS(<select * from t>), `cls, `x0`x1, 2);\n```\n\n把模型用于预测\n\n```\nt1 = table(-0.5 0 1 2 as x0, -2 0 1 3 as x1)\npredict(model, t1);\n```\n\n保存模型到磁盘，以及加载保存的模型\n\n```\nsaveModel(model, \"C:/DolphinDB/data/classifierModel.bin\");\nloadModel(\"C:/DolphinDB/data/classifierModel.bin\");\n```\n\n相关函数：[adaBoostRegressor](https://docs.dolphindb.cn/zh/funcs/a/adaBoostRegressor.html), [randomForestClassifier](https://docs.dolphindb.cn/zh/funcs/r/randomForestClassifier.html), [randomForestRegressor](https://docs.dolphindb.cn/zh/funcs/r/randomForestRegressor.html)\n"
    },
    "adaBoostRegressor": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/adaBoostRegressor.html",
        "signatures": [
            {
                "full": "adaBoostRegressor(ds, yColName, xColNames, [maxFeatures=0], [numTrees=10], [numBins=32], [maxDepth=10], [minImpurityDecrease=0.0], [learningRate=0.1], [loss='linear'], [randomSeed])",
                "name": "adaBoostRegressor",
                "parameters": [
                    {
                        "full": "ds",
                        "name": "ds"
                    },
                    {
                        "full": "yColName",
                        "name": "yColName"
                    },
                    {
                        "full": "xColNames",
                        "name": "xColNames"
                    },
                    {
                        "full": "[maxFeatures=0]",
                        "name": "maxFeatures",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[numTrees=10]",
                        "name": "numTrees",
                        "optional": true,
                        "default": "10"
                    },
                    {
                        "full": "[numBins=32]",
                        "name": "numBins",
                        "optional": true,
                        "default": "32"
                    },
                    {
                        "full": "[maxDepth=10]",
                        "name": "maxDepth",
                        "optional": true,
                        "default": "10"
                    },
                    {
                        "full": "[minImpurityDecrease=0.0]",
                        "name": "minImpurityDecrease",
                        "optional": true,
                        "default": "0.0"
                    },
                    {
                        "full": "[learningRate=0.1]",
                        "name": "learningRate",
                        "optional": true,
                        "default": "0.1"
                    },
                    {
                        "full": "[loss='linear']",
                        "name": "loss",
                        "optional": true,
                        "default": "'linear'"
                    },
                    {
                        "full": "[randomSeed]",
                        "name": "randomSeed",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [adaBoostRegressor](https://docs.dolphindb.cn/zh/funcs/a/adaBoostRegressor.html)\n\n\n\n#### 语法\n\nadaBoostRegressor(ds, yColName, xColNames, \\[maxFeatures=0], \\[numTrees=10], \\[numBins=32], \\[maxDepth=10], \\[minImpurityDecrease=0.0], \\[learningRate=0.1], \\[loss='linear'], \\[randomSeed])\n\n#### 详情\n\n进行 AdaBoost 回归。\n\n生成的模型可以作为 `predict` 函数的输入\n\n#### 参数\n\n**ds** 是数据源，通常用 `sqlDS` 函数生成。\n\n**yColName** 是字符串，表示数据源中作为因变量（所属分类）的列名。\n\n**xColNames** 是字符串标量或向量，表示数据源中作为自变量的列名。\n\n**maxFeatures** 是一个整数或浮点数，表示一次分裂节点选取的特征个数或比例。默认值是0。\n\n* 如果 *maxFeatures* 为正整数，则在一次分裂时选取 *maxFeatures* 个特征。\n* 如果 *maxFeatures* =0 ，则在一次分裂时选取全部特征。\n* 如果 *maxFeatures* 是一个0和1之间的浮点数，则在一次分裂时选取 int(特征列数量\\*maxFeatures)个特征。\n\n**numTrees** 是正整数，表示产生树的最大个数，即停止提升时的最大迭代次数。如果能够完美训练，学习会提前中止。默认值为10。\n\n**numBins** 是正整数，表示离散化连续特征时的桶数。默认值为32。增加 *numBins* 会使算法考虑更多的分裂节点的决策值，产生更好的分裂结果，但也会提高计算量和通讯量。\n\n**maxDepth** 是正整数，表示树的最大深度。默认值为10。\n\n**minImpurityDecrease** 是浮点数，如果分裂产生的基尼指数纯度减少值大于或等于这个值，节点会继续分裂。\n\n**learningRate** 是正浮点数，表示迭代过程中的每个分类器对下一个分类器的样本权重的影响。\n\n**loss** 是一个字符串，表示在提升迭代时，更新样本权重时所用的损失函数，可以取值 \"linear\", \"square\" 或 \"exponential\"。默认值为 \"linear\"。\n\n**randomSeed** 是随机数生成器使用的种子。\n\n#### 返回值\n\n返回结果是字典，包含以下 key：predict, minImpurityDecrease, maxDepth, numBins, numTrees, maxFeatures, model, modelName, xColNames, learningRate,loss. 其中 model 是一个元组，保存了训练生成的树；modelName 为 \"AdaBoost Regressor\"。\n\n#### 例子\n\n用模拟数据训练一个 AdaBoost 分类模型\n\n```\nn=10\nx1 = rand(1.0, n)\nx2 = rand(1.0, n)\nb0 = 1\nb1 = 1\nb2 = -2\nerr = norm(0, 0.2, n)\ny = b0 + b1 * x1 + b2 * x2 + err\nt = table(y, x1, x2)\nmodel = adaBoostRegressor(sqlDS(<select * from t>), `y, `x1`x2);\n```\n\n把模型用于预测\n\n```\nt1 = table(0 0.4 0.7 1 as x1, 0.9 0.2 0.1 0 as x2)\npredict(model, t1);\n```\n\n保存模型到磁盘及加载保存的模型\n\n```\nsaveModel(model, \"C:/DolphinDB/data/regressionModel.bin\")\nloadModel(\"C:/DolphinDB/data/regressionModel.bin\");\n```\n\n相关函数：[adaBoostClassifier](https://docs.dolphindb.cn/zh/funcs/a/adaBoostClassifier.html), [randomForestClassifier](https://docs.dolphindb.cn/zh/funcs/r/randomForestClassifier.html), [randomForestRegressor](https://docs.dolphindb.cn/zh/funcs/r/randomForestRegressor.html)\n"
    },
    "add": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/add.html",
        "signatures": [
            {
                "full": "add(X, Y)",
                "name": "add",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [add](https://docs.dolphindb.cn/zh/funcs/a/add.html)\n\n\n\n#### 语法\n\nadd(X, Y)\n\n#### 详情\n\n对 *X* 和 *Y* 内的元素逐个求和并返回。\n\nDolphinDB `add` 函数与 numpy `add`、pandas `Series.add` / `DataFrame.add` 的功能与实现对比：\n\n| 对比维度 | DolphinDB `add`                                        | `numpy.add`                | pandas `add`               |\n| ---- | ------------------------------------------------------ | -------------------------- | -------------------------- |\n| 功能核心 | 支持标量、向量、矩阵等数据的逐元素加法                                    | 支持标量、ndarray，遵循 NumPy 广播规则 | 按索引对齐加法，支持广播标量             |\n| 索引对齐 | 索引序列和索引矩阵可按索引对齐                                        | 不支持                        | 可指定按索引或列对齐                 |\n| 空值处理 | NULL 值传播（NULL + 任何值 = NULL）；可结合 `withNullFill` 函数指定填充值 | NaN 传播（NaN + 任何数 = NaN）    | 自动处理，可通过 fill\\_value 指定填充值 |\n\n#### 参数\n\n**X** 和 **Y** 可以是标量、数据对、向量或矩阵。如果 *X* 和 *Y* 中其中一个是数据对、向量或矩阵，另一个参数的长度或维度必须相同。\n\n#### 返回值\n\n若**X** 和 **Y**至少一个是矩阵，则返回矩阵；否则，若至少一个是数据对，则返回数据对;否则，若至少有一个是向量，则返回向量;若**X** 和 **Y**均为标量，则返回标量。\n\n#### 例子\n\n```\nadd(3,2)\n// output\n5\n\n1:2+6\n// output\n7:8\n\n1:2+3:4\n// output\n4 : 6\n\n3+1..3\n// output\n[4,5,6]\n\nadd(1..3, 4..6)\n// output\n[5,7,9]\n\n(1..3).add(4..6)\n// output\n[5,7,9]\n\nx=reshape(1..6, 3:2)\nx\n```\n\n| 0 | 1 |\n| - | - |\n| 1 | 4 |\n| 2 | 5 |\n| 3 | 6 |\n\n```\nx+1.5\n```\n\n| 0   | 1   |\n| --- | --- |\n| 2.5 | 5.5 |\n| 3.5 | 6.5 |\n| 4.5 | 7.5 |\n\n```\ny=reshape(5..10, 3:2)\ny\n```\n\n| 0 | 1  |\n| - | -- |\n| 5 | 8  |\n| 6 | 9  |\n| 7 | 10 |\n\n```\nx+y\n```\n\n| 0  | 1  |\n| -- | -- |\n| 6  | 12 |\n| 8  | 14 |\n| 10 | 16 |\n\n参见 [\"+\" 运算符](https://docs.dolphindb.cn/zh/progr/operators/add.html)\n\n相关函数：[sub](https://docs.dolphindb.cn/zh/funcs/s/sub.html)\n"
    },
    "addAccessControl": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/addAccessControl.html",
        "signatures": [
            {
                "full": "addAccessControl(table)",
                "name": "addAccessControl",
                "parameters": [
                    {
                        "full": "table",
                        "name": "table"
                    }
                ]
            }
        ],
        "markdown": "### [addAccessControl](https://docs.dolphindb.cn/zh/funcs/a/addAccessControl.html)\n\n\n\n#### 语法\n\naddAccessControl(table)\n\n#### 详情\n\n限制其他用户访问当前用户创建的共享表或者流数据引擎。添加访问限制后，其他用户只有被管理员赋予访问权限后，才可访问当前用户创建的共享表或者流数据引擎。\n\n**Note:**\n\n1. 只能由管理员或者创建共享表/流数据引擎的用户执行该函数。\n2. 如果管理员已经为其他用户 [grant](https://docs.dolphindb.cn/zh/funcs/g/grant.html)/[deny](https://docs.dolphindb.cn/zh/funcs/d/deny.html)/[revoke](https://docs.dolphindb.cn/zh/funcs/r/revoke.html) 共享表/流数据引擎的权限，其他未经授权的用户无法再访问共享表/流数据引擎，无需调用 `addAccessControl` 添加访问限制。\n\n#### 参数\n\n**table** 共享表或者流数据引擎对象。\n\n#### 例子\n\n创建一组用户，进行权限管理。\n\n```\nlogin(`admin, `123456)\ncreateUser(`u1, \"111111\");\ncreateUser(`u2, \"222222\");\ncreateUser(`u3, \"333333\");\n```\n\n例1：限制其他用户访问流数据引擎\n\n1. 用户 u1 创建流数据引擎 agg1。\n\n   ```\n   login(`u1, \"111111\")\n   share streamTable(1000:0, `time`sym`volume, [TIMESTAMP, SYMBOL, INT]) as trades\n   output1 = table(10000:0, `time`sym`sumVolume, [TIMESTAMP, SYMBOL, INT])\n   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)\n   subscribeTable(tableName=\"trades\", actionName=\"agg1\", offset=0, handler=append!{agg1}, msgAsTable=true);\n   ```\n\n2. 给引擎 agg1 添加访问限制。\n\n   ```\n   addAccessControl(agg1)\n   ```\n\n3. 用户 u2 注入数据到引擎 agg1 或删除引擎 agg1 时报错。\n\n   ```\n   // 以用户 u2 的身份登录服务器\n   login(`u2, \"222222\")\n\n   // 注入数据\n   insert into trades values(2018.10.08T01:01:01.785,`A,10) // OK!\n   insert into agg1 values(2018.10.08T01:01:01.785,`A,10) // ERROR: No access to table [agg1]\n\n   // 注销引擎\n   dropStreamEngine(\"agg1\") // No access to drop stream engine agg1\n   ```\n\n4. 给用户 u2 赋予引擎 agg1 的写入权限。\n\n   ```\n   login(`admin, `123456)\n   grant(\"u2\", TABLE_WRITE, \"agg1\")\n   ```\n\n   如果在集群中，权限对象必须为 \"nodeAlias:tableName\"，例如引擎 agg1 在节点 dnode1 中。\n\n   ```\n   grant(\"u2\", TABLE_WRITE, \"dnode1:agg1\")\n   ```\n\n5. 此时用户 u2 可以成功注入数据到引擎 agg1。\n\n   ```\n   insert into agg1 values(2018.10.08T01:01:01.785,`A,10)\n   ```\n\n例2：限制其他用户访问流数据引擎\n\n```\nlogin(`u1, \"111111\")\nt = table(take(`a`b`c`, 10) as sym, 1..10 as val)\nshare t as st;\naddAccessControl(`st)\n\nlogin(`u3, \"333333\")\nselect * from st # ERROR: No access to shared table [st]\ninsert into st values(`a, 4) // ERROR: No access to shared table [st]\n```\n\n**相关函数**：[grant](https://docs.dolphindb.cn/zh/funcs/g/grant.html)、[deny](https://docs.dolphindb.cn/zh/funcs/d/deny.html)、[revoke](https://docs.dolphindb.cn/zh/funcs/r/revoke.html)\n"
    },
    "addCacheRulesForComputeGroup": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/addcacherulesforcomputegroup.html",
        "signatures": [
            {
                "full": "addCacheRulesForComputeGroup(name, tableNames)",
                "name": "addCacheRulesForComputeGroup",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "tableNames",
                        "name": "tableNames"
                    }
                ]
            }
        ],
        "markdown": "### [addCacheRulesForComputeGroup](https://docs.dolphindb.cn/zh/funcs/a/addcacherulesforcomputegroup.html)\n\n首发版本：3.00.5\n\n\n\n#### 语法\n\naddCacheRulesForComputeGroup(name, tableNames)\n\n#### 详情\n\n为计算组增加缓存规则，指定需要在计算组缓存路径中进行缓存的表。\n\n#### 参数\n\n**name** 字符串标量，指定需要增加缓存规则的计算组。\n\n**tableNames** 字符串标量或向量，指定需要在计算组缓存路径中进行缓存的表，以库名/表名的形式拼接，例如\"dfs\\://compute\\_test/tb1\"。暂不支持通配符。\n\n#### 返回值\n\n无\n\n#### 例子\n\n```\naddCacheRulesForComputeGroup(\"cgroup1\", \"dfs://compute_test/tb1\")\n\naddCacheRulesForComputeGroup(\"cgroup1\", [\"dfs://compute_test/tb1\", \"dfs://compute_test/tb2\"])\n```\n\n**相关函数：**[removeCacheRulesForComputeGroup](https://docs.dolphindb.cn/zh/funcs/r/removecacherulesforcomputegroup.html)、[getCacheRulesForComputeGroup](https://docs.dolphindb.cn/zh/funcs/g/getcacherulesforcomputegroup.html)\n"
    },
    "addColumn": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/addColumn.html",
        "signatures": [
            {
                "full": "addColumn(table, colNames, colTypes)",
                "name": "addColumn",
                "parameters": [
                    {
                        "full": "table",
                        "name": "table"
                    },
                    {
                        "full": "colNames",
                        "name": "colNames"
                    },
                    {
                        "full": "colTypes",
                        "name": "colTypes"
                    }
                ]
            }
        ],
        "markdown": "### [addColumn](https://docs.dolphindb.cn/zh/funcs/a/addColumn.html)\n\n\n\n#### 语法\n\naddColumn(table, colNames, colTypes)\n\n#### 详情\n\n给数据表添加新的列。若对分布式表（PKEY 引擎表除外）、维度表或流数据表添加新列，不能使用 SQL update 语句，只能使用 `addColumn` 命令。\n\n**Note:**\n\n* 分布式表或维度表通过 `addColumn` 命令添加新列后，需要使用 `loadTable` 后，才能更新追加的新列。\n* PKEY 引擎表不支持新增列。\n* 高可用流表不支持新增列。\n\n#### 参数\n\n**table** 内存表、流数据表、分布式表（不包括 PKEY 引擎表）或维度表。\n\n**colNames** 是字符串标量或向量，表示要添加的列的名称。\n\n**colTypes** 是表示数据类型的标量或向量。\n\n#### 例子\n\n例1： 给分布式表增加列\n\n```\nID=1..6\nx=1..6\\5\nt1=table(ID, x)\ndb=database(\"dfs://rangedb\",RANGE,  1 4 7)\npt = db.createPartitionedTable(t1, `pt, `ID)\npt.append!(t1);\naddColumn(pt,[\"price\", \"qty\"],[DOUBLE, INT]);\n```\n\n增加列后，在插入新结构数据之前，仍然可以插入原来结构的数据。\n\n```\nt2=table(1 as ID, 1.2 as x)\npt.append!(t2)\nselect * from pt;\n```\n\n| ID | x   | price | qty |\n| -- | --- | ----- | --- |\n| 1  | 0.2 |       |     |\n| 2  | 0.4 |       |     |\n| 3  | 0.6 |       |     |\n| 1  | 1.2 |       |     |\n| 4  | 0.8 |       |     |\n| 5  | 1   |       |     |\n| 6  | 1.2 |       |     |\n\n一旦插入了新结构的数据，就不能插入原来结构的数据。\n\n```\nt3=table(1 as ID, 1.6 as x, 10.0 as price, 6 as qty)\npt.append!(t3)\nselect * from pt;\n```\n\n| ID | x   | price | qty |\n| -- | --- | ----- | --- |\n| 1  | 0.2 |       |     |\n| 2  | 0.4 |       |     |\n| 3  | 0.6 |       |     |\n| 1  | 1.2 |       |     |\n| 1  | 1.6 | 10    | 6   |\n| 4  | 0.8 |       |     |\n| 5  | 1   |       |     |\n| 6  | 1.2 |       |     |\n\n```\nt4=table(2 as ID, 2.2 as x)\npt.append!(t4);\n// output\nThe data to append contains fewer columns than the schema.\n```\n\n例2：给流数据表增加列\n\n```\nn=10\nticker = rand(`MSFT`GOOG`FB`ORCL`IBM,n)\nx=rand(1.0, n)\nt=streamTable(ticker, x)\nshare t as st\naddColumn(st,[\"price\", \"qty\"],[DOUBLE, INT])\ninsert into st values(\"MSFT\",12.0,25.46,256)\nselect * from st;\n```\n\n| ticker | x                 | price | qty |\n| ------ | ----------------- | ----- | --- |\n| MSFT   | 0.743241031421349 |       |     |\n| FB     | 0.254624255700037 |       |     |\n| FB     | 0.947473830310628 |       |     |\n| FB     | 0.904140035156161 |       |     |\n| MSFT   | 0.193251194199547 |       |     |\n| MSFT   | 0.416090324753895 |       |     |\n| MSFT   | 0.479371337918565 |       |     |\n| ORCL   | 0.69910929678008  |       |     |\n| GOOG   | 0.131539688445628 |       |     |\n| MSFT   | 0.472390263108537 |       |     |\n| MSFT   | 12                | 25.46 | 256 |\n"
    },
    "addEventListener": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/addEventListener.html",
        "signatures": [
            {
                "full": "addEventListener(handler, [eventType], [condition], [times=\"all\"], [at], [wait], [within], [exceedTime], [name])",
                "name": "addEventListener",
                "parameters": [
                    {
                        "full": "handler",
                        "name": "handler"
                    },
                    {
                        "full": "[eventType]",
                        "name": "eventType",
                        "optional": true
                    },
                    {
                        "full": "[condition]",
                        "name": "condition",
                        "optional": true
                    },
                    {
                        "full": "[times=\"all\"]",
                        "name": "times",
                        "optional": true,
                        "default": "\"all\""
                    },
                    {
                        "full": "[at]",
                        "name": "at",
                        "optional": true
                    },
                    {
                        "full": "[wait]",
                        "name": "wait",
                        "optional": true
                    },
                    {
                        "full": "[within]",
                        "name": "within",
                        "optional": true
                    },
                    {
                        "full": "[exceedTime]",
                        "name": "exceedTime",
                        "optional": true
                    },
                    {
                        "full": "[name]",
                        "name": "name",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [addEventListener](https://docs.dolphindb.cn/zh/funcs/a/addEventListener.html)\n\n\n\n#### 语法\n\naddEventListener(handler, \\[eventType], \\[condition], \\[times=\"all\"], \\[at], \\[wait], \\[within], \\[exceedTime], \\[name])\n\n#### 详情\n\n该函数用于为 CEP 引擎指定事件匹配规则和回调函数。事件监听器必须在 monitor 内调用，用于监测注入引擎的每个事件。当事件或事件模式与匹配规则相匹配时，会触发执行回调函数。\n\n#### 参数\n\n**handler** 回调函数，如果指定了 *eventType* 则为一元函数，参数为匹配的事件。如果指定为按时间触发，则没有参数。\n\n```\ndef actions1(stockVal){\n    //将事件类型 stockVal 的属性写入一个共享表\n    insert into objByName(\"sharedUSPrices\") values([stockVal.price, stockVal.qty])\n} \n```\n\n*handler* 中可以动态添加新的监听器：\n\n```\ndef actions1(stockVal){\n    //将事件类型 stockVal 的属性写入一个共享表\n    insert into objByName(\"sharedUSPrices\") values([stockVal.price, stockVal.qty])\n    //新增加一个事件侦听器\n    addEventListener(handler=action2, eventType=\"Stock\", condition=<self.prices > stockVal.price>)\n}\n```\n\n自 3.00.4 版本起，*handler* 支持调用 monitor 类之外的函数。调用外部类的方法时，应使用 self（当前实例的引用）进行访问，例如：\n\n```\nclass Logic{\n    monitor::ANY \n    def Logic(monitor_){\n        monitor = monitor_\n    }\n    def processTick(stockTickEvent) { \n        str = \"StockTick event received\" + \n                \" name = \" + stockTickEvent.name + \n                \" Price = \" + stockTickEvent.price.string()\n        writeLog(str)\n    }\n    def testAddListener(){\n        monitor.addEventListener(self.processTick, \"StockTick\", ,\"all\")\n    }\n}\n```\n\n**eventType**字符串标量，表示事件类型。若指定为 \"any\"，则表示任意事件。\n\n**condition** 元代码类型，指定匹配的事件条件，即事件匹配规则。元代码的返回结果必须是布尔值。例如 *eventType* 为 Stock 时，指定 \\<Stock.price > 10 and Stock.qty < 10> 。\n\n**times** 可以是正整数或者 \"all\"，表示在 *handler* 被触发指定次数后自动删除监听，默认为 \"all\"。例如，若设置为 5，表示 *handler* 被触发 5 次后，将删除该监听器；若设置为 \"all\"，则会持续监听事件，对每个匹配的事件都触发 *handler*，直至引擎被删除。\n\n**at** 一个长度为 6 的元组，用于指定触发 *handler* 的时间频率。其形式为 (seconds，minutes, hours, days\\_of\\_the\\_week，days\\_of\\_the\\_month, month ) ，其中各元素依次表示秒（必须指定）、分钟、小时、一周中的第几天、当月的第几天、月份。如果*times*=\"all\"，则表示每月/日/周几/小时/分钟的第 seconds 秒触发 *handler*。例如：(0, 5, , , )，表示在每小时的 05 分触发 *handler*。如果 *times* 指定为具体数字，则 *handler* 只会被触发指定次数。\n\n**wait** DURATION 类型，表示等待多长时间后触发 *handler*。如果 *times*=\"all\"，则表示每隔多久触发 *handler*。例如：*wait*= 60s, *times*=\"all\"，每隔 60秒触发一次 *handler*。如果 *times* 指定为具体数字，则 *handler* 只会被触发指定次数。\n\n**within** 仅在限定的时间内收到匹配的事件时才触发 *handler*。例如：*eventType*=\"tickets\", *within*=60s ，表示60秒内匹配到事件 tickets，则触发 *handler*，否则删除这个监听器。\n\n**exceedTime** 仅在限定的时间内没有匹配的事件时才触发 *handler*。例如：*eventType*=\"tickets\", *exceedTime*=60s，表示若60秒内未匹配到事件 tickets，则触发 *handler*，否则删除这个监听器。\n\n**name**字符串标量，可选参数，表示监听器的名称，用于唯一标识该监听器。默认值根据 *condition* 得出：\n\n* 若指定 *condition*，则名称为其表达式的字符串形式；\n* 若 *condition* 为空且指定了 *eventType*，则名称为 *eventType*；\n* 若 *condition* 和 *eventType* 均未指定，则默认名称为 \"timer\"；\n* 若生成的名称与现有监听器重名，将自动在名称后追加编号以确保唯一性。\n\n#### 事件监听器触发方式\n\n事件监听器可通过不同参数配置实现多种触发方式，包括：基于事件匹配触发、基于时间的定时触发，以及时间与事件条件的组合触发。\n\n* **事件匹配**：监听单一事件或者所有事件，并且限定事件条件。相关参数：*handler*, *eventType*, *condition*。举例：\n  * 监听价格大于10.0 的股票。下例中 *eventType* 为事件，*condition* 为事件匹配条件，*handler* 为监听到符合条件的事件之后的回调函数：\n\n    ```\n    addEventListener(handler=action, eventType=`Stock,\n                                    condition=<Stock.price > 10.0>)\n    ```\n\n  * 监听所有的股票：\n\n    ```\n    addEventListener(handler=action, eventType=`Stock)\n    ```\n\n  * 监听任意事件\n\n    ```\n    addEventListener(handler=action, eventType=\"any\")\n    ```\n\n* **基于事件时间触发**：此时不会进行事件匹配，因此不可指定 *eventType*。\n  * 在固定时间触发，比如：在每天的 8:30 触发（参数*at*）：\n\n    ```\n    addEventListener(handler=action, at=(0,30,8,,,))\n    ```\n\n  * 等待固定时间之后触发，比如从监听器被添加开始，每隔60秒触发一次（参数 *wait*）：\n\n    ```\n    addEventListener(handler=action, wait=60s)\n    ```\n\n  * 等待固定时间之后触发，从监听器被添加开始，等待60秒触发一次（参数 *wait*, *times*）：\n\n    ```\n    addEventListener(handler=action, wait=60s,times=1)\n    ```\n\n* 同时限定时间和事件：*within*, *times*, *exceedTime*。\n  * 在限定时间内匹配事件，比如在60秒内匹配到价格大于10.0的 Stock 事件，则执行回调函数：\n\n    ```\n    addEventListener(handler=action, eventType=`Stock, condition=<Stock.price > 10.0>，within = 60s,times=1)\n    ```\n\n  * 在限定时间内未匹配事件，如在60秒内没有匹配到价格大于10.0的 Stock 事件，则执行回调函数：\n\n    ```\n    addEventListener(handler=action, eventType=`Stock, condition=<Stock.price > 10.0>，exceedTime= 60s,times=1)\n    ```\n\n#### 返回值\n\n返回一个 EventListener 实例。\n\n#### 例子\n\n```\nclass trades{\n    trader :: STRING\n    market :: STRING\n    code :: STRING\n    price :: DOUBLE\n    qty :: INT\n    eventTime :: TIMESTAMP\n    def trades(t, m, c, p, q){\n        trader = t\n        market = m\n        code = c\n        price = p\n        qty = q\n        eventTime = now()\n    }\n}\n\nclass mainMonitor:CEPMonitor{\n    tradesTable :: ANY\n    isBusy :: BOOL\n    def mainMonitor(){\n        tradesTable = array(ANY, 0)\n        isBusy = false\n    }\n\n    def updateTrades(event)\n\n    def updateTrades2(event)\n\n    def unOnload(){\n        undef('traderDV', SHARED)\n    }\n\n    def onload(){\n        addEventListener(updateTrades, `trades, , \"all\",,,,,\"trades1\")\n        addEventListener(updateTrades2, `trades, , \"all\",,,,,\"trades2\")\n        traderDV = streamTable(array(STRING, 0) as trader, array(STRING, 0) as market, array(SYMBOL, 0) as code, array(DOUBLE, 0) as price, array(INT, 0) as qty, array(INT, 0) as tradeCount, array(BOOL, 0) as busy, array(DATE, 0) as orderDate, array(TIMESTAMP, 0) as updateTime)\n        share(traderDV, 'traderDV')\n        createDataViewEngine('traderDV', objByName('traderDV'), `trader, `updateTime, true)\n    }\n\n    def updateTrades(event) {\n        tradesTable.append!([event.trader, event.market, event.code, event.price, event.qty])\n        getDataViewEngine('traderDV').append!(table(event.trader as trader, string() as market, string() as code, 0.0 as price, 0 as qty, 0 as tradeCount, false as busy, date(event.eventTime) as orderDate))\n        updateDataViewItems('traderDV', event.trader, ['market', 'code', 'price', 'qty', 'tradeCount'], [event.market, event.code, event.price, event.qty, tradesTable.size()])\n    }\n\n    def updateTrades2(event) {\n        tradesTable.append!([event.trader, event.market, event.code, event.price, event.qty])\n        getDataViewEngine('traderDV').append!(table(event.trader as trader, string() as market, string() as code, 0.0 as price, 0 as qty, 0 as tradeCount, false as busy, date(event.eventTime) as orderDate))\n        updateDataViewItems('traderDV', event.trader, ['market', 'code', 'price', 'qty', 'tradeCount'], [event.market, event.code, event.price, event.qty, tradesTable.size()])\n    }\n}\n\ndummy = table(array(TIMESTAMP, 0) as eventTime, array(STRING, 0) as eventType, array(BLOB, 0) as blobs)\nengineCep = createCEPEngine('cep1', <mainMonitor()>, dummy, [trades], 1, 'eventTime', 10000)\ntrade1 = trades('t1', 'sz', 's001', 11.0, 10)\ngo\nappendEvent(engineCep, trade1)\n// 查看 monitor\nmonitors = getCEPEngineMonitor('cep1',\"cep1\",\"mainMonitor\")\n// 查看 listener\nlisteners = monitors.getEventListener()\nprint(listeners)\n// 终止 listener\nlisteners['trades1'].terminate()\nprint(listeners)\n```\n\n**相关函数**：[getEventListener](https://docs.dolphindb.cn/zh/funcs/g/getEventListener.html), [terminate](https://docs.dolphindb.cn/zh/funcs/t/terminate.html)\n"
    },
    "addFunctionView": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/addFunctionView.html",
        "signatures": [
            {
                "full": "addFunctionView(udf|moduleName)",
                "name": "addFunctionView",
                "parameters": [
                    {
                        "full": "udf|moduleName",
                        "name": "udf|moduleName"
                    }
                ]
            }
        ],
        "markdown": "### [addFunctionView](https://docs.dolphindb.cn/zh/funcs/a/addFunctionView.html)\n\n\n\n#### 语法\n\naddFunctionView(udf|moduleName)\n\n#### 详情\n\n函数视图是封装了访问数据库以及相关计算语句的一种特殊的自定义函数。函数视图提供了一种灵活的方式来控制用户访问数据库和表。用户即使不具备读写数据库原始数据的权限，也可通过执行函数视图，间接访问数据库，得到所需计算结果。例如，用户不能查看个别患者的名称和年龄等原始数据，但是可以获取患者的总数与平均年龄。\n\n与其他自定义函数会话隔离不同，函数视图可以实现会话之间的共享。函数视图的定义持久化存储在控制节点，因此如果 DolphinDB 集群重启，之前定义的函数视图仍然可以使用。\n\n使用 [grant](https://docs.dolphindb.cn/zh/funcs/g/grant.html), [deny](https://docs.dolphindb.cn/zh/funcs/d/deny.html) 或 [revoke](https://docs.dolphindb.cn/zh/funcs/r/revoke.html) 命令对用户的 VIEW\\_EXEC 权限进行操作时，用户自定义函数可以作为这些命令的 objs 参数。\n\n`addFunctionView` 只能由管理员或拥有 VIEW\\_OWNER 权限的普通用户执行。\n\n#### 参数\n\n**udf** 是用户自定义函数。\n\n**moduleName** 是一个字符串标量，代表模块名称。\n\n**Note:**\n\n* 不支持匿名函数。\n* 自定义函数只能接收标量、数据对或常规数组作为默认参数。\n* *moduleName* 相应模块必须放置于节点的 modules 目录下\n* 若 modules 目录下同时存在名为 *moduleName* 的 dos 和 dom 文件，则优先加载 dos 文件。\n* 如果在当前节点使用use \\<moduleName> 的方式加载模块使用，即使同名模块和函数已通过 addFunctionView 封装，也会优先使用最新加载的模块。\n\n#### 例子\n\n下例中，自定义函数 `getSpread` 计算 `dfs://TAQ/quotes` 表中指定股票的平均买卖报价差。用户 user1 不具有读取 `dfs://TAQ/quotes` 表的权限。将函数 `getSpread` 定义为函数视图， 并赋予用户 user1 执行该视图的权限。虽然 user1 不具备读取 `dfs://TAQ/quotes` 表的权限，但可通过执行 `getSpread` 函数，对 `dfs://TAQ/quotes` 表的数据进行计算，来获得指定股票的买卖报价差。\n\n由于 `dfs://TAQ/quotes` 是分布式数据库，以下代码需要由系统管理员在控制节点上执行。用户 user1 可在任意数据节点/计算节点运行 `getSpread` 函数。\n\n```\ndef getSpread(s, d){\n return select avg((ofr-bid)/(ofr+bid)*2) as spread from loadTable(\"dfs://TAQ\",\"quotes\") where symbol=s, date=d\n}\n\naddFunctionView(getSpread)\n\n// grant 操作需在控制节点执行\ngrant(\"user1\", VIEW_EXEC, \"getSpread\")\n```\n\n确保在节点的 modules 下已存在 test.dos，模块 test 中定义了函数 f1 和 f2。\n\n```\n addFunctionView(\"test\")\n\n//为用户 user1 授权执行模块 test 下的函数 f1\ngrant(\"user1\", VIEW_EXEC, \"test::f1\")\n//为用户 user1 授权执行模块 test 下的所有函数\ngrant(`user1, VIEW_EXEC, \"test::*\")\n\n//用户可使用全限定名调用相应函数\ntest::f1()\n```\n\n相关函数： [dropFunctionView](https://docs.dolphindb.cn/zh/funcs/d/dropFunctionView.html)、[getFunctionViews](https://docs.dolphindb.cn/zh/funcs/g/getFunctionViews.html)\n"
    },
    "addGpFunction": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/addgpfunction.html",
        "signatures": [
            {
                "full": "addGpFunction(engine, func)",
                "name": "addGpFunction",
                "parameters": [
                    {
                        "full": "engine",
                        "name": "engine"
                    },
                    {
                        "full": "func",
                        "name": "func"
                    }
                ]
            }
        ],
        "markdown": "### [addGpFunction](https://docs.dolphindb.cn/zh/funcs/a/addgpfunction.html)\n\n#### 语法\n\naddGpFunction(engine, func)\n\n**Note:**\n\n社区版 License 暂不支持该函数，如需使用此功能，请联系技术支持。\n\n#### 详情\n\n在现有训练函数的基础上增加用户自定义函数，用于初始化公式树和进化时使用。支持的算子详见附录。\n\n#### 参数\n\n**engine**通过函数 `createGPLearnEngine` 创建引擎的返回对象。\n\n**func** 用户自定义函数。自定义函数目前不支持复杂赋值、if、for 等语句，只支持 return 语句，return 值为已支持的训练函数的组合。例如：\n\n```\ndef f(x, y){\n  return cos(x+y)\n}\n```\n\n#### 例子\n\n```\ndef f(x, y){\n  return cos(x+y)\n}\naddGpFunction(engine,f)\n```\n\n#### 附录\n\n目前已支持的训练函数：\n\n**Note:** 对于所有的 m 系列函数，如果当前窗口小于 n，则会直接返回 0。而 DolphinDB 默认返回空值。\n\n| 函数名             | 入参数量 | 描述                               |\n| --------------- | ---- | -------------------------------- |\n| add(x,y)        | 2    | 加法                               |\n| sub(x,y)        | 2    | 减法                               |\n| mul(x,y)        | 2    | 乘法                               |\n| div(x,y)        | 2    | 除法， 如果除数的绝对值小于0.001，返回1          |\n| max(x,y)        | 2    | 最大值                              |\n| min(x,y)        | 2    | 最小值                              |\n| sqrt(x)         | 1    | 按照绝对值开方                          |\n| log(x)          | 1    | `iif(x < 0.001, 0, log(abs(x)))` |\n| neg(x)          | 1    | 相反数                              |\n| reciprocal(x)   | 1    | 倒数，如果x的绝对值小于0.001，将返回0           |\n| abs(x)          | 1    | 绝对值                              |\n| sin(x)          | 1    | 正弦函数                             |\n| cos(x)          | 1    | 余弦函数                             |\n| tan(x)          | 1    | 正切函数                             |\n| sig(x)          | 1    | sigmoid函数                        |\n| signum(x)       | 1    | 返回 x 的符号标志                       |\n| mcovar(x, y, n) | 2    | 滑动窗口为n时，x和y的协方差                  |\n| mcorr(x, y, n)  | 2    | 滑动窗口为n时，x和y的相关性                  |\n| mstd(x, n)      | 1    | 滑动窗口为n时，x的样本标准差                  |\n| mmax(x, n)      | 1    | 滑动窗口为n时，x的最大值                    |\n| mmin(x, n)      | 1    | 滑动窗口为n时，x的最小值                    |\n| msum(x, n)      | 1    | 滑动窗口为n时，x的和                      |\n| mavg(x, n)      | 1    | 滑动窗口为n时，x的平均数                    |\n| mprod(x, n)     | 1    | 滑动窗口为n时，x的积                      |\n| mvar(x, n)      | 1    | 滑动窗口为n时，x的样本方差                   |\n| mvarp(x, n)     | 1    | 滑动窗口为n时，x的总体方差                   |\n| mstdp(x, n)     | 1    | 滑动窗口为n时，x的总体标准差                  |\n| mimin(x, n)     | 1    | 滑动窗口为n时，x的最小值下标                  |\n| mimax(x, n)     | 1    | 滑动窗口为n时，x的最大值下标                  |\n| mbeta(x, y, n)  | 2    | 滑动窗口为n时，x在y上的回归系数的最小二乘估计         |\n| mwsum(x, y, n)  | 2    | 滑动窗口为n时，x和y的内积                   |\n| mwavg(x, y, n)  | 2    | 滑动窗口为n时，x以y为权重的加权平均值             |\n\n\n\n**Related information**\n\n[Shark GPLearn 快速上手](https://docs.dolphindb.cn/zh/tutorials/gplearn.html)\n"
    },
    "addGroupMember": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/addGroupMember.html",
        "signatures": [
            {
                "full": "addGroupMember(userIds, groupIds)",
                "name": "addGroupMember",
                "parameters": [
                    {
                        "full": "userIds",
                        "name": "userIds"
                    },
                    {
                        "full": "groupIds",
                        "name": "groupIds"
                    }
                ]
            }
        ],
        "markdown": "### [addGroupMember](https://docs.dolphindb.cn/zh/funcs/a/addGroupMember.html)\n\n\n\n#### 语法\n\naddGroupMember(userIds, groupIds)\n\n#### 详情\n\n把用户添加到群组：\n\n* 添加一个用户到一个群组\n* 添加多个用户到一个群组\n* 添加一个用户到多个群组\n\n该操作可能会因为组所具有的权限而使入组用户的权限发生改变。\n\n**Note:** 该函数只能由管理员在控制节点、数据节点和计算节点运行。\n\n#### 参数\n\n**userIds** 是一个表示用户名称的字符串。\n\n**groupIds** 是一个表示群组名称的字符串。\n\n*userIds* 和 *groupIds* 不能同时为向量。\n\n#### 例子\n\n添加一个用户（Even）到一个群组（adm 组）：\n\n```\naddGroupMember(\"Even\", \"adm\");\n```\n\n添加多个用户（Alice 和 CardiB）到一个群组（adm 组）：\n\n```\naddGroupMember([\"Alice\",\"CardiB\"], \"adm\"); \n```\n\n添加一个用户（Carlos）到多个群组（adm 组和 prof 组）：\n\n```\naddGroupMember(\"Carlos\", [\"adm\",\"prof\"]);\n```\n"
    },
    "addIPBlackList": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/addipblacklist.html",
        "signatures": [
            {
                "full": "addIPBlackList(ips)",
                "name": "addIPBlackList",
                "parameters": [
                    {
                        "full": "ips",
                        "name": "ips"
                    }
                ]
            }
        ],
        "markdown": "### [addIPBlackList](https://docs.dolphindb.cn/zh/funcs/a/addipblacklist.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\naddIPBlackList(ips)\n\n#### 详情\n\n新增 IP 到黑名单中。添加第一个 IP 即为启用黑名单，IP 黑名单与白名单只能同时启用一种。启用黑名单后，服务器会拒绝来自黑名单中 IP 的连接请求。\n\n此函数仅可由管理员执行，对整个集群生效。\n\n#### 参数\n\n**ips** 是 STRING 或 IPADDR 类型的标量或向量，表示一个或多个 IP 地址。最多支持设置 65535 个 IP。\n\n#### 例子\n\n```\naddIPBlackList([\"1.1.1.1\", \"2.2.2.2\", \"3.3.3.3\"])\n```\n\n相关函数：[removeIPBlackList](https://docs.dolphindb.cn/zh/funcs/r/removeipblacklist.html)、[getIPBlackList](https://docs.dolphindb.cn/zh/funcs/g/getipblacklist.html)\n"
    },
    "addIPWhiteList": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/addipwhitelist.html",
        "signatures": [
            {
                "full": "addIPWhiteList(ips)",
                "name": "addIPWhiteList",
                "parameters": [
                    {
                        "full": "ips",
                        "name": "ips"
                    }
                ]
            }
        ],
        "markdown": "### [addIPWhiteList](https://docs.dolphindb.cn/zh/funcs/a/addipwhitelist.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\naddIPWhiteList(ips)\n\n#### 详情\n\n新增 IP 到白名单中。添加第一个 IP 即为启用白名单，IP 白名单与黑名单只能同时启用一种。启用白名单后，服务器仅接受来自白名单中 IP 的连接请求。白名单默认包含 127.0.0.1。\n\n此函数仅可由管理员执行，对整个集群生效。\n\n#### 参数\n\n**ips** 是 STRING 或 IPADDR 类型的标量或向量，表示一个或多个 IP 地址。最多支持设置 65535 个 IP。\n\n#### 例子\n\n```\naddIPWhiteList([\"1.1.1.1\", \"2.2.2.2\", \"3.3.3.3\"])\n```\n\n相关函数：[removeIPWhiteList](https://docs.dolphindb.cn/zh/funcs/r/removeipwhitelist.html)、[getIPWhiteList](https://docs.dolphindb.cn/zh/funcs/g/getipwhitelist.html)\n"
    },
    "addMarketHoliday": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/addMarketHoliday.html",
        "signatures": [
            {
                "full": "addMarketHoliday(marketName, holiday, [dateType = 'holidayDate'])",
                "name": "addMarketHoliday",
                "parameters": [
                    {
                        "full": "marketName",
                        "name": "marketName"
                    },
                    {
                        "full": "holiday",
                        "name": "holiday"
                    },
                    {
                        "full": "[dateType = 'holidayDate']",
                        "name": "[dateType = 'holidayDate']"
                    }
                ]
            }
        ],
        "markdown": "### [addMarketHoliday](https://docs.dolphindb.cn/zh/funcs/a/addMarketHoliday.html)\n\n#### 语法\n\naddMarketHoliday(marketName, holiday, \\[dateType = 'holidayDate'])\n\n#### 详情\n\n在线添加一个交易市场节假日或交易日文件，通过此文件生成一个交易日历。调用该函数后，在 *marketHolidayDir* 指定的目录下会生成一个和 *marketName* 同名的 csv 文件。\n\n**Note:**\n\n* 该函数只能由管理员调用。\n* 该函数仅对当前节点有效。集群环境中，通过 `pnodeRun` 调用该函数，使其在其它节点生效。\n\n#### 参数\n\n**marketName** 字符串标量，表示交易日历标识，例如：国外交易所的 ISO Code、国内交易所简称或自定义交易日历名称。\n\n**Note:**\n\n* *marketName* 必须由4个大写字母组成，且不能与 *marketHolidayDir* 下的文件名相同。\n\n**holiday** DATE 类型向量，表示日期。\n\n* 当 *dateType*='holidayDate' 时，*holiday* 需要指定为休市日期，因为系统默认周末为休市日，所以 *holiday* 只需指定非周末的休市日期。\n* 当 *dateType*='tradingDate' 时，*holiday* 需要指定为交易日期。\n\n**dateType** 字符串，用于指定交易日历文件的数据是休市日期还是交易日期。可选值为 ‘holidayDate’（默认）或 'tradingDate'。\n\n#### 例子\n\n例1. 以下例子展示如何通过该函数手动添加名为 \"DCBA\" 的交易日历标识。本例需要添加的数据为非周末的休市日期。\n\n```\naddMarketHoliday(\"DCBA\",2022.01.03 2022.01.05)\n```\n\n运行后，在 `/server/marketHoliday/` 路径下会新增一个名为 `DCBA.csv` 的文件，其中包含了已添加的节假日。\n\n![](https://docs.dolphindb.cn/zh/images/addMarketHoliday.png \"DCBA\")\n\n**Note:** 使用该函数添加已存在于交易日历中的交易日历标识时，会出现 `The added market '<marketName>' already exists.` 的提示，说明该交易日历标识已存在于 `/server/marketHoliday/` 目录下，不需要重复添加。\n\n```\ntemporalAdd(2022.01.01,1,\"DCBA\")\n```\n\n返回：2022.01.04\n\n```\nindex = [2022.01.01, 2022.01.02, 2022.01.03, 2022.01.04]\ns = indexedSeries(index, 1..4)\ns.resample(\"DCBA\", sum);\n```\n\n返回：\n\n```\nlabel\tcol1\n2021.12.31   6\n2022.01.04   4\n```\n\n例2. 2024 年2月18日为周日。如果因调休开盘，可以通过指定 *dateType*='tradingDate'，创建一个交易日历（包含所有易日期）。本例中需要添加的数据为交易日期，包括周末开盘的日期。\n\n```\ntradingDates=[2024.02.08, 2024.02.09, 2024.02.18, 2024.02.19, 2024.02.20, 2024.02.21]\naddMarketHoliday(marketName=\"AAAA\", holiday=tradingDates, dateType='tradingDate')\n```\n\n运行以上代码后，在 `/server/marketHoliday/` 路径下会新增一个名为 *AAAA.csv*的文件，包含1列数据，字段名称为 tradingDate，数据为 tradingDates。\n\n```\ntemporalAdd(2024.02.09, 1, \"AAAA\") \n```\n\n返回：2024.02.18\n\n```\ntemporalAdd(2024.02.21, 1, \"AAAA\")\n//计算得到的日期如果不在 AAAA.csv 文件中记录，则会报错：The returned date does not exist in trading calendar [AAAA].\n```\n\n\n\n**Related information**\n\n[updateMarketHoliday](https://docs.dolphindb.cn/zh/funcs/u/updateMarketHoliday.html)\n\n[getMarketCalendar](https://docs.dolphindb.cn/zh/funcs/g/getMarketCalendar.html)\n\n[getTradingCalendarType](https://docs.dolphindb.cn/zh/funcs/g/gettradingcalendartype.html)\n"
    },
    "addMCPPrompt": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/addMCPPrompt.html",
        "signatures": [
            {
                "full": "addMCPPrompt(name, message, [description], [extraInfo])",
                "name": "addMCPPrompt",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "message",
                        "name": "message"
                    },
                    {
                        "full": "[description]",
                        "name": "description",
                        "optional": true
                    },
                    {
                        "full": "[extraInfo]",
                        "name": "extraInfo",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [addMCPPrompt](https://docs.dolphindb.cn/zh/funcs/a/addMCPPrompt.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\naddMCPPrompt(name, message, \\[description], \\[extraInfo])\n\n#### 详情\n\n定义一个 MCP prompt 模板。\n\n#### 参数\n\n**name** STRING 类型标量，表示 prompt 模板的名称。\n\n**message** STRING 类型标量，表示 prompt 模板内容，允许包含 `{}`占位符。\n\n**description** 可选参数，STRING 类型标量，表示 prompt 模板说明。\n\n**extraInfo** 可选参数，一个字典，键是 STRING 类型，值是 ANY 或 STRING 类型，用于指定其他信息。目前键支持 \"title\"。\n\n#### 返回值\n\n一个字符串，表示新增 MCP prompt 模板的名称。\n\n#### 例子\n\n```\naddMCPPrompt(\n  name = \"stock_summary\",\n  message = \"请用一句话总结 ${stock} 从 ${startDate} 到 ${endDate} 的走势。\",\n  description = \"生成某个股票在一段时间内的自然语言概述\",\n  extraInfo = {title : \"股票走势总结\"}\n)\n\n//output:'stock_summary'\n```\n"
    },
    "addMCPTool": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/addMCPTool.html",
        "signatures": [
            {
                "full": "addMCPTool(name, func, [argNames], [argTypes], [description], [extraInfo])",
                "name": "addMCPTool",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "[argNames]",
                        "name": "argNames",
                        "optional": true
                    },
                    {
                        "full": "[argTypes]",
                        "name": "argTypes",
                        "optional": true
                    },
                    {
                        "full": "[description]",
                        "name": "description",
                        "optional": true
                    },
                    {
                        "full": "[extraInfo]",
                        "name": "extraInfo",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [addMCPTool](https://docs.dolphindb.cn/zh/funcs/a/addMCPTool.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\naddMCPTool(name, func, \\[argNames], \\[argTypes], \\[description], \\[extraInfo])\n\n#### 详情\n\n定义一个 MCP tool。\n\n#### 参数\n\n**name** STRING 类型标量，表示 tool 的名称。\n\n**func** 自定义函数。\n\n**argNames** STRING 类型向量，表示参数名。如无参数，请用 `[]` 表示。\n\n**argTypes**STRING 类型向量，表示参数类型，既可指定为 DolphinDB 数据类型，也可指定为 JSON 数据类型。支持的数据类型如下：\n\n| DolphinDB 数据类型 | JSON 数据类型         |\n| -------------- | ----------------- |\n| STRING         | \"string\"          |\n| TEMPORAL       | \"string\"          |\n| DOUBLE         | \"number\"          |\n| BOOL           | \"boolean\"         |\n| STRING\\[]      | \"array\\<string>\"  |\n| TEMPORAL\\[]    | \"array\\<string>\"  |\n| DOUBLE\\[]      | \"array\\<number>\"  |\n| BOOL\\[]        | \"array\\<boolean>\" |\n\n**description** 可选参数，STRING 类型标量，表示 tool 的描述。\n\n**extraInfo** 可选参数，一个字典，键是 STRING 类型，值是 ANY 或 STRING 类型，用于指定其他信息。目前键支持 \"title\"。\n\n#### 返回值\n\n一个字符串，表示新增 tool 的名称。\n\n#### 例子\n\n```\ndef myTool(x) {\n   return x * 2 + 1\n}\n\ninfo = {\n    \"title\": \"DolphinDB Tools\"\n}\n\naddMCPTool(name=\"myTool\", func=myTool, argNames=[\"a\"], argTypes=[\"number\"], description=\"This is a tool\", extraInfo=info)\n```\n"
    },
    "addMetrics": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/addMetrics.html",
        "signatures": [
            {
                "full": "addMetrics(engine, newMetrics, newMetricsSchema, [windowSize], [fill])",
                "name": "addMetrics",
                "parameters": [
                    {
                        "full": "engine",
                        "name": "engine"
                    },
                    {
                        "full": "newMetrics",
                        "name": "newMetrics"
                    },
                    {
                        "full": "newMetricsSchema",
                        "name": "newMetricsSchema"
                    },
                    {
                        "full": "[windowSize]",
                        "name": "windowSize",
                        "optional": true
                    },
                    {
                        "full": "[fill]",
                        "name": "fill",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [addMetrics](https://docs.dolphindb.cn/zh/funcs/a/addMetrics.html)\n\n\n\n#### 语法\n\naddMetrics(engine, newMetrics, newMetricsSchema, \\[windowSize], \\[fill])\n\n别名：extendMetrics\n\n#### 详情\n\n动态增加流数据引擎的计算指标。\n\n#### 参数\n\n**engine** 是流数据引擎，即 [createTimeSeriesEngine](https://docs.dolphindb.cn/zh/funcs/c/createTimeSeriesEngine.html) 等函数返回的抽象表对象。请注意，暂不支持 [createAnomalyDetectionEngine](https://docs.dolphindb.cn/zh/funcs/c/createAnomalyDetectionEngine.html) 和 [createReactiveStateEngine](https://docs.dolphindb.cn/zh/funcs/c/createReactiveStateEngine.html) 引擎。\n\n**newMetrics** 是元代码，表示流数据引擎增加的计算指标。可以是一个或多个表达式、系统内置或用户自定义函数，也可以是一个常量标量/向量。当指定为常量向量时，对应的输出列应该设置为数组向量类型。\n\n**newMetricsSchema** 是表对象，指定新增的计算指标在输出表中的列名和数据类型。\n\n**windowSize** 是一个正整数，表示新增指标的计算窗口长度。仅适用于时间序列引擎，且必须为已指定的窗口长度之一。若未指定，默认值为第一个已指定的窗口长度。\n\n**fill** 可选参数，一个标量或向量，指定某个分组的某个窗口无数据时的处理方法。可取以下值：\n\n* 'none': 不输出结果。\n* 'null': 输出结果为 NULL。\n* 'ffill': 输出上一个有数据的窗口的结果。\n* '具体数值'：该值的数据类型需要和对应的 *metrics* 计算结果的类型保持一致。\n\n*fill* 可以输入向量，长度与 *metrics* 元素个数保持一致，表示为每个 *metrics* 指定不同的 *fill* 方式。若为向量，向量中各项只能是 'null', 'ffill' 或一个数值，不能是 'none'。\n\n#### 例子\n\n使用流数据时间序列引擎计算 sum(x) 指标。\n\n```\nshare streamTable(10000:0,`time`id`x, [TIMESTAMP,SYMBOL,INT]) as t\noutput1 = table(10000:0, `time`sum_x, [TIMESTAMP,INT])\nagg1 = createTimeSeriesEngine(name=`agg1, windowSize=100, step=50, metrics=<sum(x)>, dummyTable=t, outputTable=output1, timeColumn=`time)\nsubscribeTable(tableName=\"t\", actionName=\"agg1\", offset=0, handler=append!{agg1}, msgAsTable=true)\nn=500\ntime=2019.01.01T00:00:00.000+(1..n)\nid=take(`ABC`DEF, n)\nx=1..n\ninsert into t values(time, id, x);\nselect * from output1;\n```\n\n| time                    | sum\\_x |\n| ----------------------- | ------ |\n| 2019.01.01T00:00:00.050 | 1,225  |\n| 2019.01.01T00:00:00.100 | 4,950  |\n| 2019.01.01T00:00:00.150 | 9,950  |\n| 2019.01.01T00:00:00.200 | 14,950 |\n| 2019.01.01T00:00:00.300 | 24,950 |\n| 2019.01.01T00:00:00.350 | 29,950 |\n| 2019.01.01T00:00:00.400 | 34,950 |\n| 2019.01.01T00:00:00.450 | 39,950 |\n| 2019.01.01T00:00:00.500 | 44,950 |\n\n给时间序列引擎增加 avg(x) 指标，该指标在输出表中的名称为 avg\\_x，数据类型为 DOUBLE。\n\n```\nnewMetricsSchema= table(1:0, [`avg_x], [DOUBLE])\naddMetrics(agg1, <avg(x)>, newMetricsSchema);\nn=300\ntime=2019.01.01T00:00:00.500+(1..n)\nid=take(`ABC`DEF, n)\nx=500+1..n\ninsert into t values(time, id, x);\nselect * from output1;\n```\n\n| time                    | sum\\_x | avg\\_x |\n| ----------------------- | ------ | ------ |\n| 2019.01.01T00:00:00.050 | 1,225  |        |\n| 2019.01.01T00:00:00.100 | 4,950  |        |\n| 2019.01.01T00:00:00.150 | 9,950  |        |\n| 2019.01.01T00:00:00.200 | 14,950 |        |\n| 2019.01.01T00:00:00.250 | 19,950 |        |\n| 2019.01.01T00:00:00.300 | 24,950 |        |\n| 2019.01.01T00:00:00.350 | 29,950 |        |\n| 2019.01.01T00:00:00.400 | 34,950 |        |\n| 2019.01.01T00:00:00.450 | 39,950 |        |\n| 2019.01.01T00:00:00.500 | 44,950 |        |\n| 2019.01.01T00:00:00.550 | 49,950 | 525    |\n| 2019.01.01T00:00:00.600 | 54,950 | 550    |\n| 2019.01.01T00:00:00.650 | 59,950 | 599.5  |\n| 2019.01.01T00:00:00.700 | 64,950 | 649.5  |\n| 2019.01.01T00:00:00.750 | 69,950 | 699.5  |\n| 2019.01.01T00:00:00.800 | 74,950 | 749.5  |\n"
    },
    "addNode": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/addNode.html",
        "signatures": [
            {
                "full": "addNode(host, port, alias, [saveConfig=true], [nodeType='datanode'], [computeGroup]), [zone])",
                "name": "addNode",
                "parameters": [
                    {
                        "full": "host",
                        "name": "host"
                    },
                    {
                        "full": "port",
                        "name": "port"
                    },
                    {
                        "full": "alias",
                        "name": "alias"
                    },
                    {
                        "full": "[saveConfig=true]",
                        "name": "saveConfig",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[nodeType='datanode']",
                        "name": "nodeType",
                        "optional": true,
                        "default": "'datanode'"
                    },
                    {
                        "full": "[computeGroup])",
                        "name": "computeGroup",
                        "optional": true
                    },
                    {
                        "full": "[zone]",
                        "name": "zone",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [addNode](https://docs.dolphindb.cn/zh/funcs/a/addNode.html)\n\n\n\n#### 语法\n\naddNode(host, port, alias, \\[saveConfig=true], \\[nodeType='datanode'], \\[computeGroup]), \\[zone])\n\n#### 详情\n\n增加数据节点或计算节点。仅限 admin 用户调用。\n\n新增加的节点为关闭状态，需要通过 Web 集群管理器或命令行启动它。\n\n**Note:**\n\n在新服务器上增加节点前需要先部署代理节点。详情参考教程： [多服务器集群部署](https://docs.dolphindb.cn/zh/tutorials/multi_machine_cluster_deployment.html)。\n\n#### 参数\n\n**host** 是字符串标量或向量，表示新增节点的 IP 地址。\n\n**port** 是正整数标量或向量，表示新增节点的端口号。\n\n**alias** 是字符串标量或向量，表示新增节点的别名。\n\n**saveConfig** 是一个布尔值，表示是否在增加节点的同时，将节点信息保存到 cluster.nodes 配置文件。默认值为 true。\n\n**nodeType** 是字符串标量或向量，表示新增节点类型。支持 'datanode' 和 'computenode' 两个选项。\n\n**computeGroup** 可选参数，字符串标量，用于指定计算节点所属的计算组名称。若未设置此参数，则表示该计算节点未加入任何计算组，不会缓存数据。\n\n**zone** 可选参数，字符串标量，指定节点所属的区域名称。若 cluster.nodes 文件中已经指定了 zone，则该参数为必填，且只能指定 cluster.nodes 文件中已有的 zone，不能指定未定义的 zone 或默认 zone。\n\n**Note:** 参数 *host*, *port*, *alias*, *nodeType* 的长度须保持一致。\n\n#### 例子\n\n增加一个别名为 “node1” 的数据节点。\n\n```\naddNode(\"192.168.1.103\",8900,\"node1\");\n```\n\n增加一个别名为 “orca4” 的计算节点到计算组 \"orca\"。\n\n```\naddNode(\"192.168.1.243\", 23796, \"orca4\", true, 'computenode', \"orca\");\n```\n"
    },
    "addRangePartitions": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/addRangePartitions.html",
        "signatures": [
            {
                "full": "addRangePartitions(dbHandle, newRanges, [level=0], [locations])",
                "name": "addRangePartitions",
                "parameters": [
                    {
                        "full": "dbHandle",
                        "name": "dbHandle"
                    },
                    {
                        "full": "newRanges",
                        "name": "newRanges"
                    },
                    {
                        "full": "[level=0]",
                        "name": "level",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[locations]",
                        "name": "locations",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [addRangePartitions](https://docs.dolphindb.cn/zh/funcs/a/addRangePartitions.html)\n\n\n\n#### 语法\n\naddRangePartitions(dbHandle, newRanges, \\[level=0], \\[locations])\n\n#### 详情\n\n给数据库增加新的分区。目标数据库必须是 RANGE 分区类型或 COMPO 分区类型并且至少其中一层分区为 RANGE 类型。注意，只能在最后一个现有数据分区后面添加分区，不能在第一个现有数据分区前面添加分区。\n\n#### 参数\n\n**dbHandle** 是数据库句柄。\n\n**newRanges** 是向量，表示新的分区。它必须按升序排序，并且第一个元素必须与数据库的原分区方案的最后一个元素相同。\n\n**level** 是整数。当分区类型为 COMPO，并且每层分区为 RANGE 时，需要使用 *level* 参数指定 RANGE 分区所在的层。它是可选参数。默认值为0。\n\n**locations** 是字符串标量或向量。如果目标数据库创建时，指定了 *locations* 参数，增加新的分区时可以使用 *locations* 参数指定新增分区的位置。它是可选参数。\n\n#### 返回值\n\n返回的结果是一个整数，表示新增的分区数量。\n\n#### 例子\n\n下面的例子是给分区类型为 COMPO 的数据库新增\\[101, 150), \\[150,200)和\\[200,250)分区，但无法新增 \\[50,100) 分区。\n\n```\nn=1000000\nID=rand(100, n)\ndates=2017.08.07..2017.08.11\ndate=rand(dates, n)\nx=rand(10.0, n)\nt=table(date, ID, x);\ndbDate = database(, VALUE, 2017.08.07..2017.08.11)\ndbID=database(, RANGE, 0 50 101);\ndb = database(\"dfs://compoDB\", COMPO, [dbDate,dbID]);\npt = db.createPartitionedTable(t, `pt, `date`ID)\npt.append!(t);\n\naddRangePartitions(db,101 150 200 250,1)\n// output\n3\n```\n\n添加新的分区后，需要重新加载数据库。\n\n```\ndb=database(\"dfs://compoDB\")\npt=loadTable(db,\"pt\")\n\nt1=table(rand(2017.08.07..2017.08.11,n) as date, rand(101..249,n) as ID, rand(10.0,n) as x)\npt.append!(t1);\n\nselect count(*) from loadTable(\"dfs://compoDB\",\"pt\");\n// output\n2000000\n```\n"
    },
    "addReactiveMetrics": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/addreactivemetrics.html",
        "signatures": [
            {
                "full": "addReactiveMetrics(name, metricNames, metrics)",
                "name": "addReactiveMetrics",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "metricNames",
                        "name": "metricNames"
                    },
                    {
                        "full": "metrics",
                        "name": "metrics"
                    }
                ]
            }
        ],
        "markdown": "### [addReactiveMetrics](https://docs.dolphindb.cn/zh/funcs/a/addreactivemetrics.html)\n\n\n\n#### 语法\n\naddReactiveMetrics(name, metricNames, metrics)\n\n#### 详情\n\n动态增加 narrowReactiveStateEngine 的计算指标。更新后的计算指标在引擎后续注入的数据时生效。\n\n#### 参数\n\n**name** 字符串，表示需要增加指标的 narrowReactiveStateEngine 的名称。\n\n**metricNames** 字符串标量或向量，表示 narrowReactiveStateEngine 增加的计算指标的名称。\n\n**metrics** 以元代码的格式表示计算指标，支持输入元组，表示流数据引擎增加的计算指标。计算指标与 *metricNames* 指定的名称一一对应。\n\n#### 例子\n\n```\ndummy = streamTable(1:0, [\"securityID1\",\"securityID2\",\"securityID3\",\"createTime\",\"updateTime\",\"upToDatePrice\",\"qty\",\"value\"], [STRING,STRING,STRING,TIMESTAMP,TIMESTAMP,DOUBLE,DOUBLE,INT]) \noutputTable = streamTable(1:0,[\"securityID1\",\"securityID2\",\"securityID3\",\"createTime\",\"updateTime\",\"metricNames\",\"factorValue\"], [STRING,STRING,STRING, TIMESTAMP,TIMESTAMP,STRING,DOUBLE])\nfactor = [<createTime>, <updateTime>,<cumsum(qty)>]\nNarrowtest = createNarrowReactiveStateEngine(name=\"narrowtest1\",metrics=factor,metricNames=\"factor1\",dummyTable=dummy,outputTable=outputTable,keyColumn=[\"securityID1\",\"securityID2\",\"securityID3\"])\nnum = 5\ntmp = table(take(\"A\" + lpad(string(1..4),4,\"0\"),num) as securityID1,take(\"CC.HH\" + lpad(string(21..34),4,\"0\"),num) as securityID2,take(\"FFICE\" + lpad(string(13..34),4,\"0\"),num) as securityID3, 2023.09.01 00:00:00+(1..num) as createTime, 2023.09.01 00:00:00+(1..num) as updateTime,100.0+(1..num) as upToDatePrice, 130.0+(1..num) as qty,take(1..3,num) as value)\nNarrowtest.append!(tmp)\n\nselect * from outputTable\n```\n\n| securityID1 | securityID2 | securityID3 | createTime              | updateTime              | metricNames | factorValue |\n| ----------- | ----------- | ----------- | ----------------------- | ----------------------- | ----------- | ----------- |\n| A0001       | CC.HH0021   | FFICE0013   | 2023.09.01T00:00:01.000 | 2023.09.01T00:00:01.000 | factor1     | 131         |\n| A0002       | CC.HH0022   | FFICE0014   | 2023.09.01T00:00:02.000 | 2023.09.01T00:00:02.000 | facto1      | 132         |\n| A0003       | CC.HH0023   | FFICE0015   | 2023.09.01T00:00:03.000 | 2023.09.01T00:00:03.000 | facto1      | 133         |\n| A0004       | CC.HH0024   | FFICE0016   | 2023.09.01T00:00:04.000 | 2023.09.01T00:00:04.000 | facto1      | 134         |\n| A0001       | CC.HH0025   | FFICE0017   | 2023.09.01T00:00:05.000 | 2023.09.01T00:00:05.000 | facto1      | 135         |\n\n```\nmetrics = [<cumavg(upToDatePrice)>]\naddReactiveMetrics(\"narrowtest1\", \"factor2\", metrics)\n\n//新增计算指标后，再次向引擎注入数据，则会输出更新后的指标计算结果\ntmp1 = table(\"A5\" as securityID1,\"CC.HH0033\" as securityID2,\"FFICE0034\" as securityID3, 2023.09.01 00:00:11 as createTime, 2023.09.01 00:00:09 as updateTime,59 as upToDatePrice,100 as qty,13 as value)\nNarrowtest.append!(tmp1)\nselect * from outputTable where securityID1=\"A5\"\n```\n\n<table id=\"table_lk3_kcx_yzb\"><tbody><tr><td>\n\nsecurityID1\n\n</td><td>\n\nsecurityID2\n\n</td><td>\n\nsecurityID3\n\n</td><td>\n\ncreateTime\n\n</td><td>\n\nupdateTime\n\n</td><td>\n\nmetricNames\n\n</td><td>\n\nfactorValue\n\n</td></tr><tr><td>\n\nA5\n\n</td><td>\n\nCC.HH0033\n\n</td><td>\n\nFFICE0034\n\n</td><td>\n\n2023.09.01T00:00:11.000\n\n</td><td>\n\n2023.09.01T00:00:09.000\n\n</td><td>\n\nfacto1\n\n</td><td>\n\n100\n\n</td></tr><tr><td>\n\nA5\n\n</td><td>\n\nCC.HH0033\n\n</td><td>\n\nFFICE0034\n\n</td><td>\n\n2023.09.01T00:00:11.000\n\n</td><td>\n\n2023.09.01T00:00:09.000\n\n</td><td>\n\nfacto2\n\n</td><td>\n\n59\n\n</td></tr></tbody>\n</table>相关函数：[createNarrowReactiveStateEngine](../c/createnarrowreactivestateengine.md)，[getReactiveMetrics](../g/getreactivemetrics.md)\n"
    },
    "addSparseReactiveMetrics": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/addSparseReactiveMetrics.html",
        "signatures": [
            {
                "full": "addSparseReactiveMetrics(name, metrics)",
                "name": "addSparseReactiveMetrics",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "metrics",
                        "name": "metrics"
                    }
                ]
            }
        ],
        "markdown": "### [addSparseReactiveMetrics](https://docs.dolphindb.cn/zh/funcs/a/addSparseReactiveMetrics.html)\n\n\n\n#### 语法\n\naddSparseReactiveMetrics(name, metrics)\n\n#### 详情\n\n为指定的 SparseReactiveStateEngine 增加稀疏状态计算规则。\n\n#### 参数\n\n**name** 字符串标量，表示需要增加计算规则的 SparseReactiveStateEngine 的名称。\n\n**metrics** 是一个表，表示需要新增的规则。表结构与 `createSparseReactiveStateEngine` 的 *metrics* 参数相同。\n\n#### 例子\n\n```\nnewMetrics = table(\n    [\"A003\"] as deviceID,\n    [\"mavg(value,3)\"] as formula,\n    [\"A003_1\"] as outputMetricKey\n)\naddSparseReactiveMetrics(\"demoengine\", newMetrics)\n```\n\n**相关函数**：[createSparseReactiveStateEngine](https://docs.dolphindb.cn/zh/funcs/c/createSparseReactiveStateEngine.html), [getSparseReactiveMetrics](https://docs.dolphindb.cn/zh/funcs/g/getSparseReactiveMetrics.html), [deleteSparseReactiveMetric](https://docs.dolphindb.cn/zh/funcs/d/deleteSparseReactiveMetric.html)\n"
    },
    "addStatelessMetrics": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/addstatelessmetrics.html",
        "signatures": [
            {
                "full": "addStatelessMetrics(name)",
                "name": "addStatelessMetrics",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    }
                ]
            }
        ],
        "markdown": "### [addStatelessMetrics](https://docs.dolphindb.cn/zh/funcs/a/addstatelessmetrics.html)\n\n\n\n#### 语法\n\naddStatelessMetrics(name)\n\n#### 详情\n\n向响应式无状态引擎中增加计算逻辑。\n\n#### 参数\n\n**name** STRING 类型标量，表示响应式无状态引擎的名字。\n\n**metrics** 一个表，表示增加的计算逻辑：\n\n* formula：STRING 类型，表示计算逻辑。其中的变量采用 *keyColumn* 指定的列中的值标识，*keyColumn* 如不止一列，则使用 `:` 连接各值。\n\n* outputMetricKey：STRING 类型，为该计算指定指标名。\n\n* triggerOn：STRING 类型，表示触发该计算的数据标识，即 *keyColumn* 指定的列为该值时触发计算，*keyColumn* 如不止一列，则使用 `:` 连接各值 。\n\n* filter：一个数据对，表示计算结果的限定范围，属于该范围的结果才会被输出。\n\n#### 例子\n\n```\nmetricsTable = table(\n    ['\"factor1\" * \"factor2\"'] as formula,\n    [\"value3\"] as outputMetricKey,\n    [\"factor1\"] as triggerOn,\n    [10:20] as filter\n)\n\naddStatelessMetrics(\"engine1\",metricsTable)\n```\n"
    },
    "addValuePartitions": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/addValuePartitions.html",
        "signatures": [
            {
                "full": "addValuePartitions(dbHandle, newValues, [level=0], [locations])",
                "name": "addValuePartitions",
                "parameters": [
                    {
                        "full": "dbHandle",
                        "name": "dbHandle"
                    },
                    {
                        "full": "newValues",
                        "name": "newValues"
                    },
                    {
                        "full": "[level=0]",
                        "name": "level",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[locations]",
                        "name": "locations",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [addValuePartitions](https://docs.dolphindb.cn/zh/funcs/a/addValuePartitions.html)\n\n\n\n#### 语法\n\naddValuePartitions(dbHandle, newValues, \\[level=0], \\[locations])\n\n#### 详情\n\n给数据库增加新的分区。目标数据库必须是 VALUE 分区类型或 COMPO 分区类型并且至少其中一层分区为 VALUE 类型。\n\n如果配置参数 *newValuePartitionPolicy*=add，系统会自动为新的数据增加分区。\n\n#### 参数\n\n**dbHandle** 是数据库句柄。\n\n**newValues** 是标量或向量，表示新的分区。\n\n**level** 是整数。当分区类型为 COMPO，并且某层分区为 VALUE 时，需要使用 *level* 参数指定 VALUE 分区所在的层。它是可选参数。默认值为0\n\n**locations** 是字符串标量或向量。如果目标数据库创建时，指定了 *locations* 参数，增加新的分区时可以使用 *locations* 参数指定新增分区的位置。它是可选参数。\n\n#### 返回值\n\n返回的结果是一个整数，表示新增的分区数量。\n\n#### 例子\n\n下面的例子是给分区类型为 COMPO 的数据库新增2017.08.12到2017.08.20分区。\n\n```\nn=1000000\nID=rand(100, n)\ndates=2017.08.07..2017.08.11\ndate=rand(dates, n)\nx=rand(10.0, n)\nt=table(ID, date, x)\n\ndbID=database(, RANGE, 0 50 100);\ndbDate = database(, VALUE, 2017.08.07..2017.08.11)\ndb = database(\"dfs://compoDB\", COMPO, [dbID, dbDate]);\npt = db.createPartitionedTable(t, `pt, `ID`date)\npt.append!(t)\n\naddValuePartitions(db,2017.08.12..2017.08.20,1)\n// output\n9\n```\n\n添加新的分区后，需要重新加载数据库。\n\n```\ndb=database(\"dfs://compoDB\")\npt=loadTable(db,\"pt\")\n\nt1=table(0..99 as ID,take(2017.08.12,100) as date,rand(10.0,100) as x)\npt.append!(t1)\n\nselect count(*) from loadTable(\"dfs://compoDB\",\"pt\")\n// output\n1000100\n```\n"
    },
    "addVolumes": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/addVolumes.html",
        "signatures": [
            {
                "full": "addVolumes(volumes)",
                "name": "addVolumes",
                "parameters": [
                    {
                        "full": "volumes",
                        "name": "volumes"
                    }
                ]
            }
        ],
        "markdown": "### [addVolumes](https://docs.dolphindb.cn/zh/funcs/a/addVolumes.html)\n\n\n\n#### 语法\n\naddVolumes(volumes)\n\n#### 详情\n\n动态增加磁盘卷，使新增磁盘卷马上可以使用而无需重启集群。\n\n**Note:** 此命令并不会改变集群配置文件。使用该命令后请更改配置文件，否则集群重启后将不能写入新增的磁盘卷。\n\n#### 参数\n\n**volumes** 是字符串标量或向量，表示磁盘卷的路径。\n\n#### 例子\n\n```\naddVolumes(\"/home/dolphindb/data\")\n```\n"
    },
    "adfuller": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/adfuller.html",
        "signatures": [
            {
                "full": "adfuller(X, [maxLag], [regression=\"c\"], [autoLag=\"aic\"], [store=false], [regResults=false])",
                "name": "adfuller",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[maxLag]",
                        "name": "maxLag",
                        "optional": true
                    },
                    {
                        "full": "[regression=\"c\"]",
                        "name": "regression",
                        "optional": true,
                        "default": "\"c\""
                    },
                    {
                        "full": "[autoLag=\"aic\"]",
                        "name": "autoLag",
                        "optional": true,
                        "default": "\"aic\""
                    },
                    {
                        "full": "[store=false]",
                        "name": "store",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[regResults=false]",
                        "name": "regResults",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [adfuller](https://docs.dolphindb.cn/zh/funcs/a/adfuller.html)\n\n\n\n#### 语法\n\nadfuller(X, \\[maxLag], \\[regression=\"c\"], \\[autoLag=\"aic\"], \\[store=false], \\[regResults=false])\n\n#### 详情\n\n进行 Augmented Dickey-Fuller (ADF) 单位根检验。用于在序列相关性存在的情况下测试单变量过程中是否存在单位根。\n\nDolphinDB `adfuller` 函数与 `statsmodels.tsa.stattools.adfuller` 在核心算法和参数设计上保持一致，主要差异体现在返回值结构上：\n\n* DolphinDB 返回结构化字典，字段语义清晰，便于工程化处理。\n* statsmodels 返回元组，可通过 ResultStore 对象提供更丰富的统计信息，更偏向分析场景。\n\n#### 参数\n\n**X** 数值向量，表示需要进行单位根检验的时间序列数据。*X* 中的所有元素不能完全相同且不能包含空值。\n\n**maxLag** 非负整数，指定检验中使用的最大滞后期，默认值为 12\\*(nobs/100)^(1/4)，其中 nobs 代表样本数量。\n\n**regression** 字符串，指定在回归中使用的常数和趋势阶数。取值有如下选择：\n\n* \"c\"：默认值，表示只使用常数。\n* \"ct：使用常数和趋势。\n* \"ctt\"：使用常数、线性趋势和二次趋势。\n* \"n\"：不使用常数和趋势。\n\n**autoLag** 字符串，指定在 0\\~maxLag 中自动确定滞后期长度时使用的方法。取值有如下选择：\n\n* \"aic\"：默认值，表示使用 Akaike Information Criterion 来确定滞后期数值。\n* \"bic\"：表示使用 Bayesian information criterion 来确定滞后期数值。\n* \"tstat\"：将滞后期初始值设为 maxLag，然后逐步减 1，直到上一个滞后期数值的 t 统计量在 5% 显著性水平上显著。\n* \"max\"：将滞后期数值设置为 maxLag。\n\n**store** 布尔标量。设置为 true 时，除了返回 ADF 统计值，还会把回归结果放在一个字典中返回。默认值为 false。\n\n**regResults** 布尔值。设置为 true 时，返回完整的回归结果，相比于 *store*=true 的结果额外包含一个字典 autoLagResult，记录在自动滞后阶数选择过程中使用的信息准则的结果。默认值为 false。\n\n#### 返回值\n\n以字典的形式输出 ADF 检验的结果，字典包括以下内容：\n\n* adfStat：浮点数标量，表示检验的统计值\n* pValue：浮点数标量，表示 MacKinnon 近似 p 值\n* usedLag：整数标量，使用的滞后期的数值\n* nobs：整数标量，用于 ADF 回归和关键值计算的观测数量\n* criticalValues：字典，在 1％、5％ 和 10％ 水平上的检验统计量的临界值\n* icBest：浮点数标量，仅在 autoLag 不设置为\"max\" 时返回，表示最大化的信息准则\n* resultStore：字典，当 regResults 或者 store 设置为 true 时，把回归结果保存在 resultStore 中返回\n\n#### 例子\n\n```\ndata = 234 267 289 301 312 323 334 345 356 367\nadfuller(data);\n```\n\n输出为字典：\n\n```\npValue->0.000375626192024\nusedLag->0\nnobs->9\nicBest->-195.234657936244450\nadfStat->-4.341905848945339\ncriticalValues->[-4.473135048010974,-3.289880603566529,-2.772382345679012]\n```\n"
    },
    "align": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/align.html",
        "signatures": [
            {
                "full": "align(left, right, [how='outer'], [byRow], [view=true])",
                "name": "align",
                "parameters": [
                    {
                        "full": "left",
                        "name": "left"
                    },
                    {
                        "full": "right",
                        "name": "right"
                    },
                    {
                        "full": "[how='outer']",
                        "name": "how",
                        "optional": true,
                        "default": "'outer'"
                    },
                    {
                        "full": "[byRow]",
                        "name": "byRow",
                        "optional": true
                    },
                    {
                        "full": "[view=true]",
                        "name": "view",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [align](https://docs.dolphindb.cn/zh/funcs/a/align.html)\n\n\n\n#### 语法\n\nalign(left, right, \\[how='outer'], \\[byRow], \\[view=true])\n\n#### 详情\n\n按照 *how* 指定的方法，将 *left* 和 *right* 根据 *byRow* 指定的行/列标签进行对齐。\n\n**Note:**\n\n* 返回矩阵不保留输入矩阵的属性，如：输入索引矩阵，返回非索引矩阵。\n* 通过函数 `rename!` 设置普通矩阵的标签；通过 exec + pivot by 也会生成以 pivot by 指定列为标签的矩阵。\n\n#### 参数\n\n**left/right**包含标签的矩阵/索引矩阵/索引序列。\n\n**how** 矩阵的对齐方法。通过将矩阵的行列标签进行 join 操作，来实现标签对齐。可选值为：'outer' (or 'fj'), 'inner' (or 'ej'), 'left' (or 'lj'), or 'asof ('aj')'，表示不同的连接方式。默认值是 'outer'，即外连接。\n\n**byRow** 布尔值或空值。若为 true，表示按行标签对齐；若为 false，表示按列标签对齐。默认为空值，表示同时按照行列标签对齐。此时，若行、列的连接方式相同，*how* 需指定一个连接方式；否则，*how* 需指定两个连接方式，格式为\"行对齐方式,列对齐方式\"，例如 *how*=\"outer,inner\"，逗号前后不能有空格或其他符号。\n\n**Note:**\n\n*left* 和 *right* 指定的矩阵必须包含 *byRow* 指定的对齐标签，且标签的数据类型需要兼容。目前支持以下类型的标签：整型、浮点型、时间类型、STRING 类型、SYMBOL 类型。其中 INT, SHORT, LONG, CHAR 互相兼容， FLOAT 和 DOUBLE 类型互相兼容，STRING 和 SYMBOL 类型也互相兼容。\n\n**view** 布尔值，默认值是 true，表示生成原矩阵的一个视图（浅拷贝），若原数据发生改变，视图的数据也会相应变化。若为 false，则生成一个新的矩阵（深拷贝）。\n\n#### 返回值\n\n返回一个长度为2的元组，其元素分别为两个矩阵按标签对齐后的对象。\n\n#### 例子\n\n```\n// 对齐包含重复标签的矩阵\nx1 = [09:00:00, 09:00:01, 09:00:03]\nx2 = [09:00:00, 09:00:03, 09:00:03, 09:00:04]\nm1 = matrix(1 2 3, 2 3 4, 3 4 5).rename!(x1)\nm2 = matrix(11 12 13, 12 13 14, 13 14 15, 14 15 16).rename!(x2)\na, b = align(left=m1, right=m2, how='fj', byRow=false);\na;\n```\n\n| 09:00:00 | 09:00:01 | 09:00:03 | 09:00:03 | 09:00:04 |\n| -------- | -------- | -------- | -------- | -------- |\n| 1        | 2        | 3        | 3        |          |\n| 2        | 3        | 4        | 4        |          |\n| 3        | 4        | 5        | 5        |          |\n\n```\nb;\n```\n\n| 09:00:00 | 09:00:01 | 09:00:03 | 09:00:03 | 09:00:04 |\n| -------- | -------- | -------- | -------- | -------- |\n| 11       |          | 12       | 13       | 14       |\n| 12       |          | 13       | 14       | 15       |\n| 13       |          | 14       | 15       | 16       |\n\n```\na+b;\n```\n\n| 09:00:00 | 09:00:01 | 09:00:03 | 09:00:03 | 09:00:04 |\n| -------- | -------- | -------- | -------- | -------- |\n| 12       |          | 15       | 16       |          |\n| 14       |          | 17       | 18       |          |\n| 16       |          | 19       | 20       |          |\n\n```\nm = align(left=m1, right=m2, how='aj', byRow=false);\nm[0];\n```\n\n| 09:00:00 | 09:00:01 | 09:00:03 |\n| -------- | -------- | -------- |\n| 1        | 2        | 3        |\n| 2        | 3        | 4        |\n| 3        | 4        | 5        |\n\n```\nm[1];\n```\n\n| 09:00:00 | 09:00:01 | 09:00:03 |\n| -------- | -------- | -------- |\n| 11       | 11       | 13       |\n| 12       | 12       | 14       |\n| 13       | 13       | 15       |\n\n```\n// 定义一个价格表 pt, 一个交易量的表 vt\ntimestamp = [09:00:00, 09:00:02, 09:00:03, 09:00:06, 09:00:08]\nid= ['st1', 'st2', 'st1', 'st1', 'st2']\nprice = [197.8, 197.5, 198.4, 198.6, 198.6]\npt = table(timestamp, id, price)\n\ntimestamp = [09:00:00, 09:00:01, 09:00:02, 09:00:05, 09:00:08]\nid = ['st1', 'st2', 'st2', 'st3', 'st2']\nvol = [200, 300, 150, 200, 180]\nvt = table(timestamp, id, vol)\n\n// 利用 pivot by 获取价格矩阵和交易量矩阵，pivot by 指定的列将作为矩阵的标签\nm1 = exec vol from vt pivot by timestamp, id\nm2 = exec price from pt pivot by timestamp, id\n\n// 使用 full join 对齐两个矩阵\nm = align(left=m1, right=m2, how='aj,fj')\n\n// 计算得到交易金额的矩阵\nre = m[0] * m[1]\nre;\n```\n\n| label    | st1   | st2   | st3 |\n| -------- | ----- | ----- | --- |\n| 09:00:00 | 39560 |       |     |\n| 09:00:01 |       |       |     |\n| 09:00:02 |       | 29625 |     |\n| 09:00:03 |       |       |     |\n| 09:00:05 |       |       |     |\n| 09:00:08 |       | 35748 |     |\n"
    },
    "all": {
        "url": "https://docs.dolphindb.cn/zh/funcs/ho_funcs/all.html",
        "signatures": [
            {
                "full": "all(func, args...)",
                "name": "all",
                "parameters": [
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "args...",
                        "name": "args..."
                    }
                ]
            }
        ],
        "markdown": "### [all](https://docs.dolphindb.cn/zh/funcs/ho_funcs/all.html)\n\n#### 语法\n\nall(func, args...)\n\n#### 详情\n\n把函数应用到参数的每一个元素。只要函数调用返回false，*all* 高阶函数就会停止执行，并返回false。如果所有的函数调用都返回true，*all* 高阶函数将返回true。\n\n如果args是一个矩阵，*all* 高阶函数将会按列执行；如果args是一个表格，它将会按行执行。\n\n#### 参数\n\n* **func** 是一个函数名。\n* **args** 是函数func的参数。它们可以是向量、矩阵或表。它们的数据形式可以不尽相同，但是长度必须相同，即向量中元素的个数，或矩阵中列的数量，或表中行的数量需要相同。\n\n#### 返回值\n\n一个布尔值标量。\n\n#### 例子\n\n*all* 高阶函数用于向量。\n\n```\nx = 1 2 NULL 11 NULL 13 NULL 102 103;\ny = x cut 3;\ny;\n// output\n([1,2,],[11,,13],[,102,103])\n\nall(hasNull, y);\n// output\n1\n// 检查是否 [1,2,],[11,,13],[,102,103]都含有 NULL值\n\nx = 1 25 7 15 11 197 16 18 23;\ny = x cut 3;\ny;\n// output\n([1,25,7],[15,11,197],[16,18,23])\n\nall(in, 7 11 23, y);\n// output\n1\n// 检查是否 7在[1, 25, 7] 中, 11在[15,11,197] 中以及 23在[16,18,23]中。\n\nall(in, 7 8 23, y);\n// output\n0\n// 由于8不在[15, 11, 197]中，返回false\n\nall(lt, 1 2 3, 4 5 6);\n// output\n1\n// 检查是否 1<4, 2<5 以及3<6\n\nall(lt, 1 2 7, 4 5 6);\n// output\n0\n//返回false，因为7>6\n```\n\n*all* 高阶函数作用在矩阵上，按列遍历。\n\n```\nx=1..6$2:3;\nx;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1  | 3  | 5  |\n| 2  | 4  | 6  |\n\n```\nall(in, 1 4 5, x);\n// output\n1\n\nall(in, 1 2 5, x);\n// output\n0\n// 返回 false，因为2不在x的第二列中\n```\n\n*all* 高阶函数作用在表上，按行遍历。下例中，定义了一个名为 *varscompare* 的函数用于比较表中的两个变量。\n\n```\nx=table(1 2 3 as a, 4 5 6 as b);\nx;\n```\n\n| a | b |\n| - | - |\n| 1 | 4 |\n| 2 | 5 |\n| 3 | 6 |\n\n```\ndef varscompare(t):t.a<t.b;\nall(varscompare, x);\n// output\n1\n\ny=table(1 7 3 as a, 4 5 6 as b);\n// output\ny;\n```\n\n| a | b |\n| - | - |\n| 1 | 4 |\n| 7 | 5 |\n| 3 | 6 |\n\n```\nall(varscompare, y);\n// output\n0\n// 返回 false，因为7>5\n```\n\n"
    },
    "and": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/and.html",
        "signatures": [
            {
                "full": "and(X, Y)",
                "name": "and",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [and](https://docs.dolphindb.cn/zh/funcs/a/and.html)\n\n\n\n#### 语法\n\nand(X, Y) 或 X && Y\n\n#### 详情\n\n对 *X* 和 *Y* 内的元素逐个进行逻辑与（logical AND）的运算并返回结果。\n\n#### 参数\n\n**X** 和 **Y** 可以是标量、数据对、向量或矩阵。\n\n#### 返回值\n\n数据类型为布尔类型。\n\n若**X** 和 **Y**至少一个是矩阵，则返回矩阵；否则，若至少一个是数据对，则返回数据对;否则，若至少有一个是向量，则返回向量;若**X** 和 **Y**均为标量，则返回标量。\n\n#### 例子\n\n```\n1 && 3;\n// output\n1\n\nx=1 2 3\nx && 0\n// output\n[0,0,0]\n\nx=1 2 3\ny=0 1 0\nx && y\n// output\n[0,1,0]\n\nt=table(1 2 2 3 as id, 4 5 6 5 as value)\nt\n```\n\n| id | value |\n| -- | ----- |\n| 1  | 4     |\n| 2  | 5     |\n| 2  | 6     |\n| 3  | 5     |\n\n```\nselect id, value from t where id=2 and value=5;   // SQL query\n```\n\n| id | value |\n| -- | ----- |\n| 2  | 5     |\n\n相关函数：[or](https://docs.dolphindb.cn/zh/funcs/o/or.html), [not](https://docs.dolphindb.cn/zh/funcs/n/not.html)\n"
    },
    "anova": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/anova.html",
        "signatures": [
            {
                "full": "anova(X)",
                "name": "anova",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [anova](https://docs.dolphindb.cn/zh/funcs/a/anova.html)\n\n\n\n#### 语法\n\nanova(X)\n\n#### 详情\n\n对 *X* 进行单因素方差分析（one-way ANOVA）。*X* 中的每一列都被视为一个单独的组。\n\n#### 参数\n\n**X** 是一个矩阵或所有列均为数值的表。\n\n#### 返回值\n\n一个字典，包含以下 key 值：\n\n* pValue：p 值\n* fValue：F 统计量\n* ssBetween：组间平方和\n* dfBetween：组间自由度\n* ssWithin：组内平方和\n* dfWithin：组内自由度\n\n#### 例子\n\n```\na=300 287 301 400 211 399 412 312 390 412\nb=240 259 302 311 210 402 390 298 347 380\nc=210 230 213 210 220 208 290 300 201 201\nm=matrix(a,b,c)\nanova(m);\n\n// output\npValue->0.000515\nfValue->10.15459\nssBetween->70528.066667\ndfBetween->2\nssWithin->93763.4\ndfWithin->27\n```\n"
    },
    "any": {
        "url": "https://docs.dolphindb.cn/zh/funcs/ho_funcs/any.html",
        "signatures": [
            {
                "full": "any(func, args...)",
                "name": "any",
                "parameters": [
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "args...",
                        "name": "args..."
                    }
                ]
            }
        ],
        "markdown": "### [any](https://docs.dolphindb.cn/zh/funcs/ho_funcs/any.html)\n\n#### 语法\n\nany(func, args...)\n\n#### 详情\n\n把函数应用到参数的每一个元素。只要函数调用返回true，*any* 高阶函数就会停止执行，并返回true。如果所有的函数调用都返回false，*any* 高阶函数将返回false。\n\n如果args是一个矩阵，*any模* 板将会按列执行；如果args是一个表格，它将会按行执行。\n\n#### 参数\n\n* **func** 是一个函数名。\n* **args** 是函数F的参数。它们可以是向量、矩阵或表。它们的数据形式可以不尽相同，但是长度必须相同，即向量中元素的个数，或矩阵中列的数量，或表中行的数量必须相同。\n\n#### 返回值\n\n一个布尔值标量。\n\n#### 例子\n\n*any* 高阶函数用于向量：\n\n```\nx = 1 2 3 11 12 13 NULL 102 103;\ny = x cut 3;\ny;\n// output\n([1,2,3],[11,12,13],[,102,103])\n\nany(hasNull, y);\n// output\n1\n// 检查是否 [1,2,],[11,,13],[,102,103]中任意一个含有 NULL值\n\nx=1 25 7 15 11 197 16 18 23;\ny=x cut 3;\ny;\n// output\n([1,25,7],[15,11,197],[16,18,23])\n\nany(in, 7 8 23, y);\n// output\n1\n// 返回true，因为虽然8不在[15, 11, 197]中, 但7在[1, 25, 7]中\n\nany(in, 8 20 19, y);\n// output\n0\n// 8不在[1, 25, 7]中，20不在[15, 11, 197]中并且19不在[16, 18, 23]中\n\nany(lt, 4 5 6, 1 2 3);\n// output\n0\n// 检查是否4<1, 5<2并且6<3\n\nany(<, 4 5 6, 1 7 3);\n// output\n1\n// 返回true，因为5<7\n```\n\n*any* 高阶函数用于矩阵，按列遍历。\n\n```\nx=1..6$2:3;\nx;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1  | 3  | 5  |\n| 2  | 4  | 6  |\n\n```\nany(in, 6 1 4, x);\n// output\n0\n\nany(in, 3 4 2, x);\n// output\n1\n// 返回 true，因为4在x的第二列中\n```\n\n*any* 高阶函数用于数据表，按行遍历。下例中，定义了一个名为 varscompare 的函数用于比较表中的两个变量。\n\n```\nx=table(1 2 3 as a, 4 5 6 as b);\nx;\n```\n\n| a | b |\n| - | - |\n| 1 | 4 |\n| 2 | 5 |\n| 3 | 6 |\n\n```\ndef varscompare(t): t.a>t.b;\nany(varscompare, x);\n// output\n0\n\ny=table(1 7 3 as a, 4 5 6 as b);\ny;\n```\n\n| a | b |\n| - | - |\n| 1 | 4 |\n| 7 | 5 |\n| 3 | 6 |\n\n```\nany(varscompare, y);\n// output\n1\n// 返回true，因为7>5\n```\n\n"
    },
    "append!": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/append!.html",
        "signatures": [
            {
                "full": "append!(obj, newData)",
                "name": "append!",
                "parameters": [
                    {
                        "full": "obj",
                        "name": "obj"
                    },
                    {
                        "full": "newData",
                        "name": "newData"
                    }
                ]
            }
        ],
        "markdown": "### [append!](https://docs.dolphindb.cn/zh/funcs/a/append!.html)\n\n\n\n#### 语法\n\nappend!(obj, newData)\n\n别名：push!\n\n#### 详情\n\n将 *newData* 中的数据追加到 *obj*。在 DolphinDB 中，函数中的感叹号(!)表示直接修改数据本身（就地操作）。\n\n**Note:**\n\n1. 该函数不会检查两表中各列列名与顺序，只要两表中对应位置的列的数据类型一致，即可执行。如果两表中各列顺序有差别，该操作不会自动对齐各列。所以，对数据表进行 `append!` 操作时，请检查两表中各列列名与顺序，以免出错。绝大部分情况下两表中各列列名与顺序应当完全一致。\n2. 请注意：若数据库为分区，且分区列为字符串类型，则追加的分区列数据不能包含空格， “/t”。\n\n#### 参数\n\n**obj** 必须是本地变量：向量、元组、矩阵、表或集合。\n\n**newData** 可以是标量、向量、元组、表或集合。\n\n* 如果 *obj* 是向量，则 *newData* 必须是标量或向量、或元素类型与 *obj* 中元素类型一致的元组。结果是比 *obj* 更长的向量。\n* 如果 *obj* 是元组，则 *newData* 必须是标量、向量或元组。若 *newData* 为向量，则作为整体追加到元组；若 *newData* 为元组，当配置项 *appendTupleAsAWhole*=true 时，作为整体追加，*appendTupleAsAWhole*=false 时，将 *newData* 的每一个元素依次追加。\n* 如果 *obj* 是矩阵，则 *newData* 必须是长度为 *obj* 行数倍数的向量。结果是新的矩阵，行数和 *obj* 相同，具有更多的列数。\n* 如果 *obj* 是表，则 *newData* 必须是一个列数和 *obj* 相同的表。结果是和 *obj* 具有相同列数和列名的表，但行数比 *obj* 多。\n* 如果 *newData* 和 *obj* 的数据类型不同，`append!` 函数会尝试将 *newData* 转换为 *obj* 的数据类型。如果无法转换，将返回一个错误信息。\n\n#### 返回值\n\n数据类型和数据形式与 *obj* 一致。\n\n#### 例子\n\n```\nx = 1 2 3\nx.append!(4)\nx\n// output\n[1,2,3,4]\nappend!(x, 5 6)\nx\n// output\n[1,2,3,4,5,6]\nx.append!(7.2)\nx\n// output\n[1,2,3,4,5,6,7]\n// 7.2 的数据类型从 DOUBLE 转化为 INT，所以值变为7\nx.append!(`XOM)\n// output\nIncompatible type. Expected: INT, Actual: STRING\n\nx=array(INT, 0, 10)\n// x 是一个空的向量\nx\n// output\n[]\nx.append!(1)\nx\n// output\n[1]\nx=array(SYMBOL, 0, 100)\nappend!(x, `TEST)\nx\n// output\n[\"TEST\"]\n\nx=1..6$3:2\nx\n```\n\n| 0 | 1 |\n| - | - |\n| 1 | 4 |\n| 2 | 5 |\n| 3 | 6 |\n\n```\nx.append!(7..12)\nx\n```\n\n| 0 | 1 | 2 | 3  |\n| - | - | - | -- |\n| 1 | 4 | 7 | 10 |\n| 2 | 5 | 8 | 11 |\n| 3 | 6 | 9 | 12 |\n\n```\nx=set(1 2 3 4)\nx.append!(6)\n// output\nx\nset(6,1,2,3,4)\n\nt1=table(1 2 3 as x, 4 5 6 as y)\nt2=table(1.1 2.2 3.3 as a, 4.4 5.5 6.6 as b)\nt1.append!(t2)\nt1\n```\n\n| x | y |\n| - | - |\n| 1 | 4 |\n| 2 | 5 |\n| 3 | 6 |\n| 1 | 4 |\n| 2 | 6 |\n| 3 | 7 |\n\n使用 `append!` 把数据添加到分布式表。下面的例子需要在集群中执行。相关配置可参考：[功能配置](https://docs.dolphindb.cn/zh/db_distr_comp/cfg/function_configuration.html)。\n\n```\nn=1000000\nt=table(rand(`IBM`MS`APPL`AMZN,n) as symbol, rand(10.0, n) as value)\ndb = database(\"dfs://rangedb_tradedata\", RANGE, `A`F`M`S`ZZZZ)\nTrades = db.createPartitionedTable(t, \"Trades\", \"symbol\")\n```\n\n上面的脚本根据表 t 的结构创建了空表 Trades。接着，把表 t 的数据追加到表 Trades 中。\n\n```\nTrades.append!(t)\nselect count(*) from Trades;\n\n// output\n1000000\n```\n\n把其他表的数据追加到表 Trades 中。\n\n```\nn=500000\nt1=table(rand(`FB`GE`MSFT,n) as symbol, rand(100.0, n) as value)\nTrades.append!(t1)\nselect count(*) from Trades\n\n// output\n1500000\n```\n\n配置项 *appendTupleAsAWhole* 的不同设置值将影响追加元组的行为。\n\n```\nx = (1,\"X\")\ny = (2,\"Y\")\nx.append!(y)\nprint(x)\n// 配置参数 appendTupleAsAWhole=true 时\n(1,\"X\",(2,\"Y\"))\n// 配置参数 appendTupleAsAWhole=false 时\n(1,\"X\",2,\"Y\")\n```\n"
    },
    "appendEvent": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/appendEvent.html",
        "signatures": [
            {
                "full": "appendEvent(engine, events)",
                "name": "appendEvent",
                "parameters": [
                    {
                        "full": "engine",
                        "name": "engine"
                    },
                    {
                        "full": "events",
                        "name": "events"
                    }
                ]
            }
        ],
        "markdown": "### [appendEvent](https://docs.dolphindb.cn/zh/funcs/a/appendEvent.html)\n\n\n\n#### 语法\n\nappendEvent(engine, events)\n\n#### 详情\n\n将事件实例写入 CEP 引擎的事件输入队列，无需序列化与反序列化。\n\n#### 参数\n\n**engine** 引擎句柄。目前支持序列化引擎和 CEP 引擎。\n\n**events** 可以是事件类型实例或者字典。如果指定为字典，系统会根据键值对构造出事件实例，因此字典的键必须包含事件类型（eventType ） 字段和事件定义中指定的事件字段（eventField）。\n\n#### 例子\n\n定义事件 Orders，其包含字段 sym，val0，val1，val2：\n\n```\nclass Orders{\n    eventTime :: TIMESTAMP \n    sym :: STRING\n    val0 :: INT\n    val1 :: FLOAT\n    val2 :: DOUBLE\n    def Orders(s,v0,v1,v2){\n        sym = s\n        val0 = v0\n        val1 = v1\n        val2 = v2\n        eventTime = now()\n    }\n}\n```\n\n定义一个简单的 monitor：\n\n```\nclass mainMonitor:CEPMonitor {\n    ordersTable :: ANY  // 定义成员变量 ordersTable，不限制数据类型和形式\n    def mainMonitor(){\n        ordersTable = array(ANY, 0)  // 这里确定 ordersTable 为一个元组\n    }    \n\n    def updateOrders(event) {\n        ordersTable.append!([event.sym, event.val0, event.val1, event.val2])\n    }\n    def onload(){\n        addEventListener(updateOrders, 'Orders',,'all') \n    }\n}\n```\n\n创建 CEP 引擎如下：\n\n```\ndummy = table(array(TIMESTAMP, 0) as eventTime,array(STRING, 0) as eventType,  array(BLOB, 0) as blobs)\nengine=createCEPEngine(name=\"test_CEP\",monitors=<mainMonitor()>,dummyTable=dummy,eventSchema=Orders,timeColumn='eventTime')\n```\n\n向引擎中追加事件：\n\n* *events* 指定为一个事件类型实例：\n\n  ```\n  appendEvent(`test_CEP,Orders(\"a000\", 3, 3.0, 30.0))\n  ```\n\n* *events* 指定为一个字典：\n\n  ```\n  d=dict(['eventType',\"sym\", \"val0\",\"val1\", \"val2\", \"eventTime\"],[\"Orders\",'a000',5,float(3.6),double(29.3),2025.09.24T11:35:22.789])\n  appendEvent(`test_CEP,d)\n  ```\n\n**相关函数**：[addEventListener](https://docs.dolphindb.cn/zh/funcs/a/addEventListener.html), [createCEPEngine](https://docs.dolphindb.cn/zh/funcs/c/createCEPEngine.html), [emitEvent](https://docs.dolphindb.cn/zh/funcs/e/emitEvent.html), [routeEvent](https://docs.dolphindb.cn/zh/funcs/r/routeEvent.html), [sendEvent](https://docs.dolphindb.cn/zh/funcs/s/sendEvent.html)\n"
    },
    "appendEventWithResponse": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/appendeventwithresponse.html",
        "signatures": [
            {
                "full": "appendEventWithResponse(engine, event, responseType, [timeout=5000], [condition], [returnType=\"instance\"])",
                "name": "appendEventWithResponse",
                "parameters": [
                    {
                        "full": "engine",
                        "name": "engine"
                    },
                    {
                        "full": "event",
                        "name": "event"
                    },
                    {
                        "full": "responseType",
                        "name": "responseType"
                    },
                    {
                        "full": "[timeout=5000]",
                        "name": "timeout",
                        "optional": true,
                        "default": "5000"
                    },
                    {
                        "full": "[condition]",
                        "name": "condition",
                        "optional": true
                    },
                    {
                        "full": "[returnType=\"instance\"]",
                        "name": "returnType",
                        "optional": true,
                        "default": "\"instance\""
                    }
                ]
            }
        ],
        "markdown": "### [appendEventWithResponse](https://docs.dolphindb.cn/zh/funcs/a/appendeventwithresponse.html)\n\n首发版本：3.00.5\n\n\n\n#### 语法\n\nappendEventWithResponse(engine, event, responseType, \\[timeout=5000], \\[condition], \\[returnType=\"instance\"])\n\n#### 详情\n\nCEP 引擎的同步事件处理函数，用于发送事件并阻塞等待特定响应事件返回。\n\n与 appendEvent 的异步模式不同，该函数采用同步等待响应模式：向 CEP 引擎发送事件后，当前线程会阻塞等待，直到收到匹配的响应事件或超时。\n\n#### 参数\n\n**engine** CEP 引擎句柄或引擎名。\n\n**event** 事件类型实例或者字典，指定要发送的事件。如果指定为字典，系统会根据键值对构造出事件实例，因此字典的键必须包含 \"eventType\"（事件类型）和事件类型中声明的字段名（eventField）。\n\n**responseType** 字符串标量，指定期望接收的响应事件类型。\n\n**timeout** 可选，整型标量，单位为毫秒，默认为 5000 毫秒。等待响应的超时时间。\n\n**condition** 可选，元代码类型。指定过滤表达式响应事件进行筛选，如 `<event.id=1>`。若指定了 *condition* 参数，系统将在类型匹配的基础上增加条件筛选，只有同时满足类型要求和条件表达式的响应事件才会被接受。\n\n**returnType**可选，字符串标量，指定返回的响应事件类型的数据形式。可选值为：\n\n* \"dict\"：以字典形式返回响应事件。\n\n* \"instance\"：默认值，返回响应事件实例。\n\n#### 返回值\n\n返回值形式由 *returnType* 参数控制：\n\n* *returnType*=\"dict\" 时，返回一个字典。\n* *returnType*=\"instance\" 时，返回一个事件实例。\n\n#### 例子\n\n该示例展示了如何实现策略启动请求的处理与同步响应机制。\n\n外部调用方发送 startRequest 事件向 CEP 引擎发起策略启动请求，CEP Monitor 接收并处理该事件，在完成相应的启动逻辑后，通过 StartResponse 事件返回启动结果。\n\n调用方通过 `appendEventWithResponse` 函数同步等待指定策略实例（以 instanceId 匹配）的启动响应，从而实现基于事件的请求-响应交互模式。\n\n```\ntry { \n    dropStreamEngine(`cep) \n} catch(ex) { print(ex) }\n\ntry {\n    dropStreamEngine(`streamEventSerializer)\n} catch(ex) { print(ex) }\n\n\nclass StartRequest{\n    instanceId :: STRING\n    strategyParams :: INT\n    def StartRequest(instanceId_, strategyParams_){\n        instanceId = instanceId_\n        strategyParams = strategyParams_\n    }\n}\n\nclass StartResponse{\n    instanceId :: STRING\n    status :: STRING\n    def StartResponse(instanceId_, status_){\n        instanceId = instanceId_\n        status = status_\n    }\n}\n\nclass Stratege:CEPMonitor {\n\t//构造函数\n\tdef Stratege(){\n\t}\n    def startStratege(StartRequestEvent){\n        // 启动策略实例\n    }\n\tdef processStartRequest(StartRequestEvent){\n        startStratege(StartRequestEvent)\n        // 发送策略启动成功响应\n        emitEvent(StartResponse(StartRequestEvent.instanceId, \"success\"))        \n    }\n\tdef onload() {\n        // 注册事件监听，监听策略启动请求\n\t\taddEventListener(handler=processStartRequest, eventType=\"StartRequest\", times=\"all\")\n\t}\n}\n\ndummy = table(array(STRING, 0) as eventType, array(BLOB, 0) as blobs)\nshare streamTable(array(STRING, 0) as eventType, array(BLOB, 0) as blobs) as outputTable\nserializer = streamEventSerializer(name=`streamEventSerializer, eventSchema=[StartResponse], outputTable=outputTable)\n// 创建 CEP 引擎\nengine = createCEPEngine(name='cep1', monitors=<Stratege()>, dummyTable=dummy, eventSchema=[StartRequest], outputTable=serializer)\n\n// 发送策略启动请求，同步等待策略实例 instance_001 启动成功的响应\nrequest = StartRequest(`instance_001, 100)\nresponse = appendEventWithResponse(engine=getStreamEngine(`cep1), event=request, responseType=\"StartResponse\", timeout=3000, condition=<StartResponse.instanceId==request.instanceId>)\n```\n\n**相关函数**：[appendEvent](https://docs.dolphindb.cn/zh/funcs/a/appendEvent.html)\n"
    },
    "appendForJoin": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/appendForJoin.html",
        "signatures": [
            {
                "full": "appendForJoin(engine, isLeftTable, data)",
                "name": "appendForJoin",
                "parameters": [
                    {
                        "full": "engine",
                        "name": "engine"
                    },
                    {
                        "full": "isLeftTable",
                        "name": "isLeftTable"
                    },
                    {
                        "full": "data",
                        "name": "data"
                    }
                ]
            }
        ],
        "markdown": "### [appendForJoin](https://docs.dolphindb.cn/zh/funcs/a/appendForJoin.html)\n\n\n\n#### 语法\n\nappendForJoin(engine, isLeftTable, data)\n\n#### 详情\n\n将数据插入流数据 join 引擎中。\n\n**Note:** 使用订阅函数 [subscribeTable](https://docs.dolphindb.cn/zh/funcs/s/subscribeTable.html) 为流数据 join 引擎订阅数据时，*handler* 参数需要为 `appendForJoin`、[getLeftStream](https://docs.dolphindb.cn/zh/funcs/g/getLeftStream.html) 或 [getRightStream](https://docs.dolphindb.cn/zh/funcs/g/getRightStream.html) 函数。\n\n#### 参数\n\n**engine** 是流数据 join 引擎，即 [createAsofJoinEngine](https://docs.dolphindb.cn/zh/funcs/c/createAsofJoinEngine.html) 等函数返回的抽象表对象。目前支持以下 join 引擎:\n\n* createAsofJoinEngine\n* createEquiJoinEngine\n* createLookupJoinEngine\n* createWindowJoinEngine\n* createLeftSemiJoinEngine\n\n**isLeftTable** 布尔类型，插入左表还是右表。\n\n**data** 将要插入表中的数据。\n\n#### 返回值\n\n#### 例子\n\n```\nleftTable=table(1:0, `timestamp`sym`price, [TIMESTAMP, SYMBOL, DOUBLE])\nrightTable=table(1:0, `timestamp`sym`val, [TIMESTAMP, SYMBOL, DOUBLE])\noutput=table(100:0, `timestamp`sym`price`val`total, [TIMESTAMP, SYMBOL, DOUBLE, DOUBLE, DOUBLE])\najEngine=createAsofJoinEngine(\"test1\", leftTable, rightTable, output, <[price, val, price*val]>, `sym, `timestamp, false, 7)\n\ntmp1=table(take(2012.01.01T00:00:00.000+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 20) as timestamp, take(`AAPL, 10) join take(`IBM, 10) as sym, double(1..20) as price)\ntmp2=table(take(2012.01.01T00:00:00.000+[1, 2, 3, 4, 4, 4, 4, 4, 4, 4], 20) as timestamp, take(`AAPL, 10) join take(`IBM, 10) as sym, double(1..20) as val)\n\nappendForJoin(ajEngine, true, (select * from tmp1 where timestamp=2012.01.01T00:00:00.001))\nappendForJoin(ajEngine, false, (select * from tmp2 where timestamp=2012.01.01T00:00:00.001))\nappendForJoin(ajEngine, true, (select * from tmp1 where timestamp=2012.01.01T00:00:00.002))\nappendForJoin(ajEngine, false, (select * from tmp2 where timestamp=2012.01.01T00:00:00.002))\nappendForJoin(ajEngine, true, (select * from tmp1 where timestamp=2012.01.01T00:00:00.003))\nappendForJoin(ajEngine, false, (select * from tmp2 where timestamp=2012.01.01T00:00:00.003))\nappendForJoin(ajEngine, true, (select * from tmp1 where timestamp=2012.01.01T00:00:00.004))\nappendForJoin(ajEngine, false, (select * from tmp2 where timestamp=2012.01.01T00:00:00.004))\nappendForJoin(ajEngine, true, (select * from tmp1 where timestamp=2012.01.01T00:00:00.005))\nappendForJoin(ajEngine, true, (select * from tmp1 where timestamp=2012.01.01T00:00:00.006))\nappendForJoin(ajEngine, true, (select * from tmp1 where timestamp=2012.01.01T00:00:00.007))\nappendForJoin(ajEngine, true, (select * from tmp1 where timestamp=2012.01.01T00:00:00.008))\nappendForJoin(ajEngine, true, (select * from tmp1 where timestamp=2012.01.01T00:00:00.009))\nappendForJoin(ajEngine, true, (select * from tmp1 where timestamp=2012.01.01T00:00:00.010))\n\nsleep(5000)\n```\n"
    },
    "appendMktData": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/appendMktData.html",
        "signatures": [
            {
                "full": "appendMktData(engine, data, [eventTime])",
                "name": "appendMktData",
                "parameters": [
                    {
                        "full": "engine",
                        "name": "engine"
                    },
                    {
                        "full": "data",
                        "name": "data"
                    },
                    {
                        "full": "[eventTime]",
                        "name": "eventTime",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [appendMktData](https://docs.dolphindb.cn/zh/funcs/a/appendMktData.html)\n\n\n\n#### 语法\n\nappendMktData(engine, data, \\[eventTime])\n\n#### 详情\n\n向市场数据构建引擎或者定价引擎中写入市场数据。\n\n* 对于市场数据构建引擎，写入数据表示更新缓存的历史数据集。\n\n* 对于定价引擎，写入数据表示使用该市场数据更新定价计算。\n\n#### 参数\n\n**engine** 市场数据构建引擎句柄或定价引擎句柄。\n\n**data** MKTDATA 类型标量/向量，或一个字典。表示市场数据。\n\n**eventTime** 可选参数，NANOTIMESTAMP 类型标量，表示事件发生时间。仅在启用 `engineConfig.outputTime=true` 时使用。\n\n#### 返回值\n\nLONG 类型标量。\n\n#### 例子\n\n例1. 向市场数据引擎中写入一个或多个市场数据。\n\n创建市场数据构建引擎。\n\n```\ntry{dropStreamEngine(\"MKTDATA_ENGINE\")}catch(ex){}\nreferenceDate = 2025.07.01\nconfig1 = {\"name\": \"USDCNY\", \"type\": \"FxSpotRate\"}\nconfig2 = {\"name\": \"EURUSD\", \"type\": \"FxSpotRate\"}\nconfig3 = {\"name\": \"EURCNY\", \"type\": \"FxSpotRate\"}\nengine = createMktDataEngine(\"MKTDATA_ENGINE\", referenceDate, [config1, config2, config3])\n```\n\n写入一个 MKTDATA 数据（标量）\n\n```\nfxSpot1 = {\n    \"mktDataType\": \"Price\",\n    \"referenceDate\": referenceDate,\n    \"spotDate\": 2025.07.03,\n    \"priceType\": \"FxSpotRate\",\n    \"value\": 7.12,\n    \"unit\": \"USDCNY\"\n}\nmktData1 = parseMktData(fxSpot1)\n\nappendMktData(engine, mktData1)\n```\n\n写入多个 MKTDATA 数据（向量）。\n\n```\nfxSpot2 = {\n    \"mktDataType\": \"Price\",\n    \"referenceDate\": referenceDate,\n    \"priceType\": \"FxSpotRate\",\n    \"value\": 7.88,\n    \"unit\": \"EURCNY\"\n}\nfxSpot3 = {\n    \"mktDataType\": \"Price\",\n    \"referenceDate\": referenceDate,\n    \"priceType\": \"FxSpotRate\",\n    \"value\": 1.10,\n    \"unit\": \"EURUSD\"\n}\nmktData2 = parseMktData(fxSpot2)\nmktData3 = parseMktData(fxSpot3)\nappendMktData(engine, [mktData1, mktData2, mktData3])  \n```\n\n查看生成的市场数据。\n\n```\nre = getMktData(engine, \"Price\", referenceDate, \"EURUSD\")\nprint(re)\n\n// output: {\"mktDataType\": \"Price\",\"priceType\": \"FxSpotRate\",\"spotDate\": \"2025.07.03\",\"referenceDate\": \"2025.07.01\",\"value\": 1.1,\"unit\": \"EURUSD\",\"version\": 2,\"underlying\": \"EURUSD\"}\n```\n\n例2. 当引擎配置为`outputTime=true` 时，使用 `appendMktData` 插入数据时需要指定 *eventTime* 参数。\n\n```\n// 清理环境（如果引擎已存在）\ntry{dropStreamEngine(\"MKTDATA_ENGINE\")}catch(ex){}\n\n// 设置参考日期和配置\nreferenceDate = 2025.07.01\nconfig1 = {\"name\": \"USDCNY\", \"type\": \"FxSpotRate\"}\nconfig2 = {\"name\": \"EURUSD\", \"type\": \"FxSpotRate\"}\nconfig3 = {\"name\": \"EURCNY\", \"type\": \"FxSpotRate\"}\n\n// 创建引擎配置，启用 outputTime\nengineConfig = {\n    \"outputTime\": true\n}\n\n// 创建市场数据构建引擎\nengine = createMktDataEngine(\n    name=\"MKTDATA_ENGINE\",\n    referenceDate=referenceDate,\n    mktDataConfig=[config1, config2, config3],\n    engineConfig=engineConfig  \n)\n\n// 创建 MKTDATA 类型数据\nfxSpot1 = {\n    \"mktDataType\": \"Price\",\n    \"referenceDate\": referenceDate,\n    \"spotDate\": 2025.07.03,\n    \"priceType\": \"FxSpotRate\",\n    \"value\": 7.12,\n    \"unit\": \"USDCNY\"\n}\nmktData1 = parseMktData(fxSpot1)\n\n// 使用 appendMktData 并指定 eventTime 参数\neventTime = now() \nappendMktData(engine, mktData1, eventTime)\n\nre = getMktData(engine, \"Price\", referenceDate, \"USDCNY\")\nprint(re)\n\n// output: {\"mktDataType\": \"Price\",\"priceType\": \"FxSpotRate\",\"spotDate\": \"2025.01.03\",\"referenceDate\": \"2025.01.01\",\"value\": 7.12,\"unit\": \"USDCNY\",\"version\": 2,\"underlying\": \"USDCNY\"}\n```\n\n**相关函数**：[createMktDataEngine](https://docs.dolphindb.cn/zh/funcs/c/createMktDataEngine.html), [createPricingEngine](https://docs.dolphindb.cn/zh/funcs/c/createpricingengine.html), [parseMktData](https://docs.dolphindb.cn/zh/funcs/p/parseMktData.html), [getMktData](https://docs.dolphindb.cn/zh/funcs/g/getMktData.html)\n"
    },
    "appendMsg": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/appendMsg.html",
        "signatures": [
            {
                "full": "appendMsg(engine, msgBody, msgId)",
                "name": "appendMsg",
                "parameters": [
                    {
                        "full": "engine",
                        "name": "engine"
                    },
                    {
                        "full": "msgBody",
                        "name": "msgBody"
                    },
                    {
                        "full": "msgId",
                        "name": "msgId"
                    }
                ]
            }
        ],
        "markdown": "### [appendMsg](https://docs.dolphindb.cn/zh/funcs/a/appendMsg.html)\n\n\n\n#### 语法\n\nappendMsg(engine, msgBody, msgId)\n\n#### 详情\n\n当流数据引擎启用快照机制（snapshot）且未开启 RaftGroup 时，订阅函数 [subscribeTable](https://docs.dolphindb.cn/zh/funcs/s/subscribeTable.html) 的handler参数必须为 `appendMsg` 函数，将数据写入流数据引擎。\n\n#### 参数\n\n**engine** 是内置流数据引擎，即 [createReactiveStateEngine](https://docs.dolphindb.cn/zh/funcs/c/createReactiveStateEngine.html) 等函数返回的抽象表对象。\n\n**msgBody** 是将要写入流数据引擎的消息。\n\n**msgId** 是写入数据之前，流数据引擎已接收到的最后一条消息的 ID。ID 从订阅发布的第一条消息开始计数。\n\n#### 例子\n\n```\nshare streamTable(10000:0,`time`sym`price, [TIMESTAMP,SYMBOL,DOUBLE]) as trades\noutput1 =table(10000:0, `time`sym`avgPrice, [TIMESTAMP,SYMBOL,DOUBLE]);\n\nengine1 = createTimeSeriesEngine(name=`engine1, windowSize=100, step=50, metrics=<avg(price)>, dummyTable=trades, outputTable=output1, timeColumn=`time, keyColumn=`sym, snapshotDir=\"C:/DolphinDB/Data/snapshotDir\", snapshotIntervalInMsgCount=100)\nsubscribeTable(tableName=\"trades\", actionName=\"engine1\", offset=0, handler=appendMsg{engine1}, msgAsTable=true, handlerNeedMsgId=true)\n\nn=500\ntimev=2021.03.12T15:00:00.000 + (1..n join 1..n)\nsymv = take(`A, n) join take(`B, n)\npricev = (100+cumsum(rand(1.0,n)-0.5)) join (200+cumsum(rand(1.0,n)-0.5))\nt=table(timev as time, symv as sym, pricev as price).sortBy!(`time)\ntrades.append!(t)\n\nselect * from output1\n```\n"
    },
    "appendOrcaStreamTable": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/appendOrcaStreamTable.html",
        "signatures": [
            {
                "full": "appendOrcaStreamTable(name, data)",
                "name": "appendOrcaStreamTable",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "data",
                        "name": "data"
                    }
                ]
            }
        ],
        "markdown": "### [appendOrcaStreamTable](https://docs.dolphindb.cn/zh/funcs/a/appendOrcaStreamTable.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nappendOrcaStreamTable(name, data)\n\n#### 详情\n\n向 orca 流表插入数据。注意：该函数不支持普通流表。\n\n#### 参数\n\n**name** 表示流表的名称。字符串标量，可以传入完整的流表全限定名（如 \"trading.orca\\_table.trades\"）；也可以仅提供流表名（如 \"trades\"），系统会根据当前的 catalog 设置自动补全为对应的全限定名。\n\n**data**数据表对象\n\n#### 例子\n\n向 orca 流表中插入表 snapshot。\n\n```\nif (!existsCatalog(\"test\")) {\n\tcreateCatalog(\"test\")\n}\ngo;\nuse catalog test\n\nt = table(1..100 as id, 1..100 as value, take(09:29:00.000..13:00:00.000, 100) as timestamp)\ng = createStreamGraph(\"factor\")\nbaseStream = g.source(\"snapshot\",  schema(t).colDefs.name, schema(t).colDefs.typeString)\n  .reactiveStateEngine([<cumsum(value)>, <timestamp>])\n  .setEngineName(\"rse\")\n  .buffer(\"end\")\n  \ng.submit()\n\nappendOrcaStreamTable(\"snapshot\", t)\n// 与 appendOrcaStreamTable(\"test.orca_table.snapshot\", t) 等价\n\n```\n\n可通过 SQL 语句 `select * from <catalog>.orca_table.<name>` 查看插入结果，其中 \\<catalog> 部分可以省略，系统会根据当前的 catalog 自动补全：\n\n```\nselect * from orca_table.end\n```\n\n| cumsum\\_value | timestamp    |\n| ------------- | ------------ |\n| 1             | 09:29:00.000 |\n| 3             | 09:29:00.001 |\n| 6             | 09:29:00.002 |\n| 10            | 09:29:00.003 |\n| 15            | 09:29:00.004 |\n| 21            | 09:29:00.005 |\n| 28            | 09:29:00.006 |\n| 36            | 09:29:00.007 |\n| 45            | 09:29:00.008 |\n| 55            | 09:29:00.009 |\n| …             | …            |\n"
    },
    "appendTuple!": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/appendTupel_.html",
        "signatures": [
            {
                "full": "appendTuple!(X, Y, [wholistic=false])",
                "name": "appendTuple!",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "[wholistic=false]",
                        "name": "wholistic",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [appendTuple!](https://docs.dolphindb.cn/zh/funcs/a/appendTupel_.html)\n\n\n\n#### 语法\n\nappendTuple!(X, Y, \\[wholistic=false])\n\n#### 详情\n\n将 *Y* 中的数据追加到 *X* 中。\n\n* 当 *wholistic* 为 true 时，将 *Y* 整体作为一个元素追加到 *X* 中\n* 当 *wholistic* 为 false 时，将 *Y* 中的每一个元素依次追加到 *X* 中\n* 当 *X* 是列式元组时，*Y* 中元素必须与 *X* 中元素类型一致，且 *wholistic* 只能为 false\n\n#### 参数\n\n**X** 是一个元组。\n\n**Y** 是一个元组。\n\n**wholistic** 是一个 bool 标量，默认值为 false。\n\n#### 返回值\n\n数据类型和数据形式与 *obj* 一致。\n\n#### 例子\n\n```\nx = (1,\"X\")\ny = ([2,3],\"Y\")\nx.appendTuple!(y,true)\nprint(x)\n// output\n(1,\"X\",([2,3],\"Y\"))\n\nx.appendTuple!(y,false)\nprint(x)\n// output\n(1,\"X\",([2,3],\"Y\"),[2,3],\"Y\")\n\nx = [[1,2,3],4]\nx.setColumnarTuple!()\nx.appendTuple!((5,6),false)\nprint(x)\n([1,2,3],4,5,6)\n```\n"
    },
    "arima": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/arima.html",
        "signatures": [
            {
                "full": "arima(ds, endogColName, order, [seasonalOrder], [exog], [trend], [enforceStationarity=true], [enforceInvertibility=true], [concentrateScale=false], [trendOffset=1], [maxIter=50])",
                "name": "arima",
                "parameters": [
                    {
                        "full": "ds",
                        "name": "ds"
                    },
                    {
                        "full": "endogColName",
                        "name": "endogColName"
                    },
                    {
                        "full": "order",
                        "name": "order"
                    },
                    {
                        "full": "[seasonalOrder]",
                        "name": "seasonalOrder",
                        "optional": true
                    },
                    {
                        "full": "[exog]",
                        "name": "exog",
                        "optional": true
                    },
                    {
                        "full": "[trend]",
                        "name": "trend",
                        "optional": true
                    },
                    {
                        "full": "[enforceStationarity=true]",
                        "name": "enforceStationarity",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[enforceInvertibility=true]",
                        "name": "enforceInvertibility",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[concentrateScale=false]",
                        "name": "concentrateScale",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[trendOffset=1]",
                        "name": "trendOffset",
                        "optional": true,
                        "default": "1"
                    },
                    {
                        "full": "[maxIter=50]",
                        "name": "maxIter",
                        "optional": true,
                        "default": "50"
                    }
                ]
            }
        ],
        "markdown": "### [arima](https://docs.dolphindb.cn/zh/funcs/a/arima.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\narima(ds, endogColName, order, \\[seasonalOrder], \\[exog], \\[trend], \\[enforceStationarity=true], \\[enforceInvertibility=true], \\[concentrateScale=false], \\[trendOffset=1], \\[maxIter=50])\n\n#### 详情\n\n差分整合移动平均自回归（ARIMA, Autoregressive Integrated Moving Average）模型是一种单变量时间序列分析模型，主要由三部分构成，分别为自回归模型（AR）、差分过程（I）和移动平均模型（MA）。\n\n`arima` 函数是 ARIMA 类模型的通用接口，可以通过 `arima` 函数构建以下时间序列分析模型：\n\n* 自回归模型 AR：用于捕捉数据与其历史值的关系\n* 移动平均模型 MA：专注于处理随机波动\n* 自回归移动平均模型 ARMA\n* 差分整合移动平均自回归模型 ARIMA\n* 季节性模型 SARIMA：处理周期性数据\n* 整合外部回归变量的带误差项模型 ARIMAX\n\n#### 参数\n\n**ds**内存表或数据源（DATASOURCE）向量，指定包含单变量时间序列的数据。\n\n**endogColName** 字符串标量，指定 *ds* 中的列名，该列为待分析的单变量时间序列数据。\n\n**order** 长度为 3 的非负整数向量，表示 ARIMA 模型的 (p, d, q) 阶数。其中，p 表示自回归（AR）部分的阶数，d 表示差分阶数，q 表示移动平均（MA）部分的阶数。\n\n**seasonalOrder** 可选参数。长度为 4 的非负整数向量， 表示季节性 ARIMA 模型的 (P, D, Q, s) 阶数。其中，P，D，Q 分别表示模型中季节性成分的 AR、差分、MA 阶数，s 表示该季节性序列的周期大小。默认值为 \\[0, 0, 0, 0]，表示无季节性。\n\n**exog** 可选参数。数值矩阵，表示外生变量。矩阵每一列表示一个外生变量的时间序列，矩阵行数为时间序列样本数，与 *ds* 的行数相等。\n\n**trend** 可选参数。字符串标量， 用于控制确定性趋势。可选值为：\n\n* “n”：不使用常量和趋势（当 *d*> 0 或者 D>0 时，以此为默认值）；\n* ”c”：仅使用常量（当 *d* = 0 且 D = 0 时，以此为默认值）；\n* ”t”：仅使用线性趋势；\n* ”ct”：同时使用常量和线性趋势；\n\n**enforceStationarity** 可选参数。BOOL 类型标量， 表示是否强制自回归 AR部分满足平稳性条件。默认值为 true。\n\n**enforceInvertibility** 可选参数。BOOL 类型标量， 表示是否强制移动平均 MA 部分满足可逆性条件。默认值为 true。\n\n**concentrateScale** 可选参数。BOOL 类型标量， 表示是否在似然性之外集中标度（误差项的方差），从而减少一个参数。仅在使用数值最大似然估计时适用。默认值为 false。\n\n**trendOffset** 可选参数。整数类型标量， 指定开始时间趋势值的偏移量。默认值为 1，因此如果 *trend*='t'，则趋势等于 1, 2, ..., nobs。\n\n**maxIter** 可选参数。正整数，表示拟合时最大的迭代次数，默认值为 50。\n\n#### 返回值\n\n一个字典，表示 ARIMA 模型的拟合结果，包含以下键值：\n\n* params：浮点数向量，表示 ARIMA 模型拟合得到的参数\n* llf：浮点数标量，表示 ARIMA 模型的对数似然值\n* aic：浮点数标量，表示 Akaike 信息准则\n* bic：浮点数标量，表示 Bayesian 信息准则\n* hqic：浮点数标量，表示 Hannan-Quinn 信息准则\n\n#### 例子\n\n以下代码使用 1959-2009 年的季度经济指标数据，对实际 GDP（`realgdp`）进行 ARIMA 模型拟合。假设通过分析确定使用 ARIMA(1,0,0) 模型，即自回归阶数为 1，无需差分，移动平均阶数为 0：\n\n```\ndata = loadText(\"./macrodata.csv\")\nres = arima(data, \"realgdp\", [1,0,0]);\nres;\n/* \nparams->[0.007795600187477,0.306055792984419,0.000069811276429]\nllf->679.783769203580163\naic->-1353.567538407160327\nbic->-1343.64273531495678\nhqic->-1349.551945119058927\n*/\n```\n\n[macrodata.csv](https://docs.dolphindb.cn/zh/funcs/data/arima/macrodata.csv)\n"
    },
    "array": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/array.html",
        "signatures": [
            {
                "full": "array(dataType|template, [initialSize], [capacity], [defaultValue])",
                "name": "array",
                "parameters": [
                    {
                        "full": "dataType|template",
                        "name": "dataType|template"
                    },
                    {
                        "full": "[initialSize]",
                        "name": "initialSize",
                        "optional": true
                    },
                    {
                        "full": "[capacity]",
                        "name": "capacity",
                        "optional": true
                    },
                    {
                        "full": "[defaultValue]",
                        "name": "defaultValue",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [array](https://docs.dolphindb.cn/zh/funcs/a/array.html)\n\n\n\n#### 语法\n\narray(dataType|template, \\[initialSize], \\[capacity], \\[defaultValue])\n\n#### 详情\n\n创建一个向量。\n\n与 Python 中 `numpy.array` 和 `pandas.array` 的区别：`numpy.array` 用于把 *object* 转换为 ndarray，并可推断或指定 *dtype*、维度、内存顺序和复制策略；`pandas.array` 用于从序列创建 pandas ExtensionArray，侧重 nullable/extension *dtype* 推断；DolphinDB 的 `array` 用于按指定数据类型或模板创建 DolphinDB 向量，并可指定 *initialSize*、*capacity* 和 *defaultValue*。\n\n#### 参数\n\n**dataType** 是向量的数据类型。\n\n**template** 是一个已有向量。这个已有向量的数据类型决定了新向量的数据类型。\n\n**initialSize** 是正整数，表示向量的初始长度，即该向量新建时的元素数量。\n\n**capacity** 是正整数，表示向量的容量，即该向量新建时系统为该向量分配的内存（以元素数为单位）。当元素数超过capacity时，系统会自动扩充容量。系统首先会分配当前容量1.2\\~2倍的内存，然后复制数据到新的内存空间，最后释放原来的内存。\n\n**defaultValue** 是向量的默认值。若指定，则只能是标量。若不指定：对于多数数据类型，默认值是 0；对于字符串和符号（Symbol），默认值是 NULL。\n\n#### 返回值\n\n一个向量。\n\n#### 例子\n\n```\nx=array(INT, 10, 100, 1)\n// 初始长度是 10；容量是 100；默认值是 1。\nx\n// output\n[1,1,1,1,1,1,1,1,1,1]\n\nx=array(INT, 0)\n// 初始化一个空向量\nx\n// output\n[]\nx.append!(1..10)\n// output\n[1,2,3,4,5,6,7,8,9,10]\n\ny=array(x)\ny\n// output\n[0,0,0,0,0,0,0,0,0,0]\n\nsyms=array(SYMBOL, 0, 100)\n// 一个空的符号向量，容量是 100.\ntypestr syms\n// output\nFAST SYMBOL VECTOR\n```\n"
    },
    "arrayVector": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/arrayVector.html",
        "signatures": [
            {
                "full": "arrayVector(index, value)",
                "name": "arrayVector",
                "parameters": [
                    {
                        "full": "index",
                        "name": "index"
                    },
                    {
                        "full": "value",
                        "name": "value"
                    }
                ]
            }
        ],
        "markdown": "### [arrayVector](https://docs.dolphindb.cn/zh/funcs/a/arrayVector.html)\n\n\n\n#### 语法\n\narrayVector(index, value)\n\n#### 详情\n\n根据 *index* 中的元素对 *value* 进行分割，将 *value* 转换为一个数组向量。*index* 中元素的个数表示转换后数组向量的行数；*index* 中的每个元素值， 代表数组向量中，每行向量的最后一个元素对应原本 *value* 中的位置（从1开始编号）。如下图所示：\n\n![](https://docs.dolphindb.cn/zh/images/arrayVector01.png \"Index\")\n\n**Note:** *index* 中元素的最大值不能超过 *value* 的长度。\n\n#### 参数\n\n**index** 是一个严格单调递增的正整型向量。\n\n**value** 是一个向量。其元素类型必须是 `arrayVector` 支持的类型。\n\n#### 返回值\n\n一个数组向量。\n\n#### 例子\n\n```\narrayVector(2 3 4, [1,2,3,4])\n\n[[1,2],[3],[4]]\n\narrayVector(1 4 7, [1.0,2.1,4.1,6.8,0.5,2.2,2])\n\n[[1],[2.1,4.1,6.8],[0.5,2.2,2]]\n\nvalue = 2022.01.01 + 0..20\nindex = 7 14 21\narrayVector(index, value)\n\n[[2022.01.01,2022.01.02,2022.01.03,2022.01.04,2022.01.05,2022.01.06,2022.01.07],[2022.01.08,2022.01.09,2022.01.10,2022.01.11,2022.01.12,2022.01.13,2022.01.14],[2022.01.15,2022.01.16,2022.01.17,2022.01.18,2022.01.19,2022.01.20,2022.01.21]]\n```\n\n相关函数：[fixedLengthArrayVector](https://docs.dolphindb.cn/zh/funcs/f/fixedLengthArrayVector.html)\n"
    },
    "asFreq": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/asFreq.html",
        "signatures": [
            {
                "full": "asFreq(X, rule, [closed], [label], [origin='start_day'])",
                "name": "asFreq",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "rule",
                        "name": "rule"
                    },
                    {
                        "full": "[closed]",
                        "name": "closed",
                        "optional": true
                    },
                    {
                        "full": "[label]",
                        "name": "label",
                        "optional": true
                    },
                    {
                        "full": "[origin='start_day']",
                        "name": "origin",
                        "optional": true,
                        "default": "'start_day'"
                    }
                ]
            }
        ],
        "markdown": "### [asFreq](https://docs.dolphindb.cn/zh/funcs/a/asFreq.html)\n\n\n\n#### 语法\n\nasFreq(X, rule, \\[closed], \\[label], \\[origin='start\\_day'])\n\n#### 详情\n\n转换给定数据的时间频率。与 [resample](https://docs.dolphindb.cn/zh/funcs/r/resample.html) 函数不同，该函数不可使用聚合函数对数据进行处理。\n\n#### 参数\n\n**X** 是有时间类型索引的矩阵（由 `setIndexedMatrix!` 创建）或序列（由 `setIndexedSeries!` 创建）。\n\n**rule** 可以是一个字符串，可取以下值，亦可为一个时间类型的向量。\n\n| rule 参数取值 | 对应 DolphinDB 函数      |\n| --------- | -------------------- |\n| \"B\"       | businessDay          |\n| \"W\"       | weekEnd              |\n| \"WOM\"     | weekOfMonth          |\n| \"LWOM\"    | lastWeekOfMonth      |\n| \"M\"       | monthEnd             |\n| \"MS\"      | monthBegin           |\n| \"BM\"      | businessMonthEnd     |\n| \"BMS\"     | businessMonthBegin   |\n| \"SM\"      | semiMonthEnd         |\n| \"SMS\"     | semiMonthBegin       |\n| \"Q\"       | quarterEnd           |\n| \"QS\"      | quarterBegin         |\n| \"BQ\"      | businessQuarterEnd   |\n| \"BQS\"     | businessQuarterBegin |\n| \"REQ\"     | fy5253Quarter        |\n| \"A\"       | yearEnd              |\n| \"AS\"      | yearBegin            |\n| \"BA\"      | businessYearEnd      |\n| \"BAS\"     | businessYearBegin    |\n| \"RE\"      | fy5253               |\n| \"D\"       | date                 |\n| \"H\"       | hourOfDay            |\n| \"min\"     | minuteOfHour         |\n| \"S\"       | secondOfMinute       |\n| \"L\"       | millisecond          |\n| \"U\"       | microsecond          |\n| \"N\"       | nanosecond           |\n| \"SA\"      | semiannualEnd        |\n| \"SAS\"     | semiannualBegin      |\n\n上述字符串亦可配合使用数字（必须为正整数），例如 \"2M\" 表示频率为每两个月月末。此外，*rule* 也可以是交易日历标识（国外交易所的 ISO Code、国内交易所简称或自定义交易日历名称），以便基于交易日历进行计算。交易日历也可以配合使用数字，表示多个交易日，此时只能指定由4个大写字母组成的交易日历标识。例如：“2XSHG”，表示上海证券交易所每两个交易日。\n\n**closed** 字符串，表示分组区间哪一个边界是闭合的。\n\n* *rule* 为 'M', 'A', 'Q', 'BM', 'BA', 'BQ' 和 'W' 时，*closed* 的默认取值为 'right' ，否则，*closed* 的默认取值为 'left'。\n* *origin* 取 'end' 或者 'end\\_day' 时，*closed* 的默认值为 'right'。\n\n**label** 字符串，表示将分组区间的哪一个边界作为 *label* 输出。\n\n* *rule* 为 'M', 'A', 'Q', 'BM', 'BA', 'BQ' 和 'W' 时，*label* 的默认取值为 'right' ，否则，*label* 的默认取值为 'left'。\n* *origin* 取 'end' 或者 'end\\_day' 时，*label* 的默认值为 'right'。\n\n**origin** 字符串或和 *X* 具有相同时间类型的标量，表示基于时间戳调整分组。取值为 'epoch', start', 'start\\_day', 'end', 'end\\_day' 或自定义的时间对象，默认值为 'start\\_day'。\n\n* 'epoch'：分组起始点为1970-01-01。\n* 'start'：分组起始点为时间序列的第一个值。\n* 'start\\_day'：分组起始点是时间序列的第一个值对应日期的午夜零点。\n* 'end'：分组起始点是时间序列的最后一个时间戳。\n* 'end\\_day'：分组起始点是时间序列的最后一个时间戳对应日期的午夜24点（即下一日的零点）。\n\n#### 返回值\n\n数据形式与 X 相同。\n\n#### 例子\n\n```\nindex = [2000.01.01, 2000.01.31, 2000.02.15, 2000.02.20, 2000.03.31, 2000.04.16, 2000.05.06, 2000.08.31]\ns = indexedSeries(index, 1..8)\ns\n```\n\n| lable      | 0 |\n| ---------- | - |\n| 2000.01.01 | 1 |\n| 2000.01.31 | 2 |\n| 2000.02.15 | 3 |\n| 2000.02.20 | 4 |\n| 2000.03.31 | 5 |\n| 2000.04.16 | 6 |\n| 2000.05.06 | 7 |\n| 2000.08.31 | 8 |\n\n```\n// 转换为月末频率\ns.asFreq(\"M\")\n```\n\n| lable      | 0 |\n| ---------- | - |\n| 2000.01.31 | 2 |\n| 2000.02.29 |   |\n| 2000.03.31 | 5 |\n| 2000.04.30 |   |\n| 2000.05.31 |   |\n| 2000.06.30 |   |\n| 2000.07.31 |   |\n| 2000.08.31 | 8 |\n\n```\n// 转换为双月频率\ns.asFreq(\"2M\")\n```\n\n| lable      | 0 |\n| ---------- | - |\n| 2000.01.31 | 2 |\n| 2000.03.31 | 5 |\n| 2000.05.31 |   |\n| 2000.07.31 |   |\n\n```\nindex = [2020.01.01, 2020.01.03, 2020.01.06]\ns = indexedSeries(index, 1..3)\ns\n```\n\n| lable      | 0 |\n| ---------- | - |\n| 2020.01.01 | 1 |\n| 2020.01.03 | 2 |\n| 2020.01.06 | 3 |\n\n```\n// 转换为日频率\ns.asFreq(\"D\")\n```\n\n| lable      | 0 |\n| ---------- | - |\n| 2020.01.01 | 1 |\n| 2020.01.02 |   |\n| 2020.01.03 | 2 |\n| 2020.01.04 |   |\n| 2020.01.05 |   |\n| 2020.01.06 | 3 |\n\n```\n// 转换为双日频率\ns.asFreq(\"2D\")\n```\n\n| lable      | 0 |\n| ---------- | - |\n| 2020.01.01 | 1 |\n| 2020.01.03 | 2 |\n| 2020.01.05 |   |\n\n```\nindex = temporalAdd(2022.10.01 23:30:00,7*(0..8),`m)\ns = indexedSeries(index, 3*(0..8))\n// 转换为8分钟频率，默认为左闭右开区间\ns.asFreq(\"8min\")\n```\n\n| label               | col1 |\n| ------------------- | ---- |\n| 2022.10.01T23:28:00 |      |\n| 2022.10.01T23:36:00 |      |\n| 2022.10.01T23:44:00 | 6    |\n| 2022.10.01T23:52:00 |      |\n| 2022.10.02T00:00:00 |      |\n| 2022.10.02T00:08:00 |      |\n| 2022.10.02T00:16:00 |      |\n| 2022.10.02T00:24:00 |      |\n\n```\n// 设置 closed=`right 为左开右闭区间\ns.asFreq(rule=`8min,closed=`right)\n```\n\n| label               | col1 |\n| ------------------- | ---- |\n| 2022.10.01T23:36:00 |      |\n| 2022.10.01T23:44:00 | 6    |\n| 2022.10.01T23:52:00 |      |\n| 2022.10.02T00:00:00 |      |\n| 2022.10.02T00:08:00 |      |\n| 2022.10.02T00:16:00 |      |\n| 2022.10.02T00:24:00 |      |\n| 2022.10.02T00:32:00 |      |\n\n```\n// 设置 origin=`end 以结束时间为基准向前对齐\ns.asFreq(rule=`8min,closed=`right,origin=`end)\n```\n\n| label               | col1 |\n| ------------------- | ---- |\n| 2022.10.01T23:30:00 | 0    |\n| 2022.10.01T23:38:00 |      |\n| 2022.10.01T23:46:00 |      |\n| 2022.10.01T23:54:00 |      |\n| 2022.10.02T00:02:00 |      |\n| 2022.10.02T00:10:00 |      |\n| 2022.10.02T00:18:00 |      |\n| 2022.10.02T00:26:00 | 24   |\n\n```\n// 默认为左闭右开区间，设置 label=`right 输出区间右边界\ns.asFreq(rule=`8min,label=`right)\n```\n\n| label               | 0 |\n| ------------------- | - |\n| 2022.10.01 23:36:00 |   |\n| 2022.10.01 23:44:00 | 6 |\n| 2022.10.01 23:52:00 |   |\n| 2022.10.02 00:00:00 |   |\n| 2022.10.02 00:08:00 |   |\n| 2022.10.02 00:16:00 |   |\n| 2022.10.02 00:24:00 |   |\n| 2022.10.02 00:32:00 |   |\n"
    },
    "asfreq": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/asfreq1.html",
        "signatures": [
            {
                "full": "asFreq(X, rule, [closed], [label], [origin='start_day'])",
                "name": "asFreq",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "rule",
                        "name": "rule"
                    },
                    {
                        "full": "[closed]",
                        "name": "closed",
                        "optional": true
                    },
                    {
                        "full": "[label]",
                        "name": "label",
                        "optional": true
                    },
                    {
                        "full": "[origin='start_day']",
                        "name": "origin",
                        "optional": true,
                        "default": "'start_day'"
                    }
                ]
            }
        ],
        "markdown": "### [asfreq](https://docs.dolphindb.cn/zh/funcs/a/asfreq1.html)\n\n是 [asFreq](https://docs.dolphindb.cn/zh/funcs/a/asFreq.html) 的别名。\n\n\n以下是 `asFreq` 函数的文档：\n### [asFreq](https://docs.dolphindb.cn/zh/funcs/a/asFreq.html)\n\n\n\n#### 语法\n\nasFreq(X, rule, \\[closed], \\[label], \\[origin='start\\_day'])\n\n#### 详情\n\n转换给定数据的时间频率。与 [resample](https://docs.dolphindb.cn/zh/funcs/r/resample.html) 函数不同，该函数不可使用聚合函数对数据进行处理。\n\n#### 参数\n\n**X** 是有时间类型索引的矩阵（由 `setIndexedMatrix!` 创建）或序列（由 `setIndexedSeries!` 创建）。\n\n**rule** 可以是一个字符串，可取以下值，亦可为一个时间类型的向量。\n\n| rule 参数取值 | 对应 DolphinDB 函数      |\n| --------- | -------------------- |\n| \"B\"       | businessDay          |\n| \"W\"       | weekEnd              |\n| \"WOM\"     | weekOfMonth          |\n| \"LWOM\"    | lastWeekOfMonth      |\n| \"M\"       | monthEnd             |\n| \"MS\"      | monthBegin           |\n| \"BM\"      | businessMonthEnd     |\n| \"BMS\"     | businessMonthBegin   |\n| \"SM\"      | semiMonthEnd         |\n| \"SMS\"     | semiMonthBegin       |\n| \"Q\"       | quarterEnd           |\n| \"QS\"      | quarterBegin         |\n| \"BQ\"      | businessQuarterEnd   |\n| \"BQS\"     | businessQuarterBegin |\n| \"REQ\"     | fy5253Quarter        |\n| \"A\"       | yearEnd              |\n| \"AS\"      | yearBegin            |\n| \"BA\"      | businessYearEnd      |\n| \"BAS\"     | businessYearBegin    |\n| \"RE\"      | fy5253               |\n| \"D\"       | date                 |\n| \"H\"       | hourOfDay            |\n| \"min\"     | minuteOfHour         |\n| \"S\"       | secondOfMinute       |\n| \"L\"       | millisecond          |\n| \"U\"       | microsecond          |\n| \"N\"       | nanosecond           |\n| \"SA\"      | semiannualEnd        |\n| \"SAS\"     | semiannualBegin      |\n\n上述字符串亦可配合使用数字（必须为正整数），例如 \"2M\" 表示频率为每两个月月末。此外，*rule* 也可以是交易日历标识（国外交易所的 ISO Code、国内交易所简称或自定义交易日历名称），以便基于交易日历进行计算。交易日历也可以配合使用数字，表示多个交易日，此时只能指定由4个大写字母组成的交易日历标识。例如：“2XSHG”，表示上海证券交易所每两个交易日。\n\n**closed** 字符串，表示分组区间哪一个边界是闭合的。\n\n* *rule* 为 'M', 'A', 'Q', 'BM', 'BA', 'BQ' 和 'W' 时，*closed* 的默认取值为 'right' ，否则，*closed* 的默认取值为 'left'。\n* *origin* 取 'end' 或者 'end\\_day' 时，*closed* 的默认值为 'right'。\n\n**label** 字符串，表示将分组区间的哪一个边界作为 *label* 输出。\n\n* *rule* 为 'M', 'A', 'Q', 'BM', 'BA', 'BQ' 和 'W' 时，*label* 的默认取值为 'right' ，否则，*label* 的默认取值为 'left'。\n* *origin* 取 'end' 或者 'end\\_day' 时，*label* 的默认值为 'right'。\n\n**origin** 字符串或和 *X* 具有相同时间类型的标量，表示基于时间戳调整分组。取值为 'epoch', start', 'start\\_day', 'end', 'end\\_day' 或自定义的时间对象，默认值为 'start\\_day'。\n\n* 'epoch'：分组起始点为1970-01-01。\n* 'start'：分组起始点为时间序列的第一个值。\n* 'start\\_day'：分组起始点是时间序列的第一个值对应日期的午夜零点。\n* 'end'：分组起始点是时间序列的最后一个时间戳。\n* 'end\\_day'：分组起始点是时间序列的最后一个时间戳对应日期的午夜24点（即下一日的零点）。\n\n#### 返回值\n\n数据形式与 X 相同。\n\n#### 例子\n\n```\nindex = [2000.01.01, 2000.01.31, 2000.02.15, 2000.02.20, 2000.03.31, 2000.04.16, 2000.05.06, 2000.08.31]\ns = indexedSeries(index, 1..8)\ns\n```\n\n| lable      | 0 |\n| ---------- | - |\n| 2000.01.01 | 1 |\n| 2000.01.31 | 2 |\n| 2000.02.15 | 3 |\n| 2000.02.20 | 4 |\n| 2000.03.31 | 5 |\n| 2000.04.16 | 6 |\n| 2000.05.06 | 7 |\n| 2000.08.31 | 8 |\n\n```\n// 转换为月末频率\ns.asFreq(\"M\")\n```\n\n| lable      | 0 |\n| ---------- | - |\n| 2000.01.31 | 2 |\n| 2000.02.29 |   |\n| 2000.03.31 | 5 |\n| 2000.04.30 |   |\n| 2000.05.31 |   |\n| 2000.06.30 |   |\n| 2000.07.31 |   |\n| 2000.08.31 | 8 |\n\n```\n// 转换为双月频率\ns.asFreq(\"2M\")\n```\n\n| lable      | 0 |\n| ---------- | - |\n| 2000.01.31 | 2 |\n| 2000.03.31 | 5 |\n| 2000.05.31 |   |\n| 2000.07.31 |   |\n\n```\nindex = [2020.01.01, 2020.01.03, 2020.01.06]\ns = indexedSeries(index, 1..3)\ns\n```\n\n| lable      | 0 |\n| ---------- | - |\n| 2020.01.01 | 1 |\n| 2020.01.03 | 2 |\n| 2020.01.06 | 3 |\n\n```\n// 转换为日频率\ns.asFreq(\"D\")\n```\n\n| lable      | 0 |\n| ---------- | - |\n| 2020.01.01 | 1 |\n| 2020.01.02 |   |\n| 2020.01.03 | 2 |\n| 2020.01.04 |   |\n| 2020.01.05 |   |\n| 2020.01.06 | 3 |\n\n```\n// 转换为双日频率\ns.asFreq(\"2D\")\n```\n\n| lable      | 0 |\n| ---------- | - |\n| 2020.01.01 | 1 |\n| 2020.01.03 | 2 |\n| 2020.01.05 |   |\n\n```\nindex = temporalAdd(2022.10.01 23:30:00,7*(0..8),`m)\ns = indexedSeries(index, 3*(0..8))\n// 转换为8分钟频率，默认为左闭右开区间\ns.asFreq(\"8min\")\n```\n\n| label               | col1 |\n| ------------------- | ---- |\n| 2022.10.01T23:28:00 |      |\n| 2022.10.01T23:36:00 |      |\n| 2022.10.01T23:44:00 | 6    |\n| 2022.10.01T23:52:00 |      |\n| 2022.10.02T00:00:00 |      |\n| 2022.10.02T00:08:00 |      |\n| 2022.10.02T00:16:00 |      |\n| 2022.10.02T00:24:00 |      |\n\n```\n// 设置 closed=`right 为左开右闭区间\ns.asFreq(rule=`8min,closed=`right)\n```\n\n| label               | col1 |\n| ------------------- | ---- |\n| 2022.10.01T23:36:00 |      |\n| 2022.10.01T23:44:00 | 6    |\n| 2022.10.01T23:52:00 |      |\n| 2022.10.02T00:00:00 |      |\n| 2022.10.02T00:08:00 |      |\n| 2022.10.02T00:16:00 |      |\n| 2022.10.02T00:24:00 |      |\n| 2022.10.02T00:32:00 |      |\n\n```\n// 设置 origin=`end 以结束时间为基准向前对齐\ns.asFreq(rule=`8min,closed=`right,origin=`end)\n```\n\n| label               | col1 |\n| ------------------- | ---- |\n| 2022.10.01T23:30:00 | 0    |\n| 2022.10.01T23:38:00 |      |\n| 2022.10.01T23:46:00 |      |\n| 2022.10.01T23:54:00 |      |\n| 2022.10.02T00:02:00 |      |\n| 2022.10.02T00:10:00 |      |\n| 2022.10.02T00:18:00 |      |\n| 2022.10.02T00:26:00 | 24   |\n\n```\n// 默认为左闭右开区间，设置 label=`right 输出区间右边界\ns.asFreq(rule=`8min,label=`right)\n```\n\n| label               | 0 |\n| ------------------- | - |\n| 2022.10.01 23:36:00 |   |\n| 2022.10.01 23:44:00 | 6 |\n| 2022.10.01 23:52:00 |   |\n| 2022.10.02 00:00:00 |   |\n| 2022.10.02 00:08:00 |   |\n| 2022.10.02 00:16:00 |   |\n| 2022.10.02 00:24:00 |   |\n| 2022.10.02 00:32:00 |   |\n"
    },
    "asin": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/asin.html",
        "signatures": [
            {
                "full": "asin(X)",
                "name": "asin",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [asin](https://docs.dolphindb.cn/zh/funcs/a/asin.html)\n\n\n\n#### 语法\n\nasin(X)\n\n#### 详情\n\n返回 *X* 的反正弦。\n\nDolphinDB `asin` 函数与 TA-Lib `ASIN` 函数在数学语义上完全一致。区别在于：TA-Lib 的 `ASIN` 是 Math Transform 函数，输入和输出主要为一维数组；DolphinDB 的 `asin` 可用于标量、向量、矩阵或表，并保持输入的数据形式。\n\n#### 参数\n\n**X** 可以是标量、向量、矩阵或表。\n\n#### 返回值\n\n返回结果的数据形式与输入保持一致：若输入为标量，返回标量；若输入为向量、矩阵或表，返回相同维度的结果。\n\n#### 例子\n\n```\nasin(0 0.5 1);\n// output\n[0,0.523599,1.570796]\n```\n\n相关函数：[acos](https://docs.dolphindb.cn/zh/funcs/a/acos.html), [atan](https://docs.dolphindb.cn/zh/funcs/a/atan.html), [sin](https://docs.dolphindb.cn/zh/funcs/s/sin.html), [cos](https://docs.dolphindb.cn/zh/funcs/c/cos.html), [tan](https://docs.dolphindb.cn/zh/funcs/t/tan.html), [asinh](https://docs.dolphindb.cn/zh/funcs/a/asinh.html), [acosh](https://docs.dolphindb.cn/zh/funcs/a/acosh.html), [atanh](https://docs.dolphindb.cn/zh/funcs/a/atanh.html), [sinh](https://docs.dolphindb.cn/zh/funcs/s/sinh.html), [cosh](https://docs.dolphindb.cn/zh/funcs/c/cosh.html), [tanh](https://docs.dolphindb.cn/zh/funcs/t/tanh.html)\n"
    },
    "asinh": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/asinh.html",
        "signatures": [
            {
                "full": "asinh(X)",
                "name": "asinh",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [asinh](https://docs.dolphindb.cn/zh/funcs/a/asinh.html)\n\n\n\n#### 语法\n\nasinh(X)\n\n#### 详情\n\n计算 *X* 的反双曲正弦。\n\n#### 参数\n\n**X** 可以是标量、向量、矩阵或表。\n\n#### 返回值\n\n返回结果的数据形式与输入保持一致：若输入为标量，返回标量；若输入为向量、矩阵或表，返回相同维度的结果。\n\n#### 例子\n\n```\nasinh(0.841471 0.909297 0.141120);\n// output\n[0.764725,0.815761,0.140656]\n```\n\n相关函数：[asin](https://docs.dolphindb.cn/zh/funcs/a/asin.html), [acos](https://docs.dolphindb.cn/zh/funcs/a/acos.html), [atan](https://docs.dolphindb.cn/zh/funcs/a/atan.html), [sin](https://docs.dolphindb.cn/zh/funcs/s/sin.html), [cos](https://docs.dolphindb.cn/zh/funcs/c/cos.html), [tan](https://docs.dolphindb.cn/zh/funcs/t/tan.html), [acosh](https://docs.dolphindb.cn/zh/funcs/a/acosh.html), [atanh](https://docs.dolphindb.cn/zh/funcs/a/atanh.html), [sinh](https://docs.dolphindb.cn/zh/funcs/s/sinh.html), [cosh](https://docs.dolphindb.cn/zh/funcs/c/cosh.html), [tanh](https://docs.dolphindb.cn/zh/funcs/t/tanh.html)\n"
    },
    "asis": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/asIs.html",
        "signatures": [
            {
                "full": "asis(obj)",
                "name": "asis",
                "parameters": [
                    {
                        "full": "obj",
                        "name": "obj"
                    }
                ]
            }
        ],
        "markdown": "### [asis](https://docs.dolphindb.cn/zh/funcs/a/asIs.html)\n\n\n\n#### 语法\n\nasis(obj)\n\n#### 详情\n\n返回 *obj* 的引用。\n\n#### 参数\n\n**obj** 可以是任意数据类型。\n\n#### 返回值\n\n数据类型与数据形式与 *obj* 相同。\n\n#### 例子\n\n```\na = 1 2 3\nb = asis(a)\na[0] = 0\nb\n// output\n[0, 2, 3]\nb[1] = 4\n// output\na;\n[0, 4, 3]\n```\n\n相关函数：[copy](https://docs.dolphindb.cn/zh/funcs/c/copy.html), [deepCopy](https://docs.dolphindb.cn/zh/funcs/d/deepCopy.html)\n"
    },
    "asof": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/asof.html",
        "signatures": [
            {
                "full": "asof(X, Y)",
                "name": "asof",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [asof](https://docs.dolphindb.cn/zh/funcs/a/asof.html)\n\n\n\n#### 语法\n\nasof(X, Y)\n\n#### 详情\n\n当 *X* 是递增向量时，对于每个 *Y* 中的元素 y，`asof` 返回 *X* 中不大于 y 的元素的最大序号（从 0 开始编号）。如果没有找到，则返回 -1。\n\n当 *X* 是索引序列或索引矩阵时，*Y* 必须是向量。对于 *Y* 中的每个元素 y，函数在 *X* 的行索引中查找不大于 y 的最大索引，并返回该索引对应的数据。如果没有找到，则返回 NULL。\n\n#### 参数\n\n**X** 必须是一个递增的向量、索引序列、索引矩阵。若 *X* 是索引序列或索引矩阵，其行索引必须递增。\n\n**Y** 可以是标量、向量、数组向量、元组、矩阵、字典、表。若 *X* 是索引序列或索引矩阵，*Y* 必须是向量。\n\n#### 返回值\n\n若 *X* 是向量，返回 INT 类型，形式与 *Y* 相同。\n\n若 *X* 是索引序列，返回索引序列，行索引为 *Y*。若 *X* 是索引矩阵，返回索引矩阵，行索引为 *Y*，列标签与 *X* 相同。\n\n#### 例子\n\n例1. *X* 为向量。\n\n```\nasof(1..100, 60 200 -10)\n// output:\n[59,99,-1]\n\n0 0 0 1 1 1 1 2 2 3 asof 1\n// output:\n6\n```\n\n例2. *X* 为索引序列。\n\n```\nindex = [2023.05.04, 2023.05.06, 2023.05.10]\ns = indexedSeries(index, 1..3)\ny = [2023.05.03, 2023.05.04, 2023.05.05, 2023.05.09, 2023.05.12]\nasof(s, y)\n```\n\n| label      | #0 |\n| ---------- | -- |\n| 2023.05.03 |    |\n| 2023.05.04 | 1  |\n| 2023.05.05 | 1  |\n| 2023.05.09 | 2  |\n| 2023.05.12 | 3  |\n\n例3. *X* 为索引矩阵。\n\n```\nindex = [2023.05.04, 2023.05.06, 2023.05.10]\nm = matrix(1..3, 11..13).rename!(index, `A`B).setIndexedMatrix!()\ny = [2023.05.03, 2023.05.04, 2023.05.05, 2023.05.09, 2023.05.12]\nasof(m, y)\n```\n\n| label      | A | B  |\n| ---------- | - | -- |\n| 2023.05.03 |   |    |\n| 2023.05.04 | 1 | 11 |\n| 2023.05.05 | 1 | 11 |\n| 2023.05.09 | 2 | 12 |\n| 2023.05.12 | 3 | 13 |\n"
    },
    "at": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/at.html",
        "signatures": [
            {
                "full": "at(X, [index])",
                "name": "at",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[index]",
                        "name": "index",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [at](https://docs.dolphindb.cn/zh/funcs/a/at.html)\n\n\n\n#### 语法\n\nat(X, \\[index])\n\n#### 详情\n\n* 只指定一个参数 X：\n  * 如果 X 是布尔表达式或向量，函数返回 *X* 中结果为 true 的元素位置。\n  * 如果 X 是整型向量，则函数返回一个向量，该向量是根据 X 中每个位置的数值重复该位置的索引得到，其功能相当于`take(til(count(X)), X)`。例如 `at(3 0 2)` 结果为 `[0,0,0,2,2]`。若某个位置的值为非正数，则跳过该位置。\n* 指定两个参数：\n  * 如果 *index* 是布尔表达式，`at` 函数返回 *X* 中 *index* 为 true 的位置的元素。 `at` 函数等价于中括号运算符 \\[]。 比如，`X.at(X>3)` 和 `X[X>3]` 相同。\n  * 如果 *index* 是向量，以向量中的值作为索引值，寻找 *X* 中该索引位置的值并返回。\n  * 若 *X* 是函数，*index* 为元组，则 *index* 中每一个元素均作为 *X* 的参数使用。\n  * 如果 *index* 是数据对，如 a:b, 则表示索引范围为 \\[a,b)，寻找 *X* 中该范围的值并返回。\n  * 如果 *index* 是数组向量，对于 *index* 中的每行元素都作为一个索引值，寻找 *X* 中对应该索引位置的元素，然后返回一个和 *index* 结构相同的数组向量。\n\n**Note:**\n\n* *index* 作为索引值或索引范围时，若其值不在 \\[0, size(*X*) - 1] 内，则超出 \\[0, size(*X*) - 1] 的值所对应的位置返回空值。\n* 若 *X* 是函数， *index* 为元组，则 index 中每一个元素均作为 X 的参数适用。\n\n#### 参数\n\n如果只指定了一个参数，***X*** 可以是布尔表达式/向量，或是整型向量。\n\n如果指定了两个参数：\n\n***X***可以是一个标量、向量（常规向量/元组/数组向量)、矩阵、表、字典、数据对、函数。\n\n***index*** 可以是一个布尔表达式/布尔值、标量、向量（常规向量/元组/数组向量)、数据对。\n\n#### 返回值\n\n如果只指定了一个参数，则返回一个向量；如果指定了两个参数，则返回向量、数组向量或矩阵\n\n#### 例子\n\n```\nx = 2 3 -1 0 1\nat(x)\n// output:[0,0,1,1,1,4]\n\nx=5 7 0 4 2 3\nat(x>3)\n//output：[0, 1, 3]\n// 在位置 0, 1 和 3，x>3 为 true\n\n// 和 x>3 相比\nx>3;\n//output：[1, 1, 0, 1, 0, 0]\n\nx[x>3]\n//output：[5, 7, 4]\n\nx at x>3\n//output：[5, 7, 4]\n\nx=5 7 0 0 0 3\nat(x==0)\n//output：[2, 3, 4]\n\nx[x==0]\n//output：[0, 0, 0]\n\nshares=500 1000 1000 600 2000\nprices=25.5 97.5  19.2 38.4 101.5\nprices[shares>800]\n//output：[97.5, 19.2, 101.5]\n\nprices at shares>800\n//output: [97.5, 19.2, 101.5]\n```\n\n```\nm=(1..6).reshape(2:3)\nm;\n```\n\n| 0 | 1 | 2 |\n| - | - | - |\n| 1 | 3 | 5 |\n| 2 | 4 | 6 |\n\n```\nat(m>3)\n//output：[3,4,5]\n\nm[m>3] // 等价于 m at m>3\n```\n\n返回：\n\n| col1 | col2 | col3 |\n| ---- | ---- | ---- |\n|      |      | 5    |\n|      | 4    | 6    |\n\n注意区分 *index* 是向量和元组的两种不同场景：\n\n```\nm at [0,2]  // 选择第 0 列和第 2 列\n```\n\n| 0 | 1 |\n| - | - |\n| 1 | 5 |\n| 2 | 6 |\n\n```\nm at (0,2) // 查找特定行列的元素\n//output: 5\n```\n\n```\nm at 0:2 // 选择第 0 列和第 1 列\n```\n\n返回：\n\n| 0 | 1 |\n| - | - |\n| 1 | 3 |\n| 2 | 4 |\n\n*index* 是数组向量的情况：\n\n```\na = array(INT[], 0, 10).append!([0 2 3, 0 5, 0 8 8, 9 10])\nb =[1, 2, 3]\nat(b, a)\n//output: [[1,3, ], [1, ], [1, , ], [ , ]]\n\nat(a,a>3)\n//output: [,[5],[8,8],[9,10]]\n```\n\n下例中，score 是一个简单元组，包含 2 个元素，60 和 70。第二行中，`at` 函数使用 `add` 函数作为 *X*，将 score 中的每个元素作为 `add` 的入参，并将 `at` 的计算结果赋予 result。\n\n```\nscore = (60, 70);\nresult = at(add,score)\nprint result\n\n//output: 130\n```\n"
    },
    "atan": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/atan.html",
        "signatures": [
            {
                "full": "atan(X)",
                "name": "atan",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [atan](https://docs.dolphindb.cn/zh/funcs/a/atan.html)\n\n\n\n#### 语法\n\natan(X)\n\n#### 详情\n\n返回 *X* 的反正切。\n\n与 Python TA-Lib 中 `ATAN` 的区别：二者均计算反正切，结果单位均为弧度。TA-Lib 的 `ATAN(close)` 是 Math Transform 函数，输入和输出主要为一维数组；DolphinDB 的 `atan(X)` 可用于标量、向量、矩阵或表，并保持输入的数据形式。\n\n#### 参数\n\n**X** 可以是标量、向量、矩阵或表。\n\n#### 返回值\n\n返回结果的数据形式与输入保持一致：若输入为标量，返回标量；若输入为向量、矩阵或表，返回相同维度的结果。\n\n#### 例子\n\n```\natan 0.000000 1.557408 -2.185040;\n// output\n[0,1,-1.141593]\n```\n\n相关函数：[asin](https://docs.dolphindb.cn/zh/funcs/a/asin.html), [acos](https://docs.dolphindb.cn/zh/funcs/a/acos.html), [sin](https://docs.dolphindb.cn/zh/funcs/s/sin.html), [cos](https://docs.dolphindb.cn/zh/funcs/c/cos.html), [tan](https://docs.dolphindb.cn/zh/funcs/t/tan.html), [asinh](https://docs.dolphindb.cn/zh/funcs/a/asinh.html), [acosh](https://docs.dolphindb.cn/zh/funcs/a/acosh.html), [atanh](https://docs.dolphindb.cn/zh/funcs/a/atanh.html), [sinh](https://docs.dolphindb.cn/zh/funcs/s/sinh.html), [cosh](https://docs.dolphindb.cn/zh/funcs/c/cosh.html), [tanh](https://docs.dolphindb.cn/zh/funcs/t/tanh.html)\n"
    },
    "atanh": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/atanh.html",
        "signatures": [
            {
                "full": "atanh(X)",
                "name": "atanh",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [atanh](https://docs.dolphindb.cn/zh/funcs/a/atanh.html)\n\n\n\n#### 语法\n\natanh(X)\n\n#### 详情\n\n返回 *X* 的反双曲正切。\n\n#### 参数\n\n**X** 可以是标量、向量、矩阵或表。\n\n#### 返回值\n\n返回结果的数据形式与输入保持一致：若输入为标量，返回标量；若输入为向量、矩阵或表，返回相同维度的结果。\n\n#### 例子\n\n```\natanh 0.000000 0.557408 -0.185040;\n// output\n[0,0.629065,-0.187196]\n```\n\n相关函数：[asin](https://docs.dolphindb.cn/zh/funcs/a/asin.html), [acos](https://docs.dolphindb.cn/zh/funcs/a/acos.html), [atan](https://docs.dolphindb.cn/zh/funcs/a/atan.html), [sin](https://docs.dolphindb.cn/zh/funcs/s/sin.html), [cos](https://docs.dolphindb.cn/zh/funcs/c/cos.html), [tan](https://docs.dolphindb.cn/zh/funcs/t/tan.html), [asinh](https://docs.dolphindb.cn/zh/funcs/a/asinh.html), [acosh](https://docs.dolphindb.cn/zh/funcs/a/acosh.html), [sinh](https://docs.dolphindb.cn/zh/funcs/s/sinh.html), [cosh](https://docs.dolphindb.cn/zh/funcs/c/cosh.html), [tanh](https://docs.dolphindb.cn/zh/funcs/t/tanh.html)\n"
    },
    "atImax": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/atImax.html",
        "signatures": [
            {
                "full": "atImax(location, value)",
                "name": "atImax",
                "parameters": [
                    {
                        "full": "location",
                        "name": "location"
                    },
                    {
                        "full": "value",
                        "name": "value"
                    }
                ]
            }
        ],
        "markdown": "### [atImax](https://docs.dolphindb.cn/zh/funcs/a/atImax.html)\n\n\n\n#### 语法\n\natImax(location, value)\n\n#### 详情\n\n找出 *location* 中最大值所在的位置，然后返回 *value* 中该位置对应的值。如果 *location* 中有多个相同的最大值，则取第一个最大值所在的位置。\n\n若 *location* 和 *value* 是矩阵，则 *location* 和 *value* 的每列一一对应，分别计算 `atImax`。\n\natImax(location, value) 相当于 value\\[imax(location)]。\n\n#### 参数\n\n**location** 和 **value** 是向量、矩阵或表。\n\n#### 返回值\n\n根据输入形式返回不同的结果：若输入为向量，返回标量；若输入为矩阵，返回向量。\n\n数据类型与 value 一致。\n\n#### 例子\n\n```\natImax(3 5 1 2, 9 7 5 3)\n// output\n7\n\nm1=matrix(9 2 1 5 6 9, 3 1 3 NULL 5 2, 2 8 1 2 3 4)\nm2=matrix(1..6, 1..6, 1..6)\natImax(m1,m2)\n// output\n[1,5,2]\n```\n\n相关函数：[imax](https://docs.dolphindb.cn/zh/funcs/i/imax.html), [atImin](https://docs.dolphindb.cn/zh/funcs/a/atImin.html)\n"
    },
    "atImin": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/atImin.html",
        "signatures": [
            {
                "full": "atImin(location, value)",
                "name": "atImin",
                "parameters": [
                    {
                        "full": "location",
                        "name": "location"
                    },
                    {
                        "full": "value",
                        "name": "value"
                    }
                ]
            }
        ],
        "markdown": "### [atImin](https://docs.dolphindb.cn/zh/funcs/a/atImin.html)\n\n\n\n#### 语法\n\natImin(location, value)\n\n#### 详情\n\n找出 *location* 中最小值所在的位置，然后返回 *value* 中该位置对应的值。如果 *location* 中有多个相同的最小值，则取第一个最小值所在的位置。\n\n若 *location* 和 *value* 是矩阵，则 *location* 和 *value* 的每列一一对应，分别计算 `atImin`。\n\natImin(location, value) 相当于 value\\[imin(location)]。\n\n#### 参数\n\n**location** 和 **value** 是向量、矩阵或表。\n\n#### 返回值\n\n根据输入形式返回不同的结果：若输入为向量，返回标量；若输入为矩阵，返回向量。\n\n数据类型与 value 一致。\n\n#### 例子\n\n```\natImin(3 5 1 2, 9 7 5 3)\n// output\n5\n\nm1=matrix(9 2 1 5 6 9, 3 1 3 NULL 5 2, 2 8 1 2 3 4)\nm2=matrix(1..6, 1..6, 1..6)\natImin(m1,m2)\n// output\n[3,2,3]\n```\n\n相关函数：[imin](https://docs.dolphindb.cn/zh/funcs/i/imin.html), [atImax](https://docs.dolphindb.cn/zh/funcs/a/atImax.html)\n"
    },
    "attributeNames": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/attributenames.html",
        "signatures": [
            {
                "full": "attributeNames(obj)",
                "name": "attributeNames",
                "parameters": [
                    {
                        "full": "obj",
                        "name": "obj"
                    }
                ]
            }
        ],
        "markdown": "### [attributeNames](https://docs.dolphindb.cn/zh/funcs/a/attributenames.html)\n\n\n\n#### 语法\n\nattributeNames(obj)\n\n#### 详情\n\n获取类实例的所有属性名称。\n\n#### 参数\n\n**obj** 类实例。\n\n#### 返回值\n\n字符串向量\n\n#### 例子\n\n```\nclass Person {\n\t\n\tname :: STRING\n\tage :: INT\n\n\tdef Person(name_, age_) { \n\t\tname = name_\n\t\tage = age_\n\t}\n}\n\np = Person(\"Sam\", 12)\nattributeNames(p)\n\n// output: [\"name\",\"age\"]\n```\n"
    },
    "attributeTypes": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/attributeTypes.html",
        "signatures": [
            {
                "full": "attributeTypes(obj)",
                "name": "attributeTypes",
                "parameters": [
                    {
                        "full": "obj",
                        "name": "obj"
                    }
                ]
            }
        ],
        "markdown": "### [attributeTypes](https://docs.dolphindb.cn/zh/funcs/a/attributeTypes.html)\n\n首发版本：3.00.4.2，3.00.3.2\n\n\n\n#### 语法\n\nattributeTypes(obj)\n\n#### 参数\n\n**obj** 类实例。\n\n#### 详情\n\n获取类或类实例中所有属性及其对应的类型。\n\n#### 返回值\n\n一个表，包含如下列：\n\n* attr：属性名称。\n\n* type：数据类型。\n\n#### 例子\n\n```\nclass Person {\n\tname :: STRING\n\tage :: INT\n\tdef Person(name_, age_) { \n\t\tname = name_\n\t\tage = age_\n\t}\n}\np1 = Person(\"Sam\", 12)\nattributeTypes(p1)  // 或者 attributeTypes(Person)\n```\n\n| attr | type   |\n| ---- | ------ |\n| name | STRING |\n| age  | INT    |\n\n**相关函数**：[attributeNames](https://docs.dolphindb.cn/zh/funcs/a/attributenames.html)、[attributeValues](https://docs.dolphindb.cn/zh/funcs/a/attributevalues.html)\n"
    },
    "attributeValues": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/attributevalues.html",
        "signatures": [
            {
                "full": "attributeValues(obj)",
                "name": "attributeValues",
                "parameters": [
                    {
                        "full": "obj",
                        "name": "obj"
                    }
                ]
            }
        ],
        "markdown": "### [attributeValues](https://docs.dolphindb.cn/zh/funcs/a/attributevalues.html)\n\n\n\n#### 语法\n\nattributeValues(obj)\n\n#### 详情\n\n获取类实例的所有属性及其对应的属性值。\n\n#### 参数\n\n**obj** 类实例。\n\n#### 返回值\n\n一个字典，key 是属性名称，value 是属性值。\n\n#### 例子\n\n```\nclass Person {\n\tname :: STRING\n\tage :: INT\n\tdef Person(name_, age_) { \n\t\tname = name_\n\t\tage = age_\n\t}\n}\np1 = Person(\"Sam\", 12)\nattributeValues(p1)\n\n/* output: \nname->Sam\nage->12\n*/\n\np2 = Person(\"Andy\", 16)\nattributeValues(p2)\n\n/* output: \nname->Andy\nage->16\n*/\n```\n"
    },
    "autocorr": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/autocorr.html",
        "signatures": [
            {
                "full": "autocorr(X, lag)",
                "name": "autocorr",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "lag",
                        "name": "lag"
                    }
                ]
            }
        ],
        "markdown": "### [autocorr](https://docs.dolphindb.cn/zh/funcs/a/autocorr.html)\n\n\n\n#### 语法\n\nautocorr(X, lag)\n\n#### 详情\n\n计算 *X* 的 *lag* 阶自相关系数。请注意，计算时两个时间序列所用的均值均为 *X*的均值，而非两个时间序列各自的均值。\n\n#### 参数\n\n**X** 是一个向量。\n\n**lag** 是一个正整数。\n\n#### 返回值\n\nDOUBLE 类型标量。\n\n#### 例子\n\n```\nn=10000\nx=array(DOUBLE, n, n, NULL)\nx[0]=1\nr=rand(0.05, n)-0.025\nfor(i in 0:(n-1)){\n    x[i+1]=-0.8*x[i]+r[i]\n}\n\nautocorr(x, 1)\n// output\n-0.808343\n\nautocorr(x, 2)\n// output\n0.661018\n```\n\n相关函数： [acf](https://docs.dolphindb.cn/zh/funcs/a/acf.html)\n"
    },
    "avg": {
        "url": "https://docs.dolphindb.cn/zh/funcs/a/avg.html",
        "signatures": [
            {
                "full": "avg(X)",
                "name": "avg",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [avg](https://docs.dolphindb.cn/zh/funcs/a/avg.html)\n\n\n\n#### 语法\n\navg(X)\n\n#### 详情\n\n* 若 *X* 为向量，计算 *X* 的平均值。\n* 若 *X* 为矩阵，计算每列的平均值。\n* 若 *X* 为表，计算每列的平均值。\n\n该函数与 [mean](https://docs.dolphindb.cn/zh/funcs/m/mean.html) 函数完全相同。\n\n与所有其它聚合函数一致，计算时忽略 NULL 值。\n\n#### 参数\n\n**X** 可以是标量、数据对、向量、矩阵或表。\n\n#### 返回值\n\n根据输入形式返回不同的结果：若输入为向量，返回 DOUBLE 类型标量；若输入为矩阵，返回 DOUBLE 类型向量（对每列聚合）；若输入为表，返回表。\n\n#### 例子\n\n```\navg(1 2 3 NULL)\n// output\n2\n\nm=matrix(1 2 3, 4 5 6)\nm\n```\n\n| 0 | 1 |\n| - | - |\n| 1 | 4 |\n| 2 | 5 |\n| 3 | 6 |\n\n```\navg(m)\n// output\n[2,5]\n```\n"
    },
    "backup": {
        "url": "https://docs.dolphindb.cn/zh/funcs/b/backup.html",
        "signatures": [
            {
                "full": "backup(backupDir, dbPath|sqlObj, [force=false], [parallel=false], [snapshot=true], [tableName], [partition], [keyPath])",
                "name": "backup",
                "parameters": [
                    {
                        "full": "backupDir",
                        "name": "backupDir"
                    },
                    {
                        "full": "dbPath|sqlObj",
                        "name": "dbPath|sqlObj"
                    },
                    {
                        "full": "[force=false]",
                        "name": "force",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[parallel=false]",
                        "name": "parallel",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[snapshot=true]",
                        "name": "snapshot",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[tableName]",
                        "name": "tableName",
                        "optional": true
                    },
                    {
                        "full": "[partition]",
                        "name": "partition",
                        "optional": true
                    },
                    {
                        "full": "[keyPath]",
                        "name": "keyPath",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [backup](https://docs.dolphindb.cn/zh/funcs/b/backup.html)\n\n\n\n#### 语法\n\nbackup(backupDir, dbPath|sqlObj, \\[force=false], \\[parallel=false], \\[snapshot=true], \\[tableName], \\[partition], \\[keyPath])\n\n#### 详情\n\n以分区为单位，备份分布式表的数据。返回一个整数，表示备份成功的分区数量。该函数必须要用户登录后才能执行。\n\n**Note:**\n\n* 若 [database](https://docs.dolphindb.cn/zh/funcs/d/database.html) 创建数据库时，指定 *chunkGranularity* = 'DATABASE'，则只能通过 SQL 语句备份数据。\n* 若 *backupDir* 目录已存在备份文件，则再次向该目录备份数据时，需保证备份方式（*dbPath* 或 *sqlObj*）一致，否则将备份失败。\n* 若 ***backupDir*** 指定为 AWS S3 存储路径，则只能以分区方式备份，即只支持 *dbPath*，不支持 *sqlObj*。\n* 若 ***backupDir*** 指定为 AWS S3 存储路径，需要在数据节点的配置中添加配置项 *preloadModules=plugins::awss3*，同时设置 *s3AccessKeyId*、*s3SecretAccessKey* 和 *s3Region*。\n\n#### 参数\n\n**backupDir** 字符串，表示存放备份数据的目录。如需备份到 AWS S3 存储路径，此参数的值应以 `s3://` 开头。\n\n**dbPath** 字符串，表示数据库路径。若指定该参数，以分区为单位拷贝文件进行备份。\n\n**sqlObj** SQL 元代码，表示备份的数据。若指定该参数，则仅对 SQL 语句过滤出的数据进行备份。\n\n**force** 布尔值，表示是否进行全量备份。进行非首次备份时，若 *force* = true，系统将待备份数据全部进行备份；否则仅备份有修改或新增的分区数据。\n\n**parallel** 布尔值，表示是否对一个数据表下不同分区进行并行备份。默认值为 false。\n\n以下参数仅在指定 *dbPath* 时有效：\n\n**snapshot** 布尔值，仅在参数 *partition* 为空时有效。表示进行非首次备份时，源数据库中若存在被删除的表/分区，是否同步将备份中对应的表/分区删除。 若设置为 true，则备份文件中存在已经被删除的分区或表，会同步进行删除；否则不会删除。\n\n**tableName** 字符串标量或向量，表示表名。若不指定，表示数据库下的所有表。\n\n**partition** 表示分区，若不指定，则表示所有分区。有两种指定模式：\n\n* 指定路径：以 \"/\" 开头的字符串标量或向量，表示数据库目录下单个或多个分区的路径。请注意对组合分区，路径必须包括所有层次分区。\n* 指定条件：以分区列的一个或多个值作为过滤条件。对于组合分区，*partition*是一个元组，每个元素代表一层分区的过滤条件，如果某层分区不需要过滤，那么相应的过滤条件需置为空。需要注意的是，对于范围分区，需要指定为分区内的一个值。\n\n  假如一个组合分区数据库 \"dfs\\://compoDB\"，一级分区采用值分区：2017.08.07；二级分区采用哈希分区：Key0 和 Key1。分区数据的路径分别为：\\<HomeDir>/storage/CHUNKS/compoDB/20170807/Key0 和 \\<HomeDir>/storage/CHUNKS/compoDB/20170807/Key1。若要备份单个分区 20170807/Key0，指定路径时需要设置 *partition* = \"/20170807/Key0\"；指定条件时需要设置 *partition* = \\[2017.08.07, 0]。若要备份两个分区 20170807/Key0 和 20170807/Key1，则 *partition* 指定为 \\[\"/20170807/Key0\", \"/20170807/Key1\"]；指定条件时需要设置 *partition* = \\[2017.08.07,\\[0,1]]。\n\n**keyPath** 字符串标量，指定备份时使用的密钥文件路径。仅 Linux 系统支持该参数。该密钥用于对备份数据进行加密。设置为空即不加密。\n\n#### 返回值\n\nINT 类型标量。\n\n#### 补充说明\n\n备份时指定 *dbPath* 和 *sqlObj* 的功能列表：\n\n| 功能     | dbPath             | sqlObj                             |\n| ------ | ------------------ | ---------------------------------- |\n| 一键备份整库 | 支持                 | 不支持                                |\n| 数据一致性  | 保证数据一致性            | 不完全保证                              |\n| 增量备份   | 支持同步已修改、新增及删除的分区数据 | 只支持同步已修改或新增的分区数据，不支持同步已删除的分区数据     |\n| 断点续传   | 支持                 | 不支持                                |\n| 灵活语法   | 不支持                | SQL 语句，具有灵活语法，支持备份整张表或仅备份满足查询条件的数据 |\n| 性能     | 拷贝文件方式，内存消耗小，速度快   | 序列化方式，内存消耗大，速度慢                    |\n\n#### 例子\n\n创建一个组合分区的数据库 dfs\\://compoDB。\n\n```\nn=1000000\nID=rand(100, n)\ndates=2017.08.07..2017.08.11\ndate=rand(dates, n)\nx=rand(10.0, n)\nt=table(ID, date, x)\n\ndbDate = database(, VALUE, 2017.08.07..2017.08.11)\ndbID=database(, RANGE, 0 50 100);\ndb = database(\"dfs://compoDB\", COMPO, [dbDate, dbID])\npt = db.createPartitionedTable(t, `pt, `date`ID)\npt.append!(t)\n```\n\n例1. 备份表 pt 的所有数据。\n\n```\nbackup(backupDir=\"/home/DolphinDB/backup\", sqlObj=<select * from loadTable(\"dfs://compoDB\",\"pt\")>, force=true);\n// output\n10\n```\n\n例2. 备份表 pt 中日期超过2017.08.10的数据。\n\n```\nbackup(backupDir=\"/home/DolphinDB/backup\", sqlObj=<select * from loadTable(\"dfs://compoDB\",\"pt\") where date>2017.08.10>, force=true);\n// output\n2\n```\n\n例3. 备份表 pt 中日期分区 2017.08.09 对应的数据。\n\n上例创建的数据库采用组合分区，第一层为 `date` 的 VALUE 分区，第二层为 `ID` 的 RANGE 分区。此处 *partition* 指定日期值 `2017.08.09`，会直接匹配并备份一级分区 `20170809` 下的全部二级分区，即 `/20170809/0_50` 和 `/20170809/50_100`；它不是在备份过程中按日期条件逐行过滤。\n\n```\nbackup(backupDir=\"/home/DolphinDB/backup\", dbPath=\"dfs://compoDB\", force=true, tableName=`pt, partition=2017.08.09)\n```\n\n例4. 备份数据库中表数据。\n\n(1) 备份指定表或所有表\n\n```\n// dfs://compoDB 数据库下创建第2张表\npt1 = db.createPartitionedTable(t, `pt1, `date`ID)\npt1.append!(t)\n\n// 同时备份数据库中的两张表\nbackup(backupDir=\"/home/DolphinDB/backup\",dbPath=\"dfs://compoDB\",force=true);\n// output\n20\n```\n\n(2) partition 指定分区范围\n\n```\n// 备份数据库中表 pt 的指定的5个分区\npartitions=[\"/20170807/0_50\",\"/20170808/0_50\",\"/20170809/0_50\",\"/20170810/0_50\",\"/20170811/0_50\"]\nbackup(backupDir=\"/home/DolphinDB/backup\",dbPath=\"dfs://compoDB\",force=true,tableName=`pt,partition=partitions);\n// output\n5\n```\n\n(3) partition 指定过滤条件。请注意，对于范围分区，指定分区范围内的一个值，表示整个分区。\n\n```\n// 备份数据库中表 pt 的一级分区 20170807 内的 50_100 的分区\npartitions=[2017.08.07,50]\nbackup(backupDir=\"/home/DolphinDB/backup\",dbPath=\"dfs://compoDB\",force=true,tableName=`pt,partition=partitions);\n// output\n1\n// 备份数据库中表 pt 的所有一级分区内的 0_50 的分区\npartitions=[,[0]]\nbackup(backupDir=\"/home/DolphinDB/backup\",dbPath=\"dfs://compoDB\",force=true,tableName=`pt,partition=partitions);\n// output\n5\n```\n\n例5. 通过下例说明 *snapshot* 参数的作用\n\n```\n// 删除表 pt 中分区\"/20170811/0_50\"\ndb.dropPartition(\"/20170811/0_50\",`pt)\n//再次备份，指定snapshot=false\nbackup(backupDir=\"/home/DolphinDB/backup1\",dbPath=\"dfs://compoDB\",force=true,snapshot=false,tableName=`pt);\n// output\n9\n// 从备份中恢复的分区仍包含 /20170811/0_50 这个分区，说明备份文件中并没有删除/20170811/0_50 这个分区\nrestore(backupDir=\"/home/DolphinDB/backup1\",dbPath=\"dfs://compoDB\",tableName=`pt,partition=\"%\",force=true)\n// output\n[\"dfs://compoDB/20170807/0_50/9m9\",\"dfs://compoDB/20170807/50_100/9m9\",\"dfs://compoDB/20170808/0_50/9m9\",\n    \"dfs://compoDB/20170808/50_100/9m9\",\"dfs://compoDB/20170809/0_50/9m9\",\"dfs://compoDB/20170809/50_100/9m9\",\n    \"dfs://compoDB/20170810/0_50/9m9\",\"dfs://compoDB/20170810/50_100/9m9\",\"dfs://compoDB/20170811/0_50/9m9\",\n    \"dfs://compoDB/20170811/50_100/9m9\"]\n\n// 再次删除表pt中分区\"/20170811/0_50\"\ndb.dropPartition(\"/20170811/0_50\",`pt)\n\n// 再次备份，指定snapshot=true\nbackup(backupDir=\"/home/DolphinDB/backup\",dbPath=\"dfs://compoDB\",force=true,snapshot=true,tableName=`pt);\n// output\n9\n// 从备份中恢复的分区不包含 /20170811/0_50 这个分区，说明备份文件中删除了/20170811/0_50 这个分区\nrestore(backupDir=\"/home/DolphinDB/backup\",dbPath=\"dfs://compoDB\",tableName=`pt,partition=\"%\",force=true)\n// output\n[\"dfs://compoDB/20170807/0_50/9m9\",\"dfs://compoDB/20170807/50_100/9m9\",\"dfs://compoDB/20170808/0_50/9m9\",\n    \"dfs://compoDB/20170808/50_100/9m9\",\"dfs://compoDB/20170809/0_50/9m9\",\"dfs://compoDB/20170809/50_100/9m9\",\n    \"dfs://compoDB/20170810/0_50/9m9\",\"dfs://compoDB/20170810/50_100/9m9\",\"dfs://compoDB/20170811/50_100/9m9\"]\n```\n\n相关函数：[backupDB](https://docs.dolphindb.cn/zh/funcs/b/backupDB.html), [backupTable](https://docs.dolphindb.cn/zh/funcs/b/backupTable.html), [restore](https://docs.dolphindb.cn/zh/funcs/r/restore.html), [migrate](https://docs.dolphindb.cn/zh/funcs/m/migrate.html)\n"
    },
    "backupDB": {
        "url": "https://docs.dolphindb.cn/zh/funcs/b/backupDB.html",
        "signatures": [
            {
                "full": "backupDB(backupDir, dbPath, [keyPath])",
                "name": "backupDB",
                "parameters": [
                    {
                        "full": "backupDir",
                        "name": "backupDir"
                    },
                    {
                        "full": "dbPath",
                        "name": "dbPath"
                    },
                    {
                        "full": "[keyPath]",
                        "name": "keyPath",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [backupDB](https://docs.dolphindb.cn/zh/funcs/b/backupDB.html)\n\n\n\n#### 语法\n\nbackupDB(backupDir, dbPath, \\[keyPath])\n\n#### 详情\n\n备份数据库到指定路径。\n\n该函数是 [backup](https://docs.dolphindb.cn/zh/funcs/b/backup.html) 函数的特例，其等价于调用 `backup(backupDir, dbPath, force=false, parallel=true, snapshot=true)`。 调用该函数可以简化代码，方便用户一次性备份整个数据库。\n\n#### 参数\n\n**backupDir** 字符串，表示存放备份数据的目录。\n\n**dbPath** 字符串，表示数据库路径。\n\n**keyPath** 字符串标量，指定备份时使用的密钥文件路径。仅 Linux 系统支持该参数。该密钥用于对备份数据进行加密。设置为空即不加密。\n\n#### 返回值\n\nINT 类型标量，表示备份成功的数据库数量。\n\n#### 例子\n\n```\ndbName = \"dfs://compoDB2\"\nn=1000\nID=rand(\"a\"+string(1..10), n)\ndates=2017.08.07..2017.08.11\ndate=rand(dates, n)\nx=rand(10, n)\nt=table(ID, date, x)\ndb1 = database(, VALUE, 2017.08.07..2017.08.11)\ndb2 = database(, HASH,[INT, 20])\nif(existsDatabase(dbName)){\n  dropDatabase(dbName)\n}\ndb = database(dbName, COMPO,[ db1,db2])\n\n// 创建2个表\npt1 = db.createPartitionedTable(t, `pt1, `date`x).append!(t)\npt2 = db.createPartitionedTable(t, `pt2, `date`x).append!(t)\n\n// 指定存放备份数据的目录（以下为示例，请按实际情况修改目录）\nbackupDir = \"/home/test/dolphindb/server/backup/\"\n\nbackupDB(backupDir, dbName)\n```\n\n相关函数：[backup](https://docs.dolphindb.cn/zh/funcs/b/backup.html), [backupTable](https://docs.dolphindb.cn/zh/funcs/b/backupTable.html), [restore](https://docs.dolphindb.cn/zh/funcs/r/restore.html), [restoreDB](https://docs.dolphindb.cn/zh/funcs/r/restoreDB.html), [restoreTable](https://docs.dolphindb.cn/zh/funcs/r/restoreTable.html), [migrate](https://docs.dolphindb.cn/zh/funcs/m/migrate.html)\n"
    },
    "backupSettings": {
        "url": "https://docs.dolphindb.cn/zh/funcs/b/backupsettings.html",
        "signatures": [
            {
                "full": "backupSettings(fileName, [userPermission=true], [functionView=true])",
                "name": "backupSettings",
                "parameters": [
                    {
                        "full": "fileName",
                        "name": "fileName"
                    },
                    {
                        "full": "[userPermission=true]",
                        "name": "userPermission",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[functionView=true]",
                        "name": "functionView",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [backupSettings](https://docs.dolphindb.cn/zh/funcs/b/backupsettings.html)\n\n\n\n#### 语法\n\nbackupSettings(fileName, \\[userPermission=true], \\[functionView=true])\n\n#### 详情\n\n此函数只能由管理员在控制节点执行，备份当前数据库系统中的所有用户、用户权限信息和函数视图，并将备份文件保存到指定路径。\n\n函数返回一个向量，依次列出已成功备份的用户名和函数视图名称。\n\n与函数 [restoreSettings](https://docs.dolphindb.cn/zh/funcs/r/restoresettings.html) 搭配使用，可以在数据库迁移时实现用户、用户权限及函数视图的迁移。\n\n#### 参数\n\n**fileName** STRING 类型标量，指定备份文件的存储路径，可以为绝对路径或相对于 \\<HomeDir> 的相对路径。\n\n**userPermission** BOOL 类型标量，表示是否备份用户权限。默认值为 true，表示备份用户权限。\n\n**functionView** BOOL 类型标量，表示是否备份函数视图。默认值为 true，表示备份函数视图。\n\n#### 返回值\n\n一个字典，包含以下 key：\n\n* users：备份的用户信息。\n* groups：备份的权限信息。\n* functionViews：备份的函数视图信息。\n\n#### 例子\n\n```\n// 备份用户、权限信息、函数视图\nbackupSettings(fileName=\"/home/ddb/backup/permission.back\", userPermission=true, functionView=true)\n// 备份用户、权限信息，不备份函数视图\nbackupSettings(fileName=\"/home/ddb/backup/permission.back\", userPermission=true, functionView=false)\n// 备份用户、函数视图，不备份权限信息\nbackupSettings(fileName=\"/home/ddb/backup/permission.back\", userPermission=false, functionView=true)\n// 备份用户，不备份权限信息和函数视图\nbackupSettings(fileName=\"/home/ddb/backup/permission.back\", userPermission=false, functionView=false)\n```\n\n相关函数：[restoreSettings](https://docs.dolphindb.cn/zh/funcs/r/restoresettings.html)\n"
    },
    "backupTable": {
        "url": "https://docs.dolphindb.cn/zh/funcs/b/backupTable.html",
        "signatures": [
            {
                "full": "backupTable(backupDir, dbPath, tableName, [keyPath])",
                "name": "backupTable",
                "parameters": [
                    {
                        "full": "backupDir",
                        "name": "backupDir"
                    },
                    {
                        "full": "dbPath",
                        "name": "dbPath"
                    },
                    {
                        "full": "tableName",
                        "name": "tableName"
                    },
                    {
                        "full": "[keyPath]",
                        "name": "keyPath",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [backupTable](https://docs.dolphindb.cn/zh/funcs/b/backupTable.html)\n\n\n\n#### 语法\n\nbackupTable(backupDir, dbPath, tableName, \\[keyPath])\n\n#### 详情\n\n备份数据库中的表到指定路径。\n\n该函数是 [backup](https://docs.dolphindb.cn/zh/funcs/b/backup.html) 函数的特例，其等价于调用 `backup(backupDir, dbPath, force=false, parallel=true, snapshot=true, tableName)`。 调用该函数可以简化代码，方便用户一次性备份数据库的一张表。\n\n#### 参数\n\n**backupDir** 字符串，表示存放备份数据的目录。\n\n**dbPath** 字符串，表示数据库路径。\n\n**tableName** 字符串，表示表名。\n\n**keyPath** 字符串标量，指定备份时使用的密钥文件路径。仅 Linux 系统支持该参数。该密钥用于对备份数据进行加密。设置为空即不加密。\n\n#### 返回值\n\nINT 类型标量，表示备份成功的表数量。\n\n#### 例子\n\n```\ndbName = \"dfs://compoDB2\"\nn=1000\nID=rand(\"a\"+string(1..10), n)\ndates=2017.08.07..2017.08.11\ndate=rand(dates, n)\nx=rand(10, n)\nt=table(ID, date, x)\ndb1 = database(, VALUE, 2017.08.07..2017.08.11)\ndb2 = database(, HASH,[INT, 20])\nif(existsDatabase(dbName)){\n  dropDatabase(dbName)\n}\ndb = database(dbName, COMPO,[ db1,db2])\n\n// 创建2个表\npt1 = db.createPartitionedTable(t, `pt1, `date`x).append!(t)\npt2 = db.createPartitionedTable(t, `pt2, `date`x).append!(t)\n\nbackupTable(backupDir,dbName,`pt1)\n// output\n50\n```\n\n相关函数：[backup](https://docs.dolphindb.cn/zh/funcs/b/backup.html), [backupDB](https://docs.dolphindb.cn/zh/funcs/b/backupDB.html), [restore](https://docs.dolphindb.cn/zh/funcs/r/restore.html), [restoreDB](https://docs.dolphindb.cn/zh/funcs/r/restoreDB.html), [restoreTable](https://docs.dolphindb.cn/zh/funcs/r/restoreTable.html), [migrate](https://docs.dolphindb.cn/zh/funcs/m/migrate.html)\n"
    },
    "bar": {
        "url": "https://docs.dolphindb.cn/zh/funcs/b/bar.html",
        "signatures": [
            {
                "full": "bar(X, interval, [closed='left'])",
                "name": "bar",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "interval",
                        "name": "interval"
                    },
                    {
                        "full": "[closed='left']",
                        "name": "closed",
                        "optional": true,
                        "default": "'left'"
                    }
                ]
            }
        ],
        "markdown": "### [bar](https://docs.dolphindb.cn/zh/funcs/b/bar.html)\n\n\n\n#### 语法\n\nbar(X, interval, \\[closed='left'])\n\n相关函数：[dailyAlignedBar](https://docs.dolphindb.cn/zh/funcs/d/dailyAlignedBar.html)\n\n#### 详情\n\n`bar` 基于 *interval* 指定的长度，根据分组计算公式，对 *X* 进行分组。\n\n#### 参数\n\n**X** 是一个整型/时间类型的标量或向量。\n\n**interval** 是一个大于0的整型/DURATION 类型的标量或和 *X* 长度相同的向量。\n\n*interval* 是 DURATION 类型时，支持以下时间单位（区分大小写）：w, d, H, m, s, ms, us, ns。\n\n**Note:** 由于 *interval* 不支持年(y)和月(M)的时间单位，如果需要对 *X* 以年或月进行分组时，可以调用 [year](https://docs.dolphindb.cn/zh/funcs/y/year.html) 或 [month](https://docs.dolphindb.cn/zh/funcs/m/month.html) 对 *X* 进行转换后，指定 *interval* 为整数进行计算。可以参考例2。\n\n**closed** 字符串，可选值为 'left' 或 'right'。 表示 *X* 中可被 *interval* 整除的元素，归为某个分组的左边界（即该组第一个元素，此时*closed*=‘left’），还是归为某个分组的右边界（即该组最后一个元素，此时*closed*=‘right’）。\n\n对应的分组计算公式为：\n\n*closed* = 'left'时，*X*-(*X* % *interval*)，表示将余数为 0 的值作为一个分组的左边界。\n\n*closed* = 'right'时，iif((*X* % *interval*) == 0, *X*, *X* + (*interval*-(*X* % *interval*)))，表示将余数为 0 的值作为一个分组的右边界。\n\n#### 返回值\n\n返回一个和 *X* 相同数据类型和形式的对象。\n\n#### 例子\n\n例1.\n\n```\nbar(100,3);               // 100-(100%3)=100-1=99\n// output\n99\n\nbar(0..15, 3)\n// output\n[0,0,0,3,3,3,6,6,6,9,9,9,12,12,12,15]\n\nx=[7,4,5,8,9,3,3,5,2,6,12,1,0,-5,32]\nbar(x, 5)\n// output\n[5,0,5,5,5,0,0,5,0,5,10,0,0,-5,30]\n\nt=table(2021.01.01T01:00:00..2021.01.01T01:00:29 as time, rand(1.0, 30) as x)\nselect max(x) from t group by bar(time,5s)\n```\n\n| bar\\_time           | max\\_x   |\n| ------------------- | -------- |\n| 2021.01.01T01:00:00 | 0.539024 |\n| 2021.01.01T01:00:05 | 0.793327 |\n| 2021.01.01T01:00:10 | 0.958522 |\n| 2021.01.01T01:00:15 | 0.96987  |\n| 2021.01.01T01:00:20 | 0.827086 |\n| 2021.01.01T01:00:25 | 0.617353 |\n\n例2. 以3个月进行分组，需要将 `bar` 函数中的 *X* 转为月份：\n\n```\nt=table(take(2018.01.01T01:00:00+1..10,10) join take(2018.02.01T02:00:00+1..10,10) join take(2018.03.01T08:00:00+1..10,10) join take(2018.04.01T08:00:00+1..10,10) join take(2018.05.01T08:00:00+1..10, 10) as time, rand(1.0, 50) as x)\nselect max(x) from t group by bar(month(time), 3);\n```\n\n| bar      | max\\_x |\n| -------- | ------ |\n| 2018.01M | 0.9868 |\n| 2018.04M | 0.9243 |\n\n例3. 将日期按照周分组，计算每周的最大值。根据 *closed* 不同，计算结果有所区别。\n\n```\nt=table(2022.01.01 + 1..20  as time, rand(100, 20) as x)\n```\n\n| time       | x  |\n| ---------- | -- |\n| 2022.01.02 | 6  |\n| 2022.01.03 | 29 |\n| 2022.01.04 | 71 |\n| 2022.01.05 | 56 |\n| 2022.01.06 | 93 |\n| 2022.01.07 | 34 |\n| 2022.01.08 | 77 |\n| 2022.01.09 | 18 |\n| 2022.01.10 | 62 |\n| 2022.01.11 | 33 |\n| 2022.01.12 | 34 |\n| 2022.01.13 | 64 |\n| 2022.01.14 | 80 |\n| 2022.01.15 | 63 |\n| 2022.01.16 | 17 |\n| 2022.01.17 | 66 |\n| 2022.01.18 | 85 |\n| 2022.01.19 | 27 |\n| 2022.01.20 | 77 |\n| 2022.01.21 | 27 |\n\n```\nselect max(x) from t group by bar(time, 7d);\n```\n\n| bar\\_time  | max\\_x |\n| ---------- | ------ |\n| 2021.12.30 | 71     |\n| 2022.01.06 | 93     |\n| 2022.01.13 | 85     |\n| 2022.01.20 | 77     |\n\n```\nprint  select max(x) from t group by bar(time, 7d, closed='right');\n```\n\n| bar\\_time  | max\\_x |\n| ---------- | ------ |\n| 2021.01.06 | 93     |\n| 2022.01.13 | 77     |\n| 2022.01.20 | 85     |\n| 2022.01.27 | 27     |\n\n例4. 计算分钟 k 线时，n 需要转换为 NANOTIMESTAMP，此时若使用整型计算可能造成类型溢出，需要将数据类型转换成 LONG。\n\n```\nn = 1000000\nnano = (09:30:00.000000000 + rand(long(6.5*60*60*1000000000), n)).sort!()\nprice = 100+cumsum(rand(0.02, n)-0.01)\nvolume = rand(1000, n)\nsymbol = rand(`600519`000001`600000`601766, n)\ntradeNano = table(symbol, nano, price, volume).sortBy!(`symbol`nano)\nundef(`nano`price`volume`symbol)\nbarMinutes = 7\nitv = barMinutes*60*long(1000000000)\n\nOHLC_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\n```\n"
    },
    "base64Decode": {
        "url": "https://docs.dolphindb.cn/zh/funcs/b/base64Decode.html",
        "signatures": [
            {
                "full": "base64Decode(X)",
                "name": "base64Decode",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [base64Decode](https://docs.dolphindb.cn/zh/funcs/b/base64Decode.html)\n\n\n\n#### 语法\n\nbase64Decode(X)\n\n#### 详情\n\n将 Base64 编码的数据解码为二进制数据。\n\n#### 参数\n\n**X** 字符串标量或向量。\n\n#### 返回值\n\nBLOB 类型标量或向量。\n\n#### 例子\n\n```\nbase64Decode(base64Encode(`hello))\n// output\nhello\n\nbase64Decode(base64Encode(`hello`world))\n// output\n[\"hello\",\"world\"]\n```\n\n相关函数：[base64Encode](https://docs.dolphindb.cn/zh/funcs/b/base64Encode.html)\n"
    },
    "base64Encode": {
        "url": "https://docs.dolphindb.cn/zh/funcs/b/base64Encode.html",
        "signatures": [
            {
                "full": "base64Encode(X)",
                "name": "base64Encode",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [base64Encode](https://docs.dolphindb.cn/zh/funcs/b/base64Encode.html)\n\n\n\n#### 语法\n\nbase64Encode(X)\n\n#### 详情\n\n将 *X* 转换为 Base64 编码格式。\n\n#### 参数\n\n**X** 字符串标量或向量。\n\n#### 返回值\n\n字符串标量或向量。\n\n#### 例子\n\n```\nbase64Encode(`hello) \n// output\naGVsbG8=\n\nbase64Encode(`hello`world) \n// output\n[\"aGVsbG8=\",\"d29ybGQ=\"]\n\nbase64Encode(\"\")\n// output\n\"\"\n```\n\n相关函数：[base64Decode](https://docs.dolphindb.cn/zh/funcs/b/base64Decode.html)\n"
    },
    "beta": {
        "url": "https://docs.dolphindb.cn/zh/funcs/b/beta.html",
        "signatures": [
            {
                "full": "beta(Y, X)",
                "name": "beta",
                "parameters": [
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [beta](https://docs.dolphindb.cn/zh/funcs/b/beta.html)\n\n\n\n#### 语法\n\nbeta(Y, X)\n\n#### 详情\n\n返回 *Y* 在 *X* 上的回归系数的最小二乘估计。\n\n与 Python 中 `scipy.stats.beta` 的区别：`scipy.stats.beta` 是 beta 连续概率分布对象，可用于概率密度、分布函数、随机数等计算；DolphinDB 的 `beta` 是统计回归函数，返回 *Y* 对 *X* 的 OLS 回归系数。\n\n与 Python TA-Lib 中 `BETA` 的区别：TA-Lib 的 `BETA(high, low, timeperiod=5)` 是基于窗口的技术分析指标，DolphinDB 的 `beta(Y, X)` 对整段输入一次性计算 OLS 回归系数。若需要实现 TA-Lib 的 `BETA` 指标，可使用 DolphinDB TA 模块中的 `ta::beta`。\n\n#### 参数\n\n**Y** 和 **X** 是相同长度的数值型向量、维度相同的矩阵或表。若 *X* 是表，只对其内数值型和布尔型的列进行计算。\n\n#### 返回值\n\nDOUBLE 类型标量/向量/表。\n\n#### 例子\n\n```\nx=1 3 5 7 11 16 23\ny=0.1 4.2 5.6 8.8 22.1 35.6 77.2;\n\nbeta(y,x);\n// output\n3.378632\n```\n"
    },
    "between": {
        "url": "https://docs.dolphindb.cn/zh/funcs/b/between.html",
        "signatures": [
            {
                "full": "between(X, Y)",
                "name": "between",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [between](https://docs.dolphindb.cn/zh/funcs/b/between.html)\n\n\n\n#### 语法\n\nbetween(X, Y)\n\n#### 详情\n\n检查 *X* 的每个元素是否在 *Y* 确定的范围内（两个边界都是包含在内的）。返回结果的长度或维度与 *X* 相同。\n\n#### 参数\n\n**X** 可以是标量、数据对、向量或矩阵；\n\n**Y** 是一个表示范围的数据对。\n\n#### 返回值\n\n布尔类型，其数据形式同 *X*。\n\n#### 例子\n\n```\nbetween([1, 5.5, 6, 8], 1:6);\n// output\n[1,1,1,0]\n// 1, 5.5 和 6 在 1 和 6 之间，但 8 不是。\n\nbetween(1 2.4 3.6 2 3.9, 2.4:3.6);\n// output\n[0,1,1,0,0]\n```\n\n`between` 可以搭配 `select` 使用，用于筛选列的范围：\n\n```\nt = table(`abb`aac`aaa as sym, 1.8 2.3 3.7 as price);\nselect * from t where price between 1:3;\n```\n\n| sym | price |\n| --- | ----- |\n| abb | 1.8   |\n| aac | 2.3   |\n\n下例说明数据对 a:b 中出现空值的处理方式。若配置 *nullAsMinValueForComparison* =true，则 NULL 值当同数据类型的而最小值处理， 若配置 *nullAsMinValueForComparison* =false，则 NULL 值仍保留为 NULL。也可以使用 [nullCompare](https://docs.dolphindb.cn/zh/funcs/ho_funcs/nullCompare.html) 函数，无论 *nullAsMinValueForComparison* 设置为何值都保留 NULL 值。\n\n```\nbetween(10,:10)\n// output\ntrue      // 配置 nullAsMinValueForComparison=true 时的返回结果\nbetween(10,:10)\n// output\nNULL     // 配置 nullAsMinValueForComparison=false 时的返回结果\nnullCompare(between, 10, :10)\n// output\nNULL\n```\n"
    },
    "bfill": {
        "url": "https://docs.dolphindb.cn/zh/funcs/b/bfill.html",
        "signatures": [
            {
                "full": "bfill(obj, [limit])",
                "name": "bfill",
                "parameters": [
                    {
                        "full": "obj",
                        "name": "obj"
                    },
                    {
                        "full": "[limit]",
                        "name": "limit",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [bfill](https://docs.dolphindb.cn/zh/funcs/b/bfill.html)\n\n\n\n#### 语法\n\nbfill(obj, \\[limit])\n\n#### 详情\n\n* 如果 *obj*是向量，则使用空值后的第一个非空元素来填充空值。\n* 如果 *obj* 是数组向量：\n  * 对于每一行，如果该行为空，则用该行后的第一个非空行填充。\n  * 对于某一列中的空值，使用该列中空值后的第一个非空元素填充。\n* 如果 *obj*是矩阵或表，则对每一列按照上述规则进行填充。\n\n该函数会返回一个新的对象，不会改变输入的对象。函数 [bfill!](https://docs.dolphindb.cn/zh/funcs/b/bfill_.html) 会改变输入的对象。\n\n#### 参数\n\n**obj** 可以是向量、数组向量、矩阵或表。\n\n**limit** 是正整数，表示最大可填充的连续空值个数。*obj* 为数组向量时不支持该参数。\n\n#### 返回值\n\n返回填充空缺值后的对象，其类型与形式同 *obj*。\n\n#### 例子\n\n```\nx=1 2 3 NULL NULL NULL 4 5 6\nx.bfill();\n// output\n[1,2,3,4,4,4,4,5,6]\n\nx=1 2 3 NULL NULL NULL 4 5 6\nx.bfill(1);\n// output\n[1,2,3,,,4,4,5,6]\n\nx.bfill!(2);\nx;\n// output\n[1,2,3,,4,4,4,5,6]\n\ndate=[2012.06.12,2012.06.12,2012.06.13,2012.06.14,2012.06.15]\nsym=[\"IBM\",\"MSFT\",\"IBM\",\"MSFT\",\"MSFT\"]\nprice=[,,26.56,,50.76]\nqty=[,,4500,5600,6800]\ntimestamp=[09:34:07,09:35:26,09:36:42,09:36:51,09:36:59]\nt=table(date,timestamp,sym,price,qty)\nt;\n```\n\n| date       | timestamp | sym  | price | qty  |\n| ---------- | --------- | ---- | ----- | ---- |\n| 2012.06.12 | 09:34:07  | IBM  |       |      |\n| 2012.06.12 | 09:35:26  | MSFT |       |      |\n| 2012.06.13 | 09:36:42  | IBM  | 26.56 | 4500 |\n| 2012.06.14 | 09:36:51  | MSFT |       | 5600 |\n| 2012.06.15 | 09:36:59  | MSFT | 50.76 | 6800 |\n\n```\nt.bfill()\n```\n\n| date       | timestamp | sym  | price | qty  |\n| ---------- | --------- | ---- | ----- | ---- |\n| 2012.06.12 | 09:34:07  | IBM  | 26.56 | 4500 |\n| 2012.06.12 | 09:35:26  | MSFT | 26.56 | 4500 |\n| 2012.06.13 | 09:36:42  | IBM  | 26.56 | 4500 |\n| 2012.06.14 | 09:36:51  | MSFT | 50.76 | 5600 |\n| 2012.06.15 | 09:36:59  | MSFT | 50.76 | 6800 |\n\n```\nselect date, timestamp, sym, price.bfill() as price, qty.bfill() as qty from t context by sym;\n```\n\n| date       | timestamp | sym  | price | qty  |\n| ---------- | --------- | ---- | ----- | ---- |\n| 2012.06.12 | 09:34:07  | IBM  | 26.56 | 4500 |\n| 2012.06.13 | 09:36:42  | IBM  | 26.56 | 4500 |\n| 2012.06.12 | 09:35:26  | MSFT | 50.76 | 5600 |\n| 2012.06.14 | 09:36:51  | MSFT | 50.76 | 5600 |\n| 2012.06.15 | 09:36:59  | MSFT | 50.76 | 6800 |\n\n下例中，数组向量 x 的第三行为空，因此使用第四行 \\[8, 9, 10] 对其进行填充；第三列的第一个元素为空，故用该列中其后的第一个非空元素（10） 进行填充。\n\n```\nx = array(INT[], 0).append!([1 2 NULL, 4 5, NULL, 8 9 10])\nx\n// output:[[1,2,NULL],[4,5],[NULL],[8,9,10]]\nbfill(x)\n// output:[[1,2,10],[4,5],[8,9,10],[8,9,10]]\n```\n"
    },
    "bfill!": {
        "url": "https://docs.dolphindb.cn/zh/funcs/b/bfill_.html",
        "signatures": [
            {
                "full": "bfill!(obj, [limit])",
                "name": "bfill!",
                "parameters": [
                    {
                        "full": "obj",
                        "name": "obj"
                    },
                    {
                        "full": "[limit]",
                        "name": "limit",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [bfill!](https://docs.dolphindb.cn/zh/funcs/b/bfill_.html)\n\n\n\n#### 语法\n\nbfill!(obj, \\[limit])\n\n#### 详情\n\n* 如果*obj*是一个向量，使用 NULL 值后的非空元素来填充 NULL 值。\n* 如果*obj*是一个表，对于表中的每一列，使用 NULL 值后的非空元素来填充 NULL 值。\n\n#### 参数\n\n**obj** 可以是向量或表。\n\n**limit** 是正整数，表示需要填充的 NULL 值的数量。\n\n#### 返回值\n\n返回填充空缺值后的对象，其类型与形式同 *obj*。\n\n#### 例子\n\n```\nx=1 2 3 NULL NULL NULL 4 5 6\nx.bfill!()\nx;\n// output\n[1,2,3,4,4,4,4,5,6]\n\nx=1 2 3 NULL NULL NULL 4 5 6\nx.bfill!(1)\nx;\n// output\n[1,2,3,,,4,4,5,6]\n\ndate=[2012.06.12,,2012.06.13,2012.06.14,2012.06.15]\nsym=[\"IBM\",\"MSFT\",\"IBM\",\"MSFT\",\"MSFT\"]\nprice=[40.56,26.56,,,50.76]\nqty=[2200,4500,1200,5600,]\ntimestamp=[09:34:07,,09:36:42,09:36:51,09:36:59]\nt=table(date,timestamp,sym,price,qty)\n\nbfill!(t)\nt\n```\n\n| date       | timestamp | sym  | price | qty  |\n| ---------- | --------- | ---- | ----- | ---- |\n| 2012.06.12 | 09:34:07  | IBM  | 40.56 | 2200 |\n| 2012.06.13 | 09:36:42  | MSFT | 26.56 | 4500 |\n| 2012.06.13 | 09:36:42  | IBM  | 50.76 | 1200 |\n| 2012.06.14 | 09:36:51  | MSFT | 50.76 | 5600 |\n| 2012.06.15 | 09:36:59  | MSFT | 50.76 |      |\n\n如果只需要填充表中的某些列，需要使用 [update](https://docs.dolphindb.cn/zh/progr/sql/update.html) 语句和 [bfill](https://docs.dolphindb.cn/zh/funcs/b/bfill.html) 函数。具体请参考 [bfill](https://docs.dolphindb.cn/zh/funcs/b/bfill.html) 的例子。\n"
    },
    "bigarray": {
        "url": "https://docs.dolphindb.cn/zh/funcs/b/bigarray.html",
        "signatures": [
            {
                "full": "bigarray(dataType|template, [initialSize], [capacity], [defaultValue])",
                "name": "bigarray",
                "parameters": [
                    {
                        "full": "dataType|template",
                        "name": "dataType|template"
                    },
                    {
                        "full": "[initialSize]",
                        "name": "initialSize",
                        "optional": true
                    },
                    {
                        "full": "[capacity]",
                        "name": "capacity",
                        "optional": true
                    },
                    {
                        "full": "[defaultValue]",
                        "name": "defaultValue",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [bigarray](https://docs.dolphindb.cn/zh/funcs/b/bigarray.html)\n\n\n\n#### 语法\n\nbigarray(dataType|template, \\[initialSize], \\[capacity], \\[defaultValue])\n\n#### 详情\n\n大数组是专门为进行大数据分析的用户设计的。常规的数组使用连续的内存。如果没有足够的连续内存，就会产生内存不足的异常。大数组由许多小的内存块组成，而不是一个大的内存块。所以，大数组缓解了内存碎片问题。但这可能会对某些操作造成轻微的性能损失。对于多数不需要担心内存碎片问题的用户而言，应该使用常规数组，而不是大数组。\n\n大数组的最小容量是 16 MB。用户可以用 `bigarray` 函数声明一个大数组。\n\n操作大数组的方法和操作一个常规数组一样。\n\n当我们调用 [array](https://docs.dolphindb.cn/zh/funcs/a/array.html) 函数时，如果没有足够的连续内存块，或数组占据的内存超过了一个特定的阈值（默认的阈值是 2048 MB），系统会改为创建一个大数组。\n\n#### 参数\n\n**dataType** 是大数组的数据类型。\n\n**template** 是已有的向量。已有的向量作为模板，它的数据类型决定了新的大数组的数据类型。\n\n**initialSize** 是正整数，表示大数组的初始长度，即该大数组新建时的元素数量。如果第一个参数是数据类型，*initialSize*是必需参数。如果第一个参数是已有的大数组，*initialSize*是可选参数。\n\n**capacity** 是正整数，表示大数组的容量，即该大数组新建时系统为该大数组分配的内存（以元素数为单位）。当元素数超过 *capacity* 时，系统会自动扩充容量。系统首先会分配当前容量1.2\\~2倍的内存，然后复制数据到新的内存空间，最后释放原来的内存。\n\n**defaultValue** 是大数组的默认值。如果不指定默认值，对于多数数据类型，默认值是 0。对于字符串和符号（Symbol），默认值是 NULL。\n\n#### 返回值\n\n返回一个大数组，其数据类型同 *dataType*/*template*。\n\n#### 例子\n\n```\nx=bigarray(INT,10,10000000);\nx;\n// output\n[0,0,0,0,0,0,0,0,0,0]\n\n// 默认值设为 1\nx=bigarray(INT,10,10000000,1);\nx;\n// output\n[1,1,1,1,1,1,1,1,1,1]\n\nx=bigarray(INT,0,10000000).append!(1..100);\nx[0];\n// output\n1\nsum x;\n// output\n5050\n\nx[x>50&&x<60];\n// output\n[51,52,53,54,55,56,57,58,59]\n\nx=array(DOUBLE, 40000000);\ntypestr x;\n// output\nHUGE DOUBLE VECTOR\n```\n\n数组和大数组的性能比较：\n\n```\n// 对于顺序操作，数组和大数组的表现几乎相同。\nn=20000000\nx=rand(10000, n)\ny=rand(1.0, n)\nbx= bigarray(INT, 0, n).append!(x)\nby= bigarray(DOUBLE,0,n).append!(y);\n\ntimer(100) wavg(x,y);\n// output\nTime elapsed: 4869.74 ms\ntimer(100) wavg(bx,by);\n// output\nTime elapsed: 4762.89 ms\n\ntimer(100) x*y;\n// output\nTime elapsed: 7525.22 ms\ntimer(100) bx*by;\n// output\nTime elapsed: 7791.83 ms\n\n// 对于随机访问，大数组有轻微的性能损失。\nindices = shuffle 0..(n-1);\ntimer(10) x[indices];\n// output\nTime elapsed: 2942.29 ms\ntimer(10) bx[indices];\n// output\nTime elapsed: 3547.22 ms\n```\n"
    },
    "binaryExpr": {
        "url": "https://docs.dolphindb.cn/zh/funcs/b/binaryExpr.html",
        "signatures": [
            {
                "full": "binaryExpr(X, Y, optr)",
                "name": "binaryExpr",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "optr",
                        "name": "optr"
                    }
                ]
            }
        ],
        "markdown": "### [binaryExpr](https://docs.dolphindb.cn/zh/funcs/b/binaryExpr.html)\n\n\n\n#### 语法\n\nbinaryExpr(X, Y, optr)\n\n#### 详情\n\n使用 *optr* 指定的二元运算符，将 *X* 与 *Y* 连接，生成一个二元运算的元代码。使用 [eval](https://docs.dolphindb.cn/zh/funcs/e/eval.html) 函数可以执行 `binaryExpr` 函数生成的元代码。\n\n#### 参数\n\n**X** 可以是一个标量/向量/矩阵。\n\n**Y** 可以是一个标量或者和 *X* 具有相同类型的量。\n\n**optr** 是一个二元运算符。\n\n#### 返回值\n\nCODE 类型元代码。\n\n#### 例子\n\n```\nbinaryExpr(1, 1, +).eval()\n// output\n2\n\nbinaryExpr(1 2.2 3, 1 2 3, *).eval()\n// output\n[1 4.4 9]\n\nbinaryExpr(`id`st`nm, `fff, +).eval()\n// output\n[\"idfff\",\"stfff\",\"nmfff\"]\n\n\na = matrix(1 2, 3 4)\nb = matrix(4 2, 5 1)\nbinaryExpr(a, b, dot).eval()\n```\n\n| #0 | #1 |\n| -- | -- |\n| 10 | 8  |\n| 16 | 14 |\n\n相关函数： [unifiedExpr](https://docs.dolphindb.cn/zh/funcs/u/unifiedExpr.html)\n"
    },
    "binsrch": {
        "url": "https://docs.dolphindb.cn/zh/funcs/b/binsrch.html",
        "signatures": [
            {
                "full": "binsrch(X, Y)",
                "name": "binsrch",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [binsrch](https://docs.dolphindb.cn/zh/funcs/b/binsrch.html)\n\n\n\n#### 语法\n\nbinsrch(X, Y)\n\n#### 详情\n\n`binsrch` 即二分查找。对于每一个 *Y* 中的元素，`binsrch` 确定它在 *X* 中的位置。如果没有找到，返回 -1。\n\n为了充分发挥性能，应当使用 `binsrch` 在一个有序的长向量 *X* 中查找一个较短的 *Y*。要在一个长的未排序的向量中查找一个较长向量，应当使用 [find](https://docs.dolphindb.cn/zh/funcs/f/find.html) 函数，后者使用散列表实现。但是构造一个散列表会花一些时间和内存。另外也请参见相关函数 [in](https://docs.dolphindb.cn/zh/funcs/i/in.html)。\n\n#### 参数\n\n**X** 必须是一个递增向量；\n\n**Y** 可以是标量、向量、元组、数组向量、矩阵、字典、表。\n\n#### 返回值\n\nINT 类型，其数据形式同 *Y*。\n\n#### 例子\n\n```\n1..100 binsrch 12 6 88 102;\n// output\n[11,5,87,-1]\n```\n"
    },
    "bitAnd": {
        "url": "https://docs.dolphindb.cn/zh/funcs/b/bitAnd.html",
        "signatures": [
            {
                "full": "bitAnd(X, Y)",
                "name": "bitAnd",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [bitAnd](https://docs.dolphindb.cn/zh/funcs/b/bitAnd.html)\n\n\n\n#### 语法\n\nbitAnd(X, Y)或 X & Y\n\n#### 详情\n\n返回位运算与（`bitAnd`）的结果。\n\n#### 参数\n\n**X** 和 **Y** 可以是数值型的标量，向量，矩阵，或数据表。\n\n#### 返回值\n\n数值类型标量/向量/矩阵/表。\n\n#### 例子\n\n```\nx=1 0 1;\ny=0 1 1;\nx&y;\n// output\n[0,0,1]\n```\n"
    },
    "bitNot": {
        "url": "https://docs.dolphindb.cn/zh/funcs/b/bitNot.html",
        "signatures": [
            {
                "full": "bitNot(X)",
                "name": "bitNot",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [bitNot](https://docs.dolphindb.cn/zh/funcs/b/bitNot.html)\n\n\n\n#### 语法\n\nbitNot(X)\n\n#### 详情\n\n返回按位取反的结果。\n\n#### 参数\n\n**X** 可以是数值型的标量，向量，矩阵，或数据表。\n\n#### 返回值\n\n数值类型，其数据形式同 *X*。\n\n#### 例子\n\n```\nbitNot(3)\n// output\n-4\n\nav = array\\(INT\\[\\], 0, 10\\).append!\\(\\[1 2 3, 4 5\\]\\)\nbitNot\\(av\\)\n// output\n\\[\\[-2,-3,-4\\],\\[-5,-6\\]\\]\n```\n"
    },
    "bitOr": {
        "url": "https://docs.dolphindb.cn/zh/funcs/b/bitOr.html",
        "signatures": [
            {
                "full": "bitOr(X, Y)",
                "name": "bitOr",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [bitOr](https://docs.dolphindb.cn/zh/funcs/b/bitOr.html)\n\n\n\n#### 语法\n\nbitOr(X, Y) 或 X | Y\n\n#### 详情\n\n返回位运算或（`bitOr`）的结果。\n\n#### 参数\n\n**X** 和 **Y** 可以是数值型的标量，向量，矩阵，或数据表。\n\n#### 返回值\n\n数值类型标量/向量/矩阵/表。\n\n#### 例子\n\n```\nx=1 0 1;\ny=0 1 1;\nx | y;\n// output\n[1,1,1]\n```\n"
    },
    "bitXor": {
        "url": "https://docs.dolphindb.cn/zh/funcs/b/bitXor.html",
        "signatures": [
            {
                "full": "bitXor(X, Y)",
                "name": "bitXor",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [bitXor](https://docs.dolphindb.cn/zh/funcs/b/bitXor.html)\n\n\n\n#### 语法\n\nbitXor(X, Y) 或 X ^ Y\n\n#### 详情\n\n返回位运算异或（`bitXOr`）的结果。\n\n#### 参数\n\n**X** 和 **Y** 可以是数值型的标量，向量，矩阵，或数据表。\n\n#### 返回值\n\n数值类型标量/向量/矩阵/表。\n\n#### 例子\n\n```\nx=1 0 1;\ny= 0 1 1;\nx^y;\n// output\n[1,1,0]\n```\n"
    },
    "blob": {
        "url": "https://docs.dolphindb.cn/zh/funcs/b/blob.html",
        "signatures": [
            {
                "full": "blob(X)",
                "name": "blob",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [blob](https://docs.dolphindb.cn/zh/funcs/b/blob.html)\n\n\n\n#### 语法\n\nblob(X)\n\n#### 详情\n\n将一个字符串转为 BLOB 类型。\n\n注意：\n\n* BLOB 类型不支持任何计算。\n\n#### 参数\n\n**X** 是一个字符串标量或向量。\n\n#### 返回值\n\nBLOB 类型标量或向量。\n\n#### 例子\n\n```\nstr=\"hello\"\nblob(str)\n// output\nhello\n\nt=table(1..10 as id, \"A\"+string(1..10) as sym, 2012.01.01..2012.01.10 as date, rand(100.0, 10) as val, rand(uuid(), 10) as uid)\nstr=toJson(t)\nblob(str)\n```\n\n通过 `blob` 将超长字符串转为 BLOB 类型后，可作为内存表的一个字段使用：\n\n```\nd = dict(1..10000,  rand(1.0, 10000))\nstr=toStdJson(d);\nt=table(blob(str) as jsonStr)\n```\n\nTSDB 引擎的分布式表也支持变长字符 BLOB 类型：\n\n```\ndbPath=\"dfs://testBlobDB\"\nif(existsDatabase(dbPath)){\ndropDatabase(dbPath)\n}\nn=2000000\nt=table(n:0,`date`id`type`num`blob,[DATETIME,INT,SYMBOL,DOUBLE,BLOB])\ndb1=database(\"\",VALUE,2020.01.01..2020.01.10)\ndb2=database(\"\",HASH,[INT,10])\n\ndb=database(directory=dbPath,partitionType=COMPO,partitionScheme=[db1,db2],engine='TSDB')\npt1=createPartitionedTable(dbHandle=db,table=t,tableName=`pt1,partitionColumns=`date`id,sortColumns=`type)\n\ndate=concatDateTime(take(2020.01.01..2020.01.10,n),take(00:00:00..23:23:59,n))\nid=rand(1..1000,n)\ntype=rand(`A`B`C`D`E,n)\nnum=rand(100.0,n)\n\nblob=take(blob(string(1..10)),n)\n\nt1=table(date,id,type,num,blob)\npt1.append!(t1)\nselect *  from pt1\n```\n"
    },
    "bondAccrInt": {
        "url": "https://docs.dolphindb.cn/zh/funcs/b/bondaccrint.html",
        "signatures": [
            {
                "full": "bondAccrInt(start, maturity, issuePrice, coupon, frequency, dayCountConvention, bondType, settlement, [benchmark='Excel'])",
                "name": "bondAccrInt",
                "parameters": [
                    {
                        "full": "start",
                        "name": "start"
                    },
                    {
                        "full": "maturity",
                        "name": "maturity"
                    },
                    {
                        "full": "issuePrice",
                        "name": "issuePrice"
                    },
                    {
                        "full": "coupon",
                        "name": "coupon"
                    },
                    {
                        "full": "frequency",
                        "name": "frequency"
                    },
                    {
                        "full": "dayCountConvention",
                        "name": "dayCountConvention"
                    },
                    {
                        "full": "bondType",
                        "name": "bondType"
                    },
                    {
                        "full": "settlement",
                        "name": "settlement"
                    },
                    {
                        "full": "[benchmark='Excel']",
                        "name": "benchmark",
                        "optional": true,
                        "default": "'Excel'"
                    }
                ]
            }
        ],
        "markdown": "### [bondAccrInt](https://docs.dolphindb.cn/zh/funcs/b/bondaccrint.html)\n\n\n\n#### 语法\n\nbondAccrInt(start, maturity, issuePrice, coupon, frequency, dayCountConvention, bondType, settlement, \\[benchmark='Excel'])\n\n别名：fiAccrInt\n\n#### 详情\n\n计算债券的应计利息（Accrued Interest）。应计利息是指债券自上一次付息日至交易结算日之间累积的未付利息。\n\n应计利息（Accrued Interest）常用来计算净价（Clean Price）。相关计算公式为：净价（Clean Price）= 全价（Dirty Price）- 应计利息（Accrued Interest）。\n\n#### 参数\n\n注意：所有输入向量必须等长，输入标量将自动扩展以匹配其它向量的长度。\n\n**start** DATE 类型标量或向量，表示债券的起息日。\n\n**maturity** 与 *start* 等长的 DATE 类型标量或向量，表示债券的到期日。\n\n**issuePrice** 与 *start* 等长的数值型标量或向量，表示债券的发行价格。贴现债需指定真实发行价（通常小于100）；其他债券通常为100。\n\n**coupon** 数值型标量或向量，表示债券的票面利率。例如 0.03，表示票息为 3%。\n\n**frequency** 整型或 STRING 类型的标量或向量，表示债券的付息频率。可选值为：\n\n* 0/“Once”：到期一次还本付息\n* 1/“Annual”：每年付息一次\n* 2/“Semiannual：每半年付息一次\n* 4/“Quarterly”：每季度付息一次\n* 12/“Monthly”：每月付息一次\n\n**dayCountConvention** STRING 类型的标量或向量，表示债券的计息日数惯例。可选值为：\n\n* \"Thirty360US\"：US (NASD) 30/360\n* \"ActualActualISMA\"：实际/实际（ISMA 规则）\n* \"Actual360\"：实际/360\n* \"Actual365\"：实际/365\n* \"Thirty360EU\"：欧洲 30/360\n* \"ActualActualISDA\"：实际/实际（ISDA 规则）\n\n**bondType** STRING 类型标量或向量，表示债券的类型。可选值为：\n\n* \"FixedRate\"：固定利率债券，定期按息票利率支付利息。\n* \"Discount\"：贴现债券，没有利息支付，以贴现方式发行的债券，期末FV=面值。\n* \"ZeroCoupon\"：零息债券，期末一次性支付利息和面值，期末FV=面值+利息。\n\n**settlement** DATE 类型标量或向量，表示债券的结算日，即购买日期。\n\n**benchmark** 可选参数，STRING 类型标量，表示算法参考基准。目前仅支持 “Excel”（excel 中的算法）。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n假设有一张面值为 1000 的债券，购买日期为 2024 年 1 月 1 日，到期日期为 2030 年 12 月 31 日，年息票利率为 10%，每年付息 2 次（半年付息），以 US (NASD) 30/360 为日计数基准。\n\n```\nbondAccrInt(start=2024.01.01, maturity=2030.12.31, issuePrice=100, coupon=0.1, frequency=2, dayCountConvention=\"Thirty360US\", bondType=\"FixedRate\", settlement=2024.05.15)\n\n// output: 3.75\n```\n\n**相关函数**：[bondCalculator](https://docs.dolphindb.cn/zh/funcs/b/bondCalculator.html)\n"
    },
    "bondCalculator": {
        "url": "https://docs.dolphindb.cn/zh/funcs/b/bondCalculator.html",
        "signatures": [
            {
                "full": "bondCalculator(start, maturity, issuePrice, coupon, frequency, dayCountConvention, bondType, calendar, businessDayConvention, settlement, price, priceType, [calcRisk=false], [benchmark='Qeubee'])",
                "name": "bondCalculator",
                "parameters": [
                    {
                        "full": "start",
                        "name": "start"
                    },
                    {
                        "full": "maturity",
                        "name": "maturity"
                    },
                    {
                        "full": "issuePrice",
                        "name": "issuePrice"
                    },
                    {
                        "full": "coupon",
                        "name": "coupon"
                    },
                    {
                        "full": "frequency",
                        "name": "frequency"
                    },
                    {
                        "full": "dayCountConvention",
                        "name": "dayCountConvention"
                    },
                    {
                        "full": "bondType",
                        "name": "bondType"
                    },
                    {
                        "full": "calendar",
                        "name": "calendar"
                    },
                    {
                        "full": "businessDayConvention",
                        "name": "businessDayConvention"
                    },
                    {
                        "full": "settlement",
                        "name": "settlement"
                    },
                    {
                        "full": "price",
                        "name": "price"
                    },
                    {
                        "full": "priceType",
                        "name": "priceType"
                    },
                    {
                        "full": "[calcRisk=false]",
                        "name": "calcRisk",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[benchmark='Qeubee']",
                        "name": "benchmark",
                        "optional": true,
                        "default": "'Qeubee'"
                    }
                ]
            }
        ],
        "markdown": "### [bondCalculator](https://docs.dolphindb.cn/zh/funcs/b/bondCalculator.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nbondCalculator(start, maturity, issuePrice, coupon, frequency, dayCountConvention, bondType, calendar, businessDayConvention, settlement, price, priceType, \\[calcRisk=false], \\[benchmark='Qeubee'])\n\n#### 详情\n\n该函数用于实现债券到期收益率、净价和全价三者之间的互算，同时支持计算久期、凸度等风险指标。\n\n#### 参数\n\n注意：所有输入向量必须等长，输入标量将自动扩展以匹配其它向量的长度。\n\n**start**DATE 类型标量或向量，表示债券的起息日。\n\n**maturity**与 *start* 等长的 DATE 类型标量或向量，表示债券的到期日。\n\n**issuePrice**与 *start* 等长的数值型标量或向量，表示债券的发行价格。贴现债需指定真实发行价（通常小于100）；其他债券通常为100。\n\n**coupon**数值型标量或向量，表示债券的票面利率。例如 0.03，表示票息为 3%。\n\n**frequency**整型或 STRING 类型的标量或向量，表示债券的付息频率。可选值为：\n\n* 0/“Once”：到期一次还本付息\n* 1/“Annual”：每年付息一次\n* 2/“Semiannual：每半年付息一次\n* 4/“Quarterly”：每季度付息一次\n* 12/“Monthly”：每月付息一次\n\n**dayCountConvention**STRING 类型的标量或向量，表示债券的计息日数惯例。可选值为：\n\n* \"Thirty360US\"：US (NASD) 30/360\n* \"ActualActualISMA\"：实际/实际 （ISMA 规则）\n* \"Actual360\"：实际/360\n* \"Actual365\"：实际/365\n* \"Thirty360EU\"：欧洲 30/360\n* \"ActualActualISDA\"：实际/实际 （ISDA 规则）\n\n**bondType**STRING 类型标量或向量，表示债券的类型。可选值为：\n\n* \"FixedRate\"：固定利率债券，定期按息票利率支付利息。\n* \"Discount\"：贴现债券，没有利息支付，以贴现方式发行的债券，期末FV=面值。\n* \"ZeroCoupon\"：零息债券，期末一次性支付利息和面值，期末FV=面值+利息。\n\n**calendar**STRING 类型标量，表示使用的交易日历。目前仅支持 “CFET”，表示中国人民银行债券交易日历（以 .IB 结尾的债券）。\n\n**businessDayConvention**STRING 类型的标量，表示把非工作日调整到工作日的方法。目前仅支持 “Unadjusted”，表示不作调整。\n\n**settlement**DATE 类型标量或向量，表示债券的结算日，即购买日期。\n\n**price**数值型标量或向量，具体含义取决于 priceType 的取值：\n\n* 当 *priceType* 为 \"YTM\" 时，*price* 表示债券的到期收益率；\n* 当 *priceType* 为 \"CleanPrice\" 时，*price* 表示债券的净价；\n* 当 *priceType* 为 \"DirtyPrice\" 时，*price* 表示债券的全价。\n\n**priceType**STRING 类型的标量或向量，用于指定债券价格类型，可选值为：\n\n* \"YTM\"：到期收益率\n* \"CleanPrice\"：净价\n* \"DirtyPrice\"：全价\n\n**calcRisk**可选参数，布尔值，默认为 false，只计算输出全价、净价、应计利息和收益率。若设置为 true，除上述4项外，还会计算并输出麦考利久期、修正久期、凸度、基点价值。\n\n**benchmark**可选参数，STRING 类型标量，表示算法参考基准。目前仅支持 “Qeubee”（国内债券算法）。\n\n#### 返回值\n\n字典或元组。\n\n#### 例子\n\n例1. 计算固定利率债券的价格、到期收益率、应计利息和风险指标。\n\n```\nbondCalculator(start=2022.07.15, maturity=2072.07.15, issuePrice=100, coupon=0.034, frequency=\"Semiannual\", dayCountConvention=\"ActualActualISMA\", bondType=\"FixedRate\", calendar=\"CFET\", businessDayConvention=\"Unadjusted\", settlement=2025.04.10, price=0.02, priceType=\"YTM\", calcRisk=true);\n\n/* Output:\npvbp->0.3902\nytm->0.0200\nmacaulayDuration->27.4761\ndirtyPrice->143.4689\naccruedInterest->0.7983\ncleanPrice->142.6705\nmodifiedDuration->27.2041\nconvexity->1025.4003\n*/\n\n\nbondCalculator(start=2022.07.15, maturity=2072.07.15, issuePrice=100, coupon=0.034, frequency=\"Semiannual\", dayCountConvention=\"ActualActualISMA\", bondType=\"FixedRate\", calendar=\"CFET\", businessDayConvention=\"Unadjusted\", settlement=2072.04.18, price=100.2143, priceType=\"CleanPrice\", calcRisk=false);\n\n/* Output:\naccruedInterest->0.8780\ncleanPrice->100.2143\nytm->0.0250\ndirtyPrice->101.0923\n*/\n```\n\n例2. 计算零息债券的价格、到期收益率、应计利息和风险指标。\n\n```\nbondCalculator(start=2025.01.09, maturity=2026.02.05, issuePrice=100, coupon=0.0119, frequency=\"Annual\", dayCountConvention=\"ActualActualISMA\", bondType=\"ZeroCoupon\", calendar=\"CFET\", businessDayConvention=\"Unadjusted\", settlement=2025.04.10, price=0.025, priceType=\"YTM\", calcRisk=true);\n\n/* Output:\npvbp->0.0080\nytm->0.0250\nmacaulayDuration->0.8246\ndirtyPrice->99.2322\naccruedInterest->0.2966\ncleanPrice->98.9355\nmodifiedDuration->0.8079\nconvexity->1.3057\n*/\n```\n\n例3. 计算贴现债券的价格、到期收益率、应计利息和风险指标。\n\n```\nbondCalculator(start=2025.02.13, maturity=2025.05.15, issuePrice=99.663, coupon=0.0, frequency=\"Once\", dayCountConvention=\"ActualActualISMA\", bondType=\"Discount\", calendar=\"CFET\", businessDayConvention=\"Unadjusted\", settlement=2025.04.10, price=0.02, priceType=\"YTM\", calcRisk=true);\n\n/* Output:\npvbp->0.0009\nytm->0.0200\nmacaulayDuration->0.0958\ndirtyPrice->99.8085\naccruedInterest->0.2073\ncleanPrice->99.6012\nmodifiedDuration->0.0957\nconvexity->0.0183\n*/  \n```\n\n例4. 同时计算多种债券的价格、到期收益率、应计利息和风险指标。\n\n```\nresult = bondCalculator(start=[2025.02.13, 2025.01.09, 2022.07.15], maturity=[2025.05.15, 2026.02.05, 2072.07.15], issuePrice=[99.663, 100, 100], coupon=[0.0, 0.0119, 0.034], frequency=[\"Once\", \"Annual\", \"Semiannual\"], dayCountConvention=[\"ActualActualISMA\", \"ActualActualISMA\", \"ActualActualISMA\"], bondType=[\"Discount\", \"ZeroCoupon\", \"FixedRate\"], calendar=[\"CFET\", \"CFET\", \"CFET\"], businessDayConvention=[\"Unadjusted\", \"Unadjusted\", \"Unadjusted\"], settlement=[2025.04.10, 2025.04.10, 2072.04.18], price=[0.02, 0.025, 100.2143], priceType=[\"YTM\", \"YTM\", \"CleanPrice\"], calcRisk=true);\n\nprint result\n\n/* Output:\n(dirtyPrice->99.808586272901294\ncleanPrice->99.601201657516682\nytm->0.02\naccruedInterest->0.207384615384617\nmacaulayDuration->0.095890410958904\nmodifiedDuration->0.095706863549357\nconvexity->0.018319607460911\npvbp->0.000955236674747\n,dirtyPrice->99.232212603180983\ncleanPrice->98.935527671674137\nytm->0.025\naccruedInterest->0.296684931506849\nmacaulayDuration->0.824657534246575\nmodifiedDuration->0.80799946312328\nconvexity->1.305726264815019\npvbp->0.008017957450791\n,dirtyPrice->101.092321978021971\ncleanPrice->100.214299999999994\nytm->0.025000792220527\naccruedInterest->0.878021978021978\nmacaulayDuration->0.240437158469945\nmodifiedDuration->0.239000497930427\nconvexity->0.114242476021984\npvbp->0.002416111528969\n)\n*/ \n```\n\n相关函数：[bondAccrInt](https://docs.dolphindb.cn/zh/funcs/b/bondaccrint.html)、[bondConvexity](https://docs.dolphindb.cn/zh/funcs/b/bondconvexity.html)、[bondDirtyPrice](https://docs.dolphindb.cn/zh/funcs/b/bondDirtyPrice.html)、[bondDuration](https://docs.dolphindb.cn/zh/funcs/b/bondDuration.html)、[bondYield](https://docs.dolphindb.cn/zh/funcs/b/bondyield.html)\n"
    },
    "bondCashflow": {
        "url": "https://docs.dolphindb.cn/zh/funcs/b/bondCashflow.html",
        "signatures": [
            {
                "full": "bondCashflow(start, maturity, coupon, frequency, dayCountConvention, bondType, [mode='Vector'])",
                "name": "bondCashflow",
                "parameters": [
                    {
                        "full": "start",
                        "name": "start"
                    },
                    {
                        "full": "maturity",
                        "name": "maturity"
                    },
                    {
                        "full": "coupon",
                        "name": "coupon"
                    },
                    {
                        "full": "frequency",
                        "name": "frequency"
                    },
                    {
                        "full": "dayCountConvention",
                        "name": "dayCountConvention"
                    },
                    {
                        "full": "bondType",
                        "name": "bondType"
                    },
                    {
                        "full": "[mode='Vector']",
                        "name": "mode",
                        "optional": true,
                        "default": "'Vector'"
                    }
                ]
            }
        ],
        "markdown": "### [bondCashflow](https://docs.dolphindb.cn/zh/funcs/b/bondCashflow.html)\n\n\n\n#### 语法\n\nbondCashflow(start, maturity, coupon, frequency, dayCountConvention, bondType, \\[mode='Vector'])\n\n#### 详情\n\n计算面值为 100 元的债券的现金流，支持固息债券，零息债券和贴现债券。\n\n#### 参数\n\n注意：所有输入向量必须等长，输入标量将自动扩展以匹配其它向量的长度。\n\n**start** DATE 类型标量或向量，表示债券的起息日。\n\n**maturity** 与 *start* 等长的 DATE 类型标量或向量，表示债券的到期日。\n\n**coupon** 数值型标量或向量，表示债券的票面利率。例如 0.03，表示票息为 3%。\n\n**frequency** 整型或 STRING 类型的标量或向量，表示债券的付息频率。可选值为：\n\n* 0/“Once”：到期一次还本付息\n* 1/“Annual”：每年付息一次\n* 2/“Semiannual：每半年付息一次\n* 4/“Quarterly”：每季度付息一次\n* 12/“Monthly”：每月付息一次\n\n**dayCountConvention** STRING 类型的标量或向量，表示债券的计息日数惯例。可选值为：\n\n* \"Thirty360US\"：US (NASD) 30/360\n* \"ActualActualISMA\"：实际/实际（ISMA 规则）\n* \"Actual360\"：实际/360\n* \"Actual365\"：实际/365\n* \"Thirty360EU\"：欧洲 30/360\n* \"ActualActualISDA\"：实际/实际（ISDA 规则）\n\n**bondType** STRING 类型标量或向量，表示债券的类型。可选值为：\n\n* \"FixedRate\"：固定利率债券，定期按息票利率支付利息。\n* \"Discount\"：贴现债券，没有利息支付，以贴现方式发行的债券，期末FV=面值。\n* \"ZeroCoupon\"：零息债券，期末一次性支付利息和面值，期末FV=面值+利息。\n\n**mode**可选参数，STRING 类型标量，用于指定结果的输出格式。可选值包括：\n\n* \"Vector\"（默认值）：只返回现金流金额。\n* \"Table\"：返回现金流明细表。\n\n#### 返回值\n\n* 若 *mode* = \"Vector\"，则返回 DOUBLE 类型的向量或数组向量，表示单只或多只债券的现金流金额。\n\n* 若 *mode* = \"Table\"，则返回一个表或由表组成的元组，表示单只或多只债券的现金流明细。每个表包含以下字段：\n\n  * paymentDate：支付日，DATE 类型。\n\n  * coupon：利息金额，DOUBLE 类型。\n\n  * notional：本金，DOUBLE 类型。\n\n  * total：总金额，DOUBLE 类型。\n\n#### 例子\n\n```\nfrequency=\"Annual\"\nstart=2022.09.28\nmaturity=2025.09.28\ncoupon=0.078\nbondCashflow(start=start, maturity=maturity, coupon=coupon, frequency=frequency, dayCountConvention=\"Thirty360US\", bondType=\"FixedRate\")\n\n// output: [7.8,7.8,107.799999]\n\nbondCashflow(start=start, maturity=maturity, coupon=coupon, frequency=frequency, dayCountConvention=\"Thirty360US\", bondType=\"FixedRate\", mode=\"Table\")\n\n/* output:\npaymentDate coupon notional total              \n----------- ------ -------- ----------\n2023.09.28  7.8    0        7.8                \n2024.09.28  7.8    0        7.8                \n2025.09.28  7.8    100      107.799999\n```\n\n**相关函数**：[bondCalculator](https://docs.dolphindb.cn/zh/funcs/b/bondCalculator.html)\n"
    },
    "bondConvexity": {
        "url": "https://docs.dolphindb.cn/zh/funcs/b/bondconvexity.html",
        "signatures": [
            {
                "full": "bondConvexity(start, maturity, issuePrice, coupon, frequency, dayCountConvention, bondType, settlement, price, priceType, [benchmark='Excel'])",
                "name": "bondConvexity",
                "parameters": [
                    {
                        "full": "start",
                        "name": "start"
                    },
                    {
                        "full": "maturity",
                        "name": "maturity"
                    },
                    {
                        "full": "issuePrice",
                        "name": "issuePrice"
                    },
                    {
                        "full": "coupon",
                        "name": "coupon"
                    },
                    {
                        "full": "frequency",
                        "name": "frequency"
                    },
                    {
                        "full": "dayCountConvention",
                        "name": "dayCountConvention"
                    },
                    {
                        "full": "bondType",
                        "name": "bondType"
                    },
                    {
                        "full": "settlement",
                        "name": "settlement"
                    },
                    {
                        "full": "price",
                        "name": "price"
                    },
                    {
                        "full": "priceType",
                        "name": "priceType"
                    },
                    {
                        "full": "[benchmark='Excel']",
                        "name": "benchmark",
                        "optional": true,
                        "default": "'Excel'"
                    }
                ]
            }
        ],
        "markdown": "### [bondConvexity](https://docs.dolphindb.cn/zh/funcs/b/bondconvexity.html)\n\n\n\n#### 语法\n\nbondConvexity(start, maturity, issuePrice, coupon, frequency, dayCountConvention, bondType, settlement, price, priceType, \\[benchmark='Excel'])\n\n别名：fiConvexity\n\n#### 详情\n\n返回面值为 100 的债券的凸性。凸性指债券价格与利率间非线性关系的一种量度，表示为债券价格对利率的二阶导数。\n\n#### 参数\n\n注意：所有输入向量必须等长，输入标量将自动扩展以匹配其它向量的长度。\n\n**start** DATE 类型标量或向量，表示债券的起息日。\n\n**maturity** 与 *start* 等长的 DATE 类型标量或向量，表示债券的到期日。\n\n**issuePrice** 与 *start* 等长的数值型标量或向量，表示债券的发行价格。贴现债需指定真实发行价（通常小于100）；其他债券通常为100。\n\n**coupon** 数值型标量或向量，表示债券的票面利率。例如 0.03，表示票息为 3%。\n\n**frequency** 整型或 STRING 类型的标量或向量，表示债券的付息频率。可选值为：\n\n* 0/“Once”：到期一次还本付息\n* 1/“Annual”：每年付息一次\n* 2/“Semiannual：每半年付息一次\n* 4/“Quarterly”：每季度付息一次\n* 12/“Monthly”：每月付息一次\n\n**dayCountConvention** STRING 类型的标量或向量，表示债券的计息日数惯例。可选值为：\n\n* \"Thirty360US\"：US (NASD) 30/360\n* \"ActualActualISMA\"：实际/实际（ISMA 规则）\n* \"Actual360\"：实际/360\n* \"Actual365\"：实际/365\n* \"Thirty360EU\"：欧洲 30/360\n* \"ActualActualISDA\"：实际/实际（ISDA 规则）\n\n**bondType** STRING 类型标量或向量，表示债券的类型。可选值为：\n\n* \"FixedRate\"：固定利率债券，定期按息票利率支付利息。\n* \"Discount\"：贴现债券，没有利息支付，以贴现方式发行的债券，期末FV=面值。\n* \"ZeroCoupon\"：零息债券，期末一次性支付利息和面值，期末FV=面值+利息。\n\n**settlement** DATE 类型标量或向量，表示债券的结算日，即购买日期。\n\n**price** 数值型标量或向量，表示债券的到期收益率。\n\n**priceType**STRING 类型的标量或向量，用于指定债券价格类型。目前仅支持 \"YTM\"（到期收益率）。\n\n**benchmark** 可选参数，STRING 类型标量，表示算法参考基准。目前仅支持 “Excel”（excel 中的算法）。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\nbondConvexity(start=2023.01.01, maturity=2030.12.31, issuePrice=100, coupon=0.05, frequency=1, dayCountConvention=\"ActualActualISMA\", bondType=\"FixedRate\", settlement=2023.04.01, price=0.03, priceType=\"YTM\")\n// output: 51.864347713454684\n```\n\n**相关函数**：[bondCalculator](https://docs.dolphindb.cn/zh/funcs/b/bondCalculator.html)\n"
    },
    "bondDirtyPrice": {
        "url": "https://docs.dolphindb.cn/zh/funcs/b/bondDirtyPrice.html",
        "signatures": [
            {
                "full": "bondDirtyPrice(start, maturity, issuePrice, coupon, frequency, dayCountConvention, bondType, settlement, price, priceType, [benchmark='Excel'])",
                "name": "bondDirtyPrice",
                "parameters": [
                    {
                        "full": "start",
                        "name": "start"
                    },
                    {
                        "full": "maturity",
                        "name": "maturity"
                    },
                    {
                        "full": "issuePrice",
                        "name": "issuePrice"
                    },
                    {
                        "full": "coupon",
                        "name": "coupon"
                    },
                    {
                        "full": "frequency",
                        "name": "frequency"
                    },
                    {
                        "full": "dayCountConvention",
                        "name": "dayCountConvention"
                    },
                    {
                        "full": "bondType",
                        "name": "bondType"
                    },
                    {
                        "full": "settlement",
                        "name": "settlement"
                    },
                    {
                        "full": "price",
                        "name": "price"
                    },
                    {
                        "full": "priceType",
                        "name": "priceType"
                    },
                    {
                        "full": "[benchmark='Excel']",
                        "name": "benchmark",
                        "optional": true,
                        "default": "'Excel'"
                    }
                ]
            }
        ],
        "markdown": "### [bondDirtyPrice](https://docs.dolphindb.cn/zh/funcs/b/bondDirtyPrice.html)\n\n\n\n#### 语法\n\nbondDirtyPrice(start, maturity, issuePrice, coupon, frequency, dayCountConvention, bondType, settlement, price, priceType, \\[benchmark='Excel'])\n\n别名：fiDirtyPrice\n\n#### 详情\n\n返回面值为 100 的债券的全价。\n\n#### 参数\n\n注意：所有输入向量必须等长，输入标量将自动扩展以匹配其它向量的长度。\n\n**start** DATE 类型标量或向量，表示债券的起息日。\n\n**maturity** 与 *start* 等长的 DATE 类型标量或向量，表示债券的到期日。\n\n**issuePrice** 与 *start* 等长的数值型标量或向量，表示债券的发行价格。贴现债需指定真实发行价（通常小于100）；其他债券通常为100。\n\n**coupon** 数值型标量或向量，表示债券的票面利率。例如 0.03，表示票息为 3%。\n\n**frequency** 整型或 STRING 类型的标量或向量，表示债券的付息频率。可选值为：\n\n* 0/“Once”：到期一次还本付息\n* 1/“Annual”：每年付息一次\n* 2/“Semiannual：每半年付息一次\n* 4/“Quarterly”：每季度付息一次\n* 12/“Monthly”：每月付息一次\n\n**dayCountConvention** STRING 类型的标量或向量，表示债券的计息日数惯例。可选值为：\n\n* \"Thirty360US\"：US (NASD) 30/360\n* \"ActualActualISMA\"：实际/实际（ISMA 规则）\n* \"Actual360\"：实际/360\n* \"Actual365\"：实际/365\n* \"Thirty360EU\"：欧洲 30/360\n* \"ActualActualISDA\"：实际/实际（ISDA 规则）\n\n**bondType** STRING 类型标量或向量，表示债券的类型。可选值为：\n\n* \"FixedRate\"：固定利率债券，定期按息票利率支付利息。\n* \"Discount\"：贴现债券，没有利息支付，以贴现方式发行的债券，期末FV=面值。\n* \"ZeroCoupon\"：零息债券，期末一次性支付利息和面值，期末FV=面值+利息。\n\n**settlement** DATE 类型标量或向量，表示债券的结算日，即购买日期。\n\n**price** 数值型标量或向量，具体含义取决于 priceType 的取值：\n\n* 当 *priceType* 为 \"YTM\" 时，*price* 表示债券的到期收益率；\n* 当 *priceType* 为 \"CleanPrice\" 时，*price* 表示债券的净价；\n\n**priceType** STRING 类型的标量或向量，用于指定债券价格类型，可选值为：\n\n* \"YTM\"：到期收益率\n* \"CleanPrice\"：净价\n\n**benchmark** 可选参数，STRING 类型标量，表示算法参考基准。目前仅支持 “Excel”（excel 中的算法）。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\nbondDirtyPrice(start=2023.01.01, maturity=2030.12.31, issuePrice=100, coupon=0.05, frequency=1, dayCountConvention=\"ActualActualISMA\", bondType=\"FixedRate\", settlement=2023.04.01, price=100.2143, priceType=\"CleanPrice\")\n\n// output: 101.447176\n```\n\n**相关函数**：[bondCalculator](https://docs.dolphindb.cn/zh/funcs/b/bondCalculator.html)\n"
    },
    "bondDuration": {
        "url": "https://docs.dolphindb.cn/zh/funcs/b/bondDuration.html",
        "signatures": [
            {
                "full": "bondDuration(start, maturity, issuePrice, coupon, frequency, dayCountConvention, bondType, settlement, price, priceType, [benchmark='Excel'])",
                "name": "bondDuration",
                "parameters": [
                    {
                        "full": "start",
                        "name": "start"
                    },
                    {
                        "full": "maturity",
                        "name": "maturity"
                    },
                    {
                        "full": "issuePrice",
                        "name": "issuePrice"
                    },
                    {
                        "full": "coupon",
                        "name": "coupon"
                    },
                    {
                        "full": "frequency",
                        "name": "frequency"
                    },
                    {
                        "full": "dayCountConvention",
                        "name": "dayCountConvention"
                    },
                    {
                        "full": "bondType",
                        "name": "bondType"
                    },
                    {
                        "full": "settlement",
                        "name": "settlement"
                    },
                    {
                        "full": "price",
                        "name": "price"
                    },
                    {
                        "full": "priceType",
                        "name": "priceType"
                    },
                    {
                        "full": "[benchmark='Excel']",
                        "name": "benchmark",
                        "optional": true,
                        "default": "'Excel'"
                    }
                ]
            }
        ],
        "markdown": "### [bondDuration](https://docs.dolphindb.cn/zh/funcs/b/bondDuration.html)\n\n\n\n#### 语法\n\nbondDuration(start, maturity, issuePrice, coupon, frequency, dayCountConvention, bondType, settlement, price, priceType, \\[benchmark='Excel'])\n\n别名：fiDuration\n\n#### 详情\n\n返回面值为 100 的债券的麦考利久期（Macauley Duration）。麦考利久期利用折现后的债券现金流的加权平均来计算债券的到期时间。\n\n#### 参数\n\n注意：所有输入向量必须等长，输入标量将自动扩展以匹配其它向量的长度。\n\n**start** DATE 类型标量或向量，表示债券的起息日。\n\n**maturity** 与 *start* 等长的 DATE 类型标量或向量，表示债券的到期日。\n\n**issuePrice** 与 *start* 等长的数值型标量或向量，表示债券的发行价格。贴现债需指定真实发行价（通常小于100）；其他债券通常为100。\n\n**coupon** 数值型标量或向量，表示债券的票面利率。例如 0.03，表示票息为 3%。\n\n**frequency** 整型或 STRING 类型的标量或向量，表示债券的付息频率。可选值为：\n\n* 0/“Once”：到期一次还本付息\n* 1/“Annual”：每年付息一次\n* 2/“Semiannual：每半年付息一次\n* 4/“Quarterly”：每季度付息一次\n* 12/“Monthly”：每月付息一次\n\n**dayCountConvention** STRING 类型的标量或向量，表示债券的计息日数惯例。可选值为：\n\n* \"Thirty360US\"：US (NASD) 30/360\n* \"ActualActualISMA\"：实际/实际（ISMA 规则）\n* \"Actual360\"：实际/360\n* \"Actual365\"：实际/365\n* \"Thirty360EU\"：欧洲 30/360\n* \"ActualActualISDA\"：实际/实际（ISDA 规则）\n\n**bondType** STRING 类型标量或向量，表示债券的类型。可选值为：\n\n* \"FixedRate\"：固定利率债券，定期按息票利率支付利息。\n* \"Discount\"：贴现债券，没有利息支付，以贴现方式发行的债券，期末FV=面值。\n* \"ZeroCoupon\"：零息债券，期末一次性支付利息和面值，期末FV=面值+利息。\n\n**settlement** DATE 类型标量或向量，表示债券的结算日，即购买日期。\n\n**priceType**STRING 类型的标量或向量，用于指定债券价格类型。目前仅支持 \"YTM\"（到期收益率）。\n\n**benchmark** 可选参数，STRING 类型标量，表示算法参考基准。目前仅支持 “Excel”（excel 中的算法）。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n现计算 2023年1月1日 购买，2030年12月31日 到期的债券的久期。其年息票利率为 0.05，预计收益率为 0.06，付息频率为每年一次，日计数基准为实际/实际。\n\n```\nbondDuration(start=2023.01.01, maturity=2030.12.31, issuePrice=100, coupon=0.05, frequency=1, dayCountConvention=\"ActualActualISMA\", bondType=\"FixedRate\", settlement=2023.04.01, price=0.03, priceType=\"YTM\")\n\n// output: 6.628495977602801\n```\n\n**相关函数**：[bondCalculator](https://docs.dolphindb.cn/zh/funcs/b/bondCalculator.html)\n"
    },
    "bondFuturesPricer": {
        "url": "https://docs.dolphindb.cn/zh/funcs/b/bondFuturesPricer.html",
        "signatures": [
            {
                "full": "bondFuturesPricer(instrument, pricingDate, discountCurve)",
                "name": "bondFuturesPricer",
                "parameters": [
                    {
                        "full": "instrument",
                        "name": "instrument"
                    },
                    {
                        "full": "pricingDate",
                        "name": "pricingDate"
                    },
                    {
                        "full": "discountCurve",
                        "name": "discountCurve"
                    }
                ]
            }
        ],
        "markdown": "### [bondFuturesPricer](https://docs.dolphindb.cn/zh/funcs/b/bondFuturesPricer.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\nbondFuturesPricer(instrument, pricingDate, discountCurve)\n\n#### 详情\n\n计算国债期货合约的净现值。\n\n#### 参数\n\n注意：所有输入向量必须等长，输入标量将自动扩展以匹配其它向量的长度。\n\n**instrument** INSTRUMENT 类型标量或向量，一个 BondFutures 对象，表示国债期货合约。\n\n**pricingDate** DATE 类型标量或向量，表示定价日期 。\n\n**discountCurve** MKTDATA 类型标量或向量，一个 IrYieldCurve 对象，表示折现曲线。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\nbond = {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Bond\",\n    \"bondType\": \"FixedRateBond\",\n    \"instrumentId\": \"220010.IB\",\n    \"start\": \"2022.05.15\",\n    \"maturity\": \"2032.05.15\",\n    \"issuePrice\": 100.0,\n    \"coupon\": 0.0276,\n    \"frequency\": \"Semiannual\",\n    \"dayCountConvention\": \"ActualActualISDA\"\n}\n\nbondFutures = { \n    \"productType\": \"Futures\",\n    \"futuresType\": \"BondFutures\",\n    \"instrumentId\": \"T2509\",\n    \"nominal\": 100.0,\n    \"maturity\": \"2025.09.12\",\n    \"settlement\": \"2025.09.16\",\n    \"underlying\": bond,\n    \"nominalCouponRate\": 0.03\n}\n\ninstrument = parseInstrument(bondFutures)\npricingDate = 2025.06.10\ncurve = {\n    \"mktDataType\": \"Curve\",\n    \"curveType\": \"IrYieldCurve\",\n    \"referenceDate\": pricingDate,\n    \"currency\": \"CNY\",\n    \"dayCountConvention\": \"ActualActualISDA\",\n    \"compounding\": \"Compounded\",\n    \"interpMethod\": \"Linear\",\n    \"extrapMethod\": \"Flat\",\n    \"frequency\": \"Semiannual\",\n    \"dates\":[2025.09.05, 2025.12.05, 2026.03.05, 2027.03.05, 2028.03.05, 2030.03.05, 2035.03.05, 2040.03.05, 2045.03.05, 2055.03.05, 2075.03.05],\n    \"values\":[1.5347, 1.4958, 1.4447, 1.3955, 1.5029, 1.5561, 1.7156, 1.8652, 2.0329, 1.8955, 2.1059] / 100.0\n}\ndiscountCurve = parseMktData(curve)\nnpv = bondFuturesPricer(instrument, pricingDate, discountCurve)\nprint(npv)  // output:108.716241945330267\nbondFuturesPricer([instrument, instrument], pricingDate, discountCurve)\nbondFuturesPricer(instrument, [pricingDate, pricingDate, pricingDate], discountCurve)\nbondFuturesPricer(instrument, [pricingDate, pricingDate, pricingDate], [discountCurve, discountCurve, discountCurve])\nbondFuturesPricer(instrument, pricingDate, [discountCurve, discountCurve, discountCurve])\n```\n"
    },
    "bondInstrumentCalculator": {
        "url": "https://docs.dolphindb.cn/zh/funcs/b/bondinstrumentcalculator.html",
        "signatures": [
            {
                "full": "bondInstrumentCalculator(bond, settlement, price, priceType, [calcRisk=false], [benchmark='Qeubee'], [isExercised])",
                "name": "bondInstrumentCalculator",
                "parameters": [
                    {
                        "full": "bond",
                        "name": "bond"
                    },
                    {
                        "full": "settlement",
                        "name": "settlement"
                    },
                    {
                        "full": "price",
                        "name": "price"
                    },
                    {
                        "full": "priceType",
                        "name": "priceType"
                    },
                    {
                        "full": "[calcRisk=false]",
                        "name": "calcRisk",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[benchmark='Qeubee']",
                        "name": "benchmark",
                        "optional": true,
                        "default": "'Qeubee'"
                    },
                    {
                        "full": "[isExercised]",
                        "name": "isExercised",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [bondInstrumentCalculator](https://docs.dolphindb.cn/zh/funcs/b/bondinstrumentcalculator.html)\n\n首发版本：3.00.4.1\n\n\n\n#### 语法\n\nbondInstrumentCalculator(bond, settlement, price, priceType, \\[calcRisk=false], \\[benchmark='Qeubee'], \\[isExercised])\n\n#### 详情\n\n债券计算器，实现债券价格 (ytm / cleanPrice / dirtyPrice) 三者互算，同时计算久期、凸度等风险指标。\n\n#### 参数\n\n**bond** INSTRUMENT 类型标量或向量，表示债券金融工具。\n\n**Note:** bond instrument 的 instrumentId 字段如果指定了后缀，且后缀为 .SH 或者 .SZ， 则债券会被视为交易所债券，它的应计利息计算会增加一天。\n\n**settlement** DATE 类型标量或向量，表示债券的结算日，即购买日期。\n\n**price** 数值型标量或向量，具体含义取决于 priceType 的取值：\n\n* 当 *priceType* 为 \"YTM\" 时，*price* 表示债券的到期收益率；\n* 当 *priceType* 为 \"CleanPrice\" 时，*price* 表示债券的净价；\n* 当 *priceType* 为 \"DirtyPrice\" 时，*price* 表示债券的全价。\n* 当 *priceType* 为 \"YTE\" 时，*price* 表示债券的行权收益率。\n\n**priceType**STRING 类型的标量或向量，用于指定债券价格类型，可选值为：\n\n* \"YTM\"：到期收益率\n* \"CleanPrice\"：净价\n* \"DirtyPrice\"：全价\n* \"YTE\"：行权收益率，仅在 bond 为 OptionBond 时可用。\n\n**calcRisk** 可选参数，布尔值，默认为 false，只计算输出全价、净价、应计利息和收益率。若设置为 true，除上述4项外，还会计算并输出麦考利久期、修正久期、凸度、基点价值。\n\n**benchmark** 可选参数，STRING 类型标量，表示算法参考基准。目前支持：\n\n* \"Qeubee\"（默认值）：表示终端算法。\n* \"CSI\"：表示中证算法。\n\n**isExercised** 可选参数，BOOL 类型标量，表示是否行权。\n\n* 如果不指定则会自动判断是否行权。\n* 如果指定为 true，则按照行权来计算。\n* 如果指定为 false 则按照不行权来计算。\n\n#### 返回值\n\n一个字典或元组。\n\n#### 例子\n\n例1. 计算固定利率债券的价格、到期收益率、应计利息和风险指标。\n\n```\nfixedRateBondDict = {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Bond\",\n    \"bondType\": \"FixedRateBond\",\n    \"start\": 2022.07.15,\n    \"maturity\": 2072.07.15,\n    \"issuePrice\": 100.0,\n    \"coupon\": 0.034,\n    \"dayCountConvention\": \"ActualActualISMA\",\n    \"calendar\": \"CFET\",\n    \"frequency\": \"Semiannual\"\n}\nfixedRateBond = parseInstrument(fixedRateBondDict);\nbondInstrumentCalculator(fixedRateBond, settlement=2025.04.10, price=0.02, priceType=\"YTM\", calcRisk=true);\n\n/* Output:\ndirtyPrice->143.4689\ncleanPrice->142.6705\nytm->0.02\naccruedInterest->0.7983\nmacaulayDuration->27.4761\nmodifiedDuration->27.2041\nconvexity->1025.4003\npvbp->0.3902\n*/\n\n\nbondInstrumentCalculator(fixedRateBond, settlement=2072.04.18, price=100.2143, priceType=\"CleanPrice\", calcRisk=false);\n\n/* Output:\ndirtyPrice: 101.0923\ncleanPrice: 100.2143\nytm: 0.0250\naccruedInterest: 0.8780\n*/\n```\n\n例2. 计算零息债券的价格、到期收益率、应计利息和风险指标。\n\n```\nzeroCouponBondDict = {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Bond\",\n    \"bondType\": \"ZeroCouponBond\",\n    \"coupon\": 0.0119,\n    \"start\": 2025.01.09,\n    \"maturity\": 2026.02.05,\n    \"issuePrice\": 100.0,\n    \"dayCountConvention\": \"ActualActualISMA\",\n    \"calendar\": \"CFET\"\n}\nzeroCouponBond = parseInstrument(zeroCouponBondDict);\nbondInstrumentCalculator(zeroCouponBond, settlement=2025.04.10, price=0.025, priceType=\"YTM\", calcRisk=true);\n\n/* Output:\ndirtyPrice->99.2322\ncleanPrice->98.9355\nytm->0.025\naccruedInterest->0.2966\nmacaulayDuration->0.8246\nmodifiedDuration->0.8079\nconvexity->1.3057\npvbp->0.0080\n*/\n```\n\n例3. 计算贴现债券的价格、到期收益率、应计利息和风险指标。\n\n```\ndiscountBondDict = {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Bond\",\n    \"bondType\": \"Discount\",\n    \"start\": 2025.02.13,\n    \"maturity\": 2025.05.15,\n    \"issuePrice\": 99.663,\n    \"dayCountConvention\": \"ActualActualISMA\",\n    \"calendar\": \"CFET\"\n}\ndiscountBond = parseInstrument(discountBondDict);\nbondInstrumentCalculator(discountBond, settlement=2025.04.10, price=0.02, priceType=\"YTM\", calcRisk=true);\n\n/* Output:\ndirtyPrice->99.8085\ncleanPrice->99.6012\nytm->0.02\naccruedInterest->0.2073\nmacaulayDuration->0.0958\nmodifiedDuration->0.0957\nconvexity->0.0183\npvbp->0.0009\n*/\n```\n\n例4. 同时计算多种债券的价格、到期收益率、应计利息和风险指标。\n\n```\nresult = bondInstrumentCalculator([discountBond, zeroCouponBond, fixedRateBond], settlement=[2025.04.10, 2025.04.10, 2072.04.18], price=[0.02, 0.025, 100.2143], priceType=[\"YTM\", \"YTM\", \"CleanPrice\"], calcRisk=true);\n\nprint result\n\n/* Output:\n(dirtyPrice->99.808599999999998\ncleanPrice->99.601200000000005\nytm->0.02\naccruedInterest->0.2074\nmacaulayDuration->0.0959\nmodifiedDuration->0.0957\nconvexity->0.0183\npvbp->0.001\n,dirtyPrice->99.232200000000005\ncleanPrice->98.935500000000004\nytm->0.025\naccruedInterest->0.2967\nmacaulayDuration->0.8247\nmodifiedDuration->0.808\nconvexity->1.3057\npvbp->0.008\n,dirtyPrice->101.092299999999994\ncleanPrice->100.214299999999994\nytm->0.025\naccruedInterest->0.878\nmacaulayDuration->0.2404\nmodifiedDuration->0.239\nconvexity->0.1142\npvbp->0.0024\n*/\n```\n\n例5. 计算含权债券的价格、到期收益率、应计利息和风险指标。\n\n```\noptionBond = {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Bond\",\n    \"bondType\": \"OptionBond\",\n    \"version\": 0,\n    \"instrumentId\": \"242659.SH\",\n    \"nominal\": 100.0,\n    \"start\": 2025.03.26,\n    \"maturity\": 2030.03.26,\n    \"coupon\": 0.0207,\n    \"frequency\": \"Annual\",\n    \"exerciseDates\": [2028.03.26],\n    \"hasCallOption\": true,\n    \"hasPutOption\": true,\n    \"hasCouponAdjust\": true,\n    \"dayCountConvention\": \"ActualActualISMA\"\n}\nins = parseInstrument(optionBond)\n\nbondInstrumentCalculator(ins, settlement=2025.12.19, price=0.0195216, priceType=\"YTM\", calcRisk=true, benchmark=\"CSI\");\n\n/* Output:\ndirtyPrice: 101.99383706183775\ncleanPrice: 100.46827541800214\naccruedInterest: 1.5255616438356157\nytm: 0.0195216\nyte: 0.018527802311956366\nmacaulayDuration: 2.20553110943836\nmodifiedDuration: 2.1654108060987873\nconvexity: 6.908516501810582\npvbp: 0.02208585569291825\n*/\n```\n\n相关函数：[bondPricer](https://docs.dolphindb.cn/zh/funcs/b/bondPricer.html)\n"
    },
    "bondPricer": {
        "url": "https://docs.dolphindb.cn/zh/funcs/b/bondPricer.html",
        "signatures": [
            {
                "full": "bondPricer(instrument, pricingDate, discountCurve, [spreadCurve], [setting])",
                "name": "bondPricer",
                "parameters": [
                    {
                        "full": "instrument",
                        "name": "instrument"
                    },
                    {
                        "full": "pricingDate",
                        "name": "pricingDate"
                    },
                    {
                        "full": "discountCurve",
                        "name": "discountCurve"
                    },
                    {
                        "full": "[spreadCurve]",
                        "name": "spreadCurve",
                        "optional": true
                    },
                    {
                        "full": "[setting]",
                        "name": "setting",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [bondPricer](https://docs.dolphindb.cn/zh/funcs/b/bondPricer.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\nbondPricer(instrument, pricingDate, discountCurve, \\[spreadCurve], \\[setting])\n\n#### 详情\n\n对债券进行定价，输出净现值（NPV），同时可计算多种风险指标，包括一阶敏感度（Delta）、二阶敏感度（Gamma）以及关键利率久期（Key Rate Duration）。\n\n#### 参数\n\n注意：所有输入向量必须等长，输入标量将自动扩展以匹配其它向量的长度。\n\n**instrument** INSTRUMENT 类型标量或向量，表示需要定价的债券产品。不同类型的债券产品所需的关键字段各不相同，详见债券[产品字段要求](https://docs.dolphindb.cn/zh/funcs/b/bondPricer.html#topic_nsv_2k2_ngc)。\n\n**pricingDate** DATE 类型标量或向量，表示定价日期。\n\n**discountCurve** MKTDATA 类型标量或向量（IrYieldCurve），表示贴现曲线。贴现曲线所需包含的关键字段见[曲线字段要求](https://docs.dolphindb.cn/zh/funcs/b/bondPricer.html#topic_o4f_fk2_ngc)。\n\n**spreadCurve** 可选参数，MKTDATA 类型标量或向量（IrYieldCurve），表示信用利差曲线。若未提供，则默认使用 0% 利率的平坦曲线。利差曲线所需包含的关键字段见[曲线字段要求](https://docs.dolphindb.cn/zh/funcs/b/bondPricer.html#topic_o4f_fk2_ngc)。\n\n**setting**可选参数，字典（Dictionary\\<STRING, ANY>），用于定价设置，包括以下键值对：\n\n| 键                                  | 值类型          | 描述                                                                 |\n| ---------------------------------- | ------------ | ------------------------------------------------------------------ |\n| \"calcDiscountCurveDelta\"           | BOOL         | 是否计算债券对贴现曲线的一阶敏感度                                                  |\n| \"calcDiscountCurveGamma\"           | BOOL         | 是否计算债券对贴现曲线的二阶敏感度                                                  |\n| \"calcDiscountCurveKeyRateDuration\" | BOOL         | 是否计算债券的关键利率久期                                                      |\n| \"discountCurveShift\"               | DOUBLE 标量    | 贴现曲线的平行扰动，比如一个 bp(0.0001)                                          |\n| \"discountCurveKeyTerms\"            | DOUBLE 标量或向量 | 关键期限年数，比如 \\[1.0, 3.0, 5.0]                                         |\n| \"discountCurveKeyShifts\"           | DOUBLE 标量或向量 | 关键期限的扰动幅度, 与 discountCurveKeyTerms 等长，比如 \\[0.0001, 0.0002, 0.0015] |\n\n#### 返回值\n\n若输入为标量：\n\n* 若未指定 *setting*，返回 NPV（DOUBLE 类型标量）。\n\n* 若指定 *setting*，返回 Dictionary\\<STRING, ANY>，键为指标名称，值为相应结果：\n\n  * \"npv\"：DOUBLE 标量\n\n  * \"discountCurveDelta\"：DOUBLE 标量\n\n  * \"discountCurveGamma\"：DOUBLE 标量\n\n  * \"discountCurveKeyRateDuration\"：DOUBLE 向量\n\n若输入为向量，返回 DOUBLE 类型向量（若未指定 *setting*）或字典组成的元组（若指定 *setting*）。\n\n#### 例子\n\n```\nbond = {\n  \"productType\": \"Cash\",\n  \"assetType\": \"Bond\",\n  \"bondType\": \"FixedRateBond\",\n  \"version\": 0, \n  \"instrumentId\": \"240025.IB\",\n  \"start\": 2024.12.25,\n  \"maturity\": 2031.12.25,\n  \"issuePrice\": 100.0,\n  \"coupon\": 0.0149,\n  \"frequency\": \"Annual\",\n  \"dayCountConvention\": \"ActualActualISDA\"\n}\n\npricingDate = 2025.08.18\n\ncurve = {\n  \"mktDataType\": \"Curve\",\n  \"curveType\": \"IrYieldCurve\",\n  \"referenceDate\": pricingDate,\n  \"currency\": \"CNY\",\n  \"curveName\": \"CNY_TREASURY_BOND\",\n  \"dayCountConvention\": \"ActualActualISDA\",\n  \"compounding\": \"Compounded\",\n  \"interpMethod\": \"Linear\",\n  \"extrapMethod\": \"Flat\",\n  \"frequency\": \"Annual\",\n  \"dates\":[2025.09.18, 2025.11.18, 2026.02.18, 2026.08.18, 2027.08.18, 2028.08.18, 2030.08.18,\n      2032.08.18, 2035.08.18, 2040.08.18, 2045.08.18, 2055.08.18,2065.08.18, 2075.08.18],\n  \"values\":[1.3000, 1.3700, 1.3898, 1.3865, 1.4299, 1.4471, 1.6401,\n       1.7654, 1.7966, 1.9930, 2.1834, 2.1397, 2.1987, 2.2225] / 100.0\n}\n\ninstrument = parseInstrument(bond)\ndiscountCurve = parseMktData(curve)\n\nsetting = dict(STRING, ANY)\nsetting[\"calcDiscountCurveDelta\"] = true\nsetting[\"calcDiscountCurveGamma\"] = true\nsetting[\"calcDiscountCurveKeyRateDuration\"] = true\nsetting[\"discountCurveShift\"] = 0.0001\nsetting[\"discountCurveKeyTerms\"] = [1.0, 3.0, 5.0]\nsetting[\"discountCurveKeyShifts\"] = [0.0002, 0.0003, 0.0001]\n\nbondPricer(instrument, pricingDate, discountCurve, setting=setting)\n\nbondPricer([instrument, instrument], pricingDate, discountCurve, setting=setting)\nbondPricer(instrument, pricingDate, [discountCurve, discountCurve], setting=setting)\nbondPricer(instrument, [pricingDate], discountCurve, setting=setting)\nbondPricer(instrument, [pricingDate, pricingDate], discountCurve, setting=setting)\n```\n\n**相关函数：**[parseInstrument](https://docs.dolphindb.cn/zh/funcs/p/parseInstrument.html), [parseMktData](https://docs.dolphindb.cn/zh/funcs/p/parseMktData.html)\n\n#### 债券产品字段要求\n\n**贴现债**\n\n<table id=\"table_j5m_mnl_ngc\"><thead><tr><th>\n\n字段名\n\n</th><th>\n\n类型\n\n</th><th>\n\n描述\n\n</th><th>\n\n是否必填\n\n</th></tr></thead><tbody><tr><td>\n\nproductType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"Cash\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nassetType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"Bond\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nbondType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"DiscountBond\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nnominal\n\n</td><td>\n\nDOUBLE\n\n</td><td>\n\n名义金额，默认值 100\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ninstrumentId\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n债券代码，如 \"259926.IB\"\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\nstart\n\n</td><td>\n\nDATE\n\n</td><td>\n\n起息日\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nmaturity\n\n</td><td>\n\nDATE\n\n</td><td>\n\n到期日\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ndayCountConvention\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n日期计数惯例，可选 \"ActualActualISDA\", \"ActualActualISMA\", \"Actual365\", \"Actual360\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nissuePrice\n\n</td><td>\n\nDOUBLE\n\n</td><td>\n\n发行价格\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ncurrency\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n货币，默认为 \"CNY\"\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ncashFlow\n\n</td><td>\n\nTABLE\n\n</td><td>\n\n债券现金流表\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ndiscountCurve\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n定价时参考的贴现曲线名称，如 \"CNY\\_TRASURY\\_BOND\"\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\nspreadCurve\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n定价时参考的利差曲线名称\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\nsubType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n债券子类型，中国债券可选值为：\n\n* \"TREASURY\\_BOND\"：国债\n\n* \"CENTRAL\\_BANK\\_BILL\"：央行票据\n\n* \"CDB\\_BOND\"：政策性金融债（国开）\n\n* \"EIBC\\_BOND\"：政策性金融债（进出口行）\n\n* \"ADBC\\_BOND\"：政策性金融债（农发行）。\n\n* \"MTN\"：中期票据\n\n* \"CORP\\_BOND\"：企业债。\n\n* \"UNSECURED\\_CORP\\_BOND\"：无担保企业债\n\n* \"SHORT\\_FIN\\_BOND\"：短期融资券\n\n* \"NCD\"：同业存单\n\n* \"LOC\\_GOV\\_BOND\"：地方政府债\n\n* \"COMM\\_BANK\\_FIN\\_BOND\"：商业银行普通金融债\n\n* \"BANK\\_SUB\\_CAP\\_BOND\"：商业银行二级资本债\n\n* \"ABS\"：资产支持证券\n\n* \"PPN\"：非公开发行债\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ncreditRating\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n信用等级类型，可选值为：\"B\", \"BB\", \"BBB\", \"BBB+\", \"A-\", \"A\", \"A+\", \"AA-\", \"AA\", \"AA+\", \"AAA-\", \"AAA\", \"AAA+\"\n\n</td><td>\n\n否\n\n</td></tr></tbody>\n</table>**零息债**\n\n<table id=\"table_ydr_4nl_ngc\"><thead><tr><th>\n\n字段名\n\n</th><th>\n\n类型\n\n</th><th>\n\n描述\n\n</th><th>\n\n是否必填\n\n</th></tr></thead><tbody><tr><td>\n\nproductType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"Cash\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nassetType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"Bond\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nbondType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"ZeroCouponBond\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nnominal\n\n</td><td>\n\nDOUBLE\n\n</td><td>\n\n名义金额，默认值 100\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ninstrumentId\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n债券代码，如 \"250401.IB\"\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\nstart\n\n</td><td>\n\nDATE\n\n</td><td>\n\n起息日\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nmaturity\n\n</td><td>\n\nDATE\n\n</td><td>\n\n到期日\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ncoupon\n\n</td><td>\n\nDOUBLE\n\n</td><td>\n\n票面利率，如 0.03 表示 3%\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nfrequency\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n付息频率\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ndayCountConvention\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n日期计数惯例，可选 \"ActualActualISDA\", \"ActualActualISMA\", \"Actual365\", \"Actual360\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ncurrency\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n货币，默认为 \"CNY\"\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ncashFlow\n\n</td><td>\n\nTABLE\n\n</td><td>\n\n债券现金流表\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ndiscountCurve\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n定价时参考的贴现曲线名称，如 \"CNY\\_TRASURY\\_BOND\"\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\nspreadCurve\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n定价时参考的利差曲线名称\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\nsubType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n债券子类型，中国债券可选值为：\n\n* \"TREASURY\\_BOND\"：国债\n\n* \"CENTRAL\\_BANK\\_BILL\"：央行票据\n\n* \"CDB\\_BOND\"：政策性金融债（国开）\n\n* \"EIBC\\_BOND\"：政策性金融债（进出口行）\n\n* \"ADBC\\_BOND\"：政策性金融债（农发行）。\n\n* \"MTN\"：中期票据\n\n* \"CORP\\_BOND\"：企业债。\n\n* \"UNSECURED\\_CORP\\_BOND\"：无担保企业债\n\n* \"SHORT\\_FIN\\_BOND\"：短期融资券\n\n* \"NCD\"：同业存单\n\n* \"LOC\\_GOV\\_BOND\"：地方政府债\n\n* \"COMM\\_BANK\\_FIN\\_BOND\"：商业银行普通金融债\n\n* \"BANK\\_SUB\\_CAP\\_BOND\"：商业银行二级资本债\n\n* \"ABS\"：资产支持证券\n\n* \"PPN\"：非公开发行债\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ncreditRating\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n信用等级类型，可选值为：\"B\", \"BB\", \"BBB\", \"BBB+\", \"A-\", \"A\", \"A+\", \"AA-\", \"AA\", \"AA+\", \"AAA-\", \"AAA\", \"AAA+\"\n\n</td><td>\n\n否\n\n</td></tr></tbody>\n</table>**固定利率债**\n\n<table id=\"table_gq4_qnl_ngc\"><thead><tr><th>\n\n字段名\n\n</th><th>\n\n类型\n\n</th><th>\n\n描述\n\n</th><th>\n\n是否必填\n\n</th></tr></thead><tbody><tr><td>\n\nproductType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"Cash\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nassetType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"Bond\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nbondType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"FixedRateBond\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nnominal\n\n</td><td>\n\nDOUBLE\n\n</td><td>\n\n名义金额，默认值 100\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ninstrumentId\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n债券代码，如 \"250401.IB\"\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\nstart\n\n</td><td>\n\nDATE\n\n</td><td>\n\n起息日\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nmaturity\n\n</td><td>\n\nDATE\n\n</td><td>\n\n到期日\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ncoupon\n\n</td><td>\n\nDOUBLE\n\n</td><td>\n\n票面利率，如0.03表示3%\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nfrequency\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n付息频率\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ndayCountConvention\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n日期计数惯例，可选 \"ActualActualISDA\", \"ActualActualISMA\", \"Actual365\", \"Actual360\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ncurrency\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n货币，默认为 \"CNY\"\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ncashFlow\n\n</td><td>\n\nTABLE\n\n</td><td>\n\n债券现金流表\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ndiscountCurve\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n定价时参考的贴现曲线名称，如 \"CNY\\_TRASURY\\_BOND\"\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\nspreadCurve\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n定价时参考的利差曲线名称\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\nsubType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n债券子类型，中国债券可选值为：\n\n* \"TREASURY\\_BOND\"：国债\n\n* \"CENTRAL\\_BANK\\_BILL\"：央行票据\n\n* \"CDB\\_BOND\"：政策性金融债（国开）\n\n* \"EIBC\\_BOND\"：政策性金融债（进出口行）\n\n* \"ADBC\\_BOND\"：政策性金融债（农发行）。\n\n* \"MTN\"：中期票据\n\n* \"CORP\\_BOND\"：企业债。\n\n* \"UNSECURED\\_CORP\\_BOND\"：无担保企业债\n\n* \"SHORT\\_FIN\\_BOND\"：短期融资券\n\n* \"NCD\"：同业存单\n\n* \"LOC\\_GOV\\_BOND\"：地方政府债\n\n* \"COMM\\_BANK\\_FIN\\_BOND\"：商业银行普通金融债\n\n* \"BANK\\_SUB\\_CAP\\_BOND\"：商业银行二级资本债\n\n* \"ABS\"：资产支持证券\n\n* \"PPN\"：非公开发行债\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ncreditRating\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n信用等级类型，可选值为：\"B\", \"BB\", \"BBB\", \"BBB+\", \"A-\", \"A\", \"A+\", \"AA-\", \"AA\", \"AA+\", \"AAA-\", \"AAA\", \"AAA+\"\n\n</td><td>\n\n否\n\n</td></tr></tbody>\n</table>## 曲线字段要求\n\n<table id=\"table_ksj_snl_ngc\"><thead><tr><th>\n\n字段名\n\n</th><th>\n\n类型\n\n</th><th>\n\n描述\n\n</th><th>\n\n是否必填\n\n</th></tr></thead><tbody><tr><td>\n\nmktDataType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"Curve\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nreferenceDate\n\n</td><td>\n\nDATE\n\n</td><td>\n\n参考日期\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ncurveType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"IrYieldCurve\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ndayCountConvention\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n曲线的日期计数惯例，可选值为：\n\n* \"Actual360\"：实际天数除以360\n\n* \"Actual365\"：实际天数除以365（不区分闰年）\n\n* \"ActualActualISMA\"：实际天数/实际天数（ISMA规则）\n\n* \"ActualActualISDA\"：实际天数/实际天数（ISDA规则）\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ninterpMethod\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n内插方法，可选值为：\n\n* \"Linear\"：线性插值\n\n* \"CubicSpline\"：三次样条插值\n\n* \"CubicHermiteSpline\"：三次埃尔米特样条插值\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nextrapMethod\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n外插方法，可选值为：\n\n* \"Flat\"：平插\n\n* \"Linear\"：线性插值\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ndates\n\n</td><td>\n\nDATE 向量\n\n</td><td>\n\n数据点的日期\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nvalues\n\n</td><td>\n\nDOUBLE 向量\n\n</td><td>\n\n数据点的值，与 *dates* 中的元素一一对应\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ncurveName\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n曲线名称\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ncurrency\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n货币，可选值为\"CNY\", \"USD\", \"EUR\", \"GBP\", \"JPY\", \"HKD\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ncompounding\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n复利类型，可选值为：\n\n* \"Simple\"：单利\n\n* \"Compounded\"：离散复利\n\n* \"Continuous\"：连续复利\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nsettlement\n\n</td><td>\n\nDATE\n\n</td><td>\n\n结算日，如果指定了结算日，则后续期限间隔的计算都将从 *settlement* 开始，而不是 *referenceDate*\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\nfrequency\n\n</td><td>\n\nINTEGRAL或 STRING\n\n</td><td>\n\n计息频率，可选值为：\n\n* 1 或 \"Annual\"：每年付息一次\n\n* 2 或 \"Semiannual\"：每半年付息一次\n\n* 3 或 \"EveryFourthMonth\"：每四个月付息一次\n\n* 4 或 \"Quarterly\"：每季度付息一次\n\n* 6 或 \"BiMonthly\"：每两月付息一次\n\n* 12 或 \"Monthly\"：每月付息一次\n\n* 13 或 \"EveryFourthWeek\"：每四周付息一次\n\n* 26 或 \"BiWeekly\"：每两周付息一次\n\n* 52 或 \"Weekly\"：每周付息一次\n\n* 365 或 \"Daily\"：每日付息一次\n\n* 999 或 \"Other\"：其他计息频率\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ncurveModel\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n曲线构建模型，可选值为 \"Bootstrap\"（默认），\"NS\"，\"NSS\"。\n\n当取值 \"NSS\" 或 \"NS\"，无需传 *interpMethod*、*extrapMethod*、*dates*、*values*字段。\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ncurveParams\n\n</td><td>\n\nDICT\n\n</td><td>\n\n模型的参数，当 *curveModel*取值 \"NSS\" 或 \"NS\" 时必填：\n\n* curveModel = \"NS\"：应包含键 'beta0', 'beta1', 'beta2', 'lambda'\n\n* curveModel = \"NSS\"：应包含键'beta0', ‘beta1', 'beta2', 'beta3', 'lambda0', 'lambda1'\n\n</td><td>\n\n否\n\n</td></tr></tbody>\n</table>\n"
    },
    "bondYield": {
        "url": "https://docs.dolphindb.cn/zh/funcs/b/bondyield.html",
        "signatures": [
            {
                "full": "bondYield(start, maturity, issuePrice, coupon, frequency, dayCountConvention, bondType, settlement, price, priceType, [method='newton'], [maxIter=100], [benchmark='Excel'])",
                "name": "bondYield",
                "parameters": [
                    {
                        "full": "start",
                        "name": "start"
                    },
                    {
                        "full": "maturity",
                        "name": "maturity"
                    },
                    {
                        "full": "issuePrice",
                        "name": "issuePrice"
                    },
                    {
                        "full": "coupon",
                        "name": "coupon"
                    },
                    {
                        "full": "frequency",
                        "name": "frequency"
                    },
                    {
                        "full": "dayCountConvention",
                        "name": "dayCountConvention"
                    },
                    {
                        "full": "bondType",
                        "name": "bondType"
                    },
                    {
                        "full": "settlement",
                        "name": "settlement"
                    },
                    {
                        "full": "price",
                        "name": "price"
                    },
                    {
                        "full": "priceType",
                        "name": "priceType"
                    },
                    {
                        "full": "[method='newton']",
                        "name": "method",
                        "optional": true,
                        "default": "'newton'"
                    },
                    {
                        "full": "[maxIter=100]",
                        "name": "maxIter",
                        "optional": true,
                        "default": "100"
                    },
                    {
                        "full": "[benchmark='Excel']",
                        "name": "benchmark",
                        "optional": true,
                        "default": "'Excel'"
                    }
                ]
            }
        ],
        "markdown": "### [bondYield](https://docs.dolphindb.cn/zh/funcs/b/bondyield.html)\n\n\n\n#### 语法\n\nbondYield(start, maturity, issuePrice, coupon, frequency, dayCountConvention, bondType, settlement, price, priceType, \\[method='newton'], \\[maxIter=100], \\[benchmark='Excel'])\n\n#### 详情\n\n通过债券净价(Clean Price)或全价(Dirty Price)计算债券的到期收益率 (Yield To Maturity)。\n\n注意：\n\n* 如果结算日（settlement）距离到期日（maturity）不足一个票息期（coupon period），则收益率按以下方式计算：\n\n![](https://docs.dolphindb.cn/zh/tutorials/images/yield.png)\n\n* 部分参数说明：\n  * A：票息期开始日至结算日之间的天数（应计利息天数）。\n\n  * DSR：从结算日期到赎回日期之间的天数。\n\n  * E ：一个票息期内的天数。\n\n* 如果在到期日之前有多个票息期，则通过牛顿法等优化算法迭代地调整收益率的值，使基于该收益率计算得到的债券净价接近用户输入的实际价格。本函数将收益率的初值设置为年息票利率（Annual Coupon Rate）。\n\n#### 参数\n\n注意：所有输入向量必须等长，输入标量将自动扩展以匹配其它向量的长度。\n\n**start** DATE 类型标量或向量，表示债券的起息日。\n\n**maturity** 与 *start* 等长的 DATE 类型标量或向量，表示债券的到期日。\n\n**issuePrice** 与 *start* 等长的数值型标量或向量，表示债券的发行价格。贴现债需指定真实发行价（通常小于100）；其他债券通常为100。\n\n**coupon** 数值型标量或向量，表示债券的票面利率。例如 0.03，表示票息为 3%。\n\n**frequency** 整型或 STRING 类型的标量或向量，表示债券的付息频率。可选值为：\n\n* 0/“Once”：到期一次还本付息\n* 1/“Annual”：每年付息一次\n* 2/“Semiannual：每半年付息一次\n* 4/“Quarterly”：每季度付息一次\n* 12/“Monthly”：每月付息一次\n\n**dayCountConvention** STRING 类型的标量或向量，表示债券的计息日数惯例。可选值为：\n\n* \"Thirty360US\"：US (NASD) 30/360\n* \"ActualActualISMA\"：实际/实际（ISMA 规则）\n* \"Actual360\"：实际/360\n* \"Actual365\"：实际/365\n* \"Thirty360EU\"：欧洲 30/360\n* \"ActualActualISDA\"：实际/实际（ISDA 规则）\n\n**bondType** STRING 类型标量或向量，表示债券的类型。可选值为：\n\n* \"FixedRate\"：固定利率债券，定期按息票利率支付利息。\n* \"Discount\"：贴现债券，没有利息支付，以贴现方式发行的债券，期末FV=面值。\n* \"ZeroCoupon\"：零息债券，期末一次性支付利息和面值，期末FV=面值+利息。\n\n**settlement** DATE 类型标量或向量，表示债券的结算日，即购买日期。\n\n**price** 数值型标量或向量，具体含义取决于 priceType 的取值：\n\n* 当 *priceType* 为 \"CleanPrice\" 时，*price* 表示债券的净价；\n* 当 *priceType* 为 \"DirtyPrice\" 时，*price* 表示债券的全价。\n\n**priceType** STRING 类型的标量或向量，用于指定债券价格类型，可选值为：\n\n* \"CleanPrice\"：净价\n* \"DirtyPrice\"：全价\n\n**method** 可选参数，字符串标量或向量，表示求解收益率所使用的优化算法，可选值为：\n\n* \"newton\"：表示使用 Newton 算法，默认值。\n\n* \"brent\"：表示使用 brent 算法。\n\n* \"nm\"：表示使用 Nelder-Mead 单纯形算法。\n\n* \"bfgs\"：表示使用 bfgs 算法。\n\n* \"lbfgs\"：表示使用 lbfgs 算法。\n\n**maxIter** 可选参数，整型标量或向量，表示求解收益率时优化算法的最大迭代次数。默认值为 100。\n\n**benchmark** 可选参数，STRING 类型标量，表示算法参考基准。目前仅支持 “Excel”（excel 中的算法）。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\nbondYield(start=2023.01.01, maturity=2030.12.31, issuePrice=100, coupon=0.05, frequency=1, dayCountConvention=\"ActualActualISMA\", bondType=\"FixedRate\", settlement=2023.04.01, price=100.2143, priceType=\"CleanPrice\", method = ['newton', 'nm', 'brentq', 'bfgs','lbfgs'])\n\n// output: [0.049630,0.049628,0.049630,0.049630,0.049635]\n```\n\n**相关函数**：[bondCalculator](https://docs.dolphindb.cn/zh/funcs/b/bondCalculator.html)\n"
    },
    "bondYieldCurveBuilder": {
        "url": "https://docs.dolphindb.cn/zh/funcs/b/bondYieldCurveBuilder.html",
        "signatures": [
            {
                "full": "bondYieldCurveBuilder(referenceDate, currency, bonds, terms, quotes, dayCountConvention, [compounding='Compounded'], [frequency='Annual'], [curveName], [method='Bootstrap'], [interpMethod='Linear'], [extrapMethod='Flat'])",
                "name": "bondYieldCurveBuilder",
                "parameters": [
                    {
                        "full": "referenceDate",
                        "name": "referenceDate"
                    },
                    {
                        "full": "currency",
                        "name": "currency"
                    },
                    {
                        "full": "bonds",
                        "name": "bonds"
                    },
                    {
                        "full": "terms",
                        "name": "terms"
                    },
                    {
                        "full": "quotes",
                        "name": "quotes"
                    },
                    {
                        "full": "dayCountConvention",
                        "name": "dayCountConvention"
                    },
                    {
                        "full": "[compounding='Compounded']",
                        "name": "compounding",
                        "optional": true,
                        "default": "'Compounded'"
                    },
                    {
                        "full": "[frequency='Annual']",
                        "name": "frequency",
                        "optional": true,
                        "default": "'Annual'"
                    },
                    {
                        "full": "[curveName]",
                        "name": "curveName",
                        "optional": true
                    },
                    {
                        "full": "[method='Bootstrap']",
                        "name": "method",
                        "optional": true,
                        "default": "'Bootstrap'"
                    },
                    {
                        "full": "[interpMethod='Linear']",
                        "name": "interpMethod",
                        "optional": true,
                        "default": "'Linear'"
                    },
                    {
                        "full": "[extrapMethod='Flat']",
                        "name": "extrapMethod",
                        "optional": true,
                        "default": "'Flat'"
                    }
                ]
            }
        ],
        "markdown": "### [bondYieldCurveBuilder](https://docs.dolphindb.cn/zh/funcs/b/bondYieldCurveBuilder.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\nbondYieldCurveBuilder(referenceDate, currency, bonds, terms, quotes, dayCountConvention, \\[compounding='Compounded'], \\[frequency='Annual'], \\[curveName], \\[method='Bootstrap'], \\[interpMethod='Linear'], \\[extrapMethod='Flat'])\n\n#### 详情\n\n构建债券收益率曲线，可作为定价时使用的贴现曲线（即期收益率曲线）。\n\n#### 参数\n\n**referenceDate** DATE 类型标量，收益率曲线的参考日期。\n\n**currency** STRING 类型标量，表示曲线所定义的货币，可选值为：\n\n* \"CNY\"：人民币\n\n* \"USD\"：美元\n\n* \"EUR\"：欧元\n\n* \"GBP\"：英镑\n\n* \"JPY\"：日元\n\n* \"HKD\"：港币\n\n**bonds** INSTRUMENT 类型向量，表示用于曲线构建的样本债券，包含各债券的基本信息。不同类型的债券产品所需的关键字段各不相同，详见[债券产品字段要求](https://docs.dolphindb.cn/zh/funcs/b/bondYieldCurveBuilder.html#topic_e5t_sl2_ngc)。\n\n**terms** DURATION 类型的严格递增向量，与 *bonds* 等长，表示样本券的剩余期限。\n\n**quotes** 数值类型的向量，与 *bonds* 等长，表示每只债券在 *referenceDate* 当日的到期收益率（YTM）报价。\n\n**dayCountConvention** STRING 类型标量，表示计息日数规则，可选值为：\n\n* \"Actual360\": 实际/360\n\n* \"Actual365\": 实际/365\n\n* \"ActualActualISDA\"：实际/实际，遵循 ISDA（International Swaps and Derivatives Association，国际掉期及衍生工具协会）规则\n\n* \"ActualActualISMA\": 实际/实际，遵循 ISMA（International Securities Market Association，国际证券市场协会）规则\n\n**compounding** 可选参数，STRING 类型标量，表示利率复利方式。可选值为：\n\n* \"Compounded\"：默认值，离散复利。\n\n* \"Simple\"：简单复利。\n\n* \"Continuous\"：连续复利。\n\n**frequency** 可选参数，STRING 类型标量，表示曲线的频率，用于指定曲线的频率，不影响曲线构建，仅会记录在返回的曲线中，默认值为“Annual”。可选值为：\n\n* \"Annual\"：默认值，每年付息一次\n\n* \"NoFrequency\"：无计息频率\n\n* \"Once\"：到期一次还本付息，仅用于贴现债和零息债\n\n* \"Semiannual\"：每半年付息一次\n\n* \"EveryFourthMonth\"：每四个月付息一次\n\n* \"Quarterly\"：每季度付息一次\n\n* \"BiMonthly\"：每两月付息一次\n\n* \"Monthly\"：每月付息一次\n\n* \"EveryFourthWeek\"：每四周付息一次\n\n* \"BiWeekly\"：每两周付息一次\n\n* \"Weekly\"：每周付息一次\n\n* \"Daily\"：每日付息一次\n\n* \"Other\"：其他计息频率\n\n**curveName** 可选参数，STRING 类型标量，表示生成的曲线名称，默认为空。\n\n**method** 可选参数，STRING 类型标量，表示曲线构建方法。 可选值为：\n\n* \"Bootstrap\"：默认值，拨靴法。\n\n* \"NS\"：Nelson-Siegel 模型，至少需要 4 个样本点输入用于曲线构建。\n\n* \"NSS\"：Nelson-Siegel-Svensson 模型，至少需要 6 个样本点输入用于曲线构建。\n\n**interpMethod** 可选参数，STRING 类型标量，表示内插方法。可选值为：\n\n* \"Linear\"：默认值，线性插值。\n\n* \"CubicSpline\"：三次样条插值。\n\n* \"CubicHermiteSpline\"：三次埃尔米特样条插值。\n\n**extrapMethod** 可选参数，STRING 类型标量，表示外插方法。可选值为：\n\n* \"Flat\"：默认值，平插。\n\n* \"Linear\"：线性插值。\n\n#### 返回值\n\nMKTDATA 类型对象。\n\n#### 例子\n\n基于2025年8月18日的国债市场数据构建收益率曲线。\n\n```\nbond1 = {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Bond\",\n    \"bondType\": \"DiscountBond\",\n    \"instrumentId\": \"259916.IB\",\n    \"start\": 2025.03.13,\n    \"maturity\": 2025.09.11,\n    \"issuePrice\":  99.2070,\n    \"dayCountConvention\": \"ActualActualISDA\"\n}\nbond2 = {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Bond\",\n    \"bondType\": \"FixedRateBond\",\n    \"instrumentId\": \"240021.IB\",\n    \"start\": 2024.10.25,\n    \"maturity\": 2025.10.25,\n    \"issuePrice\": 100,\n    \"coupon\": 0.0133,\n    \"frequency\": \"Annual\",\n    \"dayCountConvention\": \"ActualActualISDA\"\n}\nbond3 = {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Bond\",\n    \"bondType\": \"FixedRateBond\",\n    \"instrumentId\": \"250001.IB\",\n    \"start\": 2025.01.15,\n    \"maturity\": 2026.01.15,\n    \"issuePrice\": 100,\n    \"coupon\": 0.0116,\n    \"frequency\": \"Annual\",\n    \"dayCountConvention\": \"ActualActualISDA\"\n}\nbond4 = {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Bond\",\n    \"bondType\": \"FixedRateBond\",\n    \"instrumentId\": \"250013.IB\",\n    \"start\": 2025.07.25,\n    \"maturity\": 2026.07.25,\n    \"issuePrice\": 100,\n    \"coupon\": 0.0133,\n    \"frequency\": \"Annual\",\n    \"dayCountConvention\": \"ActualActualISDA\"\n}\nbond5 = {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Bond\",\n    \"bondType\": \"FixedRateBond\",\n    \"instrumentId\": \"250012.IB\",\n    \"start\": 2025.06.15,\n    \"maturity\": 2027.06.15,\n    \"issuePrice\": 100,\n    \"coupon\": 0.0138,\n    \"frequency\": \"Annual\",\n    \"dayCountConvention\": \"ActualActualISDA\"\n}\nbond6 = {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Bond\",\n    \"bondType\": \"FixedRateBond\",\n    \"instrumentId\": \"250010.IB\",\n    \"start\": 2025.05.25,\n    \"maturity\": 2028.05.25,\n    \"issuePrice\": 100,\n    \"coupon\": 0.0146,\n    \"frequency\": \"Annual\",\n    \"dayCountConvention\": \"ActualActualISDA\"\n}\nbond7 = {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Bond\",\n    \"bondType\": \"FixedRateBond\",\n    \"instrumentId\": \"250014.IB\",\n    \"start\": 2025.07.25,\n    \"maturity\": 2030.07.25,\n    \"issuePrice\": 100,\n    \"coupon\": 0.0155,\n    \"frequency\": \"Annual\",\n    \"dayCountConvention\": \"ActualActualISDA\"\n}\nbond8 = {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Bond\",\n    \"bondType\": \"FixedRateBond\",\n    \"instrumentId\": \"2500802.IB\",\n    \"start\": 2025.05.25,\n    \"maturity\": 2032.05.25,\n    \"issuePrice\": 100,\n    \"coupon\": 0.0157,\n    \"frequency\": \"Annual\",\n    \"dayCountConvention\": \"ActualActualISDA\"\n}\nbond9 = {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Bond\",\n    \"bondType\": \"FixedRateBond\",\n    \"instrumentId\": \"250011.IB\",\n    \"start\": 2025.05.25,\n    \"maturity\": 2035.05.25,\n    \"issuePrice\": 100,\n    \"coupon\": 0.0167,\n    \"frequency\": \"Semiannual\",\n    \"dayCountConvention\": \"ActualActualISDA\"\n}\nbond10 = {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Bond\",\n    \"bondType\": \"FixedRateBond\",\n    \"instrumentId\": \"2400102.IB\",\n    \"start\": 2024.08.29,\n    \"maturity\": 2039.08.29,\n    \"issuePrice\": 100,\n    \"coupon\": 0.0225,\n    \"frequency\": \"Semiannual\",\n    \"dayCountConvention\": \"ActualActualISDA\"\n}\nbond11 = {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Bond\",\n    \"bondType\": \"FixedRateBond\",\n    \"instrumentId\": \"2500004.IB\",\n    \"start\": 2025.07.15,\n    \"maturity\": 2045.07.15,\n    \"issuePrice\": 100,\n    \"coupon\": 0.0192,\n    \"frequency\": \"Semiannual\",\n    \"dayCountConvention\": \"ActualActualISDA\"\n}\nbond12 = {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Bond\",\n    \"bondType\": \"FixedRateBond\",\n    \"instrumentId\": \"2500005.IB\",\n    \"start\": 2025.07.15,\n    \"maturity\": 2055.07.15,\n    \"issuePrice\": 100,\n    \"coupon\": 0.019,\n    \"frequency\": \"Semiannual\",\n    \"dayCountConvention\": \"ActualActualISDA\"\n}\nbond13 = {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Bond\",\n    \"bondType\": \"FixedRateBond\",\n    \"instrumentId\": \"200007.IB\",\n    \"start\": 2020.05.25,\n    \"maturity\": 2070.05.25,\n    \"issuePrice\": 100,\n    \"coupon\": 0.0373,\n    \"frequency\": \"Semiannual\",\n    \"dayCountConvention\": \"ActualActualISDA\"\n}\nbond14 = {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Bond\",\n    \"bondType\": \"FixedRateBond\",\n    \"instrumentId\": \"2400003.IB\",\n    \"start\": 2024.06.15,\n    \"maturity\": 2074.06.15,\n    \"issuePrice\": 100,\n    \"coupon\": 0.0253,\n    \"frequency\": \"Semiannual\",\n    \"dayCountConvention\": \"ActualActualISDA\"\n}\n\nreferenceDate = 2025.08.18\nbondsTmp = [bond1, bond2, bond3, bond4, bond5, bond6, bond7, bond8, bond9,\n         bond10, bond11, bond12, bond13, bond14]\nbonds = parseInstrument(bondsTmp)\n\n```\n\n本案例参考外汇交易中心标准期限[收盘收益率曲线历史数据下载\\_中国货币网](https://www.chinamoney.com.cn/chinese/bkcurvclosedyhis/index.html)，样本券的剩余期限（term）和报价（quote）均为模拟数据。\n\n```\nterms = [1M, 3M, 6M, 1y, 2y, 3y, 5y, 7y, 10y, 15y, 20y, 30y, 40y, 50y]\nquotes=[1.3000, 1.3700, 1.3898, 1.3865, 1.4296, 1.4466, 1.6348, \n        1.7557, 1.7875, 1.9660, 2.1300, 2.1100, 2.1556, 2.1750]/100\n       \n// method = \"BoostStarp\"\nbootstrapCurve = bondYieldCurveBuilder(referenceDate, `CNY, bonds, terms, quotes, \"ActualActualISDA\", method='Bootstrap')\nbootstrapCurveDict = extractMktData(bootstrapCurve)\nprint(bootstrapCurveDict)\n\n// method = \"NS\"\nnsCurve = bondYieldCurveBuilder(referenceDate, `CNY, bonds, terms, quotes, \"ActualActualISDA\", method='NS')\nnsCurveDict = extractMktData(nsCurve)\nprint(nsCurveDict)\n\n// method = \"NSS\"\nnssCurve = bondYieldCurveBuilder(referenceDate, `CNY, bonds, terms, quotes, \"ActualActualISDA\", method='NSS')\nnssCurveDict=extractMktData(nssCurve)\nprint(nssCurveDict)\n```\n\n实际应用中，应根据样本券到期日减去曲线参考日期计算剩余期限，并使用实际到期收益率（YTM）报价参与曲线构建，以符合 CFETS 债券收盘估值标准，[债券估值\\_债券收盘估值\\_债券动态估值\\_中国货币网](https://www.chinamoney.com.cn/chinese/bkval/)。\n\n```\nterms2 = array(DURATION)\nfor(bond in bondsTmp){\n   term = duration(string(bond[\"maturity\"] - referenceDate)+\"d\")\n   terms2.append!(term)\n}\n\nquotes2 = [1.2799, 1.3440, 1.3450, 1.3849, 1.4200, 1.4450, 1.6295, \n          1.7350, 1.7860, 2.0493, 2.1304, 2.1140, 2.1558, 2.1728] / 100\n          \n// method = \"BoostStarp\"\nbootstrapCurve2 = bondYieldCurveBuilder(referenceDate, `CNY, bonds, terms2, quotes2, \"ActualActualISDA\", method='Bootstrap')\nbootstrapCurveDict2 = extractMktData(bootstrapCurve2)\nprint(bootstrapCurveDict2)\n\n// method = \"NS\"\nnsCurve2 = bondYieldCurveBuilder(referenceDate, `CNY, bonds, terms2, quotes2, \"ActualActualISDA\", method='NS')\nnsCurveDict2 = extractMktData(nsCurve2)\nprint(nsCurveDict2)\n\n// method = \"NSS\"\nnssCurve2 = bondYieldCurveBuilder(referenceDate, `CNY, bonds, terms2, quotes2, \"ActualActualISDA\",method='NSS')\nnssCurveDict2 =extractMktData(nssCurve2)\nprint(nssCurveDict2)\n```\n\n**相关函数：**[extractMktData](https://docs.dolphindb.cn/zh/funcs/e/extractMktData.html), [parseInstrument](https://docs.dolphindb.cn/zh/funcs/p/parseInstrument.html)\n\n#### 债券产品字段要求\n\n**贴现债**\n\n<table id=\"table_or3_p4l_ngc\"><thead><tr><th>\n\n字段名\n\n</th><th>\n\n类型\n\n</th><th>\n\n描述\n\n</th><th>\n\n是否必填\n\n</th></tr></thead><tbody><tr><td>\n\nproductType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"Cash\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nassetType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"Bond\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nbondType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"DiscountBond\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nnominal\n\n</td><td>\n\nDOUBLE\n\n</td><td>\n\n名义金额，默认值 100\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ninstrumentId\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n债券代码，如 \"259926.IB\"\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\nstart\n\n</td><td>\n\nDATE\n\n</td><td>\n\n起息日\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nmaturity\n\n</td><td>\n\nDATE\n\n</td><td>\n\n到期日\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ndayCountConvention\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n日期计数惯例，可选 \"ActualActualISDA\", \"ActualActualISMA\", \"Actual365\", \"Actual360\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nissuePrice\n\n</td><td>\n\nDOUBLE\n\n</td><td>\n\n发行价格\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ncurrency\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n货币，默认为 \"CNY\"\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ncashFlow\n\n</td><td>\n\nTABLE\n\n</td><td>\n\n债券现金流表\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ndiscountCurve\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n定价时参考的贴现曲线名称，如 \"CNY\\_TRASURY\\_BOND\"\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\nspreadCurve\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n定价时参考的利差曲线名称\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\nsubType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n债券子类型，中国债券可选值为：\n\n* \"TREASURY\\_BOND\"：国债\n\n* \"CENTRAL\\_BANK\\_BILL\"：央行票据\n\n* \"CDB\\_BOND\"：政策性金融债（国开）\n\n* \"EIBC\\_BOND\"：政策性金融债（进出口行）\n\n* \"ADBC\\_BOND\"：政策性金融债（农发行）。\n\n* \"MTN\"：中期票据\n\n* \"CORP\\_BOND\"：企业债。\n\n* \"UNSECURED\\_CORP\\_BOND\"：无担保企业债\n\n* \"SHORT\\_FIN\\_BOND\"：短期融资券\n\n* \"NCD\"：同业存单\n\n* \"LOC\\_GOV\\_BOND\"：地方政府债\n\n* \"COMM\\_BANK\\_FIN\\_BOND\"：商业银行普通金融债\n\n* \"BANK\\_SUB\\_CAP\\_BOND\"：商业银行二级资本债\n\n* \"ABS\"：资产支持证券\n\n* \"PPN\"：非公开发行债\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ncreditRating\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n信用等级类型，可选值为：\"B\", \"BB\", \"BBB\", \"BBB+\", \"A-\", \"A\", \"A+\", \"AA-\", \"AA\", \"AA+\", \"AAA-\", \"AAA\", \"AAA+\"\n\n</td><td>\n\n否\n\n</td></tr></tbody>\n</table>**零息债**\n\n<table id=\"table_rgb_r4l_ngc\"><thead><tr><th>\n\n字段名\n\n</th><th>\n\n类型\n\n</th><th>\n\n描述\n\n</th><th>\n\n是否必填\n\n</th></tr></thead><tbody><tr><td>\n\nproductType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"Cash\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nassetType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"Bond\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nbondType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"ZeroCouponBond\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nnominal\n\n</td><td>\n\nDOUBLE\n\n</td><td>\n\n名义金额，默认值 100\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ninstrumentId\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n债券代码，如 \"250401.IB\"\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\nstart\n\n</td><td>\n\nDATE\n\n</td><td>\n\n起息日\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nmaturity\n\n</td><td>\n\nDATE\n\n</td><td>\n\n到期日\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ncoupon\n\n</td><td>\n\nDOUBLE\n\n</td><td>\n\n票面利率，如 0.03 表示 3%\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nfrequency\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n付息频率\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ndayCountConvention\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n日期计数惯例，可选 \"ActualActualISDA\", \"ActualActualISMA\", \"Actual365\", \"Actual360\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ncurrency\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n货币，默认为 \"CNY\"\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ncashFlow\n\n</td><td>\n\nTABLE\n\n</td><td>\n\n债券现金流表\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ndiscountCurve\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n定价时参考的贴现曲线名称，如 \"CNY\\_TRASURY\\_BOND\"\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\nspreadCurve\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n定价时参考的利差曲线名称\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\nsubType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n债券子类型，中国债券可选值为：\n\n* \"TREASURY\\_BOND\"：国债\n\n* \"CENTRAL\\_BANK\\_BILL\"：央行票据\n\n* \"CDB\\_BOND\"：政策性金融债（国开）\n\n* \"EIBC\\_BOND\"：政策性金融债（进出口行）\n\n* \"ADBC\\_BOND\"：政策性金融债（农发行）。\n\n* \"MTN\"：中期票据\n\n* \"CORP\\_BOND\"：企业债。\n\n* \"UNSECURED\\_CORP\\_BOND\"：无担保企业债\n\n* \"SHORT\\_FIN\\_BOND\"：短期融资券\n\n* \"NCD\"：同业存单\n\n* \"LOC\\_GOV\\_BOND\"：地方政府债\n\n* \"COMM\\_BANK\\_FIN\\_BOND\"：商业银行普通金融债\n\n* \"BANK\\_SUB\\_CAP\\_BOND\"：商业银行二级资本债\n\n* \"ABS\"：资产支持证券\n\n* \"PPN\"：非公开发行债\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ncreditRating\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n信用等级类型，可选值为：\"B\", \"BB\", \"BBB\", \"BBB+\", \"A-\", \"A\", \"A+\", \"AA-\", \"AA\", \"AA+\", \"AAA-\", \"AAA\", \"AAA+\"\n\n</td><td>\n\n否\n\n</td></tr></tbody>\n</table>**固定利率债**\n\n<table id=\"table_rq3_t4l_ngc\"><thead><tr><th>\n\n字段名\n\n</th><th>\n\n类型\n\n</th><th>\n\n描述\n\n</th><th>\n\n是否必填\n\n</th></tr></thead><tbody><tr><td>\n\nproductType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"Cash\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nassetType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"Bond\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nbondType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"FixedRateBond\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nnominal\n\n</td><td>\n\nDOUBLE\n\n</td><td>\n\n名义金额，默认值 100\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ninstrumentId\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n债券代码，如 \"250401.IB\"\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\nstart\n\n</td><td>\n\nDATE\n\n</td><td>\n\n起息日\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nmaturity\n\n</td><td>\n\nDATE\n\n</td><td>\n\n到期日\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ncoupon\n\n</td><td>\n\nDOUBLE\n\n</td><td>\n\n票面利率，如0.03表示3%\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nfrequency\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n付息频率\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ndayCountConvention\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n日期计数惯例，可选 \"ActualActualISDA\", \"ActualActualISMA\", \"Actual365\", \"Actual360\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ncurrency\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n货币，默认为 \"CNY\"\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ncashFlow\n\n</td><td>\n\nTABLE\n\n</td><td>\n\n债券现金流表\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ndiscountCurve\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n定价时参考的贴现曲线名称，如 \"CNY\\_TRASURY\\_BOND\"\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\nspreadCurve\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n定价时参考的利差曲线名称\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\nsubType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n债券子类型，中国债券可选值为：\n\n* \"TREASURY\\_BOND\"：国债\n\n* \"CENTRAL\\_BANK\\_BILL\"：央行票据\n\n* \"CDB\\_BOND\"：政策性金融债（国开）\n\n* \"EIBC\\_BOND\"：政策性金融债（进出口行）\n\n* \"ADBC\\_BOND\"：政策性金融债（农发行）。\n\n* \"MTN\"：中期票据\n\n* \"CORP\\_BOND\"：企业债。\n\n* \"UNSECURED\\_CORP\\_BOND\"：无担保企业债\n\n* \"SHORT\\_FIN\\_BOND\"：短期融资券\n\n* \"NCD\"：同业存单\n\n* \"LOC\\_GOV\\_BOND\"：地方政府债\n\n* \"COMM\\_BANK\\_FIN\\_BOND\"：商业银行普通金融债\n\n* \"BANK\\_SUB\\_CAP\\_BOND\"：商业银行二级资本债\n\n* \"ABS\"：资产支持证券\n\n* \"PPN\"：非公开发行债\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ncreditRating\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n信用等级类型，可选值为：\"B\", \"BB\", \"BBB\", \"BBB+\", \"A-\", \"A\", \"A+\", \"AA-\", \"AA\", \"AA+\", \"AAA-\", \"AAA\", \"AAA+\"\n\n</td><td>\n\n否\n\n</td></tr></tbody>\n</table>\n"
    },
    "bool": {
        "url": "https://docs.dolphindb.cn/zh/funcs/b/bool.html",
        "signatures": [
            {
                "full": "bool(X)",
                "name": "bool",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [bool](https://docs.dolphindb.cn/zh/funcs/b/bool.html)\n\n\n\n#### 语法\n\nbool(X)\n\n#### 详情\n\n把输入转换为布尔值。\n\n#### 参数\n\n**X** 可以是任意的数据类型。\n\n#### 返回值\n\n布尔类型，其数据形式同 *X*。\n\n#### 例子\n\n```\nx=bool();\nx;\n```\n\n返回：null\n\n```\ntypestr x;\n```\n\n返回：BOOL\n\n```\nbool(`true);\n```\n\n返回：true\n\n```\nbool(`false);\n```\n\n返回：false\n\n```\nbool(`true`false)\n```\n\n返回：\\[true, false]\n\n```\nbool(100.2);\n```\n\n返回：true\n\n```\nbool(0);\n```\n\n返回：false\n"
    },
    "boxcox": {
        "url": "https://docs.dolphindb.cn/zh/funcs/b/boxcox.html",
        "signatures": [
            {
                "full": "boxcox(X, [lmbda])",
                "name": "boxcox",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[lmbda]",
                        "name": "lmbda",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [boxcox](https://docs.dolphindb.cn/zh/funcs/b/boxcox.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nboxcox(X, \\[lmbda])\n\n#### 详情\n\n使用 Box-Cox 变换方法对 *X* 进行转换。\n\nBox-Cox 变换由下式给出：\n\n![](https://docs.dolphindb.cn/zh/funcs/images/boxcox.png)\n\n与 Python 中 `scipy.stats.boxcox` 的区别：二者都可进行 Box-Cox 变换，并在未指定 *lmbda* 时估计最优 lambda；DolphinDB 的 *lmbda* 可为标量或向量，向量时逐元素变换，SciPy 还支持 *alpha* 置信区间和 *optimizer* 参数。\n\n#### 参数\n\n**X** 数值型向量，表示要转换的输入向量。如果未指定 *lmbda* 参数，*X* 不能包含空值或非正数，且 *X* 的所有元素不能相同。\n\n**lmbda**可选参数，数值类型标量或向量，表示 lambda 参数。若为向量，*X* 与 *lmbda* 的长度必须相同。\n\n#### 返回值\n\n* 如果指定了 *lmbda* 参数，返回值为与 *X* 等长的 DOUBLE 类型向量。\n  * 如果 *lmbda* 是标量，则返回值是使用 *lmbda* 对 *X* 进行 Box-Cox 转换的结果。\n  * 如果 *lmbda* 是向量，则返回值的每个元素分别为 boxcox(Xi, lmbdai)。\n* 如果未指定 *lmbda* 参数，返回值为元组，包含两个元素：\n  * 第一个元素为 DOUBLE 类型的向量，表示对 *X* 进行 Box-Cox 转换的结果。\n  * 第二个元素为 DOUBLE 类型的标量，表示最优的 lambda 参数。\n\n#### 例子\n\n```\ndata = [1.5, 2.3, 3.1, 4.8, 5.5, 6.7, 8.2, 9.0, 10.1, 12.4]\nlmb = 2\nboxcox(data)\n// output: ([0.4541,1.0562,1.5689,2.4892,2.82394,3.3559,3.9636,4.267,4.6653,5.4393],0.5495)\nboxcox(data, lmb)\n// output: [0.625,2.145,4.305,11.02,14.625,21.945,33.12,40,50.505,76.38]\n```\n"
    },
    "brentq": {
        "url": "https://docs.dolphindb.cn/zh/funcs/b/brentq.html",
        "signatures": [
            {
                "full": "brentq(f, a, b, [xtol], [rtol], [maxIter], [funcDataParam])",
                "name": "brentq",
                "parameters": [
                    {
                        "full": "f",
                        "name": "f"
                    },
                    {
                        "full": "a",
                        "name": "a"
                    },
                    {
                        "full": "b",
                        "name": "b"
                    },
                    {
                        "full": "[xtol]",
                        "name": "xtol",
                        "optional": true
                    },
                    {
                        "full": "[rtol]",
                        "name": "rtol",
                        "optional": true
                    },
                    {
                        "full": "[maxIter]",
                        "name": "maxIter",
                        "optional": true
                    },
                    {
                        "full": "[funcDataParam]",
                        "name": "funcDataParam",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [brentq](https://docs.dolphindb.cn/zh/funcs/b/brentq.html)\n\n\n\n#### 语法\n\nbrentq(f, a, b, \\[xtol], \\[rtol], \\[maxIter], \\[funcDataParam])\n\n#### 详情\n\n使用 Brent 方法在一个给定区间 \\[a, b] 内求出函数 f(x) 的一个根 x0，使得 f(x0)=0 ，求解精度满足 `|x-x0| <= (xtol + rtol* |x0| )`，其中 x 是精确根，x0 为计算结果。\n\n与 Python 中 `scipy.optimize.brentq` 的区别：二者都使用 Brent 方法在有符号变化的区间内求根；DolphinDB 返回长度为 2 的结果，包含状态字符串和根，额外参数通过 *funcDataParam* 向量传入，SciPy 默认返回根，*full\\_output*=True 时返回根和 `RootResults`，额外参数通过 *args* 元组传入。\n\n#### 参数\n\n**f** 是一个返回值为一个数值的函数。函数在 \\[a, b] 内连续且 f(a) 与 f(b) 的正负号需要相反。\n\n**a** 是一个数值标量，指定区间的左边界。\n\n**b** 是一个数值标量，指定区间的右边界。\n\n**xtol** 是一个数值标量，用于指定求解结果的精度，默认值为 2e-12。\n\n**rtol** 是一个数值标量，用于指定求解结果的精度，默认值为 4 倍的 DOUBLE 类型的机器精度。\n\n**maxIter** 是一个整形标量，指定 Brent 的最大迭代次数，默认值为 100 。\n\n**funcDataParam** 是一个向量，指定函数 f 的其他参数。\n\n#### 返回值\n\n返回值为长度为2的向量 res：\n\n* res\\[0] 是一个字符串标量，表示求解状态。共有三种求解状态：\n  * CONVERGED， 表示得到符合预期的解；\n  * SIGNERR，表示 f(a) 与 f(b) 同号，不满足正负号相反的要求；\n  * CONVERR，表示达到最大迭代次数\n* res\\[1] 是一个数值标量，表示求得的根。\n\n#### 例子\n\n求解 f(x) = x^2 - 1 在 \\[-2,0], \\[0,2] 的根\n\n```\ndef f(x) {\n    return (pow(x, 2) - 1)\n}\n\nroot1 = brentq(f, -2, 0)\nroot2 = brentq(f, 0, 2)\nprint(\"root1 : \", root1)\nprint(\"root2 : \", root2)\n```\n\n返回如下：\n\n```\nroot1 :\n(\"CONVERGED\",-1)\nroot2 :\n(\"CONVERGED\",1)\n```\n\n求解带有额外参数的函数 f(x,b) 在 \\[0,2] 的根：\n\n```\ndef f(x, b) {\n    return (pow(x, 2) - b)\n}\nroot = brentq(f, 0, 2, 2e-12, 1e-9, 100, [2])\nprint(\"root : \", root)\n```\n\n返回如下：\n\n```\nroot : \n(\"CONVERGED\",1.414213562373136)\n```\n"
    },
    "brute": {
        "url": "https://docs.dolphindb.cn/zh/funcs/b/brute.html",
        "signatures": [
            {
                "full": "brute(func, ranges, [ns=20], [finish=fmin])",
                "name": "brute",
                "parameters": [
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "ranges",
                        "name": "ranges"
                    },
                    {
                        "full": "[ns=20]",
                        "name": "ns",
                        "optional": true,
                        "default": "20"
                    },
                    {
                        "full": "[finish=fmin]",
                        "name": "finish",
                        "optional": true,
                        "default": "fmin"
                    }
                ]
            }
        ],
        "markdown": "### [brute](https://docs.dolphindb.cn/zh/funcs/b/brute.html)\n\n\n\n#### 语法\n\nbrute(func, ranges, \\[ns=20], \\[finish=fmin])\n\n#### 详情\n\n通过穷举法在给定范围内最小化一个函数。穷举法使用网格搜索，即计算多维网格点上每个点处的函数值，以找到函数的全局最小值。\n\n注意：穷举法效率低下，其原因是网格点的数量呈指数级增加。因此，即使网格间距较粗、或者问题仅为中等大小等情况，也可能需要很长的运行时间，还可能遇到内存限制。\n\n与 Python 中 `scipy.optimize.brute` 的区别：二者都用于网格穷举最小化，并可接后续优化；DolphinDB 的 *ranges* 使用 `(low, high)` 或 `(low, high, num)` 元组，返回包含 `xopt`、`fopt` 的字典，SciPy 支持 slice 网格、*args*、*full\\_output*、*workers* 等参数，并可返回网格和函数值数组。\n\n#### 参数\n\n**func** 函数名，表示需要最小化的目标函数。注意：其返回值须是数值标量类型。\n\n**ranges** 元组类型，表示每个参数分量的数值范围。*ranges* 中每个元素为形如`(low, high)`或`(low, high, num)`的元组。其中 `low` 和 `high` 都是数值类型，`low` 表示该参数分量的最低取值，`high` 表示该参数分量的最高取值；`num` 为正整数，表示沿轴线的网格点数量，即该参数分量在范围内的取值个数。\n\n**ns** 可选参数，正整数标量，表示沿轴线的网格点数量。优先取 *ranges* 元素`(low, high, num)`中的 `num` 值；若 *ranges*中未设置\\*，\\*则 `num` 为 *ns*。该参数默认值为 20。\n\n**finish** 可选参数，函数名，表示一个优化函数。其输入需满足 `finish(func, X)`；输出应返回一个字典，包含键`\"xopt\"`和`\"fopt\"`，且值为数值类型。默认值为函数 `fmin`。将穷举法网格搜索的结果作为初始猜测，使用该函数对目标函数进行优化。注意：也可传入“NULL”，表示直接返回穷举法网格搜索的结果，不进行优化。\n\n#### 返回值\n\n返回一个字典，字典有以下成员：\n\n* xopt：浮点数向量，使目标函数最小化的参数值。\n* fopt：浮点数标量，目标函数最小值。fopt=func(xopt)。\n\n#### 例子\n\n以下自定义一个函数 `f`，传入指定 *ranges* 和 *ns* 值，计算 `f` 函数在 *ranges* 内最小化的参数值和对应的最小值。\n\n```\ndef f(z) {\n\ta = 2\n\tb = 3\n\tc = 7\n\td = 8\n\tee = 9\n\tf = 10\n\tg = 44\n\th = -1\n\ti = 2\n\tj = 26\n\tk = 1\n\tl = -2\n\tscale = 0.5\n\tx = z[0]\n\ty = z[1]\n\tf1 = a * square(x) + b * x * y + c * square(y) + d * x + ee* y + f\n\tf2 = -g * exp(-(square(x-h)+square(y-i)) / scale)\n\tf3 =  -j * exp(-(square(x-k)+square(y-l)) / scale)\n\treturn f1+f2+f3\n}\nranges=((-4, 3.75),(-4, 3.75))\nbrute(f, ranges, 32)\n\n/* Ouput:\n\nfopt->-3.408581876799\nxopt->[-1.056651921797,1.808348429512]\n\n*/\n```\n"
    },
    "bucket": {
        "url": "https://docs.dolphindb.cn/zh/funcs/b/bucket.html",
        "signatures": [
            {
                "full": "bucket(vector, dataRange, bucketNum, [includeOutbound=false])",
                "name": "bucket",
                "parameters": [
                    {
                        "full": "vector",
                        "name": "vector"
                    },
                    {
                        "full": "dataRange",
                        "name": "dataRange"
                    },
                    {
                        "full": "bucketNum",
                        "name": "bucketNum"
                    },
                    {
                        "full": "[includeOutbound=false]",
                        "name": "includeOutbound",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [bucket](https://docs.dolphindb.cn/zh/funcs/b/bucket.html)\n\n\n\n#### 语法\n\nbucket(vector, dataRange, bucketNum, \\[includeOutbound=false])\n\n#### 详情\n\n返回一个和 *vector* 相同长度的向量，表明根据 *dataRange* 和 *bucketNum* 所给出的分类规则，每一个元素应该属于哪个桶。\n\n例如，*dataRange* 是 0:10，*bucketNum* 是 2，则两个桶分别是 \\[0, 5) 和 \\[5, 10)，桶的编号分别为0和1。如果 *includeOutbound* 为true，这个例子会产生 4 个桶，即 <0, \\[0, 5), \\[5,10) 和 >=10。如果 *includeOutbound* 为false，任何小于下限或大于等于上限的值会返回 NULL。\n\n#### 参数\n\n**vector** 一个数值或时间向量。\n\n**dataRange** 一对表示数据范围的值，包括下限，不包括上限。\n\n**bucketNum** 桶的数量。当 *dataRange* 是整型数据对时，它的范围大小必须是 *bucketNum* 的整数倍。\n\n**includeOutbound** 一个可选的布尔值，表明是否包括小于下限的值，以及大于或等于上限的值。默认值为 false。\n\n#### 返回值\n\n返回一个和 *vector* 相同长度的 INT 类型向量。\n\n#### 例子\n\n```\nbucket(9 23 54 36 46 12, 12:54, 2);\n// output\n[,0,,1,1,0]\n\nbucket(9 23 54 36 46 12, 12:54, 2, 1);\n// output\n[0,1,3,2,2,1]\n```\n"
    },
    "bucketCount": {
        "url": "https://docs.dolphindb.cn/zh/funcs/b/bucketCount.html",
        "signatures": [
            {
                "full": "bucketCount(vector, dataRange, bucketNum, [includeOutbound=false])",
                "name": "bucketCount",
                "parameters": [
                    {
                        "full": "vector",
                        "name": "vector"
                    },
                    {
                        "full": "dataRange",
                        "name": "dataRange"
                    },
                    {
                        "full": "bucketNum",
                        "name": "bucketNum"
                    },
                    {
                        "full": "[includeOutbound=false]",
                        "name": "includeOutbound",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [bucketCount](https://docs.dolphindb.cn/zh/funcs/b/bucketCount.html)\n\n\n\n#### 语法\n\nbucketCount(vector, dataRange, bucketNum, \\[includeOutbound=false])\n\n#### 详情\n\n函数 `bucketCount` 有和 [bucket](https://docs.dolphindb.cn/zh/funcs/b/bucket.html) 相同的参数，但是返回每个桶中元素的计数。\n\n#### 参数\n\n**vector** 一个数值或时间向量。\n\n**dataRange** 一对表示数据范围的值，包括下限，不包括上限。\n\n**bucketNum** 桶的数量。当 *dataRange* 是整型数据对时，它的范围大小必须是 *bucketNum* 的整数倍。\n\n**includeOutbound** 一个可选的布尔值，表明是否包括小于下限的值，和大于等于上限的值。默认值为 false。\n\n#### 返回值\n\n返回一个长度为 *bucketNum* 的 INT 类型向量。\n\n#### 例子\n\n```\nbucketCount(9 23 54 36 46 12, 12:54, 2);\n// output\n[2,2]\n\nbucketCount(9 23 54 36 46 12, 12:54, 2, 1);\n// output\n[1,2,2,1]\n```\n"
    },
    "businessDay": {
        "url": "https://docs.dolphindb.cn/zh/funcs/b/businessDay.html",
        "signatures": [
            {
                "full": "businessDay(X, [offset], [n=1])",
                "name": "businessDay",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[offset]",
                        "name": "offset",
                        "optional": true
                    },
                    {
                        "full": "[n=1]",
                        "name": "n",
                        "optional": true,
                        "default": "1"
                    }
                ]
            }
        ],
        "markdown": "### [businessDay](https://docs.dolphindb.cn/zh/funcs/b/businessDay.html)\n\n\n\n#### 语法\n\nbusinessDay(X, \\[offset], \\[n=1])\n\n#### 详情\n\n如果 *X* 所在的日期是工作日（周一到周五），返回 *X* 的日期，反之返回 *X* 最近的工作日。\n\n如果指定了 *offset* 和 *n*，且 *n* > 1，则函数按长度为 *n* 个工作日的周期计算。此时，*offset* 用于确定工作日周期的对齐方式：系统会先计算出 *offset* 对应的工作日，然后以该工作日为基准，每隔 *n* 个工作日生成一个周期边界，并返回 *X* 所属周期对应的工作日。\n\nDolphinDB 和 pandas 在概念层面上都提供了类似日期偏移的功能，计算规则对比参见 [与 Date Offset 相关的函数](https://docs.dolphindb.cn/zh/progr/data_mani/temp_obj_mani.md#section_cwb_1p5_h1c)。\n\n#### 参数\n\n**X** 可以是 DATE, DATEHOUR, DATETIME, TIMESTAMP 或 NANOTIMESTAMP 类型的标量或向量。\n\n**offset** 是与 *X* 类型相同的标量，并且它必须小于等于 *X* 中的最小值。它是一个可选参数。如果没有指定，*offset* 默认为 *X* 中的最小值。\n\n**n** 是一个正整数。它是一个可选参数，默认值为1。\n\n#### 返回值\n\nDATE 类型标量或向量。\n\n#### 例子\n\n```\nbusinessDay(2019.01.06);\n// output: 2019.01.04\n\nbusinessDay(2019.01.04);\n// output:　2019.01.04\n\ndate=2019.01.06 + 1..10\nbusinessDay = businessDay(date)\nbusinessDay2 = businessDay(date,min(date),2)\ntable(date, businessDay, businessDay2);\n```\n\n| date       | businessDay | businessDay2 |\n| ---------- | ----------- | ------------ |\n| 2019.01.07 | 2019.01.07  | 2019.01.07   |\n| 2019.01.08 | 2019.01.08  | 2019.01.07   |\n| 2019.01.09 | 2019.01.09  | 2019.01.09   |\n| 2019.01.10 | 2019.01.10  | 2019.01.09   |\n| 2019.01.11 | 2019.01.11  | 2019.01.11   |\n| 2019.01.12 | 2019.01.11  | 2019.01.11   |\n| 2019.01.13 | 2019.01.11  | 2019.01.11   |\n| 2019.01.14 | 2019.01.14  | 2019.01.11   |\n| 2019.01.15 | 2019.01.15  | 2019.01.15   |\n| 2019.01.16 | 2019.01.16  | 2019.01.15   |\n"
    },
    "businessMonthBegin": {
        "url": "https://docs.dolphindb.cn/zh/funcs/b/businessMonthBegin.html",
        "signatures": [
            {
                "full": "businessMonthBegin(X, [offset], [n=1])",
                "name": "businessMonthBegin",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[offset]",
                        "name": "offset",
                        "optional": true
                    },
                    {
                        "full": "[n=1]",
                        "name": "n",
                        "optional": true,
                        "default": "1"
                    }
                ]
            }
        ],
        "markdown": "### [businessMonthBegin](https://docs.dolphindb.cn/zh/funcs/b/businessMonthBegin.html)\n\n\n\n#### 语法\n\nbusinessMonthBegin(X, \\[offset], \\[n=1])\n\n#### 详情\n\n返回 *X* 所属 business month 的第一个工作日。\n\n默认情况下，一个周期对应一个自然月，函数返回 `X` 所在月份的第一个工作日。这里的工作日仅按星期判断，即周一到周五为工作日，周六和周日为非工作日，不考虑法定节假日或交易所日历。\n\n如果指定了 *offset* 和 *n*，且 *n* > 1，则函数按长度为 *n* 个月的周期计算。此时，*offset* 用于确定多月周期的对齐方式：系统会先计算出 *offset* 所在月份的第一个工作日，然后以该日期为基准，每隔 *n* 个月生成一个周期结束边界，并返回 *X* 所属周期对应的第一个工作日。\n\nDolphinDB 和 pandas 在概念层面上都提供了类似日期偏移的功能，计算规则对比参见 [与 Date Offset 相关的函数](https://docs.dolphindb.cn/zh/progr/data_mani/temp_obj_mani.md#section_cwb_1p5_h1c)。\n\n#### 参数\n\n**X** 可以是 DATE, DATEHOUR, DATETIME, TIMESTAMP 或 NANOTIMESTAMP 类型的标量或向量。\n\n**offset** 是与 *X* 类型相同的标量，并且它必须小于等于 *X* 中的最小值。它是一个可选参数。如果没有指定，*offset* 默认为 *X* 中的最小值。\n\n**n** 是一个正整数。它是一个可选参数，默认值为1。\n\n#### 返回值\n\nDATE 类型标量或向量。\n\n#### 例子\n\n```\nbusinessMonthBegin(2018.09.12);\n// output: 2018.09.03\n\nbusinessMonthBegin(2018.09.12, 2018.07.12, 3);\n// output: 2018.07.02\n\ndate=2016.04.12+(1..10)*30\ntime = take(09:30:00, 10)\nsym = take(`MSFT,10)\nprice= 49.6 29.46 29.52 30.02 174.97 175.23 50.76 50.32 51.29 52.38\nqty = 2200 1900 2100 3200 6800 5400 1300 2500 8800 4500\nt1 = table(date, time, sym, qty, price);\nt1;\n```\n\n| date       | time     | sym  | qty  | price  |\n| ---------- | -------- | ---- | ---- | ------ |\n| 2016.05.12 | 09:30:00 | MSFT | 2200 | 49.6   |\n| 2016.06.11 | 09:30:00 | MSFT | 1900 | 29.46  |\n| 2016.07.11 | 09:30:00 | MSFT | 2100 | 29.52  |\n| 2016.08.10 | 09:30:00 | MSFT | 3200 | 30.02  |\n| 2016.09.09 | 09:30:00 | MSFT | 6800 | 174.97 |\n| 2016.10.09 | 09:30:00 | MSFT | 5400 | 175.23 |\n| 2016.11.08 | 09:30:00 | MSFT | 1300 | 50.76  |\n| 2016.12.08 | 09:30:00 | MSFT | 2500 | 50.32  |\n| 2017.01.07 | 09:30:00 | MSFT | 8800 | 51.29  |\n| 2017.02.06 | 09:30:00 | MSFT | 4500 | 52.38  |\n\n```\nselect avg(price),sum(qty) from t1 group by businessMonthBegin(date,2016.01.01,2);\n```\n\n| businessMonthBegin\\_date | avg\\_price | sum\\_qty |\n| ------------------------ | ---------- | -------- |\n| 2016.05.02               | 39.53      | 4100     |\n| 2016.07.01               | 29.77      | 5300     |\n| 2016.09.01               | 175.1      | 12200    |\n| 2016.11.01               | 50.54      | 3800     |\n| 2017.01.02               | 51.835     | 13300    |\n\n相关函数：[businessMonthEnd](https://docs.dolphindb.cn/zh/funcs/b/businessMonthEnd.html), [monthBegin](https://docs.dolphindb.cn/zh/funcs/m/monthBegin.html), [monthEnd](https://docs.dolphindb.cn/zh/funcs/m/monthEnd.html), [semiMonthBegin](https://docs.dolphindb.cn/zh/funcs/s/semiMonthBegin.html), [semiMonthEnd](https://docs.dolphindb.cn/zh/funcs/s/semiMonthEnd.html)\n"
    },
    "businessMonthEnd": {
        "url": "https://docs.dolphindb.cn/zh/funcs/b/businessMonthEnd.html",
        "signatures": [
            {
                "full": "businessMonthEnd(X, [offset], [n=1])",
                "name": "businessMonthEnd",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[offset]",
                        "name": "offset",
                        "optional": true
                    },
                    {
                        "full": "[n=1]",
                        "name": "n",
                        "optional": true,
                        "default": "1"
                    }
                ]
            }
        ],
        "markdown": "### [businessMonthEnd](https://docs.dolphindb.cn/zh/funcs/b/businessMonthEnd.html)\n\n\n\n#### 语法\n\nbusinessMonthEnd(X, \\[offset], \\[n=1])\n\n#### 详情\n\n返回 *X* 所属 business month 的最后一个工作日。\n\n默认情况下，一个周期对应一个自然月，函数返回 *X* 所在月份的最后一个工作日。这里的工作日仅按星期判断，即周一到周五为工作日，周六和周日为非工作日，不考虑法定节假日或交易所日历。\n\n如果指定了 *offset* 和 *n*，且 *n* > 1，则函数按长度为 *n* 个月的周期计算。此时，*offset* 用于确定多月周期的对齐方式：系统会先计算出 *offset* 所在月份的最后一个工作日，然后以该日期为基准，每隔 *n* 个月生成一个周期结束边界，并返回 *X* 所属周期对应的最后一个工作日。\n\nDolphinDB 和 pandas 在概念层面上都提供了类似日期偏移的功能，计算规则对比参见 [时序对象的操作](https://docs.dolphindb.cn/zh/progr/data_mani/temp_obj_mani.html)。\n\n#### 参数\n\n**X** 可以是 DATE, DATEHOUR, DATETIME, TIMESTAMP 或 NANOTIMESTAMP 类型的标量或向量。\n\n**offset** 是与 *X* 类型相同的标量，并且它必须小于等于 *X* 中的最小值。它是一个可选参数。如果没有指定，*offset* 默认为 *X* 中的最小值。\n\n**n** 是一个不小于 1 的正整数。它是一个可选参数，默认值为 1。\n\n#### 返回值\n\nDATE 类型标量或向量。\n\n#### 例子\n\n```\nbusinessMonthEnd(2010.10.12);\n// output: 2010.10.29\n\nbusinessMonthEnd(2010.10.12, 2000.03.31, 3);\n// output: 2010.12.31\n\ndate=2016.04.12+(1..10)*30\ntime = take(09:30:00, 10)\nsym = take(`MSFT,10)\nprice= 49.6 29.46 29.52 30.02 174.97 175.23 50.76 50.32 51.29 52.38\nqty = 2200 1900 2100 3200 6800 5400 1300 2500 8800 4500\nt1 = table(date, time, sym, qty, price);\nt1;\n```\n\n| date       | time     | sym  | qty  | price  |\n| ---------- | -------- | ---- | ---- | ------ |\n| 2016.05.12 | 09:30:00 | MSFT | 2200 | 49.6   |\n| 2016.06.11 | 09:30:00 | MSFT | 1900 | 29.46  |\n| 2016.07.11 | 09:30:00 | MSFT | 2100 | 29.52  |\n| 2016.08.10 | 09:30:00 | MSFT | 3200 | 30.02  |\n| 2016.09.09 | 09:30:00 | MSFT | 6800 | 174.97 |\n| 2016.10.09 | 09:30:00 | MSFT | 5400 | 175.23 |\n| 2016.11.08 | 09:30:00 | MSFT | 1300 | 50.76  |\n| 2016.12.08 | 09:30:00 | MSFT | 2500 | 50.32  |\n| 2017.01.07 | 09:30:00 | MSFT | 8800 | 51.29  |\n| 2017.02.06 | 09:30:00 | MSFT | 4500 | 52.38  |\n\n```\nselect avg(price),sum(qty) from t1 group by businessMonthEnd(date,2016.01.31,2);\n```\n\n| businessMonthEnd\\_date | avg\\_price | sum\\_qty |\n| ---------------------- | ---------- | -------- |\n| 2016.06.30             | 39.53      | 4100     |\n| 2016.08.31             | 29.77      | 5300     |\n| 2016.10.31             | 175.1      | 12200    |\n| 2016.12.30             | 50.54      | 3800     |\n| 2017.02.28             | 51.835     | 13300    |\n\n相关函数：[businessMonthBegin](https://docs.dolphindb.cn/zh/funcs/b/businessMonthBegin.html), [monthBegin](https://docs.dolphindb.cn/zh/funcs/m/monthBegin.html), [monthEnd](https://docs.dolphindb.cn/zh/funcs/m/monthEnd.html), [semiMonthBegin](https://docs.dolphindb.cn/zh/funcs/s/semiMonthBegin.html), [semiMonthEnd](https://docs.dolphindb.cn/zh/funcs/s/semiMonthEnd.html)\n"
    },
    "businessQuarterBegin": {
        "url": "https://docs.dolphindb.cn/zh/funcs/b/businessQuarterBegin.html",
        "signatures": [
            {
                "full": "businessQuarterBegin(X, [startingMonth=1], [offset], [n=1])",
                "name": "businessQuarterBegin",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[startingMonth=1]",
                        "name": "startingMonth",
                        "optional": true,
                        "default": "1"
                    },
                    {
                        "full": "[offset]",
                        "name": "offset",
                        "optional": true
                    },
                    {
                        "full": "[n=1]",
                        "name": "n",
                        "optional": true,
                        "default": "1"
                    }
                ]
            }
        ],
        "markdown": "### [businessQuarterBegin](https://docs.dolphindb.cn/zh/funcs/b/businessQuarterBegin.html)\n\n\n\n#### 语法\n\nbusinessQuarterBegin(X, \\[startingMonth=1], \\[offset], \\[n=1])\n\n#### 详情\n\n返回 *X* 所在季度的第一个工作日（周一到周五）。每个季度包含的月份由参数 *startingMonth* 决定。这里的工作日仅按星期判断，即周一到周五为工作日，周六和周日为非工作日。\n\n如果指定了 *offset* 和 *n*，且 *n* > 1，则函数按长度为 *n* 个季度的周期计算。此时，*offset* 用于确定多季度周期的对齐方式：系统会先根据 *startingMonth* 计算出 *offset* 所在季度的第一个工作日，然后以该日期为基准，每隔 *n* 个季度生成一个周期起始边界，并返回 *X* 所属周期对应的第一个工作日。\n\nDolphinDB 和 pandas 在概念层面上都提供了类似日期偏移的功能，计算规则对比参见 [与 Date Offset 相关的函数](https://docs.dolphindb.cn/zh/progr/data_mani/temp_obj_mani.md#section_cwb_1p5_h1c)。\n\n#### 参数\n\n**X** 可以是 DATE, DATETIME, DATEHOUR, TIMESTAMP 或 NANOTIMESTAMP 类型的标量或向量。\n\n**startingMonth** 是1到12之间的整数，用于指定一年中第一个季度的起始月份。默认值为 1，表示按自然季度划分，即 1-3 月、4-6 月、7-9 月、10-12 月。\n\n**offset** 是与 **X** 类型相同的标量，并且它必须小于等于 *X* 中的最小值。它是一个可选参数。如果没有指定，*offset* 默认为 *X* 中的最小值。\n\n**n** 是一个正整数。它是一个可选参数，默认值为1。\n\n#### 返回值\n\nDATE 类型标量或向量。\n\n#### 例子\n\n```\nbusinessQuarterBegin(2012.06.12);\n// output: 2012.04.02\n\nbusinessQuarterBegin(2012.06.12, 3);\n// output: 2012.06.01\n\nbusinessQuarterBegin(2012.06.12, 8, 2011.08.01, 3);\n// output: 2012.05.01\n\ndate=2011.04.25+(1..10)*90\ntime = take(09:30:00, 10)\nsym = take(`MSFT,10)\nprice= 49.6 29.46 29.52 30.02 174.97 175.23 50.76 50.32 51.29 52.38\nqty = 2200 1900 2100 3200 6800 5400 1300 2500 8800 4500\nt1 = table(date, time, sym, qty, price);\n\nt1;\n```\n\n| date       | time     | sym  | qty  | price  |\n| ---------- | -------- | ---- | ---- | ------ |\n| 2011.07.24 | 09:30:00 | MSFT | 2200 | 49.6   |\n| 2011.10.22 | 09:30:00 | MSFT | 1900 | 29.46  |\n| 2012.01.20 | 09:30:00 | MSFT | 2100 | 29.52  |\n| 2012.04.19 | 09:30:00 | MSFT | 3200 | 30.02  |\n| 2012.07.18 | 09:30:00 | MSFT | 6800 | 174.97 |\n| 2012.10.16 | 09:30:00 | MSFT | 5400 | 175.23 |\n| 2013.01.14 | 09:30:00 | MSFT | 1300 | 50.76  |\n| 2013.04.14 | 09:30:00 | MSFT | 2500 | 50.32  |\n| 2013.07.13 | 09:30:00 | MSFT | 8800 | 51.29  |\n| 2013.10.11 | 09:30:00 | MSFT | 4500 | 52.38  |\n\n```\nselect avg(price),sum(qty) from t1 group by businessQuarterBegin(date, 10, 2010.10.01, 2);\n```\n\n| businessQuarterBegin\\_date | avg\\_price | sum\\_qty |\n| -------------------------- | ---------- | -------- |\n| 2011.04.01                 | 49.6       | 2200     |\n| 2011.10.03                 | 29.49      | 4000     |\n| 2012.04.02                 | 102.495    | 10000    |\n| 2012.10.01                 | 112.995    | 6700     |\n| 2013.04.01                 | 50.805     | 11300    |\n| 2013.10.01                 | 52.38      | 4500     |\n\n相关函数：[businessQuarterEnd](https://docs.dolphindb.cn/zh/funcs/b/businessQuarterEnd.html), [quarterBegin](https://docs.dolphindb.cn/zh/funcs/q/quarterBegin.html), [quarterEnd](https://docs.dolphindb.cn/zh/funcs/q/quarterEnd.html)\n"
    },
    "businessQuarterEnd": {
        "url": "https://docs.dolphindb.cn/zh/funcs/b/businessQuarterEnd.html",
        "signatures": [
            {
                "full": "businessQuarterEnd(X, [endingMonth=12], [offset], [n=1])",
                "name": "businessQuarterEnd",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[endingMonth=12]",
                        "name": "endingMonth",
                        "optional": true,
                        "default": "12"
                    },
                    {
                        "full": "[offset]",
                        "name": "offset",
                        "optional": true
                    },
                    {
                        "full": "[n=1]",
                        "name": "n",
                        "optional": true,
                        "default": "1"
                    }
                ]
            }
        ],
        "markdown": "### [businessQuarterEnd](https://docs.dolphindb.cn/zh/funcs/b/businessQuarterEnd.html)\n\n\n\n#### 语法\n\nbusinessQuarterEnd(X, \\[endingMonth=12], \\[offset], \\[n=1])\n\n#### 详情\n\n返回 *X* 所在季度的最后一个工作日（周一到周五）。每个季度包含的月份由参数 *endingMonth* 决定。这里的工作日仅按星期判断，即周一到周五为工作日，周六和周日为非工作日。\n\n如果指定了 *offset* 和 *n*，且 *n* > 1，则函数按长度为 n 个季度的周期计算。此时，*offset* 用于确定多季度周期的对齐方式：系统会先根据 *endingMonth* 计算出 *offset* 所在季度的最后一个工作日，然后以该日期为基准，每隔 *n* 个季度生成一个周期结束边界，并返回 *X* 所属周期对应的最后一个工作日。\n\nDolphinDB 和 pandas 在概念层面上都提供了类似日期偏移的功能，计算规则对比参见 [与 Date Offset 相关的函数](https://docs.dolphindb.cn/zh/progr/data_mani/temp_obj_mani.md#section_cwb_1p5_h1c)。\n\n#### 参数\n\n**X** 可以是 DATE, DATETIME, DATEHOUR, TIMESTAMP 或 NANOTIMESTAMP 类型的标量或向量。\n\n**endingMonth** 是1到12之间的整数，用于指定一年中最后一个季度的结束月份。默认值为 12，表示按自然季度划分，即 1-3 月、4-6 月、7-9 月、10-12 月。\n\n**offset** 是与 **X** 类型相同的标量，并且它必须小于等于 *X* 中的最小值。它是一个可选参数。如果没有指定，*offset* 默认为 *X* 中的最小值。\n\n**n** 是一个正整数。它是一个可选参数，默认值为1。\n\n#### 返回值\n\nDATE 类型标量或向量。\n\n#### 例子\n\n```\nbusinessQuarterEnd(2012.04.12);\n// output: 2012.06.30\n\nbusinessQuarterEnd(2012.04.12, 2);\n// output: 2012.05.31\n\nbusinessQuarterEnd(2012.04.12, 8, 2011.08.01, 3);\n// output: 2012.05.31\n\ndate=2011.04.25+(1..10)*90\ntime = take(09:30:00, 10)\nsym = take(`MSFT,10)\nprice= 49.6 29.46 29.52 30.02 174.97 175.23 50.76 50.32 51.29 52.38\nqty = 2200 1900 2100 3200 6800 5400 1300 2500 8800 4500\nt1 = table(date, time, sym, qty, price);\n\nt1;\n```\n\n| date       | time     | sym  | qty  | price  |\n| ---------- | -------- | ---- | ---- | ------ |\n| 2011.07.24 | 09:30:00 | MSFT | 2200 | 49.6   |\n| 2011.10.22 | 09:30:00 | MSFT | 1900 | 29.46  |\n| 2012.01.20 | 09:30:00 | MSFT | 2100 | 29.52  |\n| 2012.04.19 | 09:30:00 | MSFT | 3200 | 30.02  |\n| 2012.07.18 | 09:30:00 | MSFT | 6800 | 174.97 |\n| 2012.10.16 | 09:30:00 | MSFT | 5400 | 175.23 |\n| 2013.01.14 | 09:30:00 | MSFT | 1300 | 50.76  |\n| 2013.04.14 | 09:30:00 | MSFT | 2500 | 50.32  |\n| 2013.07.13 | 09:30:00 | MSFT | 8800 | 51.29  |\n| 2013.10.11 | 09:30:00 | MSFT | 4500 | 52.38  |\n\n```\nselect avg(price),sum(qty) from t1 group by businessQuarterEnd(date, , 2010.06.01, 2)\n```\n\n| businessQuarterEnd\\_date | avg\\_price | sum\\_qty |\n| ------------------------ | ---------- | -------- |\n| 2011.12.30               | 39.53      | 4100     |\n| 2012.06.29               | 29.77      | 5300     |\n| 2012.12.31               | 175.1      | 12200    |\n| 2013.06.28               | 50.54      | 3800     |\n| 2013.12.31               | 51.835     | 13300    |\n\n相关函数：[businessQuarterBegin](https://docs.dolphindb.cn/zh/funcs/b/businessQuarterBegin.html), [quarterBegin](https://docs.dolphindb.cn/zh/funcs/q/quarterBegin.html), [quarterEnd](https://docs.dolphindb.cn/zh/funcs/q/quarterEnd.html)\n"
    },
    "businessYearBegin": {
        "url": "https://docs.dolphindb.cn/zh/funcs/b/businessYearBegin.html",
        "signatures": [
            {
                "full": "businessYearBegin(X, [startingMonth=1], [offset], [n=1])",
                "name": "businessYearBegin",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[startingMonth=1]",
                        "name": "startingMonth",
                        "optional": true,
                        "default": "1"
                    },
                    {
                        "full": "[offset]",
                        "name": "offset",
                        "optional": true
                    },
                    {
                        "full": "[n=1]",
                        "name": "n",
                        "optional": true,
                        "default": "1"
                    }
                ]
            }
        ],
        "markdown": "### [businessYearBegin](https://docs.dolphindb.cn/zh/funcs/b/businessYearBegin.html)\n\n\n\n#### 语法\n\nbusinessYearBegin(X, \\[startingMonth=1], \\[offset], \\[n=1])\n\n#### 详情\n\n返回最近一个小于等于 *X* 的年度首个工作日（周一到周五）。\n\n默认情况下，一个周期对应一年，函数返回 *X* 所在年度的第一个工作日。年度的起始月份由参数 *startingMonth* 决定。这里的工作日仅按星期判断，即周一到周五为工作日，周六和周日为非工作日。\n\n如果指定了 *offset* 和 *n*，且 *n* > 1，则函数按长度为 *n* 年的周期计算。此时，*offset* 用于确定多年周期的对齐方式：系统会先根据 *startingMonth* 计算出 *offset* 所在年度的第一个工作日，然后以该日期为基准，每隔 *n* 年生成一个周期起始边界，并返回 *X* 所属周期对应的第一个工作日。\n\nDolphinDB 和 pandas 在概念层面上都提供了类似日期偏移的功能，计算规则对比参见 [与 Date Offset 相关的函数](https://docs.dolphindb.cn/zh/progr/data_mani/temp_obj_mani.md#section_cwb_1p5_h1c)。\n\n#### 参数\n\n**X** 可以是 DATE, DATETIME, DATEHOUR, TIMESTAMP 或 NANOTIMESTAMP 类型的标量或向量。\n\n**startingMonth** 是1到12之间的整数，表示一年的起始月份。默认值是1。\n\n**offset** 是与 **X** 类型相同的标量，并且它必须小于等于 *X* 中的最小值。它是一个可选参数。如果没有指定，*offset* 默认为 *X* 中的最小值。\n\n**n** 是一个正整数。它是一个可选参数，默认值为1。\n\n#### 返回值\n\nDATE 类型标量或向量。\n\n#### 例子\n\n```\nbusinessYearBegin(2012.06.12);\n// output: 2012.01.02\n\nbusinessYearBegin(2022.01.01);\n// output: 2021.01.01\n\nbusinessYearBegin(2012.06.13 10:10:10.008,5);\n// output: 2012.05.01\n\ndate=2011.10.25 2012.10.25 2013.10.25 2014.10.25 2015.10.25 2016.10.25 2017.10.25 2018.10.25 2019.10.25 2020.10.25\ntime = [09:34:07,09:36:42,09:36:51,09:36:59,09:32:47,09:35:26,09:34:16,09:34:26,09:38:12,09:38:13]\nsym = take(`MSFT,10)\nprice= 49.6 29.46 29.52 30.02 174.97 175.23 50.76 50.32 51.29 52.38\nqty = 2200 1900 2100 3200 6800 5400 1300 2500 8800 4500\nt1 = table(date, time, sym, qty, price);\n\nselect avg(price),sum(qty) from t1 group by businessYearBegin(date,1,2011.10.01,2)\n```\n\n| businessYearBegin\\_date | avg\\_price | sum\\_qty |\n| ----------------------- | ---------- | -------- |\n| 2011.01.03              | 39.53      | 4100     |\n| 2013.01.01              | 29.77      | 5300     |\n| 2015.01.01              | 175.1      | 12200    |\n| 2017.01.02              | 50.54      | 3800     |\n| 2019.01.01              | 51.835     | 13300    |\n\n相关函数：[businessYearEnd](https://docs.dolphindb.cn/zh/funcs/b/businessYearEnd.html), [yearBegin](https://docs.dolphindb.cn/zh/funcs/y/yearBegin.html), [yearEnd](https://docs.dolphindb.cn/zh/funcs/y/yearEnd.html)\n"
    },
    "businessYearEnd": {
        "url": "https://docs.dolphindb.cn/zh/funcs/b/businessYearEnd.html",
        "signatures": [
            {
                "full": "businessYearEnd(X, [endingMonth=12], [offset], [n=1])",
                "name": "businessYearEnd",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[endingMonth=12]",
                        "name": "endingMonth",
                        "optional": true,
                        "default": "12"
                    },
                    {
                        "full": "[offset]",
                        "name": "offset",
                        "optional": true
                    },
                    {
                        "full": "[n=1]",
                        "name": "n",
                        "optional": true,
                        "default": "1"
                    }
                ]
            }
        ],
        "markdown": "### [businessYearEnd](https://docs.dolphindb.cn/zh/funcs/b/businessYearEnd.html)\n\n\n\n#### 语法\n\nbusinessYearEnd(X, \\[endingMonth=12], \\[offset], \\[n=1])\n\n#### 详情\n\n返回 *X* 所在年份的最后一个工作日（周一到周五）。\n\n默认情况下，一个周期对应一年，函数返回 *X* 所在年度的最后一个工作日。年度的结束月份由参数 *endingMonth* 决定。这里的工作日仅按星期判断，即周一到周五为工作日，周六和周日为非工作日。\n\n如果指定了 *offset* 和 *n*，且 *n* > 1，则函数按长度为 *n* 年的周期计算。此时，*offset* 用于确定多年周期的对齐方式：系统会先根据 *endingMonth* 计算出 *offset* 所在年度的最后一个工作日，然后以该日期为基准，每隔 *n* 年生成一个周期结束边界，并返回 *X* 所属周期对应的最后一个工作日。\n\nDolphinDB 和 pandas 在概念层面上都提供了类似日期偏移的功能，计算规则对比参见 [与 Date Offset 相关的函数](https://docs.dolphindb.cn/zh/progr/data_mani/temp_obj_mani.md#section_cwb_1p5_h1c)。\n\n#### 参数\n\n**X** 可以是 DATE, DATETIME, DATEHOUR, TIMESTAMP 或 NANOTIMESTAMP 类型的标量或向量。\n\n**endingMonth** 是1到12之间的整数，表示一年的结束月份。默认值是12。\n\n**offset** 是与 **X** 类型相同的标量，并且它必须小于等于 *X* 中的最小值。它是一个可选参数。如果没有指定，*offset* 默认为 *X* 中的最小值。\n\n**n** 是一个正整数。它是一个可选参数，默认值为1。\n\n#### 返回值\n\nDATE 类型标量或向量。\n\n#### 例子\n\n```\nbusinessYearEnd(2012.06.12, 3);\n// output: 2013.03.29\n\nbusinessYearEnd(2012.06.12, 9);\n// output: 2012.09.28\n\nbusinessYearEnd(2012.06.12);\n// output: 2012.12.31\n\nbusinessYearEnd(2012.06.12, 12, 2009.04.03, 2);\n// output: 2013.12.31\n\ndate=2011.04.25+(1..10)*365\ntime = take(09:30:00, 10)\nsym = take(`MSFT,10)\nprice= 49.6 29.46 29.52 30.02 174.97 175.23 50.76 50.32 51.29 52.38\nqty = 2200 1900 2100 3200 6800 5400 1300 2500 8800 4500\nt1 = table(date, time, sym, qty, price);\n\nt1;\n```\n\n| date       | time     | sym  | qty  | price  |\n| ---------- | -------- | ---- | ---- | ------ |\n| 2012.04.24 | 09:30:00 | MSFT | 2200 | 49.6   |\n| 2013.04.24 | 09:30:00 | MSFT | 1900 | 29.46  |\n| 2014.04.24 | 09:30:00 | MSFT | 2100 | 29.52  |\n| 2015.04.24 | 09:30:00 | MSFT | 3200 | 30.02  |\n| 2016.04.23 | 09:30:00 | MSFT | 6800 | 174.97 |\n| 2017.04.23 | 09:30:00 | MSFT | 5400 | 175.23 |\n| 2018.04.23 | 09:30:00 | MSFT | 1300 | 50.76  |\n| 2019.04.23 | 09:30:00 | MSFT | 2500 | 50.32  |\n| 2020.04.22 | 09:30:00 | MSFT | 8800 | 51.29  |\n| 2021.04.22 | 09:30:00 | MSFT | 4500 | 52.38  |\n\n```\nselect avg(price),sum(qty) from t1 group by businessYearEnd(date, 4, 2010.04.01, 2);\n```\n\n| businessYearEnd\\_date | avg\\_price | sum\\_qty |\n| --------------------- | ---------- | -------- |\n| 2012.04.30            | 49.6       | 2200     |\n| 2014.04.30            | 29.49      | 4000     |\n| 2016.04.29            | 102.495    | 10000    |\n| 2018.04.30            | 112.995    | 6700     |\n| 2020.04.30            | 50.805     | 11300    |\n| 2022.04.29            | 52.38      | 4500     |\n\n相关函数：[businessYearBegin](https://docs.dolphindb.cn/zh/funcs/b/businessYearBegin.html), [yearBegin](https://docs.dolphindb.cn/zh/funcs/y/yearBegin.html), [yearEnd](https://docs.dolphindb.cn/zh/funcs/y/yearEnd.html)\n"
    },
    "bvls": {
        "url": "https://docs.dolphindb.cn/zh/funcs/b/bvls.html",
        "signatures": [
            {
                "full": "bvls(Y, X, bounds, [maxIter], [tolerance=1e-10], [intercept=true], [mode=0])",
                "name": "bvls",
                "parameters": [
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "bounds",
                        "name": "bounds"
                    },
                    {
                        "full": "[maxIter]",
                        "name": "maxIter",
                        "optional": true
                    },
                    {
                        "full": "[tolerance=1e-10]",
                        "name": "tolerance",
                        "optional": true,
                        "default": "1e-10"
                    },
                    {
                        "full": "[intercept=true]",
                        "name": "intercept",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[mode=0]",
                        "name": "mode",
                        "optional": true,
                        "default": "0"
                    }
                ]
            }
        ],
        "markdown": "### [bvls](https://docs.dolphindb.cn/zh/funcs/b/bvls.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nbvls(Y, X, bounds, \\[maxIter], \\[tolerance=1e-10], \\[intercept=true], \\[mode=0])\n\n#### 详情\n\n执行有界变量最小二乘法（Bounded-Variable Least-Square）。\n\n#### 参数\n\n**Y** 是一个数值型向量，表示因变量。\n\n**X** 是一个数值型向量、元组、矩阵或表，表示自变量。*X* 是矩阵时：\n\n* 如果行数等于 *Y* 的长度，*X* 的每一列都是一个因子。\n* 如果行数不等于 *Y* 的长度，并且如果列数等于 *Y* 的长度，*X* 的每一行都是一个因子。\n\n注意：*X* 与 *Y*中的值会转为 DOUBLE 后进行运算，转换后的空值将被视为 0。\n\n**bounds** 包含两个元素的元组，分别定义下界（lb）和上界（ub）。元组的元素可以是：\n\n* 标量：为所有因子指定相同的边界值。\n* 向量：向量长度等于因子数，分别为每个因子指定边界值。\n\n**maxIter** 可选参数，正整数，表示最大迭代次数。如未定义，默认为变量的数量。\n\n**tolerance** 可选参数，DOUBLE 类型，表示允许的误差，默认值为 1e-10 。如果相邻两次迭代的损失函数值的差值小于 *tolerance*，或在 *tolerance* 误差下满足 Karush-Kuhn-Tucker 条件时，停止迭代。\n\n**intercept**可选参数，布尔值，表示是否在回归中包含截距。默认为 true。为 true 时，系统自动给 X 添加一列 1 以生成截距。\n\n**mode**可选参数，表示输出模式。目前仅支持 0 （默认），表示返回系数估计向量。\n\n#### 返回值\n\nDOUBLE 向量，表示回归系数估计值。\n\n#### 例子\n\n```\nx1 = [1, 3, 5, 7, 11, 16, 23]\nx2 = [2, 8, 11, 34, 56, 54, 100]\ny = [0.1, 4.2, 5.6, 8.8, 22.1, 35.6, 77.2]\nbounds = (0.0, 10.0)\n\nbvls(y, x1, bounds)\n// output: [0,2.717777777777778]\n\nbvls(y, (x1, x2), bounds)\n// output: [0,1.409643685501234,0.315943584131198]\n```\n\n相关函数：[ols](https://docs.dolphindb.cn/zh/funcs/o/ols.html)\n"
    },
    "dailyAlignedBar": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/dailyAlignedBar.html",
        "signatures": [
            {
                "full": "dailyAlignedBar(X, timeOffset, n, [timeEnd], [mergeSessionEnd=false])",
                "name": "dailyAlignedBar",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "timeOffset",
                        "name": "timeOffset"
                    },
                    {
                        "full": "n",
                        "name": "n"
                    },
                    {
                        "full": "[timeEnd]",
                        "name": "timeEnd",
                        "optional": true
                    },
                    {
                        "full": "[mergeSessionEnd=false]",
                        "name": "mergeSessionEnd",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [dailyAlignedBar](https://docs.dolphindb.cn/zh/funcs/d/dailyAlignedBar.html)\n\n\n\n#### 语法\n\ndailyAlignedBar(X, timeOffset, n, \\[timeEnd], \\[mergeSessionEnd=false])\n\n相关函数：[bar](https://docs.dolphindb.cn/zh/funcs/b/bar.html)\n\n#### 详情\n\n按照给定的起始时刻 *timeOffset* （与结束时刻 *timeEnd* ）以及时间区间长度（由 *n* 指定），划分时间区间，返回 *X* 中每个元素所属的时间区间起始时刻，结果为与 *X* 长度相同的向量。具体而言，对于 *X* 中的每个元素，计算 X-((X-timeOffset)%n)。\n\n时间区间一般包括左边界，不包括右边界。但若指定 *mergeSessionEnd* = true，且某个时段的最后时刻为某个区间的起始时刻，则将其并入之前的区间。\n\n该函数支持隔夜时段。\n\n#### 参数\n\n**X** 时间类型向量，支持以下的类型：SECOND, TIME, NANOTIME, DATETIME, TIMESTAMP 或 NANOTIMESTAMP。\n\n**timeOffset** 标量或向量，表示每个时段的起始时刻。与 *X* 精度一致，可以是 SECOND、TIME 或 NANOTIME 类型的标量或向量。如果 *timeOffset* 是一个向量，它必须是递增的。\n\n**n** 是一个正整数或 DURATION 类型数据，表示时间区间长度。 *n* 取正整数时，其单位为 *timeOffset* 的最小精度。 *n* 取 DURATION 类型数据时，其单位不能是 y, M, w, d, B。\n\n**timeEnd** 可选参数，表示每个时段的结束时刻。和 timeOffset 的类型和长度必须一致。\n\n**mergeSessionEnd** 为可选参数，是一个布尔值，表示若某个时段的最后时刻为某个区间的起始时刻，是否将其并入之前的区间。默认值为 false。\n\n#### 返回值\n\n返回一个与 X 长度相同的时间类型向量，表示 X 中每个元素所属的时间区间起始时刻。\n\n#### 例子\n\n以下例子中均使用了随机模拟数据。结果中的 price 列之值每次执行均会有所不同。\n\n例1. 中国股票市场每天有两个交易时段：上午9:30-11:30和下午1:00-3:00。计算每个交易时段中的60分钟均价。\n\n```\nsessionsBegin = 09:30:00 13:00:00\nts = 2019.11.01T09:30:00..2019.11.01T11:30:00 join 2019.11.01T13:00:00..2019.11.01T15:00:00\nt = table(ts, rand(10.0, size(ts)) as price);\n\nselect avg(price) as price, count(*) as count from t group by dailyAlignedBar(X=ts, timeOffset=sessionsBegin, n=60*60) as k60;\n```\n\n| k60                 | price             | count |\n| ------------------- | ----------------- | ----- |\n| 2019.11.01T09:30:00 | 5.031685383252463 | 3600  |\n| 2019.11.01T10:30:00 | 5.022667285786399 | 3600  |\n| 2019.11.01T11:30:00 | 4.930270051117987 | 1     |\n| 2019.11.01T13:00:00 | 4.931854071494632 | 3600  |\n| 2019.11.01T14:00:00 | 4.979529541734115 | 3600  |\n| 2019.11.01T15:00:00 | 0.961996954865754 | 1     |\n\n由于每个区间包括左边界，不包括右边界，若每个交易时段的结束时刻（上午11:30与下午3:00）恰好是区间边界，若不指定 *timeEnd* 与 *mergeSessionEnd*，则时段的结束时刻会单独作为一区间，如上例所示。多数情况下，会希望此类结束时刻归入前一区间。可参照以下脚本。\n\n```\nsessionsEnd = 11:30:00 15:00:00;\nselect avg(price) as price, count(*) as count from t group by dailyAlignedBar(X=ts, timeOffset=sessionsBegin, n=60*60, timeEnd=sessionsEnd, mergeSessionEnd=true) as k60;\n```\n\n| k60                 | price             | count |\n| ------------------- | ----------------- | ----- |\n| 2019.11.01T09:30:00 | 5.031685383252463 | 3600  |\n| 2019.11.01T10:30:00 | 5.022641627015316 | 3601  |\n| 2019.11.01T13:00:00 | 4.931854071494632 | 3600  |\n| 2019.11.01T14:00:00 | 4.978413870368697 | 3601  |\n\n例2. 隔夜时段。期货市场每天有两个交易时段：下午1:30-4:30和晚上10:30-凌晨2:30。使用 `dailyAlignedBar` 函数计算每个交易时段中的7分钟均价。\n\n```\nsessions = 13:30:00 22:30:00\nts = 2019.11.01T13:30:00..2019.11.01T16:30:00 join 2019.11.01T22:30:00..2019.11.02T02:30:00\nts = ts join (ts+60*60*24)\nt = table(ts, rand(10.0, size(ts)) as price)\nselect avg(price) as price, count(*) as count from t group by dailyAlignedBar(X=ts, timeOffset=sessions, n=7m) as k7;\n```\n\n例3. 计算分钟 k 线时，*n* 需要转换为 NANOTIMESTAMP，此时若使用整型计算可能造成类型溢出，需要将数据类型转换成 LONG。\n\n```\nn = 1000000\nnano=(09:30:00.000000000 + rand(long(6.5*60*60*1000000000), n)).sort!()\nsessionStartNano=09:30:00.000000000\nprice = 100+cumsum(rand(0.02, n)-0.01)\nvolume = rand(1000, n)\nsymbol = rand(`600519`000001`600000`601766, n)\ntradeNano=table(symbol, nano, price, volume).sortBy!(`symbol`nano)\nundef(`nano`price`volume`symbol)\nbarMinutes=7\nitv = barMinutes*60*long(1000000000)\n\nOHLC_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(X=nano, timeOffset=sessionStartNano, n=itv) as barStart\n```\n"
    },
    "database": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/database.html",
        "signatures": [
            {
                "full": "database(directory, [partitionType], [partitionScheme], [locations], [engine='OLAP'], [atomic='TRANS'])",
                "name": "database",
                "parameters": [
                    {
                        "full": "directory",
                        "name": "directory"
                    },
                    {
                        "full": "[partitionType]",
                        "name": "partitionType",
                        "optional": true
                    },
                    {
                        "full": "[partitionScheme]",
                        "name": "partitionScheme",
                        "optional": true
                    },
                    {
                        "full": "[locations]",
                        "name": "locations",
                        "optional": true
                    },
                    {
                        "full": "[engine='OLAP']",
                        "name": "engine",
                        "optional": true,
                        "default": "'OLAP'"
                    },
                    {
                        "full": "[atomic='TRANS']",
                        "name": "atomic",
                        "optional": true,
                        "default": "'TRANS'"
                    }
                ]
            },
            {
                "full": "database(directory, [partitionType], [partitionScheme], [locations], [engine='OLAP'], [atomic='TRANS'], [chunkGranularity='TABLE'])",
                "name": "database",
                "parameters": [
                    {
                        "full": "directory",
                        "name": "directory"
                    },
                    {
                        "full": "[partitionType]",
                        "name": "partitionType",
                        "optional": true
                    },
                    {
                        "full": "[partitionScheme]",
                        "name": "partitionScheme",
                        "optional": true
                    },
                    {
                        "full": "[locations]",
                        "name": "locations",
                        "optional": true
                    },
                    {
                        "full": "[engine='OLAP']",
                        "name": "engine",
                        "optional": true,
                        "default": "'OLAP'"
                    },
                    {
                        "full": "[atomic='TRANS']",
                        "name": "atomic",
                        "optional": true,
                        "default": "'TRANS'"
                    },
                    {
                        "full": "[chunkGranularity='TABLE']",
                        "name": "chunkGranularity",
                        "optional": true,
                        "default": "'TABLE'"
                    }
                ]
            }
        ],
        "markdown": "### [database](https://docs.dolphindb.cn/zh/funcs/d/database.html)\n\n\n\n#### 语法\n\ndatabase(directory, \\[partitionType], \\[partitionScheme], \\[locations], \\[engine='OLAP'], \\[atomic='TRANS'])\n\n2.00.4 版本以后，若配置项 *enableChunkGranularityConfig* = true:\n\ndatabase(directory, \\[partitionType], \\[partitionScheme], \\[locations], \\[engine='OLAP'], \\[atomic='TRANS'], \\[chunkGranularity='TABLE'])\n\n#### 详情\n\n创建一个数据库句柄。\n\n我们需要指定 *partitionType* 和 *partitionScheme* 创建新的分布式数据库。当我们重新打开已有的分布式数据库，只需要指定 *directory*。我们不能用不同的 *partitionType* 或 *partitionScheme* 覆盖已有的分布式数据库。\n\n当 *directory* 为本地磁盘路径时，将创建本地磁盘数据库。磁盘数据库仅应用于备份数据和本地计算的场景，其相较于分布式表，在使用上具有一定局限，例如不能进行权限控制等。\n\n#### 参数\n\n**directory** 是保存数据库的目录的路径。如果需要创建分布式文件系统中的数据库，*directory* 应该以 \"dfs\\://\" 开头，如果需要创建内存在线事务处理数据库，应该以 \"oltp\\://\" 开头。\n\n**partitionType** 有六种类型：顺序分区（SEQ），范围分区（RANGE），哈希分区（HASH），数值分区（VALUE），列表分区（LIST）和组合分区（COMPO）。\n\n**partitionScheme** 描述了分区是如何创建的。它通常是一个向量，在序列域是一个整型标量。分区方案的说明决定了分区类型。*partitionScheme* 支持以下数据类型：CHAR, SHORT, INT, DATE, MONTH, TIME, MINUTE, SECOND, DATETIME 和 SYMBOL。\n\n| 分区类型 | 分区符号  | 分区方案                                      |\n| ---- | ----- | ----------------------------------------- |\n| 顺序分区 | SEQ   | 整型标量。表示分区的数量。                             |\n| 范围分区 | RANGE | 向量。向量的任意两个相邻元素定义分区的范围。                    |\n| 哈希分区 | HASH  | 元组。第一个元素是分区列的数据类型，第二个元素是分区的数量。            |\n| 值分区  | VALUE | 向量。向量的每个元素定义了一个分区。                        |\n| 列表分区 | LIST  | 向量。向量的每个元素定义了一个分区。                        |\n| 组合分区 | COMPO | 向量。向量的每个元素是一个数据库句柄。向量长度表示分区的层级，最小是2，最大是3。 |\n\n**locations** 是元组，指定分区的位置。元组中元素的数量应该与 *partitionType* 和 *partitionScheme* 共同决定的分区数量相同。若要在多个节点上保存分区时， 可以使用分布式文件系统或使用 *locations* 参数指定每个分区在哪些节点。如果没有指定 *locations* 参数，所有分区属于当前节点。我们不能指定分层域的分区。\n\n**engine = 'OLAP'** 设置数据库存储引擎。取值为：'OLAP' , 'TSDB', 'IOTDB', 'IMOLTP', 或'PKEY'，默认值为 'OLAP'。关于存储引擎的介绍，请参见[数据库](https://docs.dolphindb.cn/zh/db_distr_comp/cfg/db_intro.html)。\n\n**Note:** TSDB和 PKEY引擎只支持创建分布式数据库。\n\n**atomic** 表示写入事务的原子性层级，决定了是否允许并发写入同一分区。可选值为 'TRANS' 和 'CHUNK'，默认值为 'TRANS'。\n\n* 设置为 'TRANS'，写入事务的原子性层级为事务，即一个事务写入多个分区时，若某个分区被其他写入事务锁定而出现写入冲突，则该事务的写入全部失败。因此，该设置下，不允许并发写入同一个分区。\n\n* 设置为 'CHUNK'，写入事务的原子性层级为分区。若一个事务写入多个分区时，某分区被其它写入事务锁定而出现冲突，系统会完成其他分区的写入，同时对之前发生冲突的分区不断尝试写入，尝试数分钟后仍冲突才放弃。此设置下，允许并发写入同一个分区，但由于不能完全保证事务的原子性，可能出现部分分区写入成功而部分分区写入失败的情况。同时由于采用了重试机制，写入速度可能较慢。\n\n**chunkGranularity** 是一个字符串，用于指定分区的粒度。可选值为：\n\n* 'TABLE'：表级分区，设置后支持同时写入同一分区的不同表。\n\n* 'DATABASE'：数据库级分区，设置后只支持同时写入不同分区。\n\n该参数只有在配置 *enableChunkGranularityConfig* = true 时启用。\n\n#### 例子\n\n1.创建没有分区的磁盘数据库。\n\n```\ndb=database(directory=\"C:/DolphinDB/Data/db1/\");\nt=table(take(1..10,10000000) as id, rand(10,10000000) as x, rand(10.0,10000000) as y);\nsaveTable(db, t, `t1);\n```\n\n2.对于分布式数据库，每种类型的分区都有一个例子。\n\n* 顺序分区（SEQ）：分区是基于输入数据文件中行的顺序。它只能在本地文件系统中使用，不能在分布式文件系统中使用。\n\n```\nn=1000000\nID=rand(100, n)\ndates=2017.08.07..2017.08.11\ndate=rand(dates, n)\nx=rand(10.0, n)\nt=table(ID, date, x);\nsaveText(t, \"C:/DolphinDB/Data/t.txt\");\n\ndb = database(directory=\"C:/DolphinDB/Data/seqdb\", partitionType=SEQ, partitionScheme=8)\npt = loadTextEx(db, `pt, ,\"C:/DolphinDB/Data/t.txt\");\n```\n\n在 `\"C:/DolphinDB/data/seqdb\"` 文件夹中，有8个新建的子文件夹。每个对应输入数据文件中的分区。如果输入数据文件比计算机的可用内存大，我们可以把数据载入分区。\n\n![](https://docs.dolphindb.cn/zh/images/database01.png)\n\n* 范围分区（RANGE）：分区是由分区方案中的两个元素决定的。范围包含下限不包含上限。\n\n```\nn=1000000\nID=rand(10, n)\nx=rand(1.0, n)\nt=table(ID, x);\ndb=database(directory=\"dfs://rangedb\", partitionType=RANGE, partitionScheme=0 5 10)\npt = db.createPartitionedTable(t, `pt, `ID);\npt.append!(t);\n\npt=loadTable(db,`pt)\nx=select * from pt\nselect count(x) from pt;\n```\n\n| count\\_x |\n| -------- |\n| 1000000  |\n\n在上述例子中，数据库 db 有两个分区：\\[0,5)和\\[5,10)。表 t 在数据库 db 中保存为以 ID 为分区列的分区表 pt。\n\n![](https://docs.dolphindb.cn/zh/images/database02.png)\n\n把数据文件输入为范围域的分布式数据库：\n\n```\nn=1000000\nID=rand(10, n)\nx=rand(1.0, n)\nt=table(ID, x);\nsaveText(t, \"C:/DolphinDB/Data/t.txt\");\n\ndb=database(directory=\"dfs://rangedb\", partitionType=RANGE, partitionScheme=0 5 10)\npt = loadTextEx(db, `pt, `ID, \"C:/DolphinDB/Data/t.txt\");\n```\n\n* 哈希分区（HASH）：我们需要指定分区列的数据类型和分区数量。\n\n```\nn=1000000\nID=rand(10, n)\nx=rand(1.0, n)\nt=table(ID, x)\ndb=database(directory=\"dfs://hashdb\", partitionType=HASH, partitionScheme=[INT, 2])\n\npt = db.createPartitionedTable(t, `pt, `ID)\npt.append!(t);\n\nselect count(x) from pt;\n```\n\n| count\\_x |\n| -------- |\n| 1000000  |\n\n上面的例子中，数据库 db 有两个分区。表 t 被保存为以 ID 为分区列的分区表 pt。\n\n注意：如果导入哈希分区数据库的数据的分区列包含空值，则该条数据会被丢弃。\n\n```\nID = NULL 3 6 NULL 9\nx = rand(1.0, 5)\nt1 = table(ID, x)\npt.append!(t1)\nselect count(x) from pt;\n```\n\n| count\\_x |\n| -------- |\n| 1000003  |\n\n* 数值分区（VALUE）：分区方案中的每个元素决定一个分区。\n\n```\nn=1000000\nmonth=take(2000.01M..2016.12M, n);\nx=rand(1.0, n);\nt=table(month, x);\n\ndb=database(directory=\"dfs://valuedb\", partitionType=VALUE, partitionScheme=2000.01M..2016.12M)\npt = db.createPartitionedTable(t, `pt, `month);\npt.append!(t);\n\npt=loadTable(db,`pt)\nselect count(x) from pt;\n```\n\n| count\\_x |\n| -------- |\n| 1000000  |\n\n上述例子定义了一个具有204个分区的数据库。每个分区表示从2000年1月到2016年12月的月份。使用 `createPartitionedTable` 和 `append!` 函数，把表 t 保存为数据库 db 中以 month 作为分区列的分区表 pt。\n\n![](https://docs.dolphindb.cn/zh/images/database03.png)\n\n* 列表分区（LIST）：分区方案的每个元素决定分区。\n\n```\nn=1000000\nticker = rand(`MSFT`GOOG`FB`ORCL`IBM,n);\nx=rand(1.0, n);\nt=table(ticker, x);\n\ndb=database(directory=\"dfs://listdb\", partitionType=LIST, partitionScheme=[`IBM`ORCL`MSFT, `GOOG`FB])\npt = db.createPartitionedTable(t, `pt, `ticker)\npt.append!(t);\n\npt=loadTable(db,`pt)\nselect count(x) from pt;\n```\n\n| count\\_x |\n| -------- |\n| 1000000  |\n\n上述例子中的数据库有两个分区。第一个分区有3支股票，第二个分区有2支股票。\n\n![](https://docs.dolphindb.cn/zh/images/database04.png)\n\n* 组合分区（COMPO）：可以有2个或3个分区列。每个分区列可以是按范围分区、值分区、哈希分区或列表分区。分区列的顺序是无关的。\n\n```\nn=1000000\nID=rand(100, n)\ndates=2017.08.07..2017.08.11\ndate=rand(dates, n)\nx=rand(10.0, n)\nt=table(ID, date, x)\n\ndbDate = database(, partitionType=VALUE, partitionScheme=2017.08.07..2017.08.11)\ndbID = database(, partitionType=RANGE, partitionScheme=0 50 100)\ndb = database(directory=\"dfs://compoDB\", partitionType=COMPO, partitionScheme=[dbDate, dbID])\n\npt = db.createPartitionedTable(t, `pt, `date`ID)\npt.append!(t)\n\npt=loadTable(db,`pt)\nselect count(x) from pt;\n```\n\n| count\\_x |\n| -------- |\n| 1000000  |\n\n数值域根据天数分成5个分区：\n\n![](https://docs.dolphindb.cn/zh/images/database05.png)\n\n范围域有2个分区：\n\n![](https://docs.dolphindb.cn/zh/images/database06.png)\n\n请注意，虽然这里的数据库文件有两级文件夹，但是分层域只有一个层次的分区。与之对比，双重分区具有两个层次分区。\n\n3.创建分布式数据库\n\n我们可以根据上述例子的语法，在分布式文件系统中建立分布式数据库。唯一区别是，在 `database` 函数中，*directory* 参数要以 \"dfs\\://\" 开头。\n\n在执行下面例子之前，我们需要在 web 界面上启动 DFS 集群，并且提交数据节点的脚本。\n\n在分布式文件系统中保存分层域的分区表：\n\n```\nn=1000000\nID=rand(100, n)\ndates=2017.08.07..2017.08.11\ndate=rand(dates, n)\nx=rand(10.0, n)\nt=table(ID, date, x);\n\ndbDate = database(, partitionType=VALUE, partitionScheme=2017.08.07..2017.08.11)\ndbID=database(, partitionType=RANGE, partitionScheme=0 50 100);\ndb = database(directory=\"dfs://compoDB\", partitionType=COMPO, partitionScheme=[dbDate, dbID]);\npt = db.createPartitionedTable(t, `pt, `date`ID)\npt.append!(t);\n```\n\n我们可以在以下目录查看数据库文件：\n\n![](https://docs.dolphindb.cn/zh/images/database07.png)\n\nDFS\\_NODE1 只有4个关于日期的文件夹；在 \"20170807\" 文件夹中只有一个 ID 文件夹。这是因为有4个数据节点和基于日期和 ID 的2\\*5=10个分区。默认情况下，每个分区在分布式文件系统中有3个备份。因此，总共有5\\*2\\*3=30个分区来保存4个数据节点。不是所有数据节点都有10个分区。\n\n在分布式文件系统中把数据文件输入到范围域的分布式数据库中：\n\n```\nn=1000000\nID=rand(10, n)\nx=rand(1.0, n)\nt=table(ID, x);\nsaveText(t, \"C:/DolphinDB/Data/t.txt\");\n\ndb=database(directory=\"dfs://rangedb\", partitionType=RANGE, partitionScheme=0 5 10)\npt = loadTextEx(db, `pt, `ID, \"C:/DolphinDB/Data/t.txt\");\n```\n\n4.关于 *locations* 参数的例子：\n\n```\nn=1000000\nID=rand(10, n)\nx=rand(1.0, n)\nt=table(ID, x);\n\ndb=database(directory=\"dfs://rangedb5\", partitionType=RANGE, partitionScheme=0 5 10, locations=[`node1`node2, `node3])\npt = db.createPartitionedTable(t, `pt, `ID);\npt.append!(t);\n```\n\n上述例子定义了具有两个分区的数值域。第一个分区在 node1 和 node2 上，第二个分区在 node3 上。所有的位置必须在这些节点所在的计算机中的 dolphindb.cfg 文件的 sites 参数定义：\n\n```\nsites=111.222.3.4:8080:node1, 111.222.3.5:8080:node2, 111.222.3.6:8080:node3\n```\n\nsites 中的参数是用逗号分隔的。每个 site 包含3部分：主机名，端口号和别名。分区可以复制多个 sites。在这个例子中，每个节点位于不同的计算机。\n\n我们也可以直接使用主机名和端口号表示位置。函数将会变成：\n\n```\ndb=database(directory=\"dfs://rangedb6\", partitionType=RANGE, partitionScheme=0 5 10, locations=[[\"111.222.3.4:8080\", \"111.222.3.5:8080\"], \"111.222.3.6:8080\"])\n```\n\n5. 关于 *atomic* 参数的例子：\n\n```\nif(existsDatabase(\"dfs://test\"))\ndropDB(\"dfs://test\")\ndb = database(directory=\"dfs://test\", partitionType=VALUE, partitionScheme=1..20, atomic='CHUNK')\ndummy = table(take(1..20, 100000) as id, rand(1.0, 100000) as value)\npt = db.createPartitionedTable(dummy, \"pt\", `id)\n\ndummy1 = table(take(1..15, 1000000) as id, rand(1.0, 1000000) as value)\ndummy2 = table(take(11..20, 1000000) as id, rand(1.0, 1000000) as value)\nsubmitJob(\"write1\", \"writer1\", append!{pt, dummy1})\nsubmitJob(\"write2\", \"writer2\", append!{pt, dummy2})\nsubmitJob(\"write3\", \"writer3\", append!{pt, dummy1})\nsubmitJob(\"write4\", \"writer4\", append!{pt, dummy2})\nselect count(*) from pt\n// output\n4,000,000\n```\n\n创建 IMOLTP 数据库\n\n```\ndbName = \"oltp://test_imoltp\"\ndb = database(directory=dbName, partitionType=VALUE, partitionScheme=1..100, engine=\"IMOLTP\")\n```\n"
    },
    "date": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/date.html",
        "signatures": [
            {
                "full": "date(X)",
                "name": "date",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [date](https://docs.dolphindb.cn/zh/funcs/d/date.html)\n\n\n\n#### 语法\n\ndate(X)\n\n#### 详情\n\n返回对应的日期。返回值的类型是 DATE，一个时间值。如果参数 *X* 不是日期，则返回值是 1970.01.01 + *X* 天的日期。\n\n#### 参数\n\n**X** 可以是时间标量、向量或整数。\n\n#### 例子\n\n```\ndate();\n```\n\n返回：null\n\n```\ndate(1)\n```\n\n返回：1970.01.02\n\n```\ndate(`2011.10.12);\n```\n\n返回：2011.10.12\n\n```\ndate(now());\n```\n\n返回：2024.02.22\n\n```\ndate 2012.12.03 01:22:01;\n```\n\n返回：2012.12.03\n\n```\ndate(2016.03M);\n```\n\n返回：2016.03.01\n\n**Related information**\n\n[second](https://docs.dolphindb.cn/zh/funcs/s/second.html)\n\n[minute](https://docs.dolphindb.cn/zh/funcs/m/minute.html)\n\n[month](https://docs.dolphindb.cn/zh/funcs/m/month.html)\n\n[hour](https://docs.dolphindb.cn/zh/funcs/h/hour.html)\n\n[year](https://docs.dolphindb.cn/zh/funcs/y/year.html)\n"
    },
    "datehour": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/datehour.html",
        "signatures": [
            {
                "full": "datehour(X)",
                "name": "datehour",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [datehour](https://docs.dolphindb.cn/zh/funcs/d/datehour.html)\n\n\n\n#### 语法\n\ndatehour(X)\n\n#### 详情\n\n把时间类型的标量或向量转换为 DATEHOUR 类型。返回日期和精确到小时的时间值。\n\n**Note:**\n\n自 2.00.12 版本起，支持转换 MONTH 类型的数据。\n\n#### 参数\n\n**X** 是一个包含日期和小时信息的时间类型标量或向量。如果参数 *X* 中未包含前述时间类型标量或向量，则返回值是 1970.01.01 + *X* 小时的日期与小时的时间表达。\n\n#### 返回值\n\n返回一个 DATEHOUR 类型标量或向量。\n\n#### 例子\n\n```\ndatehour(1)\n```\n\n返回：1970.01.01T01\n\n```\ndatehour(2012.06.13 13:30:10);\n```\n\n返回：2012.06.13T13\n\n```\ndatehour([2012.06.15 15:32:10.158,2012.06.15 17:30:10.008]);\n```\n\n返回：\\[2012.06.15T15,2012.06.15T17]\n\n```\ndatehour(2012.01M)\n```\n\n返回：2012.01.01T00\n"
    },
    "datetime": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/datetime.html",
        "signatures": [
            {
                "full": "datetime(X)",
                "name": "datetime",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [datetime](https://docs.dolphindb.cn/zh/funcs/d/datetime.html)\n\n\n\n#### 语法\n\ndatetime(X)\n\n#### 详情\n\n返回日期和精确到秒的时间值。如果参数 *X* 中未包含前述时间类型标量或向量，则返回值是 1970.01.01 + *X* 秒的日期与时间。\n\n**Note:**\n\nDATETIME 类型的可用时间范围是 \\[1901.12.13T20:45:53, 2038.01.19T03:14:07]。\n\n自 2.00.12 版本起，支持转换 MONTH 类型的数据。\n\n#### 参数\n\n**X** 可以是时间标量或向量，或整数。\n\n#### 返回值\n\n返回一个 DATETIME 类型的标量或向量。\n\n#### 例子\n\n```\ndatetime(1)\n```\n\n返回：1970.01.01 00:00:01\n\n```\ndatetime(2009.11.10);\n```\n\n返回：2009.11.10 00:00:00\n\n```\ntypestr datetime(2009.11.10);\n```\n\n返回：DATETIME\n\n```\ndatetime(now());\n```\n\n返回：2024.02.22 15:55:39\n\n```\ndatetime(2012.01M)\n```\n\n返回：2012.01.01T00:00:00\n\n**Related information**\n\n[date](https://docs.dolphindb.cn/zh/funcs/d/date.html)\n\n[second](https://docs.dolphindb.cn/zh/funcs/s/second.html)\n\n[minute](https://docs.dolphindb.cn/zh/funcs/m/minute.html)\n\n[month](https://docs.dolphindb.cn/zh/funcs/m/month.html)\n\n[hour](https://docs.dolphindb.cn/zh/funcs/h/hour.html)\n\n[year](https://docs.dolphindb.cn/zh/funcs/y/year.html)\n"
    },
    "datetimeParse": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/datetimeParse.html",
        "signatures": [
            {
                "full": "temporalParse(X, format)",
                "name": "temporalParse",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "format",
                        "name": "format"
                    }
                ]
            }
        ],
        "markdown": "### [datetimeParse](https://docs.dolphindb.cn/zh/funcs/d/datetimeParse.html)\n\n是 [temporalParse](https://docs.dolphindb.cn/zh/funcs/t/temporalParse.html) 的别名。\n\n\n以下是 `temporalParse` 函数的文档：\n### [temporalParse](https://docs.dolphindb.cn/zh/funcs/t/temporalParse.html)\n\n\n\n#### 语法\n\ntemporalParse(X, format)\n\n别名：datetimeParse\n\n#### 详情\n\n把字符串转换成 DolphinDB 中的时序类型数据。如果系统不能识别时序格式，将返回 NULL。\n\nDolphinDB 具有以下时序格式：\n\n| 格式        | 含义       | 范围                                          |\n| --------- | -------- | ------------------------------------------- |\n| yyyy      | 年份（4个数字） | 1000-9999                                   |\n| yy        | 年份（2个数字） | 00-99. (00-39: 2000-2039; 40-99: 1940-1999) |\n| MM        | 月份       | 1月12日                                       |\n| MMM       | 月份       | JAN, FEB, ... DEC （不区分大小写）                  |\n| dd        | 日期       | 1月31日                                       |\n| HH        | 时（24小时制） | 0-23                                        |\n| hh        | 时（12小时制） | 0-11                                        |\n| mm        | 分钟       | 0-59                                        |\n| ss        | 秒        | 0-59                                        |\n| aa        | 上午/下午    | AM, PM. （不区分大小写）                            |\n| SSS       | 毫秒       | 0-999                                       |\n| nnnnnn    | 微秒       | 0-999999                                    |\n| nnnnnnnnn | 纳秒       | 0-999999999                                 |\n\n`temporalParse` 函数中的 *format* 参数有以下两种表示方式：\n\n* 使用分隔符\n\n  对于 *format* 参数 ，除了 y, M, d, H, h, m, s, a, S, n 以外的符号的字符都可以作为分隔符。*format* 参数中的分隔符需要与输入字符串中的分隔符一致。\n\n  ```\n  temporalParse(\"14-02-2018\",\"dd-MM-yyyy\");\n  // output\n  2018.02.14\n\n  temporalParse(\"14-02-2018\",\"dd/MM/yyyy\");\n  // output\n  00d\n\n  temporalParse(\"14//02//2018\",\"dd//MM//yyyy\");\n  // output\n  2018.02.14\n\n  temporalParse(\"14//02//2018\",\"dd/MM/yyyy\");\n  // output\n  00d\n\n  temporalParse(\"14//02//2018\",\"dd..MM..yyyy\");\n  // output\n  00d\n  ```\n\n  我们可以使用单个字母来简化格式。例如，使用 \"y/M/d\" 代替 \"yyyy/MM/dd\"。因为 \"y\" 可以表示 \"yyyy\" 和 \"yy\", 系统会根据数字的个数采用 \"yyyy\" 或 \"yy\"。\n\n  ```\n  temporalParse(\"14-02-18\",\"d-M-y\");\n  // output\n  2018.02.14\n\n  temporalParse(\"2018/2/6 02:33:01 PM\",\"y/M/d h:m:s a\");\n  // output\n  2018.02.06T14:33:01\n  ```\n\n  \"MMM\",\"SSS\", \"nnnnnn\" , \"nnnnnnnnn\" 不能使用单个字母。\n\n  ```\n  temporalParse(\"02-FEB-2018\",\"d-MMM-y\");\n  // output\n  2018.02.02\n\n  temporalParse(\"02-FEB-2018\",\"d-M-y\");\n  // output\n  00d\n\n  temporalParse(\"13:30:10.001\",\"H:m:s.SSS\");\n  // output\n  13:30:10.001\n\n  temporalParse(\"13:30:10.001\",\"H:m:s.S\");\n  // output\n  Invalid temporal format: 'H:m:s.S'. Millisecond (S) must have three digits.\n\n  temporalParse(\"13:30:10.008001\",\"H:m:s.nnnnnn\");\n  // output\n  13:30:10.008001000\n\n  temporalParse(\"13:30:10.008001\",\"H:m:s.n\");\n  // output\n  Invalid temporal format: 'H:m:s.n'. Nanosecond (n) must have six or nine digits.\n  ```\n\n  `temporalParse` 函数解释输入字符串中数字个数的方式是非常灵活的。\n\n  ```\n  temporalParse(\"2-4-18\",\"d-M-yy\");\n  // output\n  2018.04.02\n\n  temporalParse(\"2-19-6\",\"H-m-s\");\n  // output\n  02:19:06\n\n  temporalParse(\"002-019-006\",\"H-m-s\");\n  // output\n  02:19:06\n  ```\n\n  对于毫秒，微秒和纳秒，对应的数字位个数必须是3, 6, 9。\n\n  ```\n  temporalParse(\"2018/2/6 13:30:10.001\",\"y/M/d H:m:s.SSS\");\n  // output\n  2018.02.06T13:30:10.001\n\n  temporalParse(\"2018/2/6 13:30:10.01\",\"y/M/d H:m:s.SSS\");\n  // output\n  00T\n\n  temporalParse(\"2018/2/6 13:30:10.000001\",\"y/M/d H:m:s.nnnnnn\");\n  // output\n  2018.02.06T13:30:10.000001000\n\n  temporalParse(\"2018/2/6 13:30:10.0000010\",\"y/M/d H:m:s.nnnnnn\");\n  // output\n  00N\n  ```\n\n* 不使用分隔符\n\n  对于这种表示方式，*format* 参数必须与上述表格中的格式对应，不能使用单个字母来表示格式。\n\n  ```\n  temporalParse(\"20180214\",\"yyyyMMdd\");\n  // output\n  2018.02.14\n\n  temporalParse(\"122506\",\"MMddyy\");\n  // output\n  2006.12.25\n\n  temporalParse(\"155950\",\"HHmmss\");\n  // output\n  15:59:50\n\n  temporalParse(\"035901PM\",\"hhmmssaa\");\n  // output\n  15:59:01\n\n  temporalParse(\"02062018155956001000001\",\"MMddyyyyHHmmssnnnnnnnnn\");\n  // output\n  2018.02.06T15:59:56.001000001\n  ```\n\n#### 参数\n\n**X** 是一个字符串。\n\n**format** 是表示时间序列对象格式的字符串。\n\n#### 返回值\n\n时序类型标量或向量。\n"
    },
    "dayOfMonth": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/dayOfMonth.html",
        "signatures": [
            {
                "full": "dayOfMonth(X)",
                "name": "dayOfMonth",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [dayOfMonth](https://docs.dolphindb.cn/zh/funcs/d/dayOfMonth.html)\n\n\n\n#### 语法\n\ndayOfMonth(X)\n\n#### 详情\n\n计算 *X* 在当月的第几天。\n\n#### 参数\n\n**X** 可以是 DATE, DATETIME, TIMESTAMP 或 NANOTIMESTAMP 类型的标量或向量。\n\n#### 返回值\n\n整数类型的标量或向量。\n\n#### 例子\n\n```\ndayOfMonth(2011.01.01);\n// output\n1\n\ndayOfMonth([2012.06.12T12:30:00,2012.07.28T12:35:00]);\n// output\n[12,28]\n```\n\n相关函数：[dayOfYear](https://docs.dolphindb.cn/zh/funcs/d/dayOfYear.html), [quarterOfYear](https://docs.dolphindb.cn/zh/funcs/q/quarterOfYear.html), [monthOfYear](https://docs.dolphindb.cn/zh/funcs/m/monthOfYear.html), [weekOfYear](https://docs.dolphindb.cn/zh/funcs/w/weekOfYear.html), [hourOfDay](https://docs.dolphindb.cn/zh/funcs/h/hourOfDay.html), [minuteOfHour](https://docs.dolphindb.cn/zh/funcs/m/minuteOfHour.html), [secondOfMinute](https://docs.dolphindb.cn/zh/funcs/s/secondOfMinute.html), [millisecond](https://docs.dolphindb.cn/zh/funcs/m/millisecond.html), [microsecond](https://docs.dolphindb.cn/zh/funcs/m/microsecond.html), [nanosecond](https://docs.dolphindb.cn/zh/funcs/n/nanosecond.html)\n"
    },
    "dayOfWeek": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/dayOfWeek.html",
        "signatures": [
            {
                "full": "dayOfWeek(X)",
                "name": "dayOfWeek",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [dayOfWeek](https://docs.dolphindb.cn/zh/funcs/d/dayOfWeek.html)\n\n\n\n#### 语法\n\ndayOfWeek(X)\n\n#### 详情\n\n计算 *X* 是一个星期中的第几天。\n\n#### 参数\n\n**X** 可以是 DATE, DATETIME, DATEHOUR, TIMESTAMP 或 NANOTIMESTAMP 类型的标量或向量。\n\n#### 返回值\n\n整数类型的标量或向量，范围为 0 到 6，0 表示星期一，1 表示星期二，...，6 表示星期日。\n\n#### 例子\n\n```\ndayOfWeek(2012.12.05);\n// output\n2\n\ndayOfWeek 2013.05.23T12:00:00;\n// output\n3\n\ndayOfWeek(2014.01.11T23:04:28.113);\n// output\n5\n\ndayOfWeek(2012.12.05 2012.12.06 2013.01.05);\n// output\n[2,3,4]\n```\n"
    },
    "dayOfYear": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/dayOfYear.html",
        "signatures": [
            {
                "full": "dayOfYear(X)",
                "name": "dayOfYear",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [dayOfYear](https://docs.dolphindb.cn/zh/funcs/d/dayOfYear.html)\n\n\n\n#### 语法\n\ndayOfYear(X)\n\n#### 详情\n\n计算 *X* 是当年中的第几天。返回的结果是整型。\n\n#### 参数\n\n**X** 可以是 DATE, DATETIME, TIMESTAMP 或 NANOTIMESTAMP 类型的标量或向量。\n\n#### 返回值\n\n整数类型的标量或向量。\n\n#### 例子\n\n```\ndayOfYear(2011.01.01);\n// output\n1\n\ndayOfYear([2011.12.31,2012.12.31]);\n// output\n[365,366]\n\ndayOfYear([2012.06.12T12:30:00,2012.07.12T12:35:00]);\n// output\n[164,194]\n```\n\n相关函数：[dayOfMonth](https://docs.dolphindb.cn/zh/funcs/d/dayOfMonth.html), [quarterOfYear](https://docs.dolphindb.cn/zh/funcs/q/quarterOfYear.html), [monthOfYear](https://docs.dolphindb.cn/zh/funcs/m/monthOfYear.html), [weekOfYear](https://docs.dolphindb.cn/zh/funcs/w/weekOfYear.html), [hourOfDay](https://docs.dolphindb.cn/zh/funcs/h/hourOfDay.html), [minuteOfHour](https://docs.dolphindb.cn/zh/funcs/m/minuteOfHour.html), [secondOfMinute](https://docs.dolphindb.cn/zh/funcs/s/secondOfMinute.html), [millisecond](https://docs.dolphindb.cn/zh/funcs/m/millisecond.html), [microsecond](https://docs.dolphindb.cn/zh/funcs/m/microsecond.html), [nanosecond](https://docs.dolphindb.cn/zh/funcs/n/nanosecond.html)\n"
    },
    "daysInMonth": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/daysInMonth.html",
        "signatures": [
            {
                "full": "daysInMonth(X)",
                "name": "daysInMonth",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [daysInMonth](https://docs.dolphindb.cn/zh/funcs/d/daysInMonth.html)\n\n\n\n#### 语法\n\ndaysInMonth(X)\n\n#### 详情\n\n返回 *X* 所在月份的天数。\n\n#### 参数\n\n**X** 可以是 DATE, DATEHOUR, DATETIME, TIMESTAMP 或 NANOTIMESTAMP 类型的标量或向量。\n\n#### 返回值\n\n整数类型的标量或向量。\n\n#### 例子\n\n```\ndaysInMonth(2012.06.12T12:30:00);\n// output\n30\n\ndaysInMonth([2012.02.01,2013.12.05]);\n// output\n[29,31]\n```\n"
    },
    "decimal128": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/decimal128.html",
        "signatures": [
            {
                "full": "decimal128(X, scale)",
                "name": "decimal128",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "scale",
                        "name": "scale"
                    }
                ]
            }
        ],
        "markdown": "### [decimal128](https://docs.dolphindb.cn/zh/funcs/d/decimal128.html)\n\n\n\n#### 语法\n\ndecimal128(X, scale)\n\n#### 详情\n\n将输入的数据类型转换为 DECIMAL128 类型。\n\n#### 参数\n\n**X** 整型/浮点型/字符串类型标量或向量。\n\n**scale** 整型标量，表示保留的小数位数。\n\n#### 返回值\n\nDECIMAL128 类型的标量或向量。\n\n#### 例子\n\n```\na=decimal128(142, 2)\na\n```\n\n返回：142.00\n\n```\nb=decimal128(1\\7, 6)\nb\n```\n\n返回：0.142857\n\n```\na+b\n```\n\n返回：142.142857\n\n```\na*b\n```\n\n返回：20.28569400\n\n```\ndecimal128(\"3.1415926535\", 4)\n```\n\n返回：3.1416\n\n一个 DECIMAL 类型向量里的所有元素的类型和 scale 必须相同，例如：\n\n```\nd1=[1.23$DECIMAL128(4), 3$DECIMAL128(4), 3.14$DECIMAL128(4)]; \n```\n\n返回：\\[1.2300,3.0000,3.1400]\n\n```\ntypestr(d1);\n```\n\n返回：FAST DECIMAL128 VECTOR\n\n如果元素的 scale 不同，则会创建并输出元组：\n\n```\nd2=[1.23$DECIMAL128(4), 3$DECIMAL128(4), 3.14$DECIMAL128(3)];\n```\n\n返回：(1.2300,3.0000,3.140)\n\n```\ntypestr(d2);\n```\n\n返回：ANY VECTOR\n"
    },
    "decimal32": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/decimal32.html",
        "signatures": [
            {
                "full": "decimal32(X, scale)",
                "name": "decimal32",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "scale",
                        "name": "scale"
                    }
                ]
            }
        ],
        "markdown": "### [decimal32](https://docs.dolphindb.cn/zh/funcs/d/decimal32.html)\n\n\n\n#### 语法\n\ndecimal32(X, scale)\n\n#### 详情\n\n将输入的数据类型转换为 DECIMAL32 类型。\n\n#### 参数\n\n**X** 整型/浮点型/字符串类型标量或向量。\n\n**scale** 整型标量，表示保留的小数位数。\n\n#### 返回值\n\nDECIMAL32 类型的标量或向量。\n\n#### 例子\n\n```\na=decimal32(142, 2)\na\n```\n\n返回：142.00\n\n```\nb=decimal32(1\\7, 6)\nb\n```\n\n返回：0.142857\n\n```\na+b\n```\n\n返回：142.142857\n\n```\na*b\n```\n\n返回：20.28569400\n\n```\ndecimal32(\"3.1415926535\", 4)\n```\n\n返回：3.1415\n\n一个 DECIMAL 类型向量里的所有元素的类型和 scale 必须相同，例如：\n\n```\nd1=[1.23$DECIMAL32(4), 3$DECIMAL32(4), 3.14$DECIMAL32(4)];\n```\n\n返回：\\[1.2300,3.0000,3.1400]\n\n```\ntypestr(d1);\n```\n\n返回：FAST DECIMAL32 VECTOR\n\n```\nd2=[1.23$DECIMAL32(4), 3$DECIMAL32(4), 3.14$DECIMAL32(3)];\n```\n\n返回：(1.2300,3.0000,3.140)\n\n```\ntypestr(d2);\n```\n\n返回：ANY VECTOR\n\n将 STRING 或 SYMBOL 类型转换为 DECIMAL 类型时，不同版本服务器的处理方式存在差别。2.00.10 之前版本会将超出 *scale* 的小数部分直接舍去。而 2.00.10 及之后的版本，会将超出 *scale* 的小数部分进行四舍五入。例如，对于以下的转换：\n\n```\nsymbol([\"1.341\", \"4.5677\"])$DECIMAL32(2)\n```\n\n2.00.10 之前的版本，结果为：\\[1.34,4.56]\n\n2.00.10 及之后的版本，结果为：\\[1.34,4.57]\n"
    },
    "decimal64": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/decimal64.html",
        "signatures": [
            {
                "full": "decimal64(X, scale)",
                "name": "decimal64",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "scale",
                        "name": "scale"
                    }
                ]
            }
        ],
        "markdown": "### [decimal64](https://docs.dolphindb.cn/zh/funcs/d/decimal64.html)\n\n\n\n#### 语法\n\ndecimal64(X, scale)\n\n#### 详情\n\n将输入的数据类型转换为 DECIMAL64 类型。\n\n#### 参数\n\n**X** 整型/浮点型/字符串类型标量或向量。\n\n**scale** 整型标量，表示保留的小数位数。\n\n#### 返回值\n\nDECIMAL64 类型的标量或向量。\n\n#### 例子\n\n```\na=decimal64(142, 2)\na\n```\n\n返回：142.00\n\n```\nb=decimal64(1\\7, 6)\nb\n```\n\n返回：0.142857\n\n```\na+b\n```\n\n返回：142.142857\n\n```\na*b\n```\n\n返回：20.28569400\n\n```\ndecimal64(\"3.1415926535\", 4)\n```\n\n返回：3.1415\n\n一个 DECIMAL 类型向量里的所有元素的类型和 scale 必须相同，例如：\n\n```\nd1=[1.23$DECIMAL64(4), 3$DECIMAL64(4), 3.14$DECIMAL64(4)];\n```\n\n返回：\\[1.2300,3.0000,3.1400]\n\n```\ntypestr(d1);\n```\n\n返回：FAST DECIMAL64 VECTOR\n\n如果元素的 scale 不同，则会创建并输出元组：\n\n```\nd2=[1.23$DECIMAL64(4), 3$DECIMAL64(4), 3.14$DECIMAL64(3)];\n```\n\n返回：(1.2300,3.0000,3.140)\n\n```\ntypestr(d2);\n```\n\n返回：ANY VECTOR\n\n将 STRING 或 SYMBOL 类型转换为 DECIMAL 类型时，不同版本服务器的处理方式存在差别。2.00.10 之前版本会将超出 *scale* 的小数部分直接舍去。而 2.00.10 及之后的版本，会将超出 *scale* 的小数部分进行四舍五入。例如，对于以下的转换：\n\n```\nsymbol([\"1.341\", \"4.5677\"])$DECIMAL64(2)\n```\n\n2.00.10 之前的版本，结果为：\\[1.34,4.56]\n\n2.00.10 及之后的版本，结果为：\\[1.34,4.57]\n"
    },
    "decimalFormat": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/decimalFormat.html",
        "signatures": [
            {
                "full": "decimalFormat(X, format)",
                "name": "decimalFormat",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "format",
                        "name": "format"
                    }
                ]
            }
        ],
        "markdown": "### [decimalFormat](https://docs.dolphindb.cn/zh/funcs/d/decimalFormat.html)\n\n\n\n#### 语法\n\ndecimalFormat(X, format)\n\n#### 详情\n\n把数字转换成指定格式的字符串。\n\n| 标志 | 含义         | 备注  |\n| -- | ---------- | --- |\n| 0  | 强制数字位数     | 备注1 |\n| #  | 可选数字位数     | 备注2 |\n| .  | 小数点        |     |\n| %  | 百分号        | 备注3 |\n| E  | 科学计数法的符号   | 备注4 |\n| ,  | 分隔符        | 备注5 |\n| ;  | 表示正数和负数的符号 | 备注6 |\n\n* 备注1：小数点之前0的个数表示整数部分的位数。与之对比，小数点之后0的个数表示小数部分的位数。\n\n  ```\n  decimalFormat(123,\"0\");\n  // output: 123\n\n  decimalFormat(123,\"00000\");\n  // output: 00123\n\n  decimalFormat(123.45,\"0\");\n  // output: 123\n\n  decimalFormat(123.45,\"0.0\");\n  // output: 123.5\n\n  decimalFormat(123.45,\"0.000\");\n  // output: 123.450\n\n  decimalFormat(123.45, \".0\");\n  // output: 123.5\n\n  decimalFormat(0.45, \".0\");\n  // output: .5\n  ```\n\n* 备注2：如果0与#同时在小数点后使用，0必须在#前面。\n\n  ```\n  decimalFormat(123.45,\"0.#\");\n  // output: 123.5\n\n  decimalFormat(123.45,\"0.###\");\n  // output: 123.45\n\n  decimalFormat(123.456,\"0.000###\");\n  // output: 123.456\n\n  decimalFormat(123.456789110,\"0.000###\");\n  // output: 123.456789\n\n  decimalFormat(0.345, \".##\");\n  // output: .35\n  ```\n\n* 备注3：%用于格式字符串的结尾。%和 E 在一个格式字符串中不能同时出现。\n\n  ```\n  decimalFormat(0.125,\"0.00%\");\n  // output: 12.50%\n\n  decimalFormat(0.125, \"#.##%\");\n  // output: 12.5%\n\n  decimalFormat(0.12567,\"#.##%\");\n  // output: 12.57%\n  ```\n\n* 备注4：E 后面只能紧跟0，并且至少紧跟一个0。\n\n  ```\n  decimalFormat(1234567.89,\"0.##E00\");\n  // output: 1.23E06\n\n  decimalFormat(0.0000000000123456789,\"0.000E0\");\n  // output: 1.235E-11\n  ```\n\n* 备注5：分隔符在一个格式字符串中只能出现一次。分隔符与小数点之间的位数或分隔符到结尾的位数即为分隔的间距。\n\n  ```\n  decimalFormat(123456789,\"#,###\");\n  // output: 123,456,789\n\n  decimalFormat(123456789.166,\"#,###.##\");\n  // output: 123,456,789.17\n\n  decimalFormat(123456789.166,\"0,000.00\");\n  // output: 123,456,789.17\n  ```\n\n* 备注6：我们可以使用\";\"来选择数字对象的正负。\n\n  ```\n  decimalFormat(123.456,\"0.00#E00;(0.00#E00)\");\n  // output: 1.235E02\n\n  decimalFormat(-123.456,\"0.00#E00;(0.00#E00)\");\n  // output: (1.235E02)\n  ```\n\n#### 参数\n\n**X** 可以是整型或浮点型的标量或向量。\n\n**format** 是表示格式的字符串。\n\n#### 返回值\n\n字符串标量或向量。\n"
    },
    "decimalMultiply": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/decimalMultiply.html",
        "signatures": [
            {
                "full": "decimalMultiply(X, Y, scale)",
                "name": "decimalMultiply",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "scale",
                        "name": "scale"
                    }
                ]
            }
        ],
        "markdown": "### [decimalMultiply](https://docs.dolphindb.cn/zh/funcs/d/decimalMultiply.html)\n\n\n\n#### 语法\n\ndecimalMultiply(X, Y, scale)\n\n#### 详情\n\nDECIMAL 类型的乘法运算，相较于 `mul` 函数或运算符 \\*，该函数可以指定计算结果保留的小数位数。\n\n**Note:**\n\n* 在以下情况下，*scale* 参数将会失效，返回值类型为 DECIMAL：\n\n  * 只有一个参数是 DECIMAL 类型（小数位数是 S），且指定的 *scale* 值不等于 S。\n\n  * X 和 Y 都是 DECIMAL 类型（小数位数分别是 S1 和 S2），且指定的 *scale* 值小于 min(S1, S2) 或大于 S1+S2。\n\n* 当其中一个参数是浮点数时，scale 参数将会失效，并且返回值类型为 DOUBLE。\n\n当 *scale* 参数失效时，该函数的计算结果等同于 X \\* Y。\n\n#### 参数\n\n**X / Y** 标量或向量，其中至少有一个必须为 DECIMAL 类型。\n\n**scale** 非负整型标量，表示计算结果保留的小数位数。\n\n#### 返回值\n\nDECIMAL 或 DOUBLE 类型。\n\n#### 例子\n\n```\na = decimal32(`1.235, 3);\nb = decimal32(`7.5689, 4);\nc=decimalMultiply(a, b, 5)\n// output\n9.34759\n\ntypestr(c)\n// output\nDECIMAL32\n\ndecimalMultiply(a, b, 2)   // scale 小于min(3,4)，函数结果等于 a*b\n// output\n9.3475915\n\nb=float(`7.5689)\nc=decimalMultiply(a, b, 5)   // b 是浮点数， 函数结果等于 a*b，且数据类型是 DOUBLE。\n// output\n9.3475916337\n\ntypestr(c)\n// output\nDOUBLE\n```\n\n乘法运算（\\*）和 decimalMultiply 的计算结果如果溢出，会自动转换为更高精度的类型。如果无法进行转换，则会抛出异常。\n\n```\nx = decimal32(1\\7, 8)\ny = decimal32(1\\6, 8)\nz = x * y\nz\n// output\n0.0238095223809524\ntypestr z\n// output\nDECIMAL64\n\nz = decimalMultiply(x, y, 8)\nz\n// output\n0.02380952\ntypestr z\n// output\nDECIMAL64\n\nx = decimal128(1\\7, 35)\ny = decimal128(1\\6, 35)\nx*y\n// output\nx * y => Scale out of bound (valid range: [0, 38], but get: 70)\n\ndecimalMultiply(x, y, 35)\n// output\ndecimalMultiply(x, y, 35) => Decimal math overflow\n```\n\n*X* 和 *Y* 中至少有一个是向量。\n\n```\n\nx = [decimal32(3.213312, 3), decimal32(3.1435332, 3), decimal32(3.54321, 3)]\ny = 2.1\ndecimalMultiply(x, y, 5)\n// output\n[6.7473,6.6003,7.440300000000001]\n\nx = [decimal32(3.213312, 3), decimal32(3.1435332, 3), decimal32(3.54321, 3)]\ny = [decimal64(4.312412, 3), decimal64(4.53231, 3), decimal64(4.31258, 3)]\ndecimalMultiply(x, y, 5)\n// output\n[13.85445,14.24407,15.27741]\n```\n"
    },
    "declareStreamingSQLTable": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/declareStreamingSQLTable.html",
        "signatures": [
            {
                "full": "declareStreamingSQLTable(table)",
                "name": "declareStreamingSQLTable",
                "parameters": [
                    {
                        "full": "table",
                        "name": "table"
                    }
                ]
            }
        ],
        "markdown": "### [declareStreamingSQLTable](https://docs.dolphindb.cn/zh/funcs/d/declareStreamingSQLTable.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\ndeclareStreamingSQLTable(table)\n\n#### 详情\n\n将指定表声明为流式 SQL 的输入表。仅被声明的表才能通过 `registerStreamingSQL` 注册流式 SQL 查询。该声明操作不会影响该表在普通 SQL 查询或其他功能中的使用。\n\n#### 参数\n\n**table** 表对象，目前仅支持共享内存表，包括通过 `share` 共享的普通内存表、键值内存表、索引内存表。\n\n#### 返回值\n\n无\n\n#### 例子\n\n```\nt=table(1..10 as id,rand(100,10) as val)\nshare t as st\ndeclareStreamingSQLTable(st)\nregisterStreamingSQL(\"select avg(val) from st\")\n```\n\n**相关函数：**[listStreamingSQLTables](https://docs.dolphindb.cn/zh/funcs/l/listStreamingSQLTables.html), [registerStreamingSQL](https://docs.dolphindb.cn/zh/funcs/r/registerStreamingSQL.html), [revokeStreamingSQLTable](https://docs.dolphindb.cn/zh/funcs/r/revokeStreamingSQLTable.html)\n"
    },
    "decodeShortGenomeSeq": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/decodeShortGenomeSeq.html",
        "signatures": [
            {
                "full": "decodeShortGenomeSeq(X)",
                "name": "decodeShortGenomeSeq",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [decodeShortGenomeSeq](https://docs.dolphindb.cn/zh/funcs/d/decodeShortGenomeSeq.html)\n\n\n\n#### 语法\n\ndecodeShortGenomeSeq(X)\n\n别名：decodeSGS\n\n#### 详情\n\n将经过 `encodeShortGenomeSeq` 编码的整型数字解码为一个 DNA 序列。\n\n#### 参数\n\n**X** 整型标量或向量。\n\n#### 返回值\n\n字符串（STRING）或字符串向量（STRING VECTOR）\n\n#### 例子\n\n```\na=encodeShortGenomeSeq(\"TCGATCG\")\ndecodeShortGenomeSeq(a)\n// output\n\"TCGATCG\"\n    \nb=encodeShortGenomeSeq(\"TCGATCG\" \"TCGATCGCCC\")\ndecodeShortGenomeSeq(b)\n// output\n[\"TCGATCG\",\"TCGATCGCCC\"]\n    \n// 当输入为空时，返回空字符串。\ndecodeShortGenomeSeq(int(NULL))\n// output\n\"\"\n    \n// 因\"TCGATCG\"重复5次后，长度超过了28，所以返回了空的整型向量，再通过 decodeSGS 解码时，会返回为空字符。\nc=encodeShortGenomeSeq(repeat(\"TCGATCG\" \"TCGAT\", 5))\ndecodeShortGenomeSeq(c)\n// output\n[,\"TCGATTCGATTCGATTCGATTCGAT\"]     \n```\n\n相关函数：[encodeShortGenomeSeq](https://docs.dolphindb.cn/zh/funcs/e/encodeShortGenomeSeq.html), [genShortGenomeSeq](https://docs.dolphindb.cn/zh/funcs/g/genShortGenomeSeq.html)\n"
    },
    "decompress": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/decompress.html",
        "signatures": [
            {
                "full": "decompress(X)",
                "name": "decompress",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [decompress](https://docs.dolphindb.cn/zh/funcs/d/decompress.html)\n\n\n\n#### 语法\n\ndecompress(X)\n\n#### 详情\n\n对一个压缩后的向量进行解压缩。\n\n#### 参数\n\n**X** 是一个压缩后的向量。\n\n#### 返回值\n\n返回一个向量。\n\n#### 例子\n\n```\nx=1..100000000\ny=compress(x, \"delta\");\n\ny.typestr();\n// output: HUGE COMPRESSED VECTOR\n\nz=decompress(y);\nz.size();\n// output: 100000000\n```\n\n相关函数：[compress](https://docs.dolphindb.cn/zh/funcs/c/compress.html)\n"
    },
    "deepCopy": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/deepCopy.html",
        "signatures": [
            {
                "full": "deepCopy(obj)",
                "name": "deepCopy",
                "parameters": [
                    {
                        "full": "obj",
                        "name": "obj"
                    }
                ]
            }
        ],
        "markdown": "### [deepCopy](https://docs.dolphindb.cn/zh/funcs/d/deepCopy.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\ndeepCopy(obj)\n\n#### 详情\n\n返回 *obj* 的深拷贝。即复制对象及其所有可变子对象，生成一个与原对象完全独立的新副本。\n\n`copy`（浅拷贝）和 `deepCopy`（深拷贝）的区别主要体现在嵌套结构（如元组或 ANY 类型字典）中：\n\n* 使用 `copy` 时，子对象的引用会被共享（即子对象的地址保持不变）。\n* 使用 `deepCopy` 时，所有子对象都会被递归复制，引用也会完全分离。\n\n#### 参数\n\n**obj**可以是任意数据类型。\n\n#### 返回值\n\n与 *obj* 相同类型对象。\n\n#### 例子\n\n例1. 拷贝向量\n\n```\nx = 1 2 3\na = x.copy()\nb = x.deepCopy();\n\nprint constantDesc(x[0]).address  // 000000000dd3d640\nprint constantDesc(a[0]).address  // 000000000cb5a4c0\nprint constantDesc(b[0]).address  // 000000000de92c20\n```\n\n例2. 拷贝元组\n\n```\nx = ([[1, 2], [3, 4]], \"a\")\na = x.copy()\nb = x.deepCopy();\n\nprint constantDesc(x[0]).address  // 000000000c7ce880\nprint constantDesc(a[0]).address  // 000000000c7ce880\nprint constantDesc(b[0]).address  // 000000000c89be00\n```\n\n例3. 拷贝 ANY 字典\n\n```\ny = dict(`A`B`C, (1 2, 3 4, 5 6))\nc = y.copy()\nd = y.deepCopy();\n\nprint constantDesc(y[`A]).address  // 000000000c88c450\nprint constantDesc(c[`A]).address  // 000000000c88c450\nprint constantDesc(d[`A]).address  // 000000000c7cde00\n```\n\n相关函数：[copy](https://docs.dolphindb.cn/zh/funcs/c/copy.html), [asis](https://docs.dolphindb.cn/zh/funcs/a/asIs.html)\n"
    },
    "defined": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/defined.html",
        "signatures": [
            {
                "full": "defined(names, [type=VAR])",
                "name": "defined",
                "parameters": [
                    {
                        "full": "names",
                        "name": "names"
                    },
                    {
                        "full": "[type=VAR]",
                        "name": "type",
                        "optional": true,
                        "default": "VAR"
                    }
                ]
            }
        ],
        "markdown": "### [defined](https://docs.dolphindb.cn/zh/funcs/d/defined.html)\n\n\n\n#### 语法\n\ndefined(names, \\[type=VAR])\n\n#### 详情\n\n查询 *names* 中的每个元素是否已被定义。根据 *type* 参数的不同，可以检查本地变量、共享变量或函数定义。\n\n#### 参数\n\n**names** 可以是字符串标量或向量，表示对象名。\n\n**type** 可为 VAR（本地变量），SHARED（共享变量）或 DEF（函数定义）。默认值为 VAR。\n\n#### 返回值\n\n返回一个布尔类型标量/向量，“true”表示已被定义，“false”表示未被定义。\n\n#### 例子\n\n```\nx=10\ny=20\ndef f(a){return a+1}\nshare table(1..3 as x, 4..6 as y) as t1;\n\ndefined([\"x\",\"y\",\"f\",`t1]);\n// output\n[true,true,false,false]\n\ndefined([\"x\",\"y\",\"f\",`t1], DEF);\n// output\n[false,false,true,false]\n\ndefined([\"x\",\"y\",\"f\",`t1], SHARED);\n// output\n[false,false,false,true]\n```\n"
    },
    "defs": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/defs.html",
        "signatures": [
            {
                "full": "defs([X])",
                "name": "defs",
                "parameters": [
                    {
                        "full": "[X]",
                        "name": "X",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [defs](https://docs.dolphindb.cn/zh/funcs/d/defs.html)\n\n\n\n#### 语法\n\ndefs(\\[X])\n\n#### 详情\n\n查询系统中所有函数信息。\n\n#### 参数\n\n**X** 可选参数，是一个是字符串，用于匹配函数名，支持通配符\"%\"和\"?\"。\"%\"表示0，1或多个字符，“?”表示1个字符。\n\n#### 返回值\n\n返回一个表：\n\n* 如果没有指定 *X*，返回系统的所有函数信息。\n\n* 如果指定了 *X*，返回匹配 *X* 的所有函数信息。\n\n#### 例子\n\n```\ndefs();\n```\n\n| name    | isCommand | userDefined | minParamCount | maxParamCount | syntax      |\n| ------- | --------- | ----------- | ------------- | ------------- | ----------- |\n| !=\\_2   | 0         | 0           | 2             | 2             | (X, Y)      |\n| !\\_1    | 0         | 0           | 1             | 1             | (X)         |\n| $\\_2    | 0         | 0           | 2             | 2             | (obj, type) |\n| %\\_2    | 0         | 0           | 2             | 2             | (X, Y)      |\n| &&\\_2   | 0         | 0           | 2             | 2             | (X, Y)      |\n| &\\_2    | 0         | 0           | 2             | 2             | (X, Y)      |\n| \\*\\*\\_2 | 0         | 0           | 2             | 2             | (X, Y)      |\n| \\*\\_2   | 0         | 0           | 2             | 2             | (X, Y)      |\n| +\\_2    | 0         | 0           | 2             | 2             | (X, Y)      |\n| -\\_1    | 0         | 0           | 1             | 1             | (X)         |\n| ...     |           |             |               |               |             |\n\n```\ntypestr defs();\n// output\nIN-MEMORY TABLE;\n\nselect * from defs() where name like \"bit%\";\n```\n\n| name   | isCommand | userDefined | minParamCount | maxParamCount | syntax |\n| ------ | --------- | ----------- | ------------- | ------------- | ------ |\n| bitAnd | 0         | 0           | 2             | 2             | (X, Y) |\n| bitNot | 0         | 0           | 1             | 1             | (X)    |\n| bitOr  | 0         | 0           | 2             | 2             | (X, Y) |\n| bitXor | 0         | 0           | 2             | 2             | (X, Y) |\n\n```\ndefs(\"bit%\");\n```\n\n| name   | isCommand | userDefined | minParamCount | maxParamCount | syntax |\n| ------ | --------- | ----------- | ------------- | ------------- | ------ |\n| bitAnd | 0         | 0           | 2             | 2             | (X, Y) |\n| bitNot | 0         | 0           | 1             | 1             | (X)    |\n| bitOr  | 0         | 0           | 2             | 2             | (X, Y) |\n| bitXor | 0         | 0           | 2             | 2             | (X, Y) |\n\n```\ndefs(\"%sin\");\n```\n\n| name | isCommand | userDefined | minParamCount | maxParamCount | syntax |\n| ---- | --------- | ----------- | ------------- | ------------- | ------ |\n| asin | 0         | 0           | 1             | 1             | (X)    |\n| sin  | 0         | 0           | 1             | 1             | (X)    |\n\n```\ndefs(\"?sin\");\n```\n\n| name | isCommand | userDefined | minParamCount | maxParamCount | syntax |\n| ---- | --------- | ----------- | ------------- | ------------- | ------ |\n| asin | 0         | 0           | 1             | 1             | (X)    |\n"
    },
    "deg2rad": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/deg2rad.html",
        "signatures": [
            {
                "full": "deg2rad(X)",
                "name": "deg2rad",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [deg2rad](https://docs.dolphindb.cn/zh/funcs/d/deg2rad.html)\n\n\n\n#### 语法\n\ndeg2rad(X)\n\n#### 详情\n\n将角的单位从度转换成弧度。\n\n**Note:**\n\n与 NumPy 的 [numpy.deg2rad](https://numpy.com.cn/doc/stable/reference/generated/numpy.deg2rad.html) 功能基本相同，区别在于 DolphinDB 的 `deg2rad` 只接受一个参数 *X*，不支持 `numpy.deg2rad` 中的 *out*、*where*、*casting*、*order* 等参数。\n\n#### 参数\n\n**X** 可以是标量、向量、矩阵或表。\n\n#### 返回值\n\n返回值类型与 *X* 保持一致，表示对应弧度值。\n\n#### 例子\n\n```\ndeg2rad 45 90 180 360;\n// output\n[0.785398,1.570796,3.141593,6.283185]\n```\n\n相关函数：[rad2deg](https://docs.dolphindb.cn/zh/funcs/r/rad2deg.html)\n"
    },
    "deleteChunkMetaOnMasterById": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/deletechunkmetaonmasterbyid.html",
        "signatures": [
            {
                "full": "deleteChunkMetaOnMasterById(chunkPath, chunkId)",
                "name": "deleteChunkMetaOnMasterById",
                "parameters": [
                    {
                        "full": "chunkPath",
                        "name": "chunkPath"
                    },
                    {
                        "full": "chunkId",
                        "name": "chunkId"
                    }
                ]
            }
        ],
        "markdown": "### [deleteChunkMetaOnMasterById](https://docs.dolphindb.cn/zh/funcs/d/deletechunkmetaonmasterbyid.html)\n\n\n\n#### 语法\n\ndeleteChunkMetaOnMasterById(chunkPath, chunkId)\n\n#### 详情\n\n根据 chunk 的路径和 ID，删除控制节点上该 chunk 的元数据。当数据节点的数据意外丢失，可以调用此函数删除对应 chunk 的元数据。正常情况下删除 chunk 的元数据，会导致无法查询 chunk 数据，但数据依然残留在数据节点，占用磁盘空间。该函数只能由管理员在控制节点执行。\n\n#### 参数\n\n**chunkPath** 一个字符串，表示需要删除的 chunk 的路径。\n\n**chunkId** 一个字符串，表示需要删除的 chunk 的 ID。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\ndeleteChunkMetaOnMasterById(chunkPath=\"/olap_value/8/40o\", chunkId=\"11d45d2d-a995-7c97-c041-32362f3400d7\")\n```\n"
    },
    "deleteDataViewItems": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/deleteDataViewItems.html",
        "signatures": [
            {
                "full": "deleteDataViewItems(engine, keys)",
                "name": "deleteDataViewItems",
                "parameters": [
                    {
                        "full": "engine",
                        "name": "engine"
                    },
                    {
                        "full": "keys",
                        "name": "keys"
                    }
                ]
            }
        ],
        "markdown": "### [deleteDataViewItems](https://docs.dolphindb.cn/zh/funcs/d/deleteDataViewItems.html)\n\n\n\n#### 语法\n\ndeleteDataViewItems(engine, keys)\n\n#### 详情\n\n删除 DataView 引擎中指定键值的数据。若 *keys* 指定的键值列（key）不存在，则删除时会报错 。\n\n该函数可在 CEP 引擎内部或外部调用。如果在 CEP 引擎内部调用此函数，系统将优先在 CEP 引擎中查找句柄为 *engine* 的 DataView 引擎；若未找到，则会在 CEP 引擎外部进行查找。如果在 CEP 引擎外部调用此函数，系统只会在 CEP 引擎外部进行查找。\n\n#### 参数\n\n**engine** DataView 引擎句柄或引擎名。\n\n**keys** 需要更新的键值， 如果是复合键值，则需要传入一个 tuple，其中每个元素表示组成键值的列，且顺序需与引擎中 *keyedColumns* 的指定顺序保持一致。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\nclass Monitor1:CEPMonitor{\n    def addNewData(order)\n    def deleteData(s)\n    def Monitor1(){\n    }\n    def onload(){\n        addEventListener(addNewData,\"Orders\",,\"all\")\n        addEventListener(deleteData,\"Drop\",,\"all\")\n        try{\n            share(streamTable(1:0,`eventTime`sym`val0`val1`val2,[TIMESTAMP,SYMBOL,INT,FLOAT,DOUBLE]),'test_DV')\n            createDataViewEngine(\"test_DV\",objByName('test_DV'),`sym,`eventTime,false)\n        }catch(ex){}\n    }\n    def unload(){\n        undef(`test_DV,SHARED)\n    }\n    def addNewData(order){\n        getDataViewEngine('test_DV').append!(table([order.eventTime] as eventTime,[order.sym] as sym,[order.val1] as v1,[order.val2] as v2,[00i] as v3,[00i] as v4,[00i] as v5))\n    }\n    def deleteData(s){\n        deleteDataViewItems('test_DV',s.sym)\n    }\n}\nclass Orders{\n    eventTime :: TIMESTAMP \n    sym :: STRING\n    val0 :: INT\n    val1 :: FLOAT\n    val2 :: DOUBLE\n    def Orders(s,v0,v1,v2){\n        sym = s\n        val0 = v0\n        val1 = v1\n        val2 = v2\n        eventTime = now()\n    }\n}\nclass Drop{\n    sym :: STRING\n    eventTime :: TIMESTAMP\n    def Drop(s){\n        sym = s \n        eventTime = now()\n    }\n}\ndummy = table(array(TIMESTAMP, 0) as eventTime, array(STRING, 0) as eventType, array(BLOB, 0) as blobs)\ntry{dropStreamEngine(\"test_CEP\")}catch(ex){}\nengine=createCEPEngine(\"test_CEP\",<Monitor1()>,dummy,[Orders,Drop],,'eventTime',,,\"sym\")\nshare streamTable(array(TIMESTAMP, 0) as eventTime, array(STRING, 0) as eventType, array(BLOB, 0) as blobs) as input\ntry{dropStreamEngine(`serInput)}catch(ex){}\nserializer = streamEventSerializer(name=`serInput, eventSchema=Orders, outputTable=input, eventTimeField = \"eventTime\")\nsubscribeTable(,`input, `subopt1, 0,getStreamEngine('test_CEP'),true)\nappendEvent(`serInput,Orders(`a1,1,1.0,2.0))\n```\n\n**相关函数**：[createCEPEngine](https://docs.dolphindb.cn/zh/funcs/c/createCEPEngine.html), [createDataViewEngine](https://docs.dolphindb.cn/zh/funcs/c/createDataViewEngine.html), [getDataViewEngine](https://docs.dolphindb.cn/zh/funcs/g/getDataViewEngine.html)\n"
    },
    "deleteGroup": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/deleteGroup.html",
        "signatures": [
            {
                "full": "deleteGroup(groupName)",
                "name": "deleteGroup",
                "parameters": [
                    {
                        "full": "groupName",
                        "name": "groupName"
                    }
                ]
            }
        ],
        "markdown": "### [deleteGroup](https://docs.dolphindb.cn/zh/funcs/d/deleteGroup.html)\n\n\n\n#### 语法\n\ndeleteGroup(groupName)\n\n#### 详情\n\n删除一个群组。这可能会影响群组内所有成员的权限。\n\n**Note:** 该函数只能由管理员在控制节点、数据节点和计算节点运行。\n\n#### 参数\n\n**groupName** 是表示群组名称的字符串。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\ndeleteGroup(`Production);\n```\n\n**Related information**\n\n[deleteGroupMember](https://docs.dolphindb.cn/zh/funcs/d/deleteGroupMember.html)\n\n[deleteUser](https://docs.dolphindb.cn/zh/funcs/d/deleteUser.html)\n"
    },
    "deleteGroupMember": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/deleteGroupMember.html",
        "signatures": [
            {
                "full": "deleteGroupMember(userIds, groupIds)",
                "name": "deleteGroupMember",
                "parameters": [
                    {
                        "full": "userIds",
                        "name": "userIds"
                    },
                    {
                        "full": "groupIds",
                        "name": "groupIds"
                    }
                ]
            }
        ],
        "markdown": "### [deleteGroupMember](https://docs.dolphindb.cn/zh/funcs/d/deleteGroupMember.html)\n\n\n\n#### 语法\n\ndeleteGroupMember(userIds, groupIds)\n\n#### 详情\n\n删除多个组中的同一个成员，或删除同一个组中的多个成员。\n\n**Note:** 该函数只能由管理员在控制节点、数据节点和计算节点运行。\n\n#### 参数\n\n**userIds** 是表示用户名称的字符串标量或向量。\n\n**groupIds** 是表示群组名称的字符串标量或向量。\n\n*userIds* 和 *groupIds* 不能同时为向量。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\ndeleteGroupMember(`AlexEdwards`ElizabethRoberts, `production);\n```\n\n**Related information**\n\n[deleteGroup](https://docs.dolphindb.cn/zh/funcs/d/deleteGroup.html)\n\n[deleteUser](https://docs.dolphindb.cn/zh/funcs/d/deleteUser.html)\n"
    },
    "deleteMarketHoliday": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/deleteMarketHoliday.html",
        "signatures": [
            {
                "full": "deleteMarketHoliday(marketName)",
                "name": "deleteMarketHoliday",
                "parameters": [
                    {
                        "full": "marketName",
                        "name": "marketName"
                    }
                ]
            }
        ],
        "markdown": "### [deleteMarketHoliday](https://docs.dolphindb.cn/zh/funcs/d/deleteMarketHoliday.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\ndeleteMarketHoliday(marketName)\n\n#### 详情\n\n删除已有的交易日历。\n\n**Note:**\n\n* 该函数只能由管理员调用。\n* 该函数仅对当前节点有效。集群环境中，通过 `pnodeRun` 调用该函数，使其在其它节点生效。\n\n#### 参数\n\n**marketName** 字符串标量，表示要删除的交易日历标识，例如“XNYS”。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\nlistAllMarkets()\n// Output: [\"XTSE\",\"XCSE\",\"XLIM\",\"ADDA\",\"XSTO\",\"XIST\",\"AIXK\",\"SSE\",\"XMIL\",\"XFRA\",\"INE\",\"XMEX\",\"XBUD\",\"XICE\",\"XDUB\",\"SHFE\",\"CMES\",\"XOSL\",\"DCE\",\"CCFX\",\"CFFEX\",\"XIDX\",\"BVMF\",\"XBOG\",\"XKAR\",\"XSAU\",\"XBUE\",\"XTKS\",\"XBSE\",\"XMOS\"...]\n\ndeleteMarketHoliday(\"XTSE\")\n\"XTSE\" in listAllMarkets()\n// Output: false\n```\n\n**相关函数：[addMarketHoliday](https://docs.dolphindb.cn/zh/funcs/a/addMarketHoliday.html)**\n"
    },
    "deleteReplicas": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/deleteReplicas.html",
        "signatures": [
            {
                "full": "deleteReplicas(chunkId, nodeAlias)",
                "name": "deleteReplicas",
                "parameters": [
                    {
                        "full": "chunkId",
                        "name": "chunkId"
                    },
                    {
                        "full": "nodeAlias",
                        "name": "nodeAlias"
                    }
                ]
            }
        ],
        "markdown": "### [deleteReplicas](https://docs.dolphindb.cn/zh/funcs/d/deleteReplicas.html)\n\n\n\n#### 语法\n\ndeleteReplicas(chunkId, nodeAlias)\n\n#### 详情\n\n把节点上的一个或多个 chunk 的副本删除。该命令只能由管理员在控制节点上执行。\n\n#### 参数\n\n**chunkId** 是字符串标量或向量，表示 chunk 的 ID。\n\n**nodeAlias** 是一个字符串，表示节点的别名。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n删除 “node1” 上所有 chunk 的副本。\n\n```\nchunkIds=exec chunkId from pnodeRun(getChunksMeta) where node=\"node1\"\ndeleteReplicas(chunkIds,\"node1\");\n```\n"
    },
    "deleteRule": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/deleteRule.html",
        "signatures": [
            {
                "full": "deleteRule(engineName, key)",
                "name": "deleteRule",
                "parameters": [
                    {
                        "full": "engineName",
                        "name": "engineName"
                    },
                    {
                        "full": "key",
                        "name": "key"
                    }
                ]
            }
        ],
        "markdown": "### [deleteRule](https://docs.dolphindb.cn/zh/funcs/d/deleteRule.html)\n\n#### 语法\n\ndeleteRule(engineName, key)\n\n#### 详情\n\n如果该引擎规则中存在指定的规则 *key* 则删除，删除成功返回 true；否则，返回 false。\n\n**Note:** 默认规则不可删除。\n\n#### 参数\n\n**engineName** 是一个字符串，表示引擎名。\n\n**key** 是 STRING 或 INT 类型的标量，表示要删除的规则对应的 key 。\n\n#### 返回值\n\n布尔值。\n\n#### 例子\n\n```\nx = [1, 2, NULL]\ny = [ [ < value>1 > ], [ < price<2 >, < price>6 > ], [ < value*price>10 > ] ]\nruleSets = dict(x, y)\nnames = `sym`value`price`quantity\ntypes = [INT, DOUBLE, DOUBLE, DOUBLE]\ndummy = table(10:0, names, types)\noutputNames = `sym`value`price`rule\noutputTypes = [INT, DOUBLE, DOUBLE, BOOL[]]\noutputTable = table(10:0, outputNames, outputTypes)\ntest = createRuleEngine(name=\"ruleEngineTest\", ruleSets=ruleSets, dummyTable=dummy, outputColumns=[\"sym\",\"value\",\"price\"], outputTable=outputTable, policy=\"all\", ruleSetColumn=\"sym\")\n\n// 删除规则前\ntest.append!(table(1 as sym, 6 as value, 1 as price, 8 as quantity))\n\n// 删除 sym=1 的规则，sym=1会使用默认规则\ndeleteRule(\"ruleEngineTest\",1)\ntest.append!(table(1 as sym, 6 as value, 1 as price, 8 as quantity))\n```\n\n此时的输出表 outputTable 内容如下\n\n| sym | value | price |   rule   |\n| :-: | :---: | :---: | :------: |\n|  1  |   6   |   1   |  \\[true] |\n|  1  |   6   |   1   | \\[false] |\n\n\n\n**Related information**\n\n[updateRule](https://docs.dolphindb.cn/zh/funcs/u/updateRule.html)\n\n[createRuleEngine](https://docs.dolphindb.cn/zh/funcs/c/createRuleEngine.html)\n"
    },
    "deleteScheduledJob": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/deleteScheduledJob.html",
        "signatures": [
            {
                "full": "deleteScheduledJob(jobId)",
                "name": "deleteScheduledJob",
                "parameters": [
                    {
                        "full": "jobId",
                        "name": "jobId"
                    }
                ]
            }
        ],
        "markdown": "### [deleteScheduledJob](https://docs.dolphindb.cn/zh/funcs/d/deleteScheduledJob.html)\n\n\n\n#### 语法\n\ndeleteScheduledJob(jobId)\n\n#### 详情\n\n删除一个定时任务。如果指定的任务 ID 不存在，则抛出异常。\n\n#### 参数\n\n**jobId** 是一个表示定时任务 ID 的字符串。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\ndeleteScheduledJob(`dailyJob1);\n```\n"
    },
    "deleteSparseReactiveMetric": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/deleteSparseReactiveMetric.html",
        "signatures": [
            {
                "full": "deleteSparseReactiveMetric(name, outputMetricKey)",
                "name": "deleteSparseReactiveMetric",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "outputMetricKey",
                        "name": "outputMetricKey"
                    }
                ]
            }
        ],
        "markdown": "### [deleteSparseReactiveMetric](https://docs.dolphindb.cn/zh/funcs/d/deleteSparseReactiveMetric.html)\n\n\n\n#### 语法\n\ndeleteSparseReactiveMetric(name, outputMetricKey)\n\n#### 详情\n\n删除指定 SparseReactiveStateEngine 中 `outputMetricKey` 对应的规则：若存在则删除并返回 true，否则返回 false。\n\n#### 参数\n\n**name** 字符串标量，表示 SparseReactiveStateEngine 的名称。\n\n**outputMetricKey** STRING 的标量或向量，表示要删除的规则对应的输出指标名 outputMetricKey。\n\n#### 返回值\n\nBOOL 类型标量，true 代表删除成功。\n\n#### 例子\n\n```\ndeleteSparseReactiveMetric(\"demoengine\", \"A002_2\")\n```\n\n**相关函数**：[createSparseReactiveStateEngine](https://docs.dolphindb.cn/zh/funcs/c/createSparseReactiveStateEngine.html), [addSparseReactiveMetrics](https://docs.dolphindb.cn/zh/funcs/a/addSparseReactiveMetrics.html), [getSparseReactiveMetrics](https://docs.dolphindb.cn/zh/funcs/g/getSparseReactiveMetrics.html)\n"
    },
    "deleteUser": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/deleteUser.html",
        "signatures": [
            {
                "full": "deleteUser(userId)",
                "name": "deleteUser",
                "parameters": [
                    {
                        "full": "userId",
                        "name": "userId"
                    }
                ]
            }
        ],
        "markdown": "### [deleteUser](https://docs.dolphindb.cn/zh/funcs/d/deleteUser.html)\n\n\n\n#### 语法\n\ndeleteUser(userId)\n\n#### 详情\n\n删除一个用户。\n\n**Note:** 该函数只能由管理员在控制节点、数据节点和计算节点运行。\n\n#### 参数\n\n**userId** 是表示用户名的字符串。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\ndeleteUser(`JohnSmith);\n```\n\n**Related information**\n\n[deleteGroup](https://docs.dolphindb.cn/zh/funcs/d/deleteGroup.html)\n\n[deleteGroupMember](https://docs.dolphindb.cn/zh/funcs/d/deleteGroupMember.html)\n"
    },
    "deltas": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/deltas.html",
        "signatures": [
            {
                "full": "deltas(X,[n])",
                "name": "deltas",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[n]",
                        "name": "n",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [deltas](https://docs.dolphindb.cn/zh/funcs/d/deltas.html)\n\n\n\n#### 语法\n\ndeltas(X,\\[n])\n\n#### 详情\n\n对于 *X* 中的每一个元素，计算 *X*i-*X*i-n，NULL 值不参与计算。\n\n#### 参数\n\n**X** 是一个向量、矩阵或表。\n\n**n** 可选参数，一个整数，用于减数相较于被减数的索引偏移。默认是1。\n\n#### 返回值\n\n* 若 *X* 是向量，返回一个包含 *X* 中两个元素之差的向量。\n\n* 若 *X* 是矩阵，在每列内进行上述计算，返回一个与 *X* 维度相同的矩阵。\n\n* 若 *X* 是表，在每列内进行上述计算，返回一个与 *X* 行数与列数都相同的表。\n\n#### 例子\n\n```\nx=7 4 5 8 9;\ndeltas(x);\n//output: [,-3,1,3,1]\n//等价于 [, 4-7, 5-4, 8-5, 9-8]\n\nx=NULL 1 2 NULL 3;\ndeltas(x);\n//output： [,,1,,]\n\nm=matrix(1 3 2 5 6, 0 8 NULL 7 6);\nm;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 0  |\n| 3  | 8  |\n| 2  |    |\n| 5  | 7  |\n| 6  | 6  |\n\n```\ndeltas(m);\n```\n\n| #0 | #1 |\n| -- | -- |\n|    |    |\n| 2  | 8  |\n| -1 |    |\n| 3  |    |\n| 1  | -1 |\n\n*n* 是正整数时：\n\n```\ndeltas(m,2)\n```\n\n| 0 | 1  |\n| - | -- |\n|   |    |\n|   |    |\n| 1 |    |\n| 2 | -1 |\n| 4 |    |\n\n*n* 为负整数时：\n\n```\ndeltas(m,-2)\n```\n\n| 0  | 1 |\n| -- | - |\n| -1 |   |\n| -2 | 1 |\n| -4 |   |\n|    |   |\n|    |   |\n"
    },
    "dema": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/dema.html",
        "signatures": [
            {
                "full": "dema(X, window)",
                "name": "dema",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    }
                ]
            }
        ],
        "markdown": "### [dema](https://docs.dolphindb.cn/zh/funcs/d/dema.html)\n\n\n\n#### 语法\n\ndema(X, window)\n\nTA-lib 系列函数参数说明和窗口计算规则请参考：[TA-lib 系列](https://docs.dolphindb.cn/zh/funcs/themes/TAlib.html)\n\n#### 详情\n\n在给定长度（以元素个数衡量）的滑动窗口内，计算 *X* 的双重指数移动平均（Double Exponential Moving Average）。\n\n其计算公式为：\n\n![](https://docs.dolphindb.cn/zh/images/ema1.png)\n\n![](https://docs.dolphindb.cn/zh/images/dema.png)\n\n**Note:**\n\n与 TA-Lib `DEMA` 的功能相同，区别在于 DolphinDB `dema` 接受向量、矩阵、表作为输入参数，而 TA-Lib `DEMA` 主要面向一维 NumPy 数组设计，不支持矩阵或表输入。\n\n#### 返回值\n\n* 若 *X* 是一个向量，则返回一个 与 *X* 长度相同的向量，包含每个位置计算得到的 DEMA 值。\n* 若 *X* 是一个矩阵，则返回一个与 *X* 维度相同的矩阵，每一列计算对应列的 DEMA 值。\n* 若 *X* 是一个表，则返回一个与 *X* 维度相同的表，计算表中每一列的 DEMA 值。\n\n#### 例子\n\n```\nx=12.1 12.2 12.6 12.8 11.9 11.6 11.2\ndema(x,3);\n// output\n[,,,,12.091666666666668,11.689583333333335,11.266666666666665]\n\nx=matrix(12.1 12.2 12.6 12.8 11.9 11.6 11.2, 14 15 18 19 21 12 10)\ndema(x,3);\n```\n\n| col1    | col2    |\n| ------- | ------- |\n|         |         |\n|         |         |\n|         |         |\n|         |         |\n| 12.0917 | 20.9444 |\n| 11.6896 | 14.6806 |\n| 11.2667 | 10.9444 |\n\n相关函数：[ema](https://docs.dolphindb.cn/zh/funcs/e/ema.html), [tema](https://docs.dolphindb.cn/zh/funcs/t/tema.html)\n"
    },
    "demean": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/demean.html",
        "signatures": [
            {
                "full": "demean(X)",
                "name": "demean",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [demean](https://docs.dolphindb.cn/zh/funcs/d/demean.html)\n\n\n\n#### 语法\n\ndemean(X)\n\n#### 详情\n\n对一组数据进行去均值化（零均值化）操作，空值不参与计算。\n\n#### 参数\n\n**X** 数值型标量、向量、矩阵或表。\n\n#### 返回值\n\n返回一个和 *X* 维度相同的 DOUBLE 类型对象。\n\n* 若 *X* 为向量，计算 X - avg(X)；\n\n* 若 *X* 为矩阵，则在矩阵每一列进行计算；\n\n* 若 *X* 为表，则只对数值列进行计算。\n\n#### 例子\n\n```\nx = 1 NULL 2 3\ndemean(x)\n```\n\n输出返回：\\[-1,,0,1]\n\n```\nv = 1 0 1 1 8 2 -4 0\ndemean(v)\n```\n\n输出返回：\\[-0.125,-1.125,-0.125,-0.125,6.875,0.875,-5.125,-1.125]\n"
    },
    "denseRank": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/denseRank.html",
        "signatures": [
            {
                "full": "denseRank(X, [ascending=true],[ignoreNA=true], [percent=false])",
                "name": "denseRank",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[ignoreNA=true]",
                        "name": "ignoreNA",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[percent=false]",
                        "name": "percent",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [denseRank](https://docs.dolphindb.cn/zh/funcs/d/denseRank.html)\n\n\n\n#### 语法\n\ndenseRank(X, \\[ascending=true],\\[ignoreNA=true], \\[percent=false])\n\n#### 详情\n\n对 *X* 内元素进行密集排名，相同值的元素排名相同，且排名之间没有间隔。\n\n若 *X* 是向量，返回向量：\n\n* 基于 *ascending* 指定的排序顺序，返回 *X* 中每个元素连续的排名。\n\n* 如果 *ignoreNA* = true，则 NULL 值不参与排序，结果中 NULL 值的排名为空。\n\n若 *X* 是矩阵，在每列内进行上述计算，返回一个与 *X* 维度相同的矩阵。\n\n若 *X* 是字典，则按字典的值进行排序，并返回一个向量表示各元素的排名。\n\n**Note:** `denseRank` 和 [rank](https://docs.dolphindb.cn/zh/funcs/r/rank.html) 的区别在于，多个元素相等时，前者采用密集排名方式，而后者采用跳跃排名方式。\n\n#### 参数\n\n**X** 是一个向量、矩阵或字典。\n\n**ascending** 可选参数，是一个布尔值，表示是否按升序排序。默认值是 true。\n\n**ignoreNA** 可选参数，是一个布尔值，表示是否忽略 NULL 值，默认值为 true。true 表示忽略 NULL 值，false 表示 NULL 作为最小值参与排名。\n\n**percent** 可选参数，是一个布尔值，表示是否以百分比形式显示返回的排名，默认值为 false。\n\n#### 返回值\n\n返回一个向量或矩阵。\n\n#### 例子\n\n```\nx=1 5 5 6 8 8 9\nprint denseRank(x)\n// output: [0,1,1,2,3,3,4]\n\ny=time(4 1 1 2)\nprint denseRank(y, ascending=false)\n// output: [0,2,2,1]\nm = matrix(1 2 2 NULL, 0 0 0 1, 0 0 NULL 2)\ndenseRank(m, ignoreNA=false)\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1  | 0  | 1  |\n| 2  | 0  | 1  |\n| 2  | 0  | 0  |\n| 0  | 1  | 2  |\n\n```\nt=table(`A`A`B`C`B`B`A`C`C as id,[4,1,NULL,1,2,4,5,0,-1] as val)\nselect id,val, denseRank(val) from t context by id\n```\n\n| id | val | denseRank\\_val |\n| -- | --- | -------------- |\n| A  | 4   | 1              |\n| A  | 1   | 0              |\n| A  | 5   | 2              |\n| B  |     |                |\n| B  | 2   | 0              |\n| B  | 4   | 1              |\n| C  | 1   | 2              |\n| C  | 0   | 1              |\n| C  | -1  | 0              |\n\n```\ndenseRank(dict(`a`b`c`d, [4, 1, 1,2],true))\n// output: [2,0,0,1]\n```\n\n相关函数：[rowDenseRank](https://docs.dolphindb.cn/zh/funcs/r/rowDenseRank.html)\n"
    },
    "deny": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/deny.html",
        "signatures": [
            {
                "full": "deny(userId|groupId, accessType, [objs])",
                "name": "deny",
                "parameters": [
                    {
                        "full": "userId|groupId",
                        "name": "userId|groupId"
                    },
                    {
                        "full": "accessType",
                        "name": "accessType"
                    },
                    {
                        "full": "[objs]",
                        "name": "objs",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [deny](https://docs.dolphindb.cn/zh/funcs/d/deny.html)\n\n\n\n#### 语法\n\ndeny(userId|groupId, accessType, \\[objs])\n\n#### 详情\n\n拒绝某个用户或某个组的权限。管理员可以通过该命令拒绝用户所有权限（*accessType*），但普通用户在拥有相关的 OWNER 权限后，只能通过该命令拒绝以下权限：TABLE\\_READ, TABLE\\_WRITE, TABLE\\_INSERT, TABLE\\_UPDATE, TABLE\\_DELETE, DB\\_READ, DB\\_WRITE, DB\\_INSERT, DB\\_UPDATE, DB\\_DELETE, DBOBJ\\_DELETE, DBOBJ\\_CREATE 和 VIEW\\_EXEC。\n\n可被拒绝的权限类型，参见 [grant](https://docs.dolphindb.cn/zh/funcs/g/grant.html)。Orca 流图和流表相关权限：详见 [Orca 实时计算平台 6.3 节](https://docs.dolphindb.cn/zh/stream/orca.md#)。\n\n**Note:** 该函数可在控制节点、数据节点和计算节点运行。\n\n#### 参数\n\n**userId** | **groupId** 是表示用户名或组名的字符串。\n\n**accessType** 权限类型/内存限制。\n\n**objs** 标量或向量，表示权限类型的应用对象/约束规则。也可以指定为 \\*，表示全局。当 *accessType* 指定为 COMPUTE\\_GROUP\\_EXEC 时，*objs* 必须为对应的计算组名。\n\n**Note:**\n\n* 管理共享内存表、流数据表或流计算引擎的权限时，*objs* 必须为 \"tableName\\@nodeAlias\" 或\"nodeAlias:tableName\"。\n* 管理 IMOLTP 引擎库表权限时，*objs* 必须为 \"oltp\\://database/table\\@nodeAlias\" 或 \"oltp\\://database\\@nodeAlias\"。\n\n*accessType* 和 *objs* 的取值请参照 [用户权限管理](https://docs.dolphindb.cn/zh/tutorials/ACL_and_Security.html) 权限类型表。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n组 \"research\" 中的所有成员都不能向表 dfs\\://db1/t1 中写入数据：\n\n```\ndeny(`research, TABLE_WRITE, \"dfs://db1/t1\")\n```\n\n组 \"research\" 中的所有成员都不能在数据库 dfs\\://db1 和 dfs\\://db2 中创建表：\n\n```\ndeny(\"research\", DBOBJ_CREATE, [\"dfs://db1\",\"dfs://db2\"])\n```\n\n用户 \"AlexSmith\" 不能删除数据库：\n\n```\ndeny(\"AlexSmith\", DB_MANAGE)\n```\n\n用户 \"AlexSmith\" 不能执行脚本：\n\n```\ndeny(\"AlexSmith\", SCRIPT_EXEC)\n```\n\n用户 \"AlexSmith\" 不能测试脚本：\n\n```\ndeny(\"AlexSmith\", TEST_EXEC)\n```\n"
    },
    "derivative": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/derivative.html",
        "signatures": [
            {
                "full": "derivative(func, X, [dx =1.0], [n=1], [order=3])",
                "name": "derivative",
                "parameters": [
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[dx =1.0]",
                        "name": "[dx =1.0]"
                    },
                    {
                        "full": "[n=1]",
                        "name": "n",
                        "optional": true,
                        "default": "1"
                    },
                    {
                        "full": "[order=3]",
                        "name": "order",
                        "optional": true,
                        "default": "3"
                    }
                ]
            }
        ],
        "markdown": "### [derivative](https://docs.dolphindb.cn/zh/funcs/d/derivative.html)\n\n\n\n#### 语法\n\nderivative(func, X, \\[dx =1.0], \\[n=1], \\[order=3])\n\n#### 详情\n\n返回函数 *func* 在 *X* 位置的 *n* 阶导数值。\n\n#### 参数\n\n**func** 是一元函数。\n\n**X** 是数值型标量或向量，表示求导位置。\n\n**dx** 是数值型的标量，表示求导间隔。*dx* 默认值是1.0，取值范围为大于0的浮点数。\n\n**n** 是整型的标量，表示导数的阶数。*n* 的默认是1。当前函数仅支持计算1阶导数。\n\n**order** 是整型的标量，表示选取点的数量。*order* 必须是奇数，默认值是3，取值范围为\\[3, 1023]。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\nderivative(acos, 0.458, 1e-3);\n// output\n-1.12492\n\na=[0.25, -4.53, 1.85, 12.45, 2.0];\nderivative(cbrt, a, 1e-3, 1, 5);\n// output\n[0.83995,0.121753,0.221189,0.062053,0.209987]\n\nderivative(pow{3,}, 5);\n// output\n324\n```\n"
    },
    "destroyMonitor": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/destroyMonitor.html",
        "signatures": [
            {
                "full": "destroyMonitor()",
                "name": "destroyMonitor",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [destroyMonitor](https://docs.dolphindb.cn/zh/funcs/d/destroyMonitor.html)\n\n\n\n#### 语法\n\ndestroyMonitor()\n\n#### 详情\n\n终止 monitor 实例。若该实例声明了 `onDestroy` 方法，则会在终止前自动执行该方法。终止后，monitor 内部的事件监听器将不再生效。\n\n#### 参数\n\n无\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\nclass Monitor1:CEPMonitor{\n    def addNewData(order)\n    //def updateData(change)\n    def Monitor1(){\n    }\n    def myDestroyMonitor(Orders){\n        destroyMonitor()\n    }\n    def onload(){\n        addEventListener(addNewData,\"Orders\",,\"all\")\n        // 当收到事件 Orders 的 v1 值为5.0时，单次触发该 listenser，调用 myDestroyMonitor 方法销毁当前的监控器实例\n        addEventListener(handler=myDestroyMonitor, eventType=\"Orders\", condition=<Orders.v1=5.0>, times=1)\n        try{\n            share(streamTable(1:0,`eventTime`sym`val0`val1`val2,[TIMESTAMP,SYMBOL,INT,FLOAT,DOUBLE]),'test_DV')\n            createDataViewEngine(\"test_DV\",objByName('test_DV'),`sym,`eventTime,false)\n        }catch(ex){}\n    }\n    def unload(){\n        undef(`test_DV,SHARED)\n    }\n    def addNewData(order){\n        getDataViewEngine('test_DV').append!(table([order.eventTime] as eventTime,[order.sym] as sym,[order.val1] as v1,[order.val2] as v2,[00i] as v3,[00i] as v4,[00i] as v5))\n    }\n\n}\nclass Orders{\n    eventTime :: TIMESTAMP \n    sym :: STRING\n    val0 :: INT\n    val1 :: FLOAT\n    val2 :: DOUBLE\n    def Orders(s,v0,v1,v2){\n        sym = s\n        val0 = v0\n        val1 = v1\n        val2 = v2\n        eventTime = now()\n    }\n}\n\ndummy = table(array(TIMESTAMP, 0) as eventTime, array(STRING, 0) as eventType, array(BLOB, 0) as blobs)\ntry{dropStreamEngine(\"test_CEP\")}catch(ex){}\nengine=createCEPEngine(\"test_CEP\",<Monitor1()>,dummy,Orders,,'eventTime',,,\"sym\")\nshare streamTable(array(TIMESTAMP, 0) as eventTime, array(STRING, 0) as eventType, array(BLOB, 0) as blobs) as input\ntry{dropStreamEngine(`serInput)}catch(ex){}\nserializer = streamEventSerializer(name=`serInput, eventSchema=Orders, outputTable=input, eventTimeField = \"eventTime\")\nsubscribeTable(,`input, `subopt1, 0,getStreamEngine('test_CEP'),true)\n```\n"
    },
    "det": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/det.html",
        "signatures": [
            {
                "full": "det(X)",
                "name": "det",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [det](https://docs.dolphindb.cn/zh/funcs/d/det.html)\n\n\n\n#### 语法\n\ndet(X)\n\n#### 详情\n\n返回矩阵 *X* 的行列式（determinant）。在计算中，NULL 值用 0 代替。\n\nDolphinDB `det` 和 `numpy.linalg.det` 的核心功能相同，在参数设计、空值处理上存在差异：\n\n* DolphinDB `det` 要求入参必须是矩阵对象；`numpy.linalg.det` 接受类数组对象并自动转换为 ndarray。\n* 在缺失值处理上，DolphinDB `det` 将 NULL 视为 0；`numpy.linalg.det` 包含 NaN/Inf 时会返回 NaN/Inf。详见下文例子。\n\n#### 参数\n\n**X** 是一个矩阵。\n\n#### 返回值\n\nDOUBLE 类型标量。\n\n#### 例子\n\n```\nx=1..4$2:2;\nx;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 3  |\n| 2  | 4  |\n\n```\nx.det();\n// output: -2\n\nx=1 2 3 6 5 4 8 7 0$3:3;\nx;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1  | 6  | 8  |\n| 2  | 5  | 7  |\n| 3  | 4  | 0  |\n\n```\ndet(x);\n// output: 42\n\nx=1 2 3 6 5 4 8 7 NULL $3:3;\nx;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1  | 6  | 8  |\n| 2  | 5  | 7  |\n| 3  | 4  |    |\n\n```\ndet(x);\n// output: 42\n```\n\n以下代码在 Python 中运行。代码展示了 `numpy.linalg.det` 对 NaN/Inf 的处理逻辑。\n\n```\nimport numpy as np\n\nA = np.array([\n    [1, 6, 8],\n    [2, 5, 7],\n    [3, 4, np.nan]\n])\n\nprint(np.isnan(np.linalg.det(A)))\n# 返回 True\n\nB = np.array([\n    [1, 6, 8],\n    [2, 5, 7],\n    [3, 4, np.inf]\n])\nprint(np.isnan(np.linalg.det(B)))\n\n# 返回 True\n```\n"
    },
    "diag": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/diag.html",
        "signatures": [
            {
                "full": "diag(X)",
                "name": "diag",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [diag](https://docs.dolphindb.cn/zh/funcs/d/diag.html)\n\n\n\n#### 语法\n\ndiag(X)\n\n#### 详情\n\n处理矩阵的对角线元素，支持以下两种转换：\n\n* 向量转对角矩阵：将向量作为主对角线元素构造对角矩阵。\n\n* 方阵提取对角线：从方阵中提取主对角线元素。\n\nDolphinDB 的 `diag` 函数和 `numpy.diag` 函数在基本功能上相似，但在参数设计、功能范围、空值处理上存在区别。\n\n* DolphinDB `diag` 函数仅支持一个参数，不支持对角线偏移、仅能处理主对角线、输入必须是向量或方阵\n* `numpy.diag` 函数支持可选偏移参数、可以提取/设置任意对角线，输入为一维或二维数组。\n* 在空值处理方面，DolphinDB `diag` 函数将 NULL 视为 0，而 `numpy.diag` 对 NaN/Inf 采取原样保留策略。\n\n#### 参数\n\n**X** 是一个向量或方阵。\n\n#### 返回值\n\n* 如果 *X* 是向量，返回一个矩阵。\n\n* 如果 *X* 是方阵，返回一个向量。\n\n#### 例子\n\n```\ndiag(1..5);\n```\n\n| #0 | #1 | #2 | #3 | #4 |\n| -- | -- | -- | -- | -- |\n| 1  | 0  | 0  | 0  | 0  |\n| 0  | 2  | 0  | 0  | 0  |\n| 0  | 0  | 3  | 0  | 0  |\n| 0  | 0  | 0  | 4  | 0  |\n| 0  | 0  | 0  | 0  | 5  |\n\n```\nm=1..4$2:2;\nm;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 3  |\n| 2  | 4  |\n\n```\ndiag(m);\n\n// output: [1,4]\n```\n"
    },
    "dict": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/dict.html",
        "signatures": [
            {
                "full": "dict(keyObj, valueObj, [ordered=false])",
                "name": "dict",
                "parameters": [
                    {
                        "full": "keyObj",
                        "name": "keyObj"
                    },
                    {
                        "full": "valueObj",
                        "name": "valueObj"
                    },
                    {
                        "full": "[ordered=false]",
                        "name": "ordered",
                        "optional": true,
                        "default": "false"
                    }
                ]
            },
            {
                "full": "dict(keyType, valueType, [ordered=false])",
                "name": "dict",
                "parameters": [
                    {
                        "full": "keyType",
                        "name": "keyType"
                    },
                    {
                        "full": "valueType",
                        "name": "valueType"
                    },
                    {
                        "full": "[ordered=false]",
                        "name": "ordered",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [dict](https://docs.dolphindb.cn/zh/funcs/d/dict.html)\n\n\n\n#### 语法\n\ndict(keyObj, valueObj, \\[ordered=false])\n\n或\n\ndict(keyType, valueType, \\[ordered=false])\n\n#### 详情\n\n返回一个无序字典或有序字典对象。\n\n#### 参数\n\n对于第一种情形，**keyObj** 是表示键的向量，**valueObj** 是表示值的向量。\n\n对于第二种情形，**keyType** 是字典键的数据类型，**valueType** 是字典值的数据类型。系统支持以下键的数据类型：Literal、Integral（COMPRESS 除外）、Floating 和 Temporal。字典中的值不支持 COMPLEX，POINT 类别。\n\n**ordered** 一个布尔值，默认为 false，表示创建一个无序字典。当 *ordered* = true 时，创建一个有序字典。无序字典在输出或进行遍历时，其键值对不保留输入时的顺序；有序字典在输出或进行遍历时，键值对的顺序与输入顺序保持一致。\n\n#### 例子\n\n```\nx=1 6 3\ny=4.5 7.8 4.3\nz=dict(x,y);\nz;\n// output\n3->4.3\n1->4.5\n6->7.8\n\nz=dict(INT,DOUBLE);\nz[5]=7.9;\nz;\n// output\n5->7.9\n\nz[3]=6;\nz;\n// output\n3->6\n5->7.9\n\ndt=dict([`test], [1]);\ndt;\n// output\ntest->1\n\n// 创建有序字典\nz=dict(x,y,true)\nz;\n// output\n1->4.5\n6->7.8\n3->4.3\n\n\n// y 为 DECIMAL32 类型的向量，将 y 作为 value 值创建有序字典 z\nx=1 3 2\ny = decimal32\\(1.23 3 3.14, 3\\)\nz=dict\\(x,y,true\\);\nz;\n// output\n1-&gt;1.230\n3-&gt;3.000\n2-&gt;3.140\n```\n\n获取键和值:\n\n```\nx=1 6 3\ny=4.5 7.8 4.3\nz=dict(x,y);\nz.keys();\n// output\n[3,1,6]\n\nz.values();\n// output\n[4.3,4.5,7.8]\n```\n\n相关函数：[array](https://docs.dolphindb.cn/zh/funcs/a/array.html), [matrix](https://docs.dolphindb.cn/zh/funcs/m/matrix.html)， [dictUpdate!](https://docs.dolphindb.cn/zh/funcs/d/dictUpdate_.html), [syncDict](https://docs.dolphindb.cn/zh/funcs/s/syncDict.html)\n"
    },
    "dictUpdate!": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/dictUpdate_.html",
        "signatures": [
            {
                "full": "dictUpdate!(dictionary, function, keys, parameters, [initFunc=copy])",
                "name": "dictUpdate!",
                "parameters": [
                    {
                        "full": "dictionary",
                        "name": "dictionary"
                    },
                    {
                        "full": "function",
                        "name": "function"
                    },
                    {
                        "full": "keys",
                        "name": "keys"
                    },
                    {
                        "full": "parameters",
                        "name": "parameters"
                    },
                    {
                        "full": "[initFunc=copy]",
                        "name": "initFunc",
                        "optional": true,
                        "default": "copy"
                    }
                ]
            }
        ],
        "markdown": "### [dictUpdate!](https://docs.dolphindb.cn/zh/funcs/d/dictUpdate_.html)\n\n\n\n#### 语法\n\ndictUpdate!(dictionary, function, keys, parameters, \\[initFunc=copy])\n\n#### 详情\n\n更新字典中的特定的键的值。\n\n#### 参数\n\n**dictionary** 是一个字典。\n\n**function** 是一个函数。\n\n**keys** 可以是标量或向量，表示对哪些键应用函数。\n\n**parameters** 和 **keys** 具有相同长度。应用函数的参数是 *parameters* 和字典的初始值。\n\n**initFunc** 是一个一元函数。当更新的键不存在时，执行该函数。只有当字典的值是 ANY 类型时，才能指定该参数。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\nx=dict(1 2 3, 1 1 1);\nx;\n// output\n3->1\n1->1\n2->1\n\ndictUpdate!(x, add, 2 3, 1 2);\n// output\n3->3\n1->1\n2->2\n\nx.dictUpdate!(mul, 3 4, 2 4);\n// output\n4->4\n3->6\n1->1\n2->2\n\nd = dict(`IBM`MSFT, [1 2, 3 4])\nmsg = table(`IBM`MSFT`GOOG as symbol, 2 3 2 as ap)\nd.dictUpdate!(append!, msg.symbol, msg.ap, x->array(x.type(), 0, 512).append!(x))\nd;\n// output\nMSFT->[3,4,3]\nGOOG->[2]\nIBM->[1,2,2]\n```\n"
    },
    "difference": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/difference.html",
        "signatures": [
            {
                "full": "difference(X)",
                "name": "difference",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [difference](https://docs.dolphindb.cn/zh/funcs/d/difference.html)\n\n\n\n#### 语法\n\ndifference(X)\n\n#### 详情\n\n返回向量的最后一个元素减第一个元素的值。如果 *X* 是一个标量，则返回 0。\n\n#### 参数\n\n**X** 可以是标量或向量。\n\n#### 返回值\n\nDOUBLE 类型标量。\n\n#### 例子\n\n```\ndifference(2 4 2);\n// output\n0\n\ndifference(12.3 15.6 17.8);\n// output\n5.5\n\ndifference(278);\n// output\n0\n```\n"
    },
    "differentialEvolution": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/differentialevolution.html",
        "signatures": [
            {
                "full": "differentialEvolution(func, bounds, [X0], [maxIter=1000], [popSize=15], [mutation], [recombination=0.7], [tol=0.01], [atol=0], [polish=true], [seed])",
                "name": "differentialEvolution",
                "parameters": [
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "bounds",
                        "name": "bounds"
                    },
                    {
                        "full": "[X0]",
                        "name": "X0",
                        "optional": true
                    },
                    {
                        "full": "[maxIter=1000]",
                        "name": "maxIter",
                        "optional": true,
                        "default": "1000"
                    },
                    {
                        "full": "[popSize=15]",
                        "name": "popSize",
                        "optional": true,
                        "default": "15"
                    },
                    {
                        "full": "[mutation]",
                        "name": "mutation",
                        "optional": true
                    },
                    {
                        "full": "[recombination=0.7]",
                        "name": "recombination",
                        "optional": true,
                        "default": "0.7"
                    },
                    {
                        "full": "[tol=0.01]",
                        "name": "tol",
                        "optional": true,
                        "default": "0.01"
                    },
                    {
                        "full": "[atol=0]",
                        "name": "atol",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[polish=true]",
                        "name": "polish",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[seed]",
                        "name": "seed",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [differentialEvolution](https://docs.dolphindb.cn/zh/funcs/d/differentialevolution.html)\n\n\n\n#### 语法\n\ndifferentialEvolution(func, bounds, \\[X0], \\[maxIter=1000], \\[popSize=15], \\[mutation], \\[recombination=0.7], \\[tol=0.01], \\[atol=0], \\[polish=true], \\[seed])\n\n#### 详情\n\n使用差分进化算法（Differential Evolution）求解多元函数的全局最小值。返回一个字典，表示求解结果，详细说明请参见“返回值”小节。\n\n#### 参数\n\n**func** 函数名，表示需要最小化的目标函数。注意：其返回值应为标量数值。\n\n**bounds** 数值类型矩阵，形状为(N,2)，其中 N 为需要优化的参数数量。\n\n**X0** 可选参数，数值向量，表示使目标函数最小化的参数的初始猜测。\n\n注意：\n\n* 参数 *bounds* 中每一行的两个值（min, max），分别定义了 *X0* 中对应参数的下、上边界。即参数 *X0* 的每个元素值均在 *bounds* 的范围内。\n\n* 参数 *X0* 应与 *bounds* 保持相同长度，即 N=size(*X0*)。\n\n**maxIter** 可选参数，非负整数标量，表示执行的最大迭代次数，默认值为 1000。\n\n**popSize** 可选参数，正整数标量，用于设置种群大小的乘数。种群包含 popSize\\*(N - N\\_equal) 个个体，其中，N\\_equal 表示 *bounds* 中上下限相等的参数个数。默认值为 15。\n\n**mutation** 可选参数，输入形式为数值数据对 pair(min, max)，表示变异常数的范围。应满足 0<= min <=max <2。默认值为(0.5, 1)。\n\n**recombination** 可选参数，数值标量，表示重组常数，又称为交叉概率。取值范围为\\[0, 1]。\n\n**tol** 可选参数，非负浮点数标量，表示收敛的相对容忍度。默认值为 0.01。\n\n**atol** 可选参数，非负浮点数标量，表示收敛的绝对容忍度。默认值为 0。当满足条件 stdev(population\\_energies) <= *atol* + *tol* \\* abs(mean(population\\_energies)) 时，停止算法迭代，其中 population\\_energies 表示种群中每个个体求得的目标函数值构成的向量。\n\n**polish** 可选参数，布尔标量，表示是否在差分进化算法结束后进一步使用 L-BFGS-B 算法优化参数。默认值为 true，表示使用。\n\n**seed** 可选参数，整数标量，表示差分进化算法中使用的随机数种子。如果不设置，则使用非确定性的随机数生成器。该参数的作用在于让用户可以复现运行结果。默认不设置。\n\n#### 返回值\n\n返回一个字典，包含以下成员：\n\n* xopt：浮点数向量，使目标函数最小化的参数值。\n\n* fopt：浮点数标量，目标函数最小值，fopt=f(xopt)。\n\n* iterations：整数标量，优化过程中执行的总迭代数。\n\n* fcalls：整数标量，优化过程中的目标函数调用次数。\n\n* converged：布尔值标量，表示优化过程的收敛状态。\n\n  * true：表示优化结果已收敛至满足预定条件，算法停止执行。\n\n  * false：表示已达最大迭代次数，算法未收敛而停止执行。\n\n#### 例子\n\n自定义函数 `rosen`，在上下界 *bounds* 约束下使用 `differentialEvolution` 求解 `rosen` 函数的全局最小值。\n\n```\ndef rosen(x) { \n\tN = size(x);\n\treturn sum(100.0*power(x[1:]-power(x[:N-1], 2.0), 2.0)+power(1-x[:N-1], 2.0));\n}\nbounds = matrix([0 0 0 0 0, 2 2 2 2 2])\ndifferentialEvolution(rosen, bounds)\n\n/* Ouput:\nfcalls->43656\nxopt->[1.000000000000,1.000000000000,1.000000000000,1.000000000000,1.000000000000]\nfopt->0.0\niterations->581\nconverged->true\n*/\n```\n"
    },
    "digitize": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/digitize.html",
        "signatures": [
            {
                "full": "digitize(x, bins, [right=false])",
                "name": "digitize",
                "parameters": [
                    {
                        "full": "x",
                        "name": "x"
                    },
                    {
                        "full": "bins",
                        "name": "bins"
                    },
                    {
                        "full": "[right=false]",
                        "name": "right",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [digitize](https://docs.dolphindb.cn/zh/funcs/d/digitize.html)\n\n#### 语法\n\ndigitize(x, bins, \\[right=false])\n\n#### 详情\n\n返回 *x*所属的*bins*的索引，返回值的数据形式与*x* 一致。\n\n| right | bins 顺序 | 返回的索引满足                  |\n| ----- | ------- | ------------------------ |\n| false | 升序      | *bins* 里第一个大于 *x* 的元素的索引 |\n| true  | 升序      | *bins*里第一个大于等于 *x*的元素的索引 |\n| false | 降序      | *bins*里第一个小于等于 *x*的元素的索引 |\n| true  | 降序      | *bins*里第一个小于 *x*的元素的索引   |\n\n如果 *x*中的值超出 *bins* 的左或右边界，则返回 0 或 *bins* 的长度。\n\n该函数的功能和使用方法同 numpy.digitize。\n\n与 Python 中 `numpy.digitize` 的区别：DolphinDB 的 `digitize` 功能同 `numpy.digitize`，*bins* 可递增或递减；DolphinDB 的 *x* 支持标量或向量，NumPy 的 *x* 支持任意形状数组，返回同形状 ndarray。\n\n#### 参数\n\n**x** 一个浮点型、整型或 DECIMAL 类型的标量或向量。\n\n**bins** 一个单调递增或递减的浮点型、整型或 DECIMAL 类型向量。\n\n**right** 一个布尔值，为可选参数，设置区间包含右边界还是左边界，默认为 false（包含左边界）。\n\n#### 例子\n\n```\nbins = [1,3,3,5,5]\n// 返回 bins 里第一个大于 x 的元素的索引\ndigitize(3, bins=bins, right=false)\n// output: 3\n//返回 bins 里第一个大于 x 的元素的索引，由于 bins 里不存在这样的元素，返回 size(bins)\ndigitize(5, bins=bins, right=false)\n//output: 5\n// 返回 bins 里第一个大于等于 x 的元素的索引\ndigitize(5, bins=bins, right=true)\n//output: 3\nbins = reverse(bins)\ndigitize(5, bins=bins, right=false)\n//output: 0\ndigitize(5, bins=bins, right=true)\n//output: 2\n\nx = [-1,0,1,2,3,4,5,6]\nbins = [1,3,5]\ndigitize(x=x, bins=bins, right=false)\n//output: [0,0,1,1,2,2,3,3]\ndigitize(x=x, bins=bins, right=true)\n//output: [0,0,0,1,1,2,2,3]\nbins = reverse(bins)\ndigitize(x=x, bins=bins, right=false)\n//output: [3,3,2,2,1,1,0,0]\ndigitize(x=x, bins=bins, right=true)\n//output: [3,3,3,2,2,1,1,0]\n```\n\n`digitize` 函数相较于 `bucket` 函数更灵活，可以自定义 *bins* 。以下为示例：\n\n```\nbucket(9 23 54 36 46 12, 12:53, 2) //报错：dataRange must be the mutltiplier of bucketNum.\n```\n\n因为 \\[12, 53) 中元素个数不能被2整除，所以不能使用 `bucket` 来分桶。\n\n```\ndigitize(9 23 54 36 46 12 , 12 40 53)\n// output: [0,1,3,1,2,1]\n```\n\n`digitize` 函数中，函数按照自定义的 *bins*给数据分桶。\n\n"
    },
    "disableActivePartition": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/disableActivePartition.html",
        "signatures": [
            {
                "full": "disableActivePartition(dbHandle)",
                "name": "disableActivePartition",
                "parameters": [
                    {
                        "full": "dbHandle",
                        "name": "dbHandle"
                    }
                ]
            }
        ],
        "markdown": "### [disableActivePartition](https://docs.dolphindb.cn/zh/funcs/d/disableActivePartition.html)\n\n\n\n#### 语法\n\ndisableActivePartition(dbHandle)\n\n#### 详情\n\n断开与历史数据库的连接。\n\n#### 参数\n\n**dbHandle** 是历史数据库的句柄。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\nhistdb = database(\"C:\\DolphinDBDemo\\example\\data\\dbspace\\historical-A\\Trades2ndDomain\")\nactiveNodeAlias = getNodeAlias()\nactiveDate = today()\nenableActivePartition(histdb, activeDate, activeNodeAlias);\n\ndisableActivePartition(histdb);\n```\n"
    },
    "disableDynamicScriptOptimization": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/disabledynamicscriptoptimization.html",
        "signatures": [
            {
                "full": "disableDynamicScriptOptimization()",
                "name": "disableDynamicScriptOptimization",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [disableDynamicScriptOptimization](https://docs.dolphindb.cn/zh/funcs/d/disabledynamicscriptoptimization.html)\n\n\n\n#### 语法\n\ndisableDynamicScriptOptimization()\n\n#### 详情\n\n关闭脚本引擎优化。\n\n此命令须在控制节点由管理员执行。\n\n此命令的影响将在系统重启后失效。若要永久生效，请在配置文件（集群模式为 controller.cfg，单节点模式为 dolphindb.cfg）中修改配置参数 *enableDynamicScriptOptimization* 。\n\n#### 例子\n\n```\ndisableDynamicScriptOptimization()\n```\n\n**相关函数：** [enableDynamicScriptOptimization](https://docs.dolphindb.cn/zh/funcs/e/enabledynamicscriptoptimization.html)\n"
    },
    "disableQueryMonitor": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/disableQueryMonitor.html",
        "signatures": [
            {
                "full": "disableQueryMonitor()",
                "name": "disableQueryMonitor",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [disableQueryMonitor](https://docs.dolphindb.cn/zh/funcs/d/disableQueryMonitor.html)\n\n\n\n#### 语法\n\ndisableQueryMonitor()\n\n#### 详情\n\n关闭监控查询任务状态的功能。\n\n由于监控查询任务状态具有一定的内存开销，内存资源紧张时，可以关闭该功能。注意：调用该命令后，用户将无法调用 [getQueryStatus](https://docs.dolphindb.cn/zh/funcs/g/getQueryStatus.html) 函数获取查询任务的状态。\n\n#### 参数\n\n无。\n\n#### 返回值\n\n无。\n\n相关函数： [enableQueryMonitor](https://docs.dolphindb.cn/zh/funcs/e/enableQueryMonitor.html)\n"
    },
    "disableResourceTracking": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/disableresourcetracking.html",
        "signatures": [
            {
                "full": "disableResourceTracking()",
                "name": "disableResourceTracking",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [disableResourceTracking](https://docs.dolphindb.cn/zh/funcs/d/disableresourcetracking.html)\n\n\n\n#### 语法\n\ndisableResourceTracking()\n\n#### 详情\n\n在线关闭资源跟踪。仅当 resourceSamplingInterval 设置为正整数时才能调用该函数。该函数仅限管理员在数据节点上调用。\n\n**Note:** 资源跟踪开启和关闭不会影响日志回收。\n\n#### 参数\n\n无。\n\n#### 返回值\n\n无。\n\n**相关函数**：[enableResourceTracking](https://docs.dolphindb.cn/zh/funcs/e/enableresourcetracking.html)\n"
    },
    "disableTablePersistence": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/disableTablePersistence.html",
        "signatures": [
            {
                "full": "disableTablePersistence(table)",
                "name": "disableTablePersistence",
                "parameters": [
                    {
                        "full": "table",
                        "name": "table"
                    }
                ]
            }
        ],
        "markdown": "### [disableTablePersistence](https://docs.dolphindb.cn/zh/funcs/d/disableTablePersistence.html)\n\n\n\n#### 语法\n\ndisableTablePersistence(table)\n\n#### 详情\n\n停止把表持久化到磁盘，后续表更新的内容将不会持久化到磁盘上。\n\n```\ncolName=[\"time\",\"x\"]\ncolType=[\"timestamp\",\"int\"]\nt = streamTable(100:0, colName, colType);\nshare t as st\nenableTablePersistence(table=st, cacheSize=1200000)\n\nfor(s in 0:200){\n   n=10000\n   time=2019.01.01T00:00:00.000+s*n+1..n\n   x=rand(10.0, n)\n   insert into st values(time, x)\n}\ndisableTablePersistence(st);\n```\n\n#### 参数\n\n**table** 是一个表对象。\n\n#### 返回值\n\n无。\n\n**相关函数**：[enableTablePersistence](https://docs.dolphindb.cn/zh/funcs/e/enableTablePersistence.html), [clearTablePersistence](https://docs.dolphindb.cn/zh/funcs/c/clearTablePersistence.html)\n"
    },
    "disableTSDBAsyncSorting": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/disableTSDBAsyncSorting.html",
        "signatures": [
            {
                "full": "disableTSDBAsyncSorting()",
                "name": "disableTSDBAsyncSorting",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [disableTSDBAsyncSorting](https://docs.dolphindb.cn/zh/funcs/d/disableTSDBAsyncSorting.html)\n\n\n\n#### 语法\n\ndisableTSDBAsyncSorting()\n\n#### 详情\n\nTSDB 写入 Cache Engine 中的数据会根据 *sortColumns* 排序。写入任务和排序任务可以同步或异步进行，该命令用于关闭异步进行数据排序的功能。只能由管理员在数据节点上执行。\n\n#### 参数\n\n无。\n\n#### 返回值\n\n无。\n\n**相关函数**：[enableTSDBAsyncSorting](https://docs.dolphindb.cn/zh/funcs/e/enableTSDBAsyncSorting.html)\n"
    },
    "distance": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/distance.html",
        "signatures": [
            {
                "full": "distance(X, Y)",
                "name": "distance",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [distance](https://docs.dolphindb.cn/zh/funcs/d/distance.html)\n\n\n\n#### 语法\n\ndistance(X, Y)\n\n#### 详情\n\n计算 *X* 和 *Y* 之间的距离（单位为米）。\n\n#### 参数\n\n**X** 和 **Y** 是 POINT 类型的标量、数据对或者向量。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\np1 = point(180, 24.118418)\np2 = point(180, 24.11931)\ndistance(p1,p2)\n// output\n99.185916\n\np1 = point(117.60972, 24.118418)\np2 = point(117.50972, 24.118418)\np3 = point(117.70972, 24.118418)\np4 = point(117.75972, 24.118418)\ndistance([p1,p2], [p3,p4])\n```\n\n| 0          | 1           |\n| ---------- | ----------- |\n| 10,148.799 | 25,371.9947 |\n\n计算地图上两点之间的距离，假设 p1 的经纬度为 (Lon1, Lat1)，p2 的经纬度为 (Lon2, Lat2)。按照0度经线的基准，东经取正值（Longitude），西经取负值（-Longitude），北纬取90-纬度值（90- Latitude），南纬取90+纬度值（90+Latitude）。经过上述处理后进行计算：\n\n```\np1 = point(-117.60972,24.118418)  // 表示西经117.60972和北纬65.881582\np2 = point(117.61113,114.11931)  // 表示东经117.60972和南纬24.118418\ndistance(p1,p2)\n// output\n6.02098E6\n```\n"
    },
    "distinct": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/distinct.html",
        "signatures": [
            {
                "full": "distinct(X)",
                "name": "distinct",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [distinct](https://docs.dolphindb.cn/zh/funcs/d/distinct.html)\n\n\n\n#### 语法\n\ndistinct(X)\n\n#### 详情\n\n去除 *X* 中的重复元素，返回唯一值。3.00.4 版本起，返回结果的顺序与输入顺序保持一致。\n\n#### 参数\n\n**X** 是一个向量或数组向量类型。\n\n#### 返回值\n\nDOUBLE 类型向量。\n\n#### 例子\n\n```\ndistinct(4 5 5 2 3)\n// output: [4,5,2,3]\n\na = array(INT[], 0, 10).append!([1 2 3,  4 5, 6 7 8, 9 10])\ndistinct(a)\n// output: [1,2,3,4,5,6,7,8,9,10]\n\nt=table(3 1 2 2 3 as x);\nselect distinct x from t;\n```\n\n| distinct\\_x |\n| ----------- |\n| 3           |\n| 1           |\n| 2           |\n\n```\nselect sort(distinct(x)) as x from t;\n```\n\n| x |\n| - |\n| 1 |\n| 2 |\n| 3 |\n\n函数 `distinct` 返回一个向量，而函数 [`set`](https://docs.dolphindb.cn/zh/funcs/s/set.html) 返回一个集合。\n\n```\nx=set(4 5 5 2 3);\nx;\n// output\nset(3,2,5,4)\nx.intersection(set(2 5));\n// output\nset(2,5)\n```\n\n在内存表或分布式表中，`distinct` 函数可以和 `group by` 配合使用，每个分组的结果为一个数组向量。\n\n```\ndbName = \"dfs://testdb\"\nif(existsDatabase(dbName)){\n   dropDatabase(dbName)\n}\n\ndb=database(\"dfs://testdb\", VALUE, 2012.01.11..2012.01.29)\n\nn=100\nt=table(take(2012.01.11..2012.01.29, n) as date, symbol(take(\"A\"+string(21..60), n)) as sym, take(100, n) as val)\n\npt=db.createPartitionedTable(t, `pt, `date).append!(t)\nresult=select distinct(date) from pt group by sym\nselect sym, distinct_date from result where sym=`A21\n```\n\n| sym | distinct\\_date                      |\n| --- | ----------------------------------- |\n| A21 | \\[2012.01.15,2012.01.13,2012.01.11] |\n"
    },
    "div": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/div.html",
        "signatures": [
            {
                "full": "div(X, Y)",
                "name": "div",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [div](https://docs.dolphindb.cn/zh/funcs/d/div.html)\n\n\n\n#### 语法\n\ndiv(X, Y) 或 X/Y\n\n#### 详情\n\n返回 *X* 和 *Y* 中元素依次相除的结果。当 *X* 或 *Y* 是浮点数时，返回一个浮点数。当 *X* 和 *Y* 都是整数时，`div` 表示整数除法，相当于在除法操作后应用 [floor](https://docs.dolphindb.cn/zh/funcs/f/floor.html) 函数。比如，5/2 返回 2. 如果想要为整数执行“真正”的除法，可以使用 [ratio](https://docs.dolphindb.cn/zh/funcs/r/ratio.html) 运算符 \"\\\\\" 代替。整数常和 [mod](https://docs.dolphindb.cn/zh/funcs/m/mod.html) 运算符一同使用，用来为数据分组。`div` 和 `mod` 的结果应该满足关系式：X=div(X,Y)\\*Y+mod(X,Y)。\n\n#### 参数\n\n**X** 和 **Y** 可以是标量、数据对、向量或矩阵。如果 *X* 或 *Y* 的其中一个是数据对、向量、矩阵，另一个必须是具有相同长度或维度的数据对、向量、矩阵或者标量。\n\n#### 返回值\n\n返回一个和 *X* 或 *Y* 相同数据类型和形式的对象。\n\n#### 例子\n\n```\n9/2:5;\n// output\n4 : 1\n\n11:25/3:4;\n// output\n3 : 6\n\nx=1 2 3;\nx/2;\n// output\n[0,1,1]\n\n2/x;\n// output\n[2,1,0]\n\ny=4 5 6;\nx/y;\n// output\n[0,0,0]\ny/x;\n// output\n[4,2,2]\n\nm1=1..6$2:3;\nm1;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1  | 3  | 5  |\n| 2  | 4  | 6  |\n\n```\nm1/2;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 0  | 1  | 2  |\n| 1  | 2  | 3  |\n\n```\nm2=6..1$2:3;\nm2;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 6  | 4  | 2  |\n| 5  | 3  | 1  |\n\n```\nm1/m2;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 0  | 0  | 2  |\n| 0  | 1  | 6  |\n\n```\n-7/5;\n// output\n-2\n\nx=-1 2 6;\nx/-5;\n// output\n[0,-1,-2]\n```\n"
    },
    "dividedDifference": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/dividedDifference.html",
        "signatures": [
            {
                "full": "dividedDifference(X, Y, resampleRule, [closed='left'], [origin='start_day'], [outputX=false])",
                "name": "dividedDifference",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "resampleRule",
                        "name": "resampleRule"
                    },
                    {
                        "full": "[closed='left']",
                        "name": "closed",
                        "optional": true,
                        "default": "'left'"
                    },
                    {
                        "full": "[origin='start_day']",
                        "name": "origin",
                        "optional": true,
                        "default": "'start_day'"
                    },
                    {
                        "full": "[outputX=false]",
                        "name": "outputX",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [dividedDifference](https://docs.dolphindb.cn/zh/funcs/d/dividedDifference.html)\n\n\n\n#### 语法\n\ndividedDifference(X, Y, resampleRule, \\[closed='left'], \\[origin='start\\_day'], \\[outputX=false])\n\n#### 详情\n\n该函数根据 *resampleRule*, *closed*, *origin* 确定的采样规则，对 *X* 进行重采样操作。并根据重采样后的 *X*，对 *Y* 进行均差插值（DividedDifference Interpolation）。\n\n若不指定 *outputX*，仅返回一个对 *Y* 插值后的向量。若指定 *outputX* = true，则返回一个 tuple，其第一个元素为 *X* 重采样后的向量，第二个元素为对 *Y* 插值后的向量。\n\n#### 参数\n\n**X** 严格递增的时间类型向量。\n\n**Y** 同 *X* 等长的数值型向量。\n\n**resampleRule** 一个字符串，可选值请参考 [resample](https://docs.dolphindb.cn/zh/funcs/r/resample.html) 的 *rule* 参数。\n\n**closed** 和 **origin** 同 [resample](https://docs.dolphindb.cn/zh/funcs/r/resample.html) 的 *closed* 和 *origin* 参数。\n\n**outputX** 布尔类型，表示是否输出 *X* 按照 *resampleRule*, *closed*, *origin* 重采样后的向量。默认值为 false。\n\n#### 例子\n\n**例 1**\n\n```\ndividedDifference([2016.02.14 00:00:00, 2016.02.15 00:00:00, 2016.02.16 00:00:00], [1.0, 2.0, 4.0], resampleRule=`60min);\n\n// output\n[1,1.0217,1.0451,1.0703,1.0972,1.1259,1.1562,1.1884,1.2222,1.2578,\n1.2951,1.3342,1.375,1.4175,1.4618,1.5078,1.5556,1.605,1.6562,1.7092,\n1.7639,1.8203,1.8785,1.9384,2,2.0634,2.1285,2.1953,2.2639,2.3342,\n2.4062,2.48,2.5556,2.6328,2.7118,2.7925,2.875,2.9592,3.0451,3.1328,\n3.2222,3.3134,3.4062,3.5009,3.5972,3.6953,3.7951,3.8967,4]\n```\n\n**例 2** 不同 *closed* 取值的影响。\n\n```\nX = 2022.01.01T00:00:00 + [0, 3, 6, 9] * 60  // 00:00, 00:03, 00:06, 00:09\nY = [1.0, 3.0, 7.0, 13.0]\n\n// closed='left'（默认）：区间为 [t, t+3min)，左闭右开\n// 00:03 归入 [00:03, 00:06)，是第二个桶的起点\ndividedDifference(X, Y, `3min, closed=`left)\n\n// closed='right'：区间为 (t, t+3min]，左开右闭\n// 00:03 归入 (00:00, 00:03]，成为第一个桶的终点\n// 重采样 X 的划分基准不同，插值结果随之变化\ndividedDifference(X, Y, `3min, closed=`right)\n```\n\n**例 3** 不同 *origin* 取值的影响。\n\n```\n// 数据从 00:00:30 开始，不与整分对齐\nX = 2022.01.01T00:00:30 + (0..4) * 60  // 00:00:30, 00:01:30, ..., 00:04:30\nY = [2.0, 4.0, 7.0, 11.0, 16.0]\n\n// origin='start_day'（默认）：从当天零点 00:00:00 对齐\n// 时间桶: [00:00:00, 00:01:00), [00:01:00, 00:02:00), ...\n// 重采样 X 为: 00:00:00, 00:01:00, 00:02:00, 00:03:00, 00:04:00\ndividedDifference(X, Y, `1min, origin=`start_day, outputX=true)\n\n// origin='start'：从第一个数据点 00:00:30 对齐\n// 时间桶: [00:00:30, 00:01:30), [00:01:30, 00:02:30), ...\n// 重采样 X 为: 00:00:30, 00:01:30, 00:02:30, 00:03:30, 00:04:30\ndividedDifference(X, Y, `1min, origin=`start, outputX=true)\n\n// origin=自定义时间戳：从 00:00:10 对齐\n// 时间桶: [00:00:10, 00:01:10), [00:01:10, 00:02:10), ...\n// 重采样 X 为: 00:00:10, 00:01:10, 00:02:10, 00:03:10, 00:04:10\ndividedDifference(X, Y, `1min, origin=2022.01.01T00:00:10, outputX=true)\n```\n\n**例 4** 不同 *outputX* 取值的影响。\n\n```\nX = [2016.02.14T00:00:00, 2016.02.15T00:00:00, 2016.02.16T00:00:00]\nY = [1.0, 2.0, 4.0]\n\n// outputX=false（默认）：只返回插值后的 Y 向量\ndividedDifference(X, Y, `60min)\n// 输出: [1, 1.0217, ..., 4]（49 个点）\n\n// outputX=true：返回 tuple，[0] 为重采样后的 X，[1] 为插值后的 Y\nresult = dividedDifference(X, Y, `60min, outputX=true)\nresult[0]  // 每小时的时间戳，共 49 个\nresult[1]  // 对应的插值 Y 值，共 49 个\n```\n"
    },
    "dot": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/dot.html",
        "signatures": [
            {
                "full": "dot(X, Y)",
                "name": "dot",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [dot](https://docs.dolphindb.cn/zh/funcs/d/dot.html)\n\n\n\n#### 语法\n\ndot(X, Y) 或 X\\*\\*Y\n\n#### 详情\n\n返回 *X* 和 *Y* 的矩阵乘法。如果 *X* 和 *Y* 是具有相同长度的向量，返回它们的内积。\n\n与 Python 中 `numpy.dot` 的区别：`numpy.dot` 对 1-D、2-D、N-D 数组分别采用不同乘法规则，并支持 *out* 参数；DolphinDB 的 `dot` 支持标量、向量和矩阵，两个向量返回内积，矩阵与向量相乘时会自动调整向量维度，且 `X**Y` 可作为矩阵乘法操作符。\n\n#### 参数\n\n**X** 和 **Y** 可以是标量、向量或矩阵。如果 *X* 和 *Y* 都是向量，他们必须具有相同的长度。如果 *X* 或 *Y* 的其中一个是矩阵，另一个必须是维度满足矩阵乘法规则的向量或矩阵。\n\n#### 返回值\n\n返回一个标量、向量或矩阵。\n\n#### 例子\n\n```\nx=1..6$2:3;\ny=1 2 3;\nx dot y;\n```\n\n| #0 |\n| -- |\n| 22 |\n| 28 |\n\n```\nx=1..6$2:3;\ny=6..1$3:2;\nx**y;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 41 | 14 |\n| 56 | 20 |\n\n```\ny**x;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 12 | 30 | 48 |\n| 9  | 23 | 37 |\n| 6  | 16 | 26 |\n\n```\na=1 2 3;\nshape a;\n// output\n3:1\nx**a;\n```\n\n| #0 |\n| -- |\n| 22 |\n| 28 |\n\n```\nb=1 2;\nshape b;\n// output\n2:1\nb**x;\n// 对于矩阵和向量之间的矩阵乘法，系统会自动转换向量的维度以便完成乘法。\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 5  | 11 | 17 |\n\n```\nx=1 2 3;\ny=4 5 6;\nx ** y;\n// output\n32\n// 两个向量之间的内积。等价于 1*4 + 2*5 + 3*6\n\nx ** 2;\n// output\n[2,4,6]\n\nx=1..6$2:3\nx ** 2;\n// output\nUse * rather than ** for scalar and matrix multiplication.\n```\n\n相关函数：[rowDot](https://docs.dolphindb.cn/zh/funcs/r/rowDot.html)\n"
    },
    "double": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/double.html",
        "signatures": [
            {
                "full": "double(X)",
                "name": "double",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [double](https://docs.dolphindb.cn/zh/funcs/d/double.html)\n\n\n\n#### 语法\n\ndouble(X)\n\n#### 详情\n\n将输入的数据类型转换为 DOUBLE。\n\n#### 参数\n\n**X** 可以是任意数据类型。\n\n#### 返回值\n\nDOUBLE 类型，数据形式同 *X*。\n\n#### 例子\n\n```\nx=double();  // 创建一个 DOUBLE 类型的变量，默认值为0。\nx;\n```\n\n返回：null\n\n```\ntypestr x;\n```\n\n返回：DOUBLE\n\n```\ntypestr double(`10);\n```\n\n返回：DOUBLE\n\n```\ndouble(`10.9);\n```\n\n返回：10.9\n\n```\ndouble(now());\n```\n\n返回：1,708,616,927,949\n\n**Note:** 该例子首先使用 `now` 函数获得当前系统时间 2024.02.22 15:50:15.528，`double` 函数将该时间转换为 1,708,616,927,949。\n"
    },
    "drop": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/drop.html",
        "signatures": [
            {
                "full": "drop(obj, count)",
                "name": "drop",
                "parameters": [
                    {
                        "full": "obj",
                        "name": "obj"
                    },
                    {
                        "full": "count",
                        "name": "count"
                    }
                ]
            }
        ],
        "markdown": "### [drop](https://docs.dolphindb.cn/zh/funcs/d/drop.html)\n\n\n\n#### 语法\n\ndrop(obj, count)\n\n#### 详情\n\n从向量/矩阵/表中删除前/后指定个数的元素/列/行。\n\n#### 参数\n\n**obj** 可以是向量、矩阵或表。\n\n**count**是一个整数，表示要删除的个数，为负数时表示从后开始删除。\n\n#### 返回值\n\n被删除了个元素/列/行的向量、矩阵或表。\n\n#### 例子\n\n```\nx=1..10;\nx.drop(2);\n// output\n[3,4,5,6,7,8,9,10]\nx.drop(-2);\n// output\n[1,2,3,4,5,6,7,8]\n\nx=1..10$2:5;\nx;\n```\n\n| #0 | #1 | #2 | #3 | #4 |\n| -- | -- | -- | -- | -- |\n| 1  | 3  | 5  | 7  | 9  |\n| 2  | 4  | 6  | 8  | 10 |\n\n```\ndrop(x,2);\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 5  | 7  | 9  |\n| 6  | 8  | 10 |\n\n```\nx drop -2;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1  | 3  | 5  |\n| 2  | 4  | 6  |\n\n```\nt=table(1 2 3 4 as x, 11..14 as y);\nt;\n```\n\n| x | y  |\n| - | -- |\n| 1 | 11 |\n| 2 | 12 |\n| 3 | 13 |\n| 4 | 14 |\n\n```\nt.drop(2);\n```\n\n| x | y  |\n| - | -- |\n| 3 | 13 |\n| 4 | 14 |\n\n**相关函数：**[pop!](https://docs.dolphindb.cn/zh/funcs/p/pop_.html)、[removeHead!](https://docs.dolphindb.cn/zh/funcs/r/removeHead_.html)、[removeTail!](https://docs.dolphindb.cn/zh/funcs/r/removeTail_.html)、[remove!](https://docs.dolphindb.cn/zh/funcs/r/remove.html)\n"
    },
    "dropAggregator": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/dropAggregator.html",
        "signatures": [
            {
                "full": "dropStreamEngine(name)",
                "name": "dropStreamEngine",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    }
                ]
            }
        ],
        "markdown": "### [dropAggregator](https://docs.dolphindb.cn/zh/funcs/d/dropAggregator.html)\n\n是 [dropStreamEngine](https://docs.dolphindb.cn/zh/funcs/d/dropStreamEngine.html) 的别名。\n\n\n以下是 `dropStreamEngine` 函数的文档：\n### [dropStreamEngine](https://docs.dolphindb.cn/zh/funcs/d/dropStreamEngine.html)\n\n#### 语法\n\ndropStreamEngine(name)\n\n别名： [dropAggregator](https://docs.dolphindb.cn/zh/funcs/d/dropAggregator.html)\n\n#### 详情\n\n释放指定的流计算引擎的定义。\n\n**Note:**\n\n该函数无法用于删除由 Orca 创建的流计算引擎。如需删除 Orca 流计算引擎，请使用 [dropStreamGraph](https://docs.dolphindb.cn/zh/funcs/d/dropStreamGraph.html) 删除其所属的流图。\n\n#### 参数\n\n**name**：字符串，表示一个流计算引擎的名称。需指定为已创建的引擎名称，否则会抛出异常。通过 [getStreamEngineStat](https://docs.dolphindb.cn/zh/funcs/g/getStreamEngineStat.html) 可查看已创建的引擎名称。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\nshare streamTable(1000:0, `time`sym`qty, [TIMESTAMP, SYMBOL, INT]) as trades\noutputTable = table(10000:0, `time`sym`sumQty, [TIMESTAMP, SYMBOL, INT])\ntradesAggregator = createTimeSeriesAggregator(name=\"StreamAggregatorDemo\", windowSize=3, step=3, metrics=<[sum(qty)]>, dummyTable=trades, outputTable=outputTable, timeColumn=`time, useSystemTime=false, keyColumn=`sym, garbageSize=50)\nsubscribeTable(tableName=\"trades\", actionName=\"tradesAggregator\", offset=0, handler=append!{tradesAggregator}, msgAsTable=true)\n\ndef writeData(n){\n    timev = 2018.10.08T01:01:01.001 + timestamp(1..n)\n    symv =take(`A`B, n)\n    qtyv = take(1, n)\n    insert into trades values(timev, symv, qtyv)\n}\n\nwriteData(6);\n\nselect * from outputTable;\n```\n\n| time                    | sym | sumQty |\n| ----------------------- | --- | ------ |\n| 2018.10.08T01:01:01.003 | A   | 1      |\n| 2018.10.08T01:01:01.006 | A   | 1      |\n| 2018.10.08T01:01:01.006 | B   | 2      |\n\n```\ndropStreamEngine(\"StreamAggregatorDemo\");\n```\n\n"
    },
    "dropCatalog": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/dropCatalog.html",
        "signatures": [
            {
                "full": "dropCatalog(catalog)",
                "name": "dropCatalog",
                "parameters": [
                    {
                        "full": "catalog",
                        "name": "catalog"
                    }
                ]
            }
        ],
        "markdown": "### [dropCatalog](https://docs.dolphindb.cn/zh/funcs/d/dropCatalog.html)\n\n\n\n#### 语法\n\ndropCatalog(catalog)\n\n#### 详情\n\n删除指定的 catalog。\n\n#### 参数\n\n**catalog** 字符串标量，表示 catalog 的名称。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\ndropCatalog(\"catalog1\")\n```\n"
    },
    "dropColumns!": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/dropColumns_.html",
        "signatures": [
            {
                "full": "dropColumns!(table, colNames)",
                "name": "dropColumns!",
                "parameters": [
                    {
                        "full": "table",
                        "name": "table"
                    },
                    {
                        "full": "colNames",
                        "name": "colNames"
                    }
                ]
            }
        ],
        "markdown": "### [dropColumns!](https://docs.dolphindb.cn/zh/funcs/d/dropColumns_.html)\n\n#### 语法\n\ndropColumns!(table, colNames)\n\n别名：drop!\n\n#### 详情\n\n从表中删除指定的列。请注意，对于分布式表，不支持删除分区列。\n\n#### 参数\n\n**table** 一个内存表或分布式表（仅支持 OLAP 引擎）。\n\n**colNames** 表示列名的标量或向量。若 *table* 是分布式表，则 *colNames* 只能是标量。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\nt=table(1 2 3 as x, 4 5 6 as y, 7..9 as z, 10..12 as a, 13..15 as b, 16..18 as c);\nt;\n```\n\n| x | y | z | a  | b  | c  |\n| - | - | - | -- | -- | -- |\n| 1 | 4 | 7 | 10 | 13 | 16 |\n| 2 | 5 | 8 | 11 | 14 | 17 |\n| 3 | 6 | 9 | 12 | 15 | 18 |\n\n```\nt.dropColumns!(`x);\n```\n\n| y | z | a  | b  | c  |\n| - | - | -- | -- | -- |\n| 4 | 7 | 10 | 13 | 16 |\n| 5 | 8 | 11 | 14 | 17 |\n| 6 | 9 | 12 | 15 | 18 |\n\n```\ndropColumns!(t, `a`b);\n```\n\n| y | z | c  |\n| - | - | -- |\n| 4 | 7 | 16 |\n| 5 | 8 | 17 |\n| 6 | 9 | 18 |\n\n"
    },
    "dropDatabase": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/dropDatabase.html",
        "signatures": [
            {
                "full": "dropDatabase(dbDir)",
                "name": "dropDatabase",
                "parameters": [
                    {
                        "full": "dbDir",
                        "name": "dbDir"
                    }
                ]
            }
        ],
        "markdown": "### [dropDatabase](https://docs.dolphindb.cn/zh/funcs/d/dropDatabase.html)\n\n\n\n#### 语法\n\ndropDatabase(dbDir)\n\n#### 详情\n\n删除指定数据库的所有物理文件。\n\n自 3.00.0 版本起，支持删除 catalog 中的数据库，其引用关系也会同时被删掉。\n\n#### 参数\n\n**dbDir** 是数据库所在的目录。对于分布式文件系统中的数据库，目录要以 `\"dfs://\"` 开始。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n删除分布式数据库：\n\n```\nn=1000000\nID=rand(10, n)\ndates=2017.08.07..2017.08.11\ndate=rand(dates, n)\nx=rand(10.0, n)\nt=table(ID, date, x);\nsaveText(t, \"C:/DolphinDB/Data/t.txt\");\n\ndb = database(\"dfs://valueDB\", VALUE, 2017.08.07..2017.08.11)\npt = loadTextEx(db, `pt1, `date, \"C:/DolphinDB/Data/t.txt\");\n\ndropDatabase(\"dfs://valueDB\")\n```\n\n删除本地磁盘数据库：\n\n```\nn=1000000\nID=rand(10, n)\ndates=2017.08.07..2017.08.11\ndate=rand(dates, n)\nx=rand(10.0, n)\nt=table(ID, date, x)\nsaveText(t, \"C:/DolphinDB/Data/t.txt\");\n\ndb = database(\"C:/DolphinDB/Data/rangedb\", RANGE, 0 5 10)\npt = loadTextEx(db, `pt, `ID, \"C:/DolphinDB/Data/t.txt\");\n\ndropDatabase(\"C:/DolphinDB/Data/rangedb\");\n```\n"
    },
    "dropDataViewEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/dropDataViewEngine.html",
        "signatures": [
            {
                "full": "dropDataViewEngine(name)",
                "name": "dropDataViewEngine",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    }
                ]
            }
        ],
        "markdown": "### [dropDataViewEngine](https://docs.dolphindb.cn/zh/funcs/d/dropDataViewEngine.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\ndropDataViewEngine(name)\n\n#### 详情\n\n删除当前 CEP 引擎中指定的 DataView 引擎。\n\n#### 参数\n\n**name** 字符串，表示 DataView 引擎的名称。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\nclass MainMonitor:CEPMonitor {\n    def MainMonitor(){\n    }\n    // 删除引擎时自动调用，删除共享流表\n    def onunload(){ \n      undef('orderDV', SHARED)\n      dropDataViewEngine('orderDV')\n    }\n\tdef checkOrders(newOrder)\n    // 创建 DataViewEngine, 指定主键为 code 列，统计每个股票的最新的委托信息\n    def onload(){\n        addEventListener(checkOrders,'Orders',,'all') \n        orderDV = streamTable(array(STRING, 0) as market, array(STRING, 0) as code, array(DOUBLE, 0) as price, array(INT, 0) as qty, array(TIMESTAMP, 0) as updateTime)\n        share(orderDV,'orderDV')\n        createDataViewEngine('orderDV', objByName('orderDV'), `code, `updateTime)\n    }\n    // 更新每个股票的最新的委托信息\n    def checkOrders(newOrder){\n\t\tgetDataViewEngine('orderDV').append!(table(newOrder.market as market, newOrder.code as code, newOrder.price as price, newOrder.qty as qty))\n    }\n}\n```\n\n**相关函数**：[createCEPEngine](https://docs.dolphindb.cn/zh/funcs/c/createCEPEngine.html), [createDataViewEngine](https://docs.dolphindb.cn/zh/funcs/c/createDataViewEngine.html), [getDataViewEngine](https://docs.dolphindb.cn/zh/funcs/g/getDataViewEngine.html)\n"
    },
    "dropDistributedInMemoryTable": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/dropDistributedInMemoryTable.html",
        "signatures": [
            {
                "full": "dropDistributedInMemoryTable(tableName)",
                "name": "dropDistributedInMemoryTable",
                "parameters": [
                    {
                        "full": "tableName",
                        "name": "tableName"
                    }
                ]
            }
        ],
        "markdown": "### [dropDistributedInMemoryTable](https://docs.dolphindb.cn/zh/funcs/d/dropDistributedInMemoryTable.html)\n\n\n\n#### 语法\n\ndropDistributedInMemoryTable(tableName)\n\n#### 详情\n\n删除指定的表。该命令只能在数据节点/计算节点上执行。\n\n#### 参数\n\n**tableName** 字符串标量，表示分布式共享内存表的名称。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\npt = createDistributedInMemoryTable(`dt, `time`id`value, `DATETIME`INT`LONG, HASH, [INT, 2],`id)\ntime = take(2021.08.20 00:00:00..2021.08.30 00:00:00, 40);\nid = 0..39;\nvalue = rand(100, 40);\ntmp = table(time, id, value);\n\npt = loadDistributedInMemoryTable(`dt)\npt.append!(tmp);\ndropDistributedInMemoryTable(`dt)\n```\n\n相关函数：[loadDistributedInMemoryTable](https://docs.dolphindb.cn/zh/funcs/l/loadDistributedInMemoryTable.html), [createDistributedInMemoryTable](https://docs.dolphindb.cn/zh/funcs/c/createDistributedInMemoryTable.html)\n"
    },
    "dropFunctionView": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/dropFunctionView.html",
        "signatures": [
            {
                "full": "dropFunctionView(name, [isNamespace=false])",
                "name": "dropFunctionView",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "[isNamespace=false]",
                        "name": "isNamespace",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [dropFunctionView](https://docs.dolphindb.cn/zh/funcs/d/dropFunctionView.html)\n\n\n\n#### 语法\n\ndropFunctionView(name, \\[isNamespace=false])\n\n#### 详情\n\n删除一个视图或一个命名空间下的所有函数。\n\n`dropFunctionView`只能由管理员或拥有 VIEW\\_OWNER 权限的普通用户执行。\n\n#### 参数\n\n**name** 是一个字符串标量，表示用户自定义函数名称或一个命名空间。\n\n**isNamespace** 是一个布尔标量，指示 name 是否是一个命名空间。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\ngetFunctionViews()\nname      body                           \n--------- ------------------\nf1        def f1(){return 1}\ntest::f1 def f1(){return 2}\ntest::f2 def f2(){return 3}\n\n// 删除 f1\ndropFunctionView(`f1)\n// 删除 test::f1\ndropFunctionView(\"test::f1\")\n// 删除命名空间 test 下所有函数\ndropFunctionView(\"test\",true)\n```\n"
    },
    "dropHaMvccTable": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/dropHaMvccTable.html",
        "signatures": [
            {
                "full": "dropHaMvccTable(tableName)",
                "name": "dropHaMvccTable",
                "parameters": [
                    {
                        "full": "tableName",
                        "name": "tableName"
                    }
                ]
            }
        ],
        "markdown": "### [dropHaMvccTable](https://docs.dolphindb.cn/zh/funcs/d/dropHaMvccTable.html)\n\n首发版本：3.00.5\n\n\n\n#### 语法\n\ndropHaMvccTable(tableName)\n\n#### 详情\n\n删除指定名称的高可用 MVCC 表。\n\n此函数必须在该表所属 Raft 组的 Leader 节点上执行。\n\n#### 参数\n\n**tableName** 字符串标量，表示要删除的高可用 MVCC 表的名称。\n\n#### 例子\n\n```\ndropHaMvccTable(\"demoHaMvcc\")\n```\n\n**相关函数**：[haMvccTable](https://docs.dolphindb.cn/zh/funcs/h/haMvccTable.html), [loadHaMvccTable](https://docs.dolphindb.cn/zh/funcs/l/loadHaMvccTable.html)\n"
    },
    "dropIPCInMemoryTable": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/dropIPCInMemoryTable.html",
        "signatures": [
            {
                "full": "dropIPCInMemoryTable(tableName)",
                "name": "dropIPCInMemoryTable",
                "parameters": [
                    {
                        "full": "tableName",
                        "name": "tableName"
                    }
                ]
            }
        ],
        "markdown": "### [dropIPCInMemoryTable](https://docs.dolphindb.cn/zh/funcs/d/dropIPCInMemoryTable.html)\n\n\n\n#### 语法\n\ndropIPCInMemoryTable(tableName)\n\n#### 详情\n\n删除跨进程共享内存表。\n\n**Note:**\n\n* 此函数仅适用于 Linux 系统。\n\n* server 关机并不能删除跨进程共享内存表，仍然需要通过 `dropIPCInMemoryTable` 进行删除。\n\n#### 参数\n\n**tableName** 字符串，表示跨进程共享内存表的名称。\n\n#### 返回值\n\n一个字符串，表示删除的跨进程共享内存表的名称。\n\n#### 例子\n\n删除函数 `createIPCInMemoryTable` 例子中创建的表 ipc\\_table。\n\n```\ndropIPCInMemoryTable(`ipc_table)\n// output\nipc_table\n```\n"
    },
    "dropMCPPrompt": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/dropMCPPrompt.html",
        "signatures": [
            {
                "full": "dropMCPPrompt(name)",
                "name": "dropMCPPrompt",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    }
                ]
            }
        ],
        "markdown": "### [dropMCPPrompt](https://docs.dolphindb.cn/zh/funcs/d/dropMCPPrompt.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\ndropMCPPrompt(name)\n\n#### 详情\n\n删除一个 MCP prompt 模板。如果该模板已被发布，需要先调用 `withdrawMCPPrompts` 撤销发布后才能删除。\n\n#### 参数\n\n**name** STRING 类型标量，表示 prompt 模板的名称。\n\n#### 返回值\n\n一个字符串，表示删除 MCP prompt 模板的名称。\n\n#### 例子\n\n```\ndropMCPPrompt(\"stock_summary\")\n// output:'stock_summary'\n```\n"
    },
    "dropMCPTool": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/dropMCPTool.html",
        "signatures": [
            {
                "full": "dropMCPTool(name)",
                "name": "dropMCPTool",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    }
                ]
            }
        ],
        "markdown": "### [dropMCPTool](https://docs.dolphindb.cn/zh/funcs/d/dropMCPTool.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\ndropMCPTool(name)\n\n#### 详情\n\n删除一个 MCP tool。如果该 tool 已被发布，需要先调用 `withdrawMCPTools` 撤销发布后才能删除。\n\n#### 参数\n\n**name** STRING 类型标量，表示 tool 的名称。\n\n#### 返回值\n\n一个字符串，表示删除 tool 的名称。\n\n#### 例子\n\n```\ndropMCPTool(\"myTool\")\n```\n"
    },
    "dropna": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/dropna.html",
        "signatures": [
            {
                "full": "dropna(X, [byRow=true], [thresh])",
                "name": "dropna",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[byRow=true]",
                        "name": "byRow",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[thresh]",
                        "name": "thresh",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [dropna](https://docs.dolphindb.cn/zh/funcs/d/dropna.html)\n\n\n\n#### 语法\n\ndropna(X, \\[byRow=true], \\[thresh])\n\n#### 详情\n\n若 *X* 是向量，将其中 NULL 值删除。\n\n若 *X* 是矩阵，删除其中含有空值的行或列。若参数 *byRow* 为 true，删除含有 NULL 值的行；若参数 *byRow* 为 false，删除含有 NULL 值的列。\n\n若指定 *thresh*，要求结果中每行或每列含有至少 *thresh* 个非 NULL 元素，否则删除。\n\n#### 参数\n\n**X** 是一个向量或矩阵。\n\n**byRow** 是一个布尔值。默认值为 true。\n\n**thresh** 是一个正整数。\n\n#### 返回值\n\n一个向量或矩阵，其数据类型同 *X*。\n\n#### 例子\n\n```\nx=1 NULL 2 3 NULL NULL 4;\nx.dropna();\n// output\n[1,2,3,4]\n\nm=matrix(1 1 1 1, 1 1 1 NULL, 1 NULL 1 NULL);\nm;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1  | 1  | 1  |\n| 1  | 1  |    |\n| 1  | 1  | 1  |\n| 1  |    |    |\n\n```\ndropna(m);\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1  | 1  | 1  |\n| 1  | 1  | 1  |\n\n```\ndropna(m,,2);\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1  | 1  | 1  |\n| 1  | 1  |    |\n| 1  | 1  | 1  |\n\n```\ndropna(m,false);\n```\n\n| #0 |\n| -- |\n| 1  |\n| 1  |\n| 1  |\n| 1  |\n\n```\ndropna(m,false,3);\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 1  |\n| 1  | 1  |\n| 1  | 1  |\n| 1  |    |\n"
    },
    "dropOrcaStreamTable": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/dropOrcaStreamTable.html",
        "signatures": [
            {
                "full": "dropOrcaStreamTable(name)",
                "name": "dropOrcaStreamTable",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    }
                ]
            }
        ],
        "markdown": "### [dropOrcaStreamTable](https://docs.dolphindb.cn/zh/funcs/d/dropOrcaStreamTable.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\ndropOrcaStreamTable(name)\n\n#### 详情\n\n删除 Orca 流表。\n\n删除时要求已无流图引用该 Orca 流表（可通过 [getOrcaStreamTableMeta](https://docs.dolphindb.cn/zh/funcs/g/getOrcaStreamTableMeta.html) 查看该流表引用情况。）\n\n注意：调用该函数前，必须先启用 Orca 功能，即在配置文件 cluster.cfg 或 controller.cfg 中配置 `enableORCA=true`）。\n\n#### 参数\n\n**name** 待删除的流表名称。字符串标量，可以传入完整的流表全限定名（如 trading.orca\\_table.trades）；也可以仅提供流表名（如 trades），系统会根据当前的 catalog 设置自动补全为对应的全限定名。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\n// 创建 Orca 流表\nif(!existsCatalog(\"demo\")){\n    createCatalog(\"demo\")\n}\ngo\nuse catalog demo\n\ncreateOrcaStreamTable(\"trade\", `time`symbol`price`volume, [DATETIME,SYMBOL,DOUBLE,LONG])\n\n// 删除 Orca 流表\ndropOrcaStreamTable(\"demo.orca_table.trade\")\n// 或 dropOrcaStreamTable(\"trade\")\n```\n"
    },
    "dropPartition": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/dropPartition.html",
        "signatures": [
            {
                "full": "dropPartition(dbHandle, partitionPaths, [tableName], [forceDelete=false], [deleteSchema=false])",
                "name": "dropPartition",
                "parameters": [
                    {
                        "full": "dbHandle",
                        "name": "dbHandle"
                    },
                    {
                        "full": "partitionPaths",
                        "name": "partitionPaths"
                    },
                    {
                        "full": "[tableName]",
                        "name": "tableName",
                        "optional": true
                    },
                    {
                        "full": "[forceDelete=false]",
                        "name": "forceDelete",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[deleteSchema=false]",
                        "name": "deleteSchema",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [dropPartition](https://docs.dolphindb.cn/zh/funcs/d/dropPartition.html)\n\n\n\n#### 语法\n\ndropPartition(dbHandle, partitionPaths, \\[tableName], \\[forceDelete=false], \\[deleteSchema=false])\n\n#### 详情\n\n删除数据库中指定分区的数据。\n\n如果指定了 *tableName* ：删除指定表中符合指定条件的分区数据。\n\n如果没有指定 *tableName*：删除指定数据库所有表中符合指定条件的分区数据。\n\n#### 参数\n\n**dbHandle** 分布式数据库的句柄。\n\n**partitionPaths** 有两种指定模式：\n\n* 指定路径：以 \"/\" 开头的字符串或字符串向量，表示数据库目录下单个或多个分区的路径。请注意对组合分区，路径必须包括所有层次分区。分区路径可通过函数 [getChunksMeta](https://docs.dolphindb.cn/zh/funcs/g/getChunksMeta.html) 返回值的 dfsPath 字段获得，该字段组成为 `/<databaseName>/<partitionPaths>/<physicalIndex>`。\n\n* 指定条件：以分区列的一个或多个值组成的标量或向量作为过滤条件，系统会找到并删除这些值所在的分区。对于组合分区，partitionPaths 是由每层分区的过滤条件组成的元组，如果某层分区不需要过滤，那么相应的过滤条件需置为空。\n\n**tableName** 字符串，表示表名。若分区粒度为数据库级（[database](https://docs.dolphindb.cn/zh/funcs/d/database.html): *chunkGranularity* = 'DATABASE'），可以不指定 *tableName*，否则必须指定该参数。\n\n**forceDelete** 布尔值，默认值为 false，表示不开启强制删除。如果 *forceDelete* =true，即使指定的分区正在恢复，系统也会将其强制删除。\n\n**deleteSchema** 布尔值，默认值为 false，表示仅删除分区数据，分区方案（partitionSchema）中仍保留其对应的分区方案信息。\n\n如果 *deleteSchema*=true，在满足以下条件时，删除分区数据及其对应的分区方案信息（可通过 [schema](https://docs.dolphindb.cn/zh/funcs/s/schema.html).partitionSchema 函数查看）：\n\n1. 数据库只包含一个表；\n\n2. 单级分区时采用 VALUE 分区，或多级分区的第一级为 VALUE 分区；\n\n3. `dropPartition` 仅删除第一级分区的数据。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n下面例子中的脚本需要在集群中的数据节点/计算节点执行。\n\n```\nn=1000000\nID=rand(150, n)\ndates=2017.08.07..2017.08.11\ndate=rand(dates, n)\nx=rand(10.0, n)\nt=table(ID, date, x)\ndbDate = database(, VALUE, 2017.08.07..2017.08.11)\ndbID = database(, RANGE, 0 50 100 150)\ndb = database(\"dfs://compoDB\", COMPO, [dbDate, dbID])\npt = db.createPartitionedTable(t, `pt, `date`ID)\npt.append!(t);\n```\n\n上面的代码创建了组合分区的数据库，第一层分区为基于日期的值分区，第二层分区为基于值的范围分区。\n\n例 1. 删除某个分区的数据\n\n例如，删除表 pt \"/20170807/0\\_50\" 分区，有以下两种方法：\n\n(1) 指定路径：\n\n```\ndropPartition(dbHandle=database(\"dfs://compoDB\"), partitionPaths=\"/20170807/0_50\", tableName=`pt);\n```\n\n**Note:** 这里使用 `database(\"dfs://compoDB\")` 获取数据库 dfs\\://compoDB 的句柄，参数 *dbHandle* 也可指定为创建数据库时返回的句柄`db`。\n\n(2) 指定条件：\n\n```\ndropPartition(dbHandle=database(\"dfs://compoDB\"), partitionPaths=[2017.08.07, 0], tableName=`pt);\n```\n\n注意：\"/20170807/0\\_50\" 分区中的 ID 的可取值范围是从 0 到 49，不包括 50。以上脚本中，可以使用 0 到 49 的任一数字来代表此分区。\n\n例 2. 删除一级分区的数据\n\n例如，删除表 pt 的一级分区 2017.08.08，有以下两种方法：\n\n(1) 使用向量指定该一级分区之下所有分区的路径：\n\n```\npartitions=[\"/20170808/0_50\",\"/20170808/50_100\",\"/20170808/100_150\"]\ndropPartition(dbHandle=database(\"dfs://compoDB\"), partitionPaths=partitions, tableName=`pt);\n```\n\n(2) 指定条件：\n\n```\ndropPartition(dbHandle=database(\"dfs://compoDB\"), partitionPaths=2017.08.08, tableName=`pt);\n```\n\n删除分区数据后，我们使用 [schema](https://docs.dolphindb.cn/zh/funcs/s/schema.html) 函数查看数据库的分区方案：\n\n```\nschema(database(\"dfs://compoDB\"));\n/*\ndatabaseDir->dfs://compoDB\npartitionSchema->([2017.08.07,2017.08.08,2017.08.09,2017.08.10,2017.08.11],[0,50,100,150])\npartitionSites->\nengineType->OLAP\natomic->TRANS\nchunkGranularity->TABLE\npartitionType->[1,2]\npartitionTypeName->[\"VALUE\",\"RANGE\"]\npartitionColumnType->[6,4]\nclusterReplicationEnabled->1\ndatabaseOwner->admin\n*/\n```\n\n可以发现，2017.08.08 仍然在分区方案中，这是因为 `dropPartition` 只删除了 2017.08.08 这个分区中的数据，并不会将 2017.08.08 从数据库的分区方案中移除。由于该例删除的是一级 VALUE 分区，通过指定 *deleteSchema* = true，来同步删除分区方案中的对应分区信息。\n\n```\ndropPartition(dbHandle=database(\"dfs://compoDB\"), partitionPaths=2017.08.08, tableName=`pt, deleteSchema = true);\n```\n\n使用 `schema` 函数查看数据库的分区方案：\n\n```\nschema(database(\"dfs://compoDB\"));\n// output\npartitionSchema->([2017.08.11,2017.08.10,2017.08.09,2017.08.07],[0,50,100,150])\n...\n```\n\n例 3. 删除二级分区的数据\n\n例如，删除表 pt 的二级分区 \\[0,50)，有以下两种方法：\n\n(1) 使用向量指定含有该二级分区的所有分区的路径：\n\n```\npartitions=[\"/20170807/0_50\",\"/20170808/0_50\",\"/20170809/0_50\",\"/20170810/0_50\",\"/20170811/0_50\"]\ndropPartition(dbHandle=database(\"dfs://compoDB\"), partitionPaths=partitions, tableName=`pt);\n```\n\n(2) 指定条件：\n\n```\ndropPartition(dbHandle=database(\"dfs://compoDB\"), partitionPaths=[,[0]], tableName=`pt);\n```\n\n例 4. 删除多个二级分区的数据\n\n例如，删除表 pt 的二级分区 \\[0,50) 和 \\[100,150)：\n\n```\ndropPartition(dbHandle=database(\"dfs://compoDB\"), partitionPaths=[,[0,100]], tableName=`pt);\n```\n\n例 5. 修改分布式数据库中的数据\n\n在 DolphinDB 中，如果要修改分布式数据库中的数据，需要先把相关分区的数据加载到内存中进行修改，然后使用 `dropPartition` 将数据库中的相关分区删除，最后将内存中修改好的分区数据重新追加到数据库中。\n\n例如，将分布式表 pt 中 date=2017.08.10, ID=88 的记录 x+10。\n\n首先，将包含 date=2017.08.10, ID=88 的所有相关分区数据加载到内存中，这些数据位于 \"20170810/50\\_100\" 分区中：\n\n```\ntmp=select * from loadTable(\"dfs://compoDB\",\"pt\") where date=2017.08.10 and 50<=ID<100 ;\n```\n\n接着，将内存表 tmp 中 date=2017.08.10, ID=88 的记录 x+10。：\n\n```\nupdate tmp set x=x+10 where date=2017.08.10 and ID=88;\n```\n\n然后，删除表 pt 中 \"20170810/50\\_100\" 分区中的数据：\n\n```\ndropPartition(dbHandle=database(\"dfs://compoDB\"), partitionPaths=\"/20170810/50_100\", tableName=`pt);\n```\n\n最后，将内存中修改好的记录追加到表 pt 中：\n\n```\npt.append!(tmp);\n```\n"
    },
    "dropSchema": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/dropSchema.html",
        "signatures": [
            {
                "full": "dropSchema(catalog, schema)",
                "name": "dropSchema",
                "parameters": [
                    {
                        "full": "catalog",
                        "name": "catalog"
                    },
                    {
                        "full": "schema",
                        "name": "schema"
                    }
                ]
            }
        ],
        "markdown": "### [dropSchema](https://docs.dolphindb.cn/zh/funcs/d/dropSchema.html)\n\n\n\n#### 语法\n\ndropSchema(catalog, schema)\n\n#### 详情\n\n删掉指定 catalog 中的指定 schema。\n\n#### 参数\n\n**catalog** 字符串标量，表示 catalog 的名称。\n\n**schema** 字符串标量，表示要删除的 schema 的名称。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\ndropSchema(\"catalog1\", \"Schema\")\n```\n"
    },
    "dropStreamEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/dropStreamEngine.html",
        "signatures": [
            {
                "full": "dropStreamEngine(name)",
                "name": "dropStreamEngine",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    }
                ]
            }
        ],
        "markdown": "### [dropStreamEngine](https://docs.dolphindb.cn/zh/funcs/d/dropStreamEngine.html)\n\n#### 语法\n\ndropStreamEngine(name)\n\n别名： [dropAggregator](https://docs.dolphindb.cn/zh/funcs/d/dropAggregator.html)\n\n#### 详情\n\n释放指定的流计算引擎的定义。\n\n**Note:**\n\n该函数无法用于删除由 Orca 创建的流计算引擎。如需删除 Orca 流计算引擎，请使用 [dropStreamGraph](https://docs.dolphindb.cn/zh/funcs/d/dropStreamGraph.html) 删除其所属的流图。\n\n#### 参数\n\n**name**：字符串，表示一个流计算引擎的名称。需指定为已创建的引擎名称，否则会抛出异常。通过 [getStreamEngineStat](https://docs.dolphindb.cn/zh/funcs/g/getStreamEngineStat.html) 可查看已创建的引擎名称。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\nshare streamTable(1000:0, `time`sym`qty, [TIMESTAMP, SYMBOL, INT]) as trades\noutputTable = table(10000:0, `time`sym`sumQty, [TIMESTAMP, SYMBOL, INT])\ntradesAggregator = createTimeSeriesAggregator(name=\"StreamAggregatorDemo\", windowSize=3, step=3, metrics=<[sum(qty)]>, dummyTable=trades, outputTable=outputTable, timeColumn=`time, useSystemTime=false, keyColumn=`sym, garbageSize=50)\nsubscribeTable(tableName=\"trades\", actionName=\"tradesAggregator\", offset=0, handler=append!{tradesAggregator}, msgAsTable=true)\n\ndef writeData(n){\n    timev = 2018.10.08T01:01:01.001 + timestamp(1..n)\n    symv =take(`A`B, n)\n    qtyv = take(1, n)\n    insert into trades values(timev, symv, qtyv)\n}\n\nwriteData(6);\n\nselect * from outputTable;\n```\n\n| time                    | sym | sumQty |\n| ----------------------- | --- | ------ |\n| 2018.10.08T01:01:01.003 | A   | 1      |\n| 2018.10.08T01:01:01.006 | A   | 1      |\n| 2018.10.08T01:01:01.006 | B   | 2      |\n\n```\ndropStreamEngine(\"StreamAggregatorDemo\");\n```\n\n"
    },
    "dropStreamGraph": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/dropStreamGraph.html",
        "signatures": [
            {
                "full": "dropStreamGraph(name, [includeTables])",
                "name": "dropStreamGraph",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "[includeTables]",
                        "name": "includeTables",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [dropStreamGraph](https://docs.dolphindb.cn/zh/funcs/d/dropStreamGraph.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\ndropStreamGraph(name, \\[includeTables])\n\n#### 详情\n\n销毁指定流图。销毁成功后，流图状态转为 destroyed，但流图记录不会被删除。\n\n* 如果 *includesTables*=true，则在删除流图的同时，也会删除该流图中用户显式创建的流表（如 source、sink 等）。必须保证该流图中的流表未被其它流图引用。可通过 getStreamTableMeta 查看流流表的引用情况。\n* 否则，仅删除流图本身，不会影响这些流表。\n\n在集群部署模式下，执行该操作的用户必须是管理员用户或拥有流图创建时所用计算组的 COMPUTE\\_GROUP\\_EXEC 权限。若在单节点部署环境中使用，则无需进行权限校验。\n\n#### 参数\n\n**name** 字符串标量，表示流图的名字。可以传入完整的流图全限定名（如 \"catalog\\_name.orca\\_graph.graph\\_name\"），也可以仅提供流图名（如 \"factors\"）；系统会根据当前的 catalog 设置自动补全为对应的全限定名。\n\n**includesTables** 可选参数，布尔值，表示在删除流图时是否同时删除该流图中用户显式创建的流表（如 source、sink 等），默认为 false。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\ndropStreamGraph(\"demo.orca_graph.indicators\")\n\ngetStreamGraphMeta(\"demo.orca_graph.indicators\")[\"status\"]\n// Output: [\"destroyed\"]\n```\n\n**相关函数：**[createStreamGraph](https://docs.dolphindb.cn/zh/funcs/c/createStreamGraph.html), [StreamGraph::dropGraph](https://docs.dolphindb.cn/zh/funcs/s/StreamGraph_dropGraph.html)\n"
    },
    "dropStreamTable": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/dropStreamTable.html",
        "signatures": [
            {
                "full": "dropStreamTable(tableName,[force=false])",
                "name": "dropStreamTable",
                "parameters": [
                    {
                        "full": "tableName",
                        "name": "tableName"
                    },
                    {
                        "full": "[force=false]",
                        "name": "force",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [dropStreamTable](https://docs.dolphindb.cn/zh/funcs/d/dropStreamTable.html)\n\n\n\n#### 语法\n\ndropStreamTable(tableName,\\[force=false])\n\n#### 详情\n\n删除流数据表。如果流数据表启用了持久化，该函数也会将磁盘上持久化的数据删除。\n\n如果流数据表已经持久化到磁盘但是尚未加载到内存，管理员用户可以通过设置参数 *force* 为 true，直接删除磁盘上的持久化数据。\n\n如果要删除高可用流数据表，只需在 Raft 组中的任意一个数据节点/计算节点上执行该函数即可，其他数据节点/计算节点上名称相同的高可用流数据表也会被删除。\n\n**Note:**\n\n该函数无法用于删除由 Orca 创建的流数据表。如需删除 Orca 流数据表，请使用 [dropOrcaStreamTable](https://docs.dolphindb.cn/zh/funcs/d/dropOrcaStreamTable.html)。\n\n#### 参数\n\n**tableName** 是一个字符串，表示流数据表的名称。\n\n**force** 是一个布尔标量，表示是否在内存没有该流数据表时强制删除同名持久化文件。默认值为 false。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n删除普通流数据表：\n\n```\ncolNames = `timestamp`sym`qty`price\ncolTypes = [TIMESTAMP,SYMBOL,INT,DOUBLE]\nt=streamTable(1:0,colNames,colTypes)\nenableTableShareAndPersistence(t,`trades);\n\ndropStreamTable(`trades);\n```\n\n删除未加载到内存的持久化流数据表：\n\n```\ncolNames = `timestamp`sym`qty`price\ncolTypes = [TIMESTAMP,SYMBOL,INT,DOUBLE]\nt=streamTable(1:0,colNames,colTypes)\nenableTableShareAndPersistence(t,`trades);\n\n//删除内存中的流数据表\nundef(`trades,SHARED)\n\n//删除持久化流表失败\ndropStreamTable(`trades)\n//dropStreamTable(\"trades\") => Can't find stream table trades\n\n// admin 设置force为true,成功删除\ndropStreamTable(tableName=`trades,force=true)\n```\n\n删除高可用流数据表：\n\n```\ncolNames = `timestamp`sym`qty`price\ncolTypes = [TIMESTAMP,SYMBOL,INT,DOUBLE]\nt=table(1:0,colNames,colTypes)\nhaStreamTable(11,t,`trades,100000);\n\ndropStreamTable(`trades);\n```\n"
    },
    "dropTable": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/dropTable.html",
        "signatures": [
            {
                "full": "dropTable(dbHandle, tableName)",
                "name": "dropTable",
                "parameters": [
                    {
                        "full": "dbHandle",
                        "name": "dbHandle"
                    },
                    {
                        "full": "tableName",
                        "name": "tableName"
                    }
                ]
            }
        ],
        "markdown": "### [dropTable](https://docs.dolphindb.cn/zh/funcs/d/dropTable.html)\n\n\n\n#### 语法\n\ndropTable(dbHandle, tableName)\n\n#### 详情\n\n删除指定的表。该命令只能在数据节点/计算节点上执行，不能在控制节点和代理节点上执行。\n\n#### 参数\n\n**dbHandle** 是数据库句柄。\n\n**tableName** 是一个字符串，表示表名。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\nn=1000000\nID=rand(10, n)\nx=rand(1.0, n)\nt=table(ID, x)\ndb=database(\"dfs://rangedb\", RANGE,  0 5 10)\npt = db.createPartitionedTable(t, `pt, `ID)\npt.append!(t)\n\ndropTable(db,`pt);\n```\n\n**Related information**\n\n[truncate](https://docs.dolphindb.cn/zh/funcs/t/truncate.html)\n"
    },
    "DStream::anomalyDetectionEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/DStream_anomalyDetectionEngine.html",
        "signatures": [
            {
                "full": "DStream::anomalyDetectionEngine(metrics, timeColumn, [keyColumn], [windowSize], [step], [garbageSize], [roundTime=true], [anomalyDescription])",
                "name": "DStream::anomalyDetectionEngine",
                "parameters": [
                    {
                        "full": "metrics",
                        "name": "metrics"
                    },
                    {
                        "full": "timeColumn",
                        "name": "timeColumn"
                    },
                    {
                        "full": "[keyColumn]",
                        "name": "keyColumn",
                        "optional": true
                    },
                    {
                        "full": "[windowSize]",
                        "name": "windowSize",
                        "optional": true
                    },
                    {
                        "full": "[step]",
                        "name": "step",
                        "optional": true
                    },
                    {
                        "full": "[garbageSize]",
                        "name": "garbageSize",
                        "optional": true
                    },
                    {
                        "full": "[roundTime=true]",
                        "name": "roundTime",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[anomalyDescription]",
                        "name": "anomalyDescription",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [DStream::anomalyDetectionEngine](https://docs.dolphindb.cn/zh/funcs/d/DStream_anomalyDetectionEngine.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nDStream::anomalyDetectionEngine(metrics, timeColumn, \\[keyColumn], \\[windowSize], \\[step], \\[garbageSize], \\[roundTime=true], \\[anomalyDescription])\n\n#### 详情\n\n创建一个流计算异常检测引擎。参考 [createAnomalyDetectionEngine](https://docs.dolphindb.cn/zh/funcs/c/createAnomalyDetectionEngine.html)。\n\n#### 参数\n\n**metrics** 以元代码或元组的格式表示异常指标，每个异常指标必须是布尔表达式，如<\\[sum(qty) > 5, avg(qty) > qty, qty < 4]>。有关元代码的更多信息可参考 [元编程](https://docs.dolphindb.cn/zh/progr/objs/meta_progr.html)。\n\n**Note:** *metrics* 中使用的列名大小写不敏感，不需要与输入表的列名大小写保持一致。\n\n**timeColumn** 字符串标量，该参数用于指定订阅的流数据表中时间列的名称。\n\n**keyColumn** 可选参数，字符串标量或向量，表示分组列名。异常检测引擎会按照 *keyColumn* 对输入的数据分组，计算将在各分组分别进行。\n\n**windowSize** 可选参数，正整数。如果 *metrics* 中包含聚合函数，必须指定 *windowSize*，它表示计算的数据窗口的长度，数据窗口只包含上边界不包含下边界。如果 *metrics* 中不包含聚合函数，该参数无效。\n\n**step** 可选参数，正整数。如果 *metrics* 中包含聚合函数，必须指定 *step*，并且必须能够被 *windowSize* 整除，它表示计算的时间间隔。如果 *metrics* 中不包含聚合函数，该参数无效。\n\n**garbageSize** 可选参数，正整数。它是可选参数，默认值是 2,000（单位为行）。如果没有指定 *keyColumn*，当内存中历史数据的数量超过 *garbageSize* 时，系统会清理本次计算不需要的历史数据。如果指定了 *keyColumn*，意味着需要分组计算时，内存清理是各分组独立进行的。当一个组的历史数据记录数超出 *garbageSize* 时，会清理该组不再需要的历史数据。若一个组的历史数据记录数未超出 *garbageSize*，则该组数据不会被清理。如果 *metrics* 中没有聚合函数，这个参数不起作用。\n\n**roundTime** 可选参数，布尔值，表示若数据时间精度为毫秒或者秒且 *step* > 一分钟，如何对窗口边界值进行规整处理。默认值为 true，表示按照既定的多分钟规则（见以上表格）进行规整。若为 false，则按一分钟规则（见以上表格）进行窗口规整（详情参考 `规整规则表`）。\n\n若要开启快照机制 (snapshot)，必须指定 *snapshotDir* 与 *snapshotIntervalInMsgCount*。\n\n**anomalyDescription** 可选参数，字符串向量，长度和 *metrics* 中定义的指标数量相同。指定该参数后，输出表的最后一列将显示异常条件对应的字符串。\n\n#### 返回值\n\n一个 DStream 对象。\n\n#### 例子\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\nadGraph = createStreamGraph(\"anomalyDetection\")\nadGraph.source(\"trade\",`time`sym`qty, [TIMESTAMP, SYMBOL, INT])\n  .anomalyDetectionEngine(metrics=<[sum(qty) > 5, avg(qty) > qty, qty < 4]>, timeColumn=`time, keyColumn=`sym, windowSize=3, step=3)\n  .sink(\"anomal_output\")\nadGraph.submit()\ngo\n\ntimes=2024.10.08T01:01:01.001 + 1..6\nsyms=[\"A\", \"B\", \"A\", \"B\", \"A\", \"B\"]\nqtys=[6, 5, 4, 3, 2, 1]\ntmp=table(times as timestamp, syms as sym, qtys as qty)\n\nappendOrcaStreamTable(\"trade\", tmp)\n\nselect * from orca_table.anomal_output \n```\n\n| time                    | sym | type | metric         |\n| ----------------------- | --- | ---- | -------------- |\n| 2024.10.08T01:01:01.003 | A   | 0    | sum(qty) > 5   |\n| 2024.10.08T01:01:01.004 | A   | 1    | avg(qty) > qty |\n| 2024.10.08T01:01:01.005 | B   | 2    | qty < 4        |\n| 2024.10.08T01:01:01.006 | A   | 1    | avg(qty) > qty |\n| 2024.10.08T01:01:01.006 | A   | 2    | qty < 4        |\n| 2024.10.08T01:01:01.006 | B   | 0    | sum(qty) > 5   |\n| 2024.10.08T01:01:01.007 | B   | 1    | avg(qty) > qty |\n| 2024.10.08T01:01:01.007 | B   | 2    | qty < 4        |\n"
    },
    "DStream::asofJoinEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/DStream_asofJoinEngine.html",
        "signatures": [
            {
                "full": "DStream::asofJoinEngine(rightStream, metrics, matchingColumn, [timeColumn], [useSystemTime=false], [delayedTime], [garbageSize], [sortByTime])",
                "name": "DStream::asofJoinEngine",
                "parameters": [
                    {
                        "full": "rightStream",
                        "name": "rightStream"
                    },
                    {
                        "full": "metrics",
                        "name": "metrics"
                    },
                    {
                        "full": "matchingColumn",
                        "name": "matchingColumn"
                    },
                    {
                        "full": "[timeColumn]",
                        "name": "timeColumn",
                        "optional": true
                    },
                    {
                        "full": "[useSystemTime=false]",
                        "name": "useSystemTime",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[delayedTime]",
                        "name": "delayedTime",
                        "optional": true
                    },
                    {
                        "full": "[garbageSize]",
                        "name": "garbageSize",
                        "optional": true
                    },
                    {
                        "full": "[sortByTime]",
                        "name": "sortByTime",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [DStream::asofJoinEngine](https://docs.dolphindb.cn/zh/funcs/d/DStream_asofJoinEngine.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nDStream::asofJoinEngine(rightStream, metrics, matchingColumn, \\[timeColumn], \\[useSystemTime=false], \\[delayedTime], \\[garbageSize], \\[sortByTime])\n\n#### 详情\n\n创建流计算 asof join 引擎。参考：[createAsofJoinEngine](https://docs.dolphindb.cn/zh/funcs/c/createAsofJoinEngine.html)。\n\n#### 参数\n\n**rightStream** DStream 对象，表示输入的右表数据源。\n\n**metrics** 以元代码的格式表示计算指标，支持输入元组。有关元代码的更多信息可参考 [Metaprogramming](https://docs.dolphindb.cn/zh/progr/objs/meta_progr.html)。\n\n* 计算指标可以是一个或多个表达式、系统内置或用户自定义函数、一个常量标量/向量，但不能是聚合函数。当指定为常量向量时，对应的输出列必须设置为数组向量类型，例子参见 [createReactiveStateEngine](https://docs.dolphindb.cn/zh/funcs/c/createReactiveStateEngine.html) 中的例4。\n* *metrics* 内支持调用具有多个返回值的函数，且必须指定列名，例如 \\<func(price) as \\`col1\\`col2>。若在 *metrics* 指定了 *leftTable* 和 *rightTable* 中具有相同名称的列，默认取左表的列，可以通过 \"tableName.colName\" 指定该列来自哪个表。\n\n  **Note:** *metrics* 中使用的列名大小写不敏感，不需要与输入表的列名大小写保持一致。\n\n**matchingColumn** 表示连接列的字符串标量/向量/字符串组成的 tuple，支持 Integral, Temporal 或 Literal（UUID 除外）类型。*matchingColumn* 指定规则为：\n\n1. 只有一个连接列：当左表和右表的连接列名相同时，*matchingColumn* 是一个字符串标量，否则是一个长度为 2 的 tuple，例如：左表连接列名为 sym，右表连接列名为 sym1，则 *matchingColumn* = \\[\\[\\`sym],\\[\\`sym1]]。\n2. 有多个连接列：当左表和右表的连接列名相同时，*matchingColumn* 是一个字符串向量，否则是一个长度为 2 的 tuple，例如：左表连接列名为 orderNo, sym，右表连接列名为 orderNo, sym1，则 *matchingColumn* = \\[\\[\\`orderNo, \\`sym], \\[\\`orderNo,\\`sym1]]。\n\n**timeColumn** 可选参数，字符串标量或向量。当 *useSystemTime* = false 时，指定要连接的两个表中时间列的名称。 *leftTable* 和 *rightTable* 时间列名称可以不同，但数据类型需保持一致。当 *leftTable* 和 *rightTable* 时间列名称不同时，*timeColumn* 为一个长度为2的字符串向量。\n\n**useSystemTime** 可选参数，布尔值。表示是否使用数据注入引擎时的系统时间作为时间列进行计算。\n\n* 当 *useSystemTime* = true 时，按照数据进入引擎的时刻（毫秒精度的本地系统时间，与数据中的时间列无关）进行计算。\n* 当 *useSystemTime* = false（缺省值）时，按照数据中的时间列进行计算。\n\n**delayedTime** 可选参数，正整数，单位同 timeColumn 精度一致。表示左表中未联结数据被触发联结并计算输出的最大等待时间。要设置 *delayedTime*， 必须指定 *timeColumn*，更多介绍见详情。\n\n**garbageSize** 可选参数，正整数，默认值是 5,000（单位为行）。随着订阅的流数据不断注入 asof join 引擎，存放在内存中的数据会越来越多，当各分组对应的缓存表（左表或右表）中数据行数超过 *garbageSize* 值时，系统会清理该表中已经触发计算的历史数据。\n\n**sortByTime** 布尔值，表示是否按全局时间顺序输出数据。默认值为 false，表示不按全局时间输出数据，仅在组内按时间顺序输出数据。\n\n**Note:** 当设置 *sortByTime* = true 时，必须保证输入的左表和右表的数据分别全局有序，且不可设置 *delayedTime*。\n\n#### 返回值\n\n返回一个 DStream 对象。\n\n#### 例子\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\n\n// 如已存在流图，则先销毁该流图\n// dropStreamGraph('asofJoin')\n\ng = createStreamGraph('asofJoin')\nr = g.source(\"right\", `time`sym`bid`ask, [TIMESTAMP, SYMBOL, DOUBLE, DOUBLE])\ng.source(\"left\", `time`sym`price, [TIMESTAMP, SYMBOL, DOUBLE])\n    .asofJoinEngine(r, <[price, bid, ask, abs(price-(bid+ask)/2)]>, `sym, `time)\n    .sink(\"output\")\ng.submit()\ngo\n\ntmp1=table(2024.08.27T09:30:00.000+2 8 20 22 23 24 as time, take(`A`B, 6) as sym, 20.01 20.04 20.07 20.08 20.4 20.5 as price)\ntmp1.sortBy!(`time)\nappendOrcaStreamTable(\"left\", tmp1)\n\ntmp2=table(2024.08.27T09:30:00.000+1 5 6 11 19 20 21 as time, take(`A`B, 7) as sym, 20 20.02 20.03 20.05 20.06 20.6 20.4 as bid,  20.01 20.03 20.04 20.06 20.07 20.5 20.6 as ask)\nappendOrcaStreamTable(\"right\", tmp2)\n\nselect * from orca_table.output\n```\n\n| time                    | sym | price | bid   | ask   | abs                  |\n| ----------------------- | --- | ----- | ----- | ----- | -------------------- |\n| 2024.08.27 09:30:00.002 | A   | 20.01 | 20.00 | 20.01 | 0.004999999999999005 |\n| 2024.08.27 09:30:00.020 | A   | 20.07 | 20.06 | 20.07 | 0.005000000000002558 |\n| 2024.08.27 09:30:00.008 | B   | 20.04 | 20.02 | 20.03 | 0.015000000000000568 |\n"
    },
    "Dstream::buffer": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/DStream_buffer.html",
        "signatures": [
            {
                "full": "DStream::buffer(name, [asyncWrite=true], [compress=true], [cacheSize], [retentionMinutes=1440], [flushMode=0], [preCache], [cachePurgeTimeColumn], [cachePurgeInterval], [cacheRetentionTime])",
                "name": "DStream::buffer",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "[asyncWrite=true]",
                        "name": "asyncWrite",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[compress=true]",
                        "name": "compress",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[cacheSize]",
                        "name": "cacheSize",
                        "optional": true
                    },
                    {
                        "full": "[retentionMinutes=1440]",
                        "name": "retentionMinutes",
                        "optional": true,
                        "default": "1440"
                    },
                    {
                        "full": "[flushMode=0]",
                        "name": "flushMode",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[preCache]",
                        "name": "preCache",
                        "optional": true
                    },
                    {
                        "full": "[cachePurgeTimeColumn]",
                        "name": "cachePurgeTimeColumn",
                        "optional": true
                    },
                    {
                        "full": "[cachePurgeInterval]",
                        "name": "cachePurgeInterval",
                        "optional": true
                    },
                    {
                        "full": "[cacheRetentionTime]",
                        "name": "cacheRetentionTime",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [Dstream::buffer](https://docs.dolphindb.cn/zh/funcs/d/DStream_buffer.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nDStream::buffer(name, \\[asyncWrite=true], \\[compress=true], \\[cacheSize], \\[retentionMinutes=1440], \\[flushMode=0], \\[preCache], \\[cachePurgeTimeColumn], \\[cachePurgeInterval], \\[cacheRetentionTime])\n\n#### 详情\n\n创建一个持久化共享流数据表，用于存储流计算中间结果。参考 [enableTableShareAndPersistence](https://docs.dolphindb.cn/zh/funcs/e/enableTableShareAndPersistence.html)。\n\n#### 参数\n\n**name** 表示流表的名称。字符串标量，可以传入完整的流表全限定名（如 \"trading.orca\\_table.trades\"）；也可以仅提供流表名（如 \"trades\"），系统会根据当前的 catalog 设置自动补全为对应的全限定名。\n\n**asyncWrite** 可选参数，是一个布尔值，表示是否异步持久化数据到磁盘。默认值为 true，流数据写入内存即为写入成功，持久化到磁盘的操作将会由另一个线程执行。\n\n**Note:**\n\n持久化数据到磁盘包含两个步骤：\n\n* 写内存数据到操作系统缓存\n\n* 写缓存数据到磁盘（是否开启同步刷盘由参数 *flushMode* 决定）\n\n**compress** 可选参数，是一个布尔值，表示是否以压缩模式模式保存至磁盘。默认值为 true。\n\n**cacheSize** 可选参数，整数，表示流数据表在内存中最多保留多少行。如果未指定该参数，则所有记录行都会保存在内存中。如果 *cacheSize* 小于 1000，它会被自动调整为 1000。\n\n**retentionMinutes** 可选参数，是一个整数，表示文件大小超过 1GB的 log 文件的保留时间(从文件的最后修改时间开始计算)，单位是分钟。默认值是 1440，即一天。如果 log 文件未达 1GB，则会一直保留至大小达到 1GB。\n\n**flushMode** 可选参数，是一个整数，表示是否开启同步刷盘，取值只能为 0 或 1。默认值是 0，表示异步刷盘，内存中的流数据写入操作系统缓存即为写入成功，并进行下一批数据的写入。 若为 1，则表示同步刷盘，当前批次的流数据必须落盘完成，才会进行下一批数据的写入。\n\n**preCache** 可选参数，是一个整数，表示从磁盘加载到内存的记录条数。如果没有指定该参数，重启后实际加载到内存的数据量受 *cacheSize* 限制。\n\n**cachePurgeTimeColumn** 可选参数，字符串标量，需要指定为持久化流表中的时间列名称。\n\n**cachePurgeInterval** 可选参数，DURATION 类型标量，表示触发清理内存中数据的时间间隔。\n\n**cacheRetentionTime** 可选参数，DURATION 类型标量，表示内存中数据的最长保留期限。\n\n#### 返回值\n\n返回一个 DStream 对象。\n\n#### 例子\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\ng = createStreamGraph(\"indicators\")\n\ng.source(\"trade\", `time`symbol`price`volume, [DATETIME,SYMBOL,DOUBLE,LONG])\n    .timeSeriesEngine(windowSize=60, step=60, metrics=[<first(price) as open>, <max(price) as high>, <min(price) as low>, <last(price) as close>, <sum(volume) as volume>], timeColumn=`time, keyColumn=`symbol)\n    .buffer(\"bufferTable\")\n```\n"
    },
    "DStream::changelogSink": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/DStream_changelogSink.html",
        "signatures": [
            {
                "full": "DStream::changelogSink(name, keyColumn, [asyncWrite=true], [compress=true], [cacheSize], [retentionMinutes=1440], [flushMode=0], [preCache], [cachePurgeTimeColumn], [cachePurgeInterval], [cacheRetentionTime])",
                "name": "DStream::changelogSink",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "keyColumn",
                        "name": "keyColumn"
                    },
                    {
                        "full": "[asyncWrite=true]",
                        "name": "asyncWrite",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[compress=true]",
                        "name": "compress",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[cacheSize]",
                        "name": "cacheSize",
                        "optional": true
                    },
                    {
                        "full": "[retentionMinutes=1440]",
                        "name": "retentionMinutes",
                        "optional": true,
                        "default": "1440"
                    },
                    {
                        "full": "[flushMode=0]",
                        "name": "flushMode",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[preCache]",
                        "name": "preCache",
                        "optional": true
                    },
                    {
                        "full": "[cachePurgeTimeColumn]",
                        "name": "cachePurgeTimeColumn",
                        "optional": true
                    },
                    {
                        "full": "[cachePurgeInterval]",
                        "name": "cachePurgeInterval",
                        "optional": true
                    },
                    {
                        "full": "[cacheRetentionTime]",
                        "name": "cacheRetentionTime",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [DStream::changelogSink](https://docs.dolphindb.cn/zh/funcs/d/DStream_changelogSink.html)\n\n首发版本：3.00.5\n\n\n\n#### 语法\n\nDStream::changelogSink(name, keyColumn, \\[asyncWrite=true], \\[compress=true], \\[cacheSize], \\[retentionMinutes=1440], \\[flushMode=0], \\[preCache], \\[cachePurgeTimeColumn], \\[cachePurgeInterval], \\[cacheRetentionTime])\n\n#### 详情\n\n将流数据输出至包含状态列的持久化键值流数据表。\n\n有关流数据表的更多信息，请参阅 [changelogStreamTable](https://docs.dolphindb.cn/zh/funcs/c/changelogStreamTable.html) 手册。\n\n#### 参数\n\n**name** 字符串，指定目标表名。\n\n**keyColumn** 字符串标量或向量，指定主键列。\n\n**asyncWrite** 可选参数，是一个布尔值，表示是否异步持久化数据到磁盘。默认值为 true，流数据写入内存即为写入成功，持久化到磁盘的操作将会由另一个线程执行。\n\n**Note:**\n\n持久化数据到磁盘包含两个步骤：\n\n* 写内存数据到操作系统缓存\n\n* 写缓存数据到磁盘（是否开启同步刷盘由参数 *flushMode* 决定）\n\n**compress** 可选参数，是一个布尔值，表示是否以压缩模式模式保存至磁盘。默认值为 true。\n\n**cacheSize** 可选参数，整数，表示流数据表在内存中最多保留多少行。如果未指定该参数，则所有记录行都会保存在内存中。如果 *cacheSize* 小于 1000，它会被自动调整为 1000。\n\n**retentionMinutes** 可选参数，是一个整数，表示文件大小超过 1GB的 log 文件的保留时间(从文件的最后修改时间开始计算)，单位是分钟。默认值是 1440，即一天。如果 log 文件未达 1GB，则会一直保留至大小达到 1GB。\n\n**flushMode** 可选参数，是一个整数，表示是否开启同步刷盘，取值只能为 0 或 1。默认值是 0，表示异步刷盘，内存中的流数据写入操作系统缓存即为写入成功，并进行下一批数据的写入。 若为 1，则表示同步刷盘，当前批次的流数据必须落盘完成，才会进行下一批数据的写入。\n\n**preCache** 可选参数，是一个整数，表示从磁盘加载到内存的记录条数。如果没有指定该参数，重启后实际加载到内存的数据量受 *cacheSize* 限制。\n\n**cachePurgeTimeColumn** 可选参数，字符串标量，需要指定为持久化流表中的时间列名称。\n\n**cachePurgeInterval** 可选参数，DURATION 类型标量，表示触发清理内存中数据的时间间隔。\n\n**cacheRetentionTime** 可选参数，DURATION 类型标量，表示内存中数据的最长保留期限。\n\n#### 返回值\n\n返回一个 DStream 对象。\n\n**相关函数**：[changelogStreamTable](https://docs.dolphindb.cn/zh/funcs/c/changelogStreamTable.html)、[enableTableShareAndPersistence](https://docs.dolphindb.cn/zh/funcs/e/enableTableShareAndPersistence.html)、[StreamGraph::changelogSource](https://docs.dolphindb.cn/zh/funcs/s/StreamGraph_changelogSource.html)\n"
    },
    "DStream::crossSectionalEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/DStream_crossSectionalEngine.html",
        "signatures": [
            {
                "full": "DStream::crossSectionalEngine(metrics, keyColumn, [triggeringPattern='perBatch'], [triggeringInterval=1000], [useSystemTime=true], [timeColumn], [lastBatchOnly=false], [contextByColumn], [roundTime=true], [keyFilter])",
                "name": "DStream::crossSectionalEngine",
                "parameters": [
                    {
                        "full": "metrics",
                        "name": "metrics"
                    },
                    {
                        "full": "keyColumn",
                        "name": "keyColumn"
                    },
                    {
                        "full": "[triggeringPattern='perBatch']",
                        "name": "triggeringPattern",
                        "optional": true,
                        "default": "'perBatch'"
                    },
                    {
                        "full": "[triggeringInterval=1000]",
                        "name": "triggeringInterval",
                        "optional": true,
                        "default": "1000"
                    },
                    {
                        "full": "[useSystemTime=true]",
                        "name": "useSystemTime",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[timeColumn]",
                        "name": "timeColumn",
                        "optional": true
                    },
                    {
                        "full": "[lastBatchOnly=false]",
                        "name": "lastBatchOnly",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[contextByColumn]",
                        "name": "contextByColumn",
                        "optional": true
                    },
                    {
                        "full": "[roundTime=true]",
                        "name": "roundTime",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[keyFilter]",
                        "name": "keyFilter",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [DStream::crossSectionalEngine](https://docs.dolphindb.cn/zh/funcs/d/DStream_crossSectionalEngine.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nDStream::crossSectionalEngine(metrics, keyColumn, \\[triggeringPattern='perBatch'], \\[triggeringInterval=1000], \\[useSystemTime=true], \\[timeColumn], \\[lastBatchOnly=false], \\[contextByColumn], \\[roundTime=true], \\[keyFilter])\n\n#### 详情\n\n创建流计算横截面引擎。参考：[createCrossSectionalEngine](https://docs.dolphindb.cn/zh/funcs/c/createCrossSectionalEngine.html)。\n\n#### 参数\n\n**metrics** 以元代码的格式表示计算指标，支持输入元组。有关元代码的更多信息可参考[元编程](https://docs.dolphindb.cn/zh/progr/objs/meta_progr.html)。\n\n* 计算指标可以是系统内置或用户自定义的函数，如 <\\[sum(qty), avg(price)]>；可以对计算结果使用表达式，如 <\\[avg(price1)-avg(price2)]>；也可以对多列进行运算，如 <\\[std(price1-price2)]>。\n* *metrics* 内支持调用具有多个返回值的函数，例如 \\<func(price) as \\`col1\\`col2>（可不指定列名）。\n* *metrics* 中使用的列名大小写不敏感，不要求与输入表的列名大小写保持一致。\n\n**keyColumn** 字符串标量或向量，指定流数据表中某列的值为横截面引擎的键值。横截面引擎的计算时，仅使用每个键值对应的最新一行记录。\n\n**triggeringPattern** 字符串标量，表示触发计算的方式，每触发一次计算，输出一条结果到输出表。该字符串可选值如下：\n\n* 'perBatch'：*triggeringPattern* 的默认值。每插入一次数据触发一次计算。\n* 'perRow'：插入的每一行数据都会触发一次计算。\n* 'interval'：基于系统时间间隔触发计算。\n* 'keyCount'：若相同时间戳的数据分批次到达，则只有在当前时间戳的记录数达到 *triggeringInterval*，或有更新时间戳的数据到达时，才会触发计算。使用该参数值时，必须指定 *timeColumn*，且 *useSystemTime* = false。若设置 *triggeringPattern* = 'keyCount'，收到的数据中出现的乱序数据会被丢弃，不参与计算。\n* 'dataInterval'：基于数据时间间隔触发计算。使用该参数值时，必须指定 *timeColumn*，且指定 *useSystemTime* = false。\n\n**triggeringInterval** 整数或元组，触发计算规则如下：\n\n* *triggeringPattern* 取值为 'interval' 时，*triggeringInterval* 是一个正整数，表示触发计算的时间间隔，单位为毫秒，默认值为 1000。每经过 *triggeringInterval* 指定的时间间隔，检查引擎中的数据是否被计算。若存在未被计算的数据，则触发一次计算。\n* *triggeringPattern* 取值为 'keyCount' 时：\n  * *triggeringInterval* 可以是一个整数。设置后，在更新的时间戳的数据到来前，当前时间戳的记录数需要累积到 *triggeringInterval* 才会触发计算。\n  * *triggeringInterval* 也可以是一个长度为 2 的 元组。元组的第一个元素是整数，表示触发计算的最新时间戳的记录数量。元组的第二个值可以是整数或者 duration 类型数据。假设设置 *triggeringInterval* = (c1, c2):\n    * 当 c2 为整数时，若收到的最新时间戳 t1 的数据数量小于 c1，这批数据不会触发计算，系统可以继续缓存更新时间戳 t2(t2>t1) 的数据，当 t2 的数据量达到 c2 或者收到更新的时间戳 t3(t3>t2) 的数据时，会触发时间戳 t1 对应数据的计算。注意必须满足 c2 < c1。\n    * 当 c2 为 duration 时，若收到的最新时间戳 t1 的数据数量小于 c1，这批数据不会触发计算，系统收到更新的时间戳 t2(t2>t1) 的数据后，会等待 duration 指定的时间，若在此期间继续收到了 t1 的数据且满足 t1 时间戳的数据总量达到 c1，或者在此期间又收到了更新的时间戳 t3(t3>t2) 的数据，则直接触发 t1 对应数据的计算，等待时间结束后不再触发计算。否则，等待 duration 设置的时间后才会触发 t1 数据的计算。\n* *triggeringPattern* 取值为 'dataInterval' 时，*triggeringInterval* 是一个正整数，单位和数据时间的单位一致，默认值为 1000。从第一条数据的时间戳开始一个窗口，窗口长度为 *triggeringInterval*。一个窗口结束后到达的第一条数据会触发当前窗口内数据的计算输出。输出表的时间为窗口结束的时间戳。\n\n**useSystemTime** 可选参数，布尔值，表示是否使用数据注入引擎时的系统时间作为计算参照的时间列。\n\n* 若 *useSystemTime* = true，*outputTable* 中第一列（时间列）为系统时间；\n* 若 *useSystemTime* = false，必须指定 *timeColumn*，*outputTable* 中第一列（时间列）为数据的时间戳。\n\n**timeColumn** 是一个字符串。当 *useSystemTime* = false 时，指定订阅的流数据表中时间列的名称。仅支持 TIMESTAMP 类型。\n\n**lastBatchOnly** 可选参数。横截面引擎是否只保留最新时间戳上的数据。当 *lastBatchOnly* = true 时，只能指定 *triggeringPattern* = 'keyCount'，此时横截面引擎维护的键值表只保存最新时间戳的键值数据；否则，更新并保留所有时间戳上的键值数据。\n\n**contextByColumn** 可选参数，字符串标量或向量。设置后，将对横截面引擎中数据按照指定的字段或字段组合分组，并在组内进行指定计算。\n\n* 设置该参数，必须指定 *metrics* 和 *outputTable*.\n* 如果 *metrics* 全为聚合函数，则分组计算结果和 groupby 分组计算结果一致，否则和 contextby 分组计算结果一致。\n\n**roundTime** 可选参数，布尔值。用于对第一个数据窗口的起始时间进行规整，仅在 *triggeringPattern*=dataInterval 时有效。系统将根据该参数、triggeringInterval 和时间精度来确定规整尺度（alignmentSize）。窗口规整规则同[时序引擎](https://docs.dolphindb.cn/zh/funcs/c/createTimeSeriesEngine.html)。\n\n**keyFilter** 可选参数，以元代码形式表示的过滤条件。过滤条件是一个表达式或者函数调用，应用于截面数据中的列（列值为 key），返回一个布尔向量。引擎会从截面数据中过滤出 key 满足条件的数据进行计算。\n\n#### 返回值\n\n返回一个 DStream 对象。\n\n#### 例子\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\n// 如已存在流图，则先销毁该流图\n// dropStreamGraph('cs')\n\ncsGraph = createStreamGraph(\"cs\")\ncsGraph.source(\"trade1\", `time`sym`price`volume,[TIMESTAMP,SYMBOL,DOUBLE,INT])\n  .crossSectionalEngine(metrics=<[avg(price), sum(volume), sum(price*volume), count(price)]>, keyColumn=`sym)\n  .sink(\"cs_output\")\ncsGraph.submit()\ngo\n\ntimes=2020.08.12T09:30:00.000 + 123 234 456 678 890 901\nsyms=`A`B`A`B`B`A\nprices=10 20 10.1 20.1 20.2 10.2\nvolumes=20 10 20 30 40 20\ntmp=table(times as time, syms as sym, prices as price, volumes as volume)\n\nappendOrcaStreamTable(\"trade1\", tmp)\n\nselect * from orca_table.cs_output;\n```\n"
    },
    "DStream::cryptoOrderBookEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/DStream_cryptoOrderBookEngine.html",
        "signatures": [
            {
                "full": "DStream::cryptoOrderBookEngine(inputColMap, depth, [updateRule='direct'], [errorHandler=NULL], [cachingInterval=5000], [timeout=-1], [cachedDepth])",
                "name": "DStream::cryptoOrderBookEngine",
                "parameters": [
                    {
                        "full": "inputColMap",
                        "name": "inputColMap"
                    },
                    {
                        "full": "depth",
                        "name": "depth"
                    },
                    {
                        "full": "[updateRule='direct']",
                        "name": "updateRule",
                        "optional": true,
                        "default": "'direct'"
                    },
                    {
                        "full": "[errorHandler=NULL]",
                        "name": "errorHandler",
                        "optional": true,
                        "default": "NULL"
                    },
                    {
                        "full": "[cachingInterval=5000]",
                        "name": "cachingInterval",
                        "optional": true,
                        "default": "5000"
                    },
                    {
                        "full": "[timeout=-1]",
                        "name": "timeout",
                        "optional": true,
                        "default": "-1"
                    },
                    {
                        "full": "[cachedDepth]",
                        "name": "cachedDepth",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [DStream::cryptoOrderBookEngine](https://docs.dolphindb.cn/zh/funcs/d/DStream_cryptoOrderBookEngine.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nDStream::cryptoOrderBookEngine(inputColMap, depth, \\[updateRule='direct'], \\[errorHandler=NULL], \\[cachingInterval=5000], \\[timeout=-1], \\[cachedDepth])\n\n#### 详情\n\n创建流计算数字货币实时订单簿引擎，支持根据数字货币全量深度快照和增量深度信息，实时更新订单簿。参考：[createCryptoOrderBookEngine](https://docs.dolphindb.cn/zh/funcs/c/createcryptoorderbookengine.html)。\n\n#### 参数\n\n**inputColMap** 字典，将 *dummyTable* 中列字段的名称映射为引擎计算所需要的列。\n\n**depth** 正整数或字典，用于指定订单簿的深度。\n\n* 正整数：所有数字货币的订单簿深度都为该设置值。\n\n* 字典：键是字符串标量或向量，表示数字货币代码；值是整型，表示订单簿深度。对于指定的数字货币，将按照设定的深度输出订单簿。未被指定的数字货币将不输出订单簿结果。\n\n**updateRule** 可选参数，字符串标量，用于指定订单簿更新规则。可选值为：\n\n* \"direct\"：默认值，表示直接更新，系统将不进行数据丢失判断，仅根据 isIncremental 字段判断是对订单簿执行增量更新（isIncremental=true）还是覆盖（isIncremental-false）。\n* \"general\"：通用更新规则。要求按顺序插入增量数据，并确保数据中 updateId 单调递增。\n* \"Binance-spot\"：基于 Binance 现货交易所订单簿更新机制定义的规则。\n* \"Binance-futures\"：基于 Binance 期货交易所订单簿更新机制定义的规则。\n\n**errorHandler** 可选参数，自定义错误处理函数。当增量数据出现缺失时，可通过该函数进行错误处理。包含 2 个参数：\n\n* 第一个是字符串标量，表示数字货币代码。\n* 第二个是整型标量，表示错误码，包括以下情况：\n  * 1：接收到历史数据。\n  * 2：接收到应在未来时间点到达的乱序数据。\n  * 3：超时错误，指定时间间隔内没有新的订单簿合成。\n  * 4：买卖价格交叉错误。判断交叉的条件为最高买价大于等于最低卖价。\n\n**cachingInterval** 可选参数，整型标量，表示缓存增量深度数据的时间间隔。默认值为 5000，单位为毫秒。对于每个数字货币，当缓存中的数据时间与当前最新一条数据时间的差值小于等于 *cachingInterval* 时，该数据才会被保留在缓存中。\n\n**timeout** 可选参数，整型标量，表示订单簿更新超时时间。单位为毫秒，默认值为 -1，表示不设置超时时间。在 *timeout* 指定的时间内未合成新的订单簿时，将触发超时错误，此时会通过 *errorHandler* 进行错误处理。\n\n**cachedDepth** 可选参数，正整数或字典，用于指定缓存中价格和数量（包括 askQty, askPrice, bidQty, bidPrice）的深度。\n\n* 正整数：缓存中所有数字货币的价格和数量将按照该值的深度进行缓存。\n\n* 字典：键是字符串标量或向量，表示数字货币代码；值是整型，表示对应的深度。对于指定的数字货币，将按照设定的深度缓存价格和数量。未被指定的数字货币将保留实际收到的所有价格和数量信息。\n\n#### 返回值\n\n返回一个 DStream 对象。\n\n#### 例子\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\n// Define input table schema\ncolNames = `isIncremental`exchange`eventTime`transactionTime`symbol`firstUpdateId`lastUpdateId`prevLastUpdateId`bidPrice`bidQty`askPrice`askQty\ncolTypes = [BOOL, SYMBOL, TIMESTAMP, TIMESTAMP, SYMBOL, LONG, LONG, LONG, DECIMAL128(18)[], DECIMAL128(8)[], DECIMAL128(18)[], DECIMAL128(8)[]]\n\ninputTarget = [\"symbol\", \"eventTime\", \"isIncremental\", \"bidPrice\", \"bidQty\", \"askPrice\", \"askQty\", \"lastUpdateId\", \"firstUpdateId\", \"prevLastUpdateId\"]\ninputSource = [\"symbol\", \"eventTime\", 'isIncremental', 'bidPrice', 'bidQty', 'askPrice', 'askQty', 'lastUpdateId', 'firstUpdateId', 'prevLastUpdateId']\n\n// Map input columns\ninputColMap = dict(inputTarget, inputSource)\n\n// Set depth\ndepth = dict([\"BTCUSDT\"], [1000])\n\ncptGraph = createStreamGraph(\"cptEngine\")\ncptGraph.source(\"cptInput\", colNames,colTypes)\n.cryptoOrderBookEngine(inputColMap, depth)\n.sink(\"output\")\ncptGraph.submit()\n```\n"
    },
    "DStream::dailyTimeSeriesEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/DStream_dailyTimeSeriesEngine.html",
        "signatures": [
            {
                "full": "DStream::dailyTimeSeriesEngine(windowSize, step, metrics, sessionBegin, [sessionEnd], [timeColumn], [useSystemTime=false], [keyColumn], [updateTime], [useWindowStartTime], [roundTime=true], [fill='none'], [mergeSessionEnd=false], [forceTriggerTime], [forceTriggerSessionEndTime], [keyPurgeFreqInSecond], [closed='left'], [subWindow], [parallelism=1],[acceptedDelay=0], [keyPurgeDaily=true])",
                "name": "DStream::dailyTimeSeriesEngine",
                "parameters": [
                    {
                        "full": "windowSize",
                        "name": "windowSize"
                    },
                    {
                        "full": "step",
                        "name": "step"
                    },
                    {
                        "full": "metrics",
                        "name": "metrics"
                    },
                    {
                        "full": "sessionBegin",
                        "name": "sessionBegin"
                    },
                    {
                        "full": "[sessionEnd]",
                        "name": "sessionEnd",
                        "optional": true
                    },
                    {
                        "full": "[timeColumn]",
                        "name": "timeColumn",
                        "optional": true
                    },
                    {
                        "full": "[useSystemTime=false]",
                        "name": "useSystemTime",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[keyColumn]",
                        "name": "keyColumn",
                        "optional": true
                    },
                    {
                        "full": "[updateTime]",
                        "name": "updateTime",
                        "optional": true
                    },
                    {
                        "full": "[useWindowStartTime]",
                        "name": "useWindowStartTime",
                        "optional": true
                    },
                    {
                        "full": "[roundTime=true]",
                        "name": "roundTime",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[fill='none']",
                        "name": "fill",
                        "optional": true,
                        "default": "'none'"
                    },
                    {
                        "full": "[mergeSessionEnd=false]",
                        "name": "mergeSessionEnd",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[forceTriggerTime]",
                        "name": "forceTriggerTime",
                        "optional": true
                    },
                    {
                        "full": "[forceTriggerSessionEndTime]",
                        "name": "forceTriggerSessionEndTime",
                        "optional": true
                    },
                    {
                        "full": "[keyPurgeFreqInSecond]",
                        "name": "keyPurgeFreqInSecond",
                        "optional": true
                    },
                    {
                        "full": "[closed='left']",
                        "name": "closed",
                        "optional": true,
                        "default": "'left'"
                    },
                    {
                        "full": "[subWindow]",
                        "name": "subWindow",
                        "optional": true
                    },
                    {
                        "full": "[parallelism=1]",
                        "name": "parallelism",
                        "optional": true,
                        "default": "1"
                    },
                    {
                        "full": "[acceptedDelay=0]",
                        "name": "acceptedDelay",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[keyPurgeDaily=true]",
                        "name": "keyPurgeDaily",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [DStream::dailyTimeSeriesEngine](https://docs.dolphindb.cn/zh/funcs/d/DStream_dailyTimeSeriesEngine.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nDStream::dailyTimeSeriesEngine(windowSize, step, metrics, sessionBegin, \\[sessionEnd], \\[timeColumn], \\[useSystemTime=false], \\[keyColumn], \\[updateTime], \\[useWindowStartTime], \\[roundTime=true], \\[fill='none'], \\[mergeSessionEnd=false], \\[forceTriggerTime], \\[forceTriggerSessionEndTime], \\[keyPurgeFreqInSecond], \\[closed='left'], \\[subWindow], \\[parallelism=1],\\[acceptedDelay=0], \\[keyPurgeDaily=true])\n\n#### 详情\n\n创建流计算日级时间序列引擎。参考：[createDailyTimeSeriesEngine](https://docs.dolphindb.cn/zh/funcs/c/createDailyTimeSeriesEngine.html)。\n\n#### 参数\n\n**windowSize** 正整数标量或向量，表示滑动窗口的长度。\n\n**step** 正整数标量，表示滑动窗口移动的步长。 *windowSize* 必须是 *step* 的整数倍，否则会抛出异常。*windowSize* 和 *step* 的单位与 *useSystemTime* 有关：\n\n* 若 *useSystemTime* 为 true，则 *windowSize* 和 *step* 的单位为毫秒。\n\n* 若 *useSystemTime* 为 false，则 *windowSize* 和 *step* 的单位与 *timeColumn* 的时间精度一致。\n\n**metrics** 以元代码的格式表示计算指标，支持输入元组。有关元代码的更多信息可参考 [元编程](https://docs.dolphindb.cn/zh/progr/objs/meta_progr.html)。\n\n* 计算指标可以是一个或多个系统内置或用户自定义的聚合函数（使用 defg 关键字定义），如 <\\[sum(volume), avg(price)]>；可以对聚合结果使用表达式，如 <\\[avg(price1)-avg(price2)]>；也可对列与列的计算结果进行聚合计算，如 <\\[std(price1-price2)]>。\n\n* *metrics* 内支持调用具有多个返回值的函数，例如 \\<func(price) as \\`col1\\`col2>（可不指定列名）。\n\n* 支持指定为一个常量标量或向量，例如 <1>，<\\[1, 2, 3]> 。当指定为常量向量时，对应的输出列必须设置为数组向量类型。\n\n* 若 *windowSize* 为向量， *windowSize* 每个值可对应 *metrics* 中多个计算指标。例如，*windowSize* 为\\[10,20]时，metrics可为 (<\\[min(volume), max(volume)]>, \\<sum(volume)>)。 *metrics* 也可以嵌套输入元组向量。例如：\\[\\[<\\[min(volume), max(volume)]>, \\<sum(volume)>], \\[\\<avg(volume)>]]\n\n  **Note:**\n\n  * *metrics* 中使用的列名大小写不敏感，不需要与输入表的列名大小写保持一致。\n  * *metrics* 中不可使用嵌套聚合函数。\n\n**sessionBegin** 可以是与时间列的数据类型对应的 SECOND、TIME 或 NANOTIME 类型的标量或向量，表示每个时间段的起始时刻。如果 *sessionBegin* 是一个向量，它必须是递增的。\n\n**sessionEnd** 为可选参数，可以是与时间列的数据类型对应的 SECOND、TIME 或 NANOTIME 类型的标量或向量，表示每个时间段的结束时刻。可在 *sessionEnd* 中指定 00:00:00 表示的次日的零点（即当日的 24:00:00）。\n\n**timeColumn** 可选参数，字符串标量或向量。当 *useSystemTime* = false 时，必须指定该参数。 该参数用于指定订阅的流数据表中时间列的名称。\n\n**Note:** 字符串向量必须是 date 和 time 组成的向量，date 类型为 DATE，time 类型为 TIME, SECOND 或 NANOTIME。此时，输出表第一列的时间类型必须与 [concatDateTime(date, time)](https://docs.dolphindb.cn/zh/funcs/c/concatDateTime.html) 的类型一致。\n\n**useSystemTime** 可选参数，布尔值，表示是否使用数据注入引擎时的系统时间作为时间列进行计算。\n\n* 当 *useSystemTime* = true时，时间序列引擎会按照数据注入时间序列引擎的时刻（毫秒精度的本地系统时间，与数据中的时间列无关），每隔固定时间截取固定长度窗口的流数据进行计算。只要一个数据窗口中含有数据，数据窗口结束后就会自动进行计算。结果中的第一列为计算发生的时间戳，与数据中的时间无关。\n\n* 当 *useSystemTime* = false（缺省值）时，时间序列引擎根据流数据中的 *timeColumn* 列来截取数据窗口。一个数据窗口结束后的第一条新数据才会触发该数据窗口的计算。请注意，触发计算的数据并不会参与该次计算。\n\n  例如，一个数据窗口从 10:10:10 到 10:10:19。若 *useSystemTime* = true，则只要该窗口中至少有一条数据，该窗口的计算会在窗口结束后的 10:10:20 触发。若 *useSystemTime* = false，且 10:10:19 后的第一条数据为 10:10:25，则该窗口的计算会在 10:10:25 触发。\n\n**keyColumn** 可选参数，字符串标量或向量，表示分组列名。若设置，则分组进行聚合计算，例如以每支股票为一组进行聚合计算。\n\n**updateTime** 可选参数，非负整数，单位与 timeColumn 的时间精度一致。用于指定比 *step* 更短的计算时间间隔。*step* 必须是 *updateTime* 的整数倍。要设置 *updateTime*， *useSystemTime* 必须设为 false。\n\n* updateTime 指定为正整数值时：\n\n  * 从当前窗口的左边界开始，每隔 *updateTime* 时间，若有新的数据到来，则对当前窗口内该数据之前的所有数据进行计算。\n\n  * 如果系统经过 2 \\* *updateTime* （至少2秒）后仍有未被处理的数据，则触发对当前窗口内所有数据的计算。\n\n  * 若分组计算，则每组内进行上述操作。\n\n* updateTime 指定为 0 时：在新的数据到来后，立即对当前窗口的最新数据计算并输出。\n\n**useWindowStartTime** 可选参数，布尔值，表示输出表中的时间是否为数据窗口起始时间。默认值为 false，表示输出表中的时间为数据窗口起始时间 + *windowSize* 。若 *windowSize* 是向量， *useWindowStartTime* 必须为 false。\n\n**roundTime** 可选参数，布尔值，表示若数据时间精度为毫秒或者秒且 *step* > 一分钟，如何对窗口边界值进行规整处理。默认值为 true，表示按照既定的多分钟规则进行规整。若为 false，则按一分钟规则进行窗口规整。\n\n* 指定的目录必须存在，否则系统会提示异常。\n\n* 创建流数据引擎时，如果指定了 *snapshotDir*，会检查该目录下是否存在快照。如果存在，会加载该快照，恢复引擎的状态。\n\n* 多个引擎可以指定同一个目录存储快照，用引擎的名称来区分快照文件。\n\n* 一个引擎的快照可能会使用三个文件名：\n\n  * 临时存储快照信息：文件名为 \\<engineName>.tmp；\n\n  * 快照生成并刷到磁盘：文件保存为 \\<engineName>.snapshot；\n\n  * 存在同名快照：旧快照自动重命名为 \\<engineName>.old。\n\n**fill** 可选参数，一个标量或向量，指定某个分组的某个窗口无数据时的处理方法。可取以下值：\n\n* 'none': 不输出结果。\n* 'null': 输出结果为 NULL。\n* 'ffill': 输出上一个有数据的窗口的结果。\n* '具体数值'：该值的数据类型需要和对应的 *metrics* 计算结果的类型保持一致。\n\n*fill* 可以输入向量，长度与 *metrics* 元素个数保持一致，表示为每个 *metrics* 指定不同的 *fill* 方式。若为向量，向量中各项只能是 'null', 'ffill' 或一个数值，不能是 'none'。\n\n**mergeSessionEnd** 为可选参数，是一个布尔值。当 *closed* = 'left' 时，表示每个 session 结束时刻的数据是否合入最后一个窗口。默认值为 false，此时该条数据不会合入当前 session 的最后一个窗口，但可以触发最后一个窗口的计算；如果当前 session 不是该自然日内最后一个 session，则该数据会合入下个 session 的第一个窗口。\n\n**forceTriggerTime** 可选参数，是非负整数，单位与 *timeColumn* 的时间精度一致。用于强制触发各个分组未计算的窗口进行计算。要设置 *forceTriggerTime*， *useSystemTime* 必须设置为 false，且不能指定 *updateTime*。强制触发计算及输出规则如下：\n\n1. 未被触发计算的窗口结束后（窗口结束时刻为 t），若收到了其他分组的数据（时间戳为 t1），且满足 t1-t ≥ *forceTriggerTime*，则该窗口将被触发计算。\n\n2. 如果某个分组在最后一个窗口被强制触发计算后，没有再收到新的数据，但其他分组仍然收到了新的数据，那么通过 *fill* 来填充该分组的所有缺失窗口，可以确保在最新时间截面上仍然输出该分组的窗口。如果不指定 *fill*，则最后一个窗口被触发计算后，该分组不会产生新的窗口。\n\n设置 *forceTriggerTime* 或 *updateTime* 时需注意以下几点：\n\n* 设置 *updateTime*，计算发生后仍有属于当前窗口的数据到达时，当前窗口计算结果会再次更新；\n\n* 设置 *forceTriggerTime*，则触发计算之后收到的数据会被丢弃，建议不要设置太小的 *forceTriggerTime*。\n\n* 如果 *timeColumn* 指定的时间为 TIME 类型，数据跨天后无法仅凭时间判断数据的先后顺序，因此会出现跨天无法强制触发的情况。*timeColumn* 的时间需要加上日期。\n\n**forceTriggerSessionEndTime** 为可选参数，正整数，单位与 *timeColumn* 的时间精度一致。若 *sessionEnd* 时刻对应的窗口数据长时间未发生计算，通过该参数可以设置系统经过多少时间后触发计算并输出。若不指定 *fill* ，未包含在该窗口内的分组不会输出结果；若指定了 *fill* ，未包含在该窗口内的分组会按照 *fill* 指定的方式输出结果。\n\n**Note:** 当系统时间达到 sessionEnd + forceTriggerSessionEndTime 时触发计算，因此该参数在回放场景下不适用。\n\n**keyPurgeFreqInSec** 正整数，单位为秒。用于控制定期清理“窗口数据已为空”的分组对应的 key，从而避免 key 持续增长带来的内存占用。指定该参数后，如果当前数据注入时间与上一次清理时间的间隔 ≥ *keyPurgeFreqInSec*，则会删除当前窗口数据为空的分组及其对应的 key。\n\n**Note:**\n\n* 若需指定该参数，必须指定 *forceTriggerTime*，且不能指定 *fill*。\n\n* 可以通过调用 [getStreamEngineStat](https://docs.dolphindb.cn/zh/funcs/g/getStreamEngineStat.html) 函数查看 TimeSeriesEngine 引擎状态的 numGroups 列，来对比响应式状态引擎清理前后分组数的变化。\n\n**closed** 字符串，用于确定滑动窗口边界的开闭情况。可选值为 'left' 或 'right'，默认值为 'left'。\n\n* closed = 'left'： 窗口左闭右开。\n\n* closed = 'right'： 窗口左开右闭。\n\n**subWindow**整型或者 DURATION 数据对。在滑动窗口内指定子窗口，仅计算子窗口内的数据。子窗口边界的开闭情况由参数 *closed* 决定。子窗口结束后收到第一条数据触发对子窗口内数据的计算（参考例4）。当 *subWindow*为整型数据对时，其单位与 *timeColumn* 的时间精度一致。若指定 *subWindow*，则：\n\n* *windowSize*和 *step*必须相等。\n* 不可设置 *updateTime*>0和 *useSystemTime*=true。\n\n**parallelism** 为不超过 63 的正整数，可选参数，表示并行计算的工作线程数，默认值为 1。在计算量较大时，合理地调整该参数能够有效利用计算资源，降低计算耗时。建议小于机器核数，推荐值为 4 到 8 。\n\n**acceptedDelay** 正整数，可选参数。指定每个窗口接收数据的最大延迟，默认值为 0。若设置该参数，则不能设置 *forceTriggerTime* 或 *updateTime*。\n\n* 当 useSystemTime= true 时，*acceptedDelay* 必须小于等于 *windowSize*。在窗口结束后的 *acceptedDelay* 时间内接收到的数据，仍然属于此窗口并参与计算，而不会参与下一个窗口的计算。\n\n* 当 useSystemTime= false 时，该参数用于处理乱序数据。假设当前窗口结束的时间戳为 t ，若收到一条时间戳大于等于 t+*acceptedDelay*的数据，则触发在此之前收到的所有属于当前窗口的数据进行计算输出，并关闭该窗口。\n\n**keyPurgeDaily** 为可选参数，是一个布尔值。默认值为 true，表示引擎在收到第一批包含新日期的数据时，先清空之前保存的所有分组，再对这批新数据进行处理。若设置为 false，则引擎不会清理前一天的分组。\n\n#### 返回值\n\n返回一个 DStream 对象。\n\n#### 例子\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\n// 如已存在流图，则先销毁该流图\n// dropStreamGraph('DailyTimeSeries')\n\ng = createStreamGraph('DailyTimeSeries')\n\ng.source(\"trades\", `date`second`sym`volume, [DATE, SECOND, SYMBOL, INT])\n.dailyTimeSeriesEngine(windowSize=60, step=60, metrics=<[sum(volume)]>, sessionBegin=09:30:00 13:00:00, sessionEnd=11:30:00 15:00:00, timeColumn=`date`second, mergeSessionEnd=true)\n.sink(\"output\")\ng.submit()\ngo\n\ndates=take(date(2025.05.07),8)\nseconds=[09:25:31, 09:26:01, 09:30:02, 09:30:10, 11:29:46, 11:29:50, 11:30:00, 11:30:01]\nsyms=[\"A\", \"B\", \"A\", \"B\", \"A\", \"B\", \"B\", \"A\"]\nvolumes=[8, 10, 26, 14, 30, 11, 14, 4]\ntmp=table(dates as date, seconds as second, syms as sym, volumes as volume)\nappendOrcaStreamTable(\"trades\", tmp)\nselect * from orca_table.output\n```\n\n| concatDateTime      | sum\\_volume |\n| ------------------- | ----------- |\n| 2025.05.07 09:31:00 | 58          |\n| 2025.05.07 11:30:00 | 55          |\n"
    },
    "DStream::dualOwnershipReactiveStateEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/DStream_dualOwnershipReactiveStateEngine.html",
        "signatures": [
            {
                "full": "DStream::dualOwnershipReactiveStateEngine(metrics1, metrics2, keyColumn1, keyColumn2, [keyPurgeFilter1], [keyPurgeFilter2], [keyPurgeFreqInSecond=0])",
                "name": "DStream::dualOwnershipReactiveStateEngine",
                "parameters": [
                    {
                        "full": "metrics1",
                        "name": "metrics1"
                    },
                    {
                        "full": "metrics2",
                        "name": "metrics2"
                    },
                    {
                        "full": "keyColumn1",
                        "name": "keyColumn1"
                    },
                    {
                        "full": "keyColumn2",
                        "name": "keyColumn2"
                    },
                    {
                        "full": "[keyPurgeFilter1]",
                        "name": "keyPurgeFilter1",
                        "optional": true
                    },
                    {
                        "full": "[keyPurgeFilter2]",
                        "name": "keyPurgeFilter2",
                        "optional": true
                    },
                    {
                        "full": "[keyPurgeFreqInSecond=0]",
                        "name": "keyPurgeFreqInSecond",
                        "optional": true,
                        "default": "0"
                    }
                ]
            }
        ],
        "markdown": "### [DStream::dualOwnershipReactiveStateEngine](https://docs.dolphindb.cn/zh/funcs/d/DStream_dualOwnershipReactiveStateEngine.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nDStream::dualOwnershipReactiveStateEngine(metrics1, metrics2, keyColumn1, keyColumn2, \\[keyPurgeFilter1], \\[keyPurgeFilter2], \\[keyPurgeFreqInSecond=0])\n\n#### 详情\n\n创建流计算 Dual Ownership 响应式状态引擎。参考：[createDualOwnershipReactiveStateEngine](https://docs.dolphindb.cn/zh/funcs/c/createDualOwnershipReactiveStateEngine.html)。\n\n#### 参数\n\n`dualOwnershipReactiveStateEngine` 与 `reactiveStateEngine` 参数基本一致，这里仅介绍有区别的参数：\n\n对 *keyColumn1* 分组后的数据按照 *metrics1* 进行计算，分组数据的清条件则由参数 *keyPurgeFilter1* 设置。\n\n对 *keyColumn2* 分组后的数据按照 *metrics2* 进行计算，分组数据的清条件则由参数 *keyPurgeFilter2* 设置。\n\n#### 返回值\n\n返回一个 DStream 对象。\n\n#### 例子\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\n// 如已存在流图，则先销毁该流图\n// dropStreamGraph('dualOwnershipReactive')\n\ng = createStreamGraph('dualOwnershipReactive')\n\ng.source(\"trades\", `date`time`sym`market`price`qty, [DATE, TIME, SYMBOL, CHAR, DOUBLE, INT])\n.dualOwnershipReactiveStateEngine(metrics1=<mfirst(price, 3)>, metrics2=<mmax(price, 3)>, keyColumn1=`date`sym, keyColumn2=`date`market)\n.sink(\"output\")\ng.submit()\ngo\n\ndates=take(2012.01.01, 10) join take(2012.01.02, 4)\ntimes=[09:00:00.030, 09:00:00.030, 09:00:00.031, 09:00:00.031, 09:00:00.031, 09:00:00.033, 09:00:00.033, 09:00:00.034, 09:00:00.034, 09:00:00.035, 09:00:00.031, 09:00:00.032, 09:00:00.032, 09:00:00.040]\nsyms=[`a, `a, `b, `a, `a, `b, `a, `b, `b, `a, `b, `a, `b, `c]\nmarkets=['B', 'B', 'A', 'B', 'A', 'B', 'A', 'A', 'A', 'A', 'A', 'B', 'B', 'B']\nprices=[10.65, 10.59, 10.59, 10.65, 10.59, 10.59, 10.59, 10.59, 10.22, 11.0, 10.22, 11.0, 15.6, 13.2]\nqtys=[1500, 2500, 2500, 1500, 2500, 2500, 2500, 2500, 1200, 2500, 1200, 2500, 1300, 2000]\ntmp=table(dates as date, times as time, syms as sym, markets as market, prices as price, qtys as qty)\n\nappendOrcaStreamTable(\"trades\", tmp)\nselect * from orca_table.output\n```\n\n| date       | sym | market | mfirst\\_price | mmax\\_price |\n| ---------- | --- | ------ | ------------- | ----------- |\n| 2012.01.01 | a   | B      |               |             |\n| 2012.01.01 | a   | B      |               |             |\n| 2012.01.01 | b   | A      |               |             |\n| 2012.01.01 | a   | B      | 10.65         | 10.65       |\n| 2012.01.01 | a   | A      | 10.59         |             |\n| 2012.01.01 | b   | B      |               | 10.65       |\n| 2012.01.01 | a   | A      | 10.65         | 10.59       |\n| 2012.01.01 | b   | A      | 10.59         | 10.59       |\n| 2012.01.01 | b   | A      | 10.59         | 10.59       |\n| 2012.01.01 | a   | A      | 10.59         | 11          |\n"
    },
    "DStream::equalJoinEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/DStream_equalJoinEngine.html",
        "signatures": [
            {
                "full": "DStream::equalJoinEngine(rightStream, metrics, matchingColumn, timeColumn, [garbageSize=5000], [maxDelayedTime])",
                "name": "DStream::equalJoinEngine",
                "parameters": [
                    {
                        "full": "rightStream",
                        "name": "rightStream"
                    },
                    {
                        "full": "metrics",
                        "name": "metrics"
                    },
                    {
                        "full": "matchingColumn",
                        "name": "matchingColumn"
                    },
                    {
                        "full": "timeColumn",
                        "name": "timeColumn"
                    },
                    {
                        "full": "[garbageSize=5000]",
                        "name": "garbageSize",
                        "optional": true,
                        "default": "5000"
                    },
                    {
                        "full": "[maxDelayedTime]",
                        "name": "maxDelayedTime",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [DStream::equalJoinEngine](https://docs.dolphindb.cn/zh/funcs/d/DStream_equalJoinEngine.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nDStream::equalJoinEngine(rightStream, metrics, matchingColumn, timeColumn, \\[garbageSize=5000], \\[maxDelayedTime])\n\n#### 详情\n\n创建流计算等值连接引擎。参考：[createEquiJoinEngine](https://docs.dolphindb.cn/zh/funcs/c/createEquiJoinEngine.html)。\n\n#### 参数\n\n**rightStream** DStream 对象，表示输入的右表数据源。\n\n**metrics** 以元代码的格式表示计算指标，支持输入元组。有关元代码的更多信息可参考 [Metaprogramming](https://docs.dolphindb.cn/zh/progr/objs/meta_progr.html)。\n\n* 计算指标可以是一个或多个表达式、系统内置或用户自定义函数、一个常量标量/向量，但不能是聚合函数。当指定为常量向量时，对应的输出列必须设置为数组向量类型，例子参见 [createReactiveStateEngine](https://docs.dolphindb.cn/zh/funcs/c/createReactiveStateEngine.html) 中的例4。\n* *metrics* 内支持调用具有多个返回值的函数，且必须指定列名，例如 \\<func(price) as \\`col1\\`col2>。若在 *metrics* 指定了 *leftTable* 和 *rightTable* 中具有相同名称的列，默认取左表的列，可以通过 \"tableName.colName\" 指定该列来自哪个表。\n\n  **Note:** *metrics* 中使用的列名大小写不敏感，不需要与输入表的列名大小写保持一致。\n\n**matchingColumn** 表示连接列的字符串标量/向量/字符串组成的 tuple，支持 Integral, Temporal 或 Literal（UUID 除外）类型。*matchingColumn* 指定规则为：\n\n1. 只有一个连接列：当左表和右表的连接列名相同时，*matchingColumn* 是一个字符串标量，否则是一个长度为 2 的 tuple，例如：左表连接列名为 sym，右表连接列名为 sym1，则 *matchingColumn* = \\[\\[\\`sym],\\[\\`sym1]]。\n2. 有多个连接列：当左表和右表的连接列名相同时，*matchingColumn* 是一个字符串向量，否则是一个长度为 2 的 tuple，例如：左表连接列名为 orderNo, sym，右表连接列名为 orderNo, sym1，则 *matchingColumn* = \\[\\[\\`orderNo, \\`sym], \\[\\`orderNo,\\`sym1]]。\n\n**timeColumn** 字符串标量或向量。用于指定 *leftTable* 和 *rightTable* 中时间列的名称。两表的时间列名称可以不同，但数据类型需保持一致。当 *leftTable* 和 *rightTable* 时间列名称相同时，*timeColumn* 是字符串标量，否则，*timeColumn* 是长度为2的字符串向量。\n\n**garbageSize** 可选参数，正整数，默认值是 5,000（单位为行）。当内存中历史数据行数超过 *garbageSize* 时，会清理本次计算不需要的历史数据。\n\n1. 历史数据中已经 join 并输出的数据；\n2. 历史数据未发生 join 的数据，但其时间戳与 *leftTable* 或 *rightTable* 收到的最新数据的时间戳的差值大于 *maxDelayedTime*。\n\n**maxDelayedTime** 可选参数，正整数，单位同 *timeColumn* 精度一致，默认值为 3 秒。该参数仅在达到 *garbageSize* 清理条件时才会起效，表示引擎内能够保留最新多长时间的数据。详情参考上述清理条件 2。不建议设置 *maxDelayedTime* 值设置过小，否则可能导致一些需关联却没及时关联的数据被清理。\n\n#### 返回值\n\n返回一个 DStream 对象。\n\n#### 例子\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\n// 如已存在流图，则先销毁该流图\n// dropStreamGraph('joinEngine')\ng = createStreamGraph('joinEngine')\nr = g.source(\"right\", `time`sym`val, [SECOND, SYMBOL, DOUBLE])\ng.source(\"left\", `time`sym`price, [SECOND, SYMBOL, DOUBLE])\n    .equalJoinEngine(r, [<price>, <val>, <price*val>], `sym, `time)\n    .sink(\"output\")\ng.submit()\n\ngo\n\ntmp1=table(13:30:10+1..20 as time, take(`AAPL, 10) join take(`IBM, 10) as sym, double(1..20) as price)\nappendOrcaStreamTable(\"left\", tmp1)\n\ntmp2=table(13:30:10+1..20 as time, take(`AAPL, 10) join take(`IBM, 10) as sym, double(50..31) as val)\nappendOrcaStreamTable(\"right\", tmp2)\n\nselect * from orca_table.output\n```\n"
    },
    "DStream::fork": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/DStream_fork.html",
        "signatures": [
            {
                "full": "DStream::fork(count)",
                "name": "DStream::fork",
                "parameters": [
                    {
                        "full": "count",
                        "name": "count"
                    }
                ]
            }
        ],
        "markdown": "### [DStream::fork](https://docs.dolphindb.cn/zh/funcs/d/DStream_fork.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nDStream::fork(count)\n\n#### 详情\n\n生成多个流数据下游 DStream 分支（以广播方式复制数据），便于在不同分支中执行各自的处理逻辑。\n\n#### 参数\n\n**count** 整数，指定分叉数量。\n\n#### 返回值\n\n指定数量的 DStream 实例列表。\n\n#### 例子\n\n将 K 线数据复制两份，分别计算 1 分钟和 5 分钟级因子：\n\n```\nuse catalog test\n\ng = createStreamGraph(\"indicators\")\nsourceStreams = g.source(\"trade\", `symbol`datetime`price`volume, [SYMBOL, TIMESTAMP,DOUBLE, INT])\n    .fork(2)\nstream_1min = sourceStreams[0]\n    .timeSeriesEngine(60*1000, 60*1000, <[first(price),max(price),min(price),last(price),sum(volume)]>, \"datetime\", false, \"symbol\")\n    .reactiveStateEngine(<[datetime, first_price, max_price, min_price, last_price, sum_volume, mmax(max_price, 5), mavg(sum_volume, 5)]>, `symbol)\n    .sink(\"output_1min\")\nstream_5min = sourceStreams[1]\n    .timeSeriesEngine(5*60*1000, 5*60*1000, <[first(price),max(price),min(price),last(price),sum(volume)]>, \"datetime\", false, \"symbol\")\n    .reactiveStateEngine(<[datetime, first_price, max_price, min_price, last_price, sum_volume, mmax(max_price, 5), mavg(sum_volume, 5)]>, `symbol)\n    .sink(\"output_5min\")\ng.submit()\n```\n"
    },
    "DStream::getOutputSchema": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/DStream_getOutputSchema.html",
        "signatures": [
            {
                "full": "DStream::getOutputSchema()",
                "name": "DStream::getOutputSchema",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [DStream::getOutputSchema](https://docs.dolphindb.cn/zh/funcs/d/DStream_getOutputSchema.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nDStream::getOutputSchema()\n\n#### 详情\n\n返回当前 DStream 对象的表结构。\n\n#### 参数\n\n无\n\n#### 例子\n\n```\naggGraph = createStreamGraph(\"aggregation\")\nengine = aggGraph.source(\"trade\", `time`sym`price, [TIMESTAMP, SYMBOL, FLOAT])\n\t.timeSeriesEngine(windowSize=60, step=60, metrics=[<sum(price)>], \ntimeColumn=\"time\", keyColumn=\"sym\")\nengine.getOutputSchema()\n\n/* output:\ntime sym sum_price\n---- --- ---------\n*/\n```\n"
    },
    "Dstream::haBuffer": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/DStream_haBuffer.html",
        "signatures": [
            {
                "full": "DStream::haBuffer(name, raftGroup, cacheLimit, [retentionMinutes=1440])",
                "name": "DStream::haBuffer",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "raftGroup",
                        "name": "raftGroup"
                    },
                    {
                        "full": "cacheLimit",
                        "name": "cacheLimit"
                    },
                    {
                        "full": "[retentionMinutes=1440]",
                        "name": "retentionMinutes",
                        "optional": true,
                        "default": "1440"
                    }
                ]
            }
        ],
        "markdown": "### [Dstream::haBuffer](https://docs.dolphindb.cn/zh/funcs/d/DStream_haBuffer.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nDStream::haBuffer(name, raftGroup, cacheLimit, \\[retentionMinutes=1440])\n\n#### 详情\n\n创建一个高可用流数据表，用于存储流计算中间结果。参考 [haStreamTable](https://docs.dolphindb.cn/zh/funcs/h/haStreamTable.html)。\n\n#### 参数\n\n**name** 表示流表的名称。字符串标量，可以传入完整的流表全限定名（如 \"trading.orca\\_table.trades\"）；也可以仅提供流表名（如 \"trades\"），系统会根据当前的 catalog 设置自动补全为对应的全限定名。\n\n**raftGroup** 是一个大于1的整数，或者字符串。\n\n* 当为整数时，表示 Raft 组的 ID。\n* 当为字符串时，表示 Raft 组的别名（需事先通过 *streamingRaftGroupAliases* 配置 ）。\n\n**cacheSize** 是一个正整数，用于指定高可用流数据表在内存中最多保留多少行。如果 *cacheSize* 是小于1000的正整数，它会被自动调整为1000。\n\n**retentionMinutes** 可选参数，整数，用于指定保留大小超过 1GB 的 log 文件的时间（从文件的最后修改时间开始计算），单位是分钟。默认值是1440，即一天。\n\n#### 返回值\n\n一个 DStream 对象。\n\n#### 例子\n\n```\nlogin(`admin,`123456)\n\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\ng = createStreamGraph(\"indicators\")\n\ng.source(\"trade\", `time`symbol`price`volume, [DATETIME,SYMBOL,DOUBLE,LONG])\n    .timeSeriesEngine(windowSize=60, step=60, metrics=[<first(price) as open>, <max(price) as high>, <min(price) as low>, <last(price) as close>, <sum(volume) as volume>], timeColumn=`time, keyColumn=`symbol)\n    .haBuffer(name=\"ha_Table\", raftGroup=3, cacheLimit=5)\n```\n"
    },
    "Dstream::haKeyedBuffer": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/DStream_haKeyedBuffer.html",
        "signatures": [
            {
                "full": "DStream::haKeyedBuffer(name, keyColumn, raftGroup, cacheLimit, [retentionMinutes=1440])",
                "name": "DStream::haKeyedBuffer",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "keyColumn",
                        "name": "keyColumn"
                    },
                    {
                        "full": "raftGroup",
                        "name": "raftGroup"
                    },
                    {
                        "full": "cacheLimit",
                        "name": "cacheLimit"
                    },
                    {
                        "full": "[retentionMinutes=1440]",
                        "name": "retentionMinutes",
                        "optional": true,
                        "default": "1440"
                    }
                ]
            }
        ],
        "markdown": "### [Dstream::haKeyedBuffer](https://docs.dolphindb.cn/zh/funcs/d/DStream_haKeyedBuffer.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nDStream::haKeyedBuffer(name, keyColumn, raftGroup, cacheLimit, \\[retentionMinutes=1440])\n\n#### 详情\n\n创建一个高可用键值流数据表，用于存储流计算中间结果。参考 [haStreamTable](https://docs.dolphindb.cn/zh/funcs/h/haStreamTable.html)。\n\n#### 参数\n\n**name** 表示流表的名称。字符串标量，可以传入完整的流表全限定名（如 \"trading.orca\\_table.trades\"）；也可以仅提供流表名（如 \"trades\"），系统会根据当前的 catalog 设置自动补全为对应的全限定名。\n\n**keyColumn** 字符串标量或向量，指定主键列。\n\n**raftGroup** 是一个大于1的整数，或者字符串。\n\n* 当为整数时，表示 Raft 组的 ID。\n* 当为字符串时，表示 Raft 组的别名（需事先通过 *streamingRaftGroupAliases* 配置 ）。\n\n**cacheSize** 是一个正整数，用于指定高可用流数据表在内存中最多保留多少行。如果 *cacheSize* 是小于1000的正整数，它会被自动调整为1000。\n\n**retentionMinutes** 可选参数，整数，用于指定保留大小超过 1GB 的 log 文件的时间（从文件的最后修改时间开始计算），单位是分钟。默认值是1440，即一天。\n\n#### 返回值\n\n一个 DStream 对象。\n\n#### 例子\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\ng = createStreamGraph(\"indicators\")\n\ng.source(\"trade\", `time`symbol`price`volume, [DATETIME,SYMBOL,DOUBLE,LONG])\n    .timeSeriesEngine(windowSize=60, step=60, metrics=[<first(price) as open>, <max(price) as high>, <min(price) as low>, <last(price) as close>, <sum(volume) as volume>], timeColumn=`time, keyColumn=`symbol)\n    .haKeyedBuffer(name=\"ha_keyedTable\", keyColumn=`symbol, raftGroup=3, cacheLimit=5000)\n```\n"
    },
    "DStream::haKeyedSink": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/DStream_haKeyedSink.html",
        "signatures": [
            {
                "full": "DStream::haKeyedSink(name, keyColumn, raftGroup, cacheLimit, [retentionMinutes=1440])",
                "name": "DStream::haKeyedSink",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "keyColumn",
                        "name": "keyColumn"
                    },
                    {
                        "full": "raftGroup",
                        "name": "raftGroup"
                    },
                    {
                        "full": "cacheLimit",
                        "name": "cacheLimit"
                    },
                    {
                        "full": "[retentionMinutes=1440]",
                        "name": "retentionMinutes",
                        "optional": true,
                        "default": "1440"
                    }
                ]
            }
        ],
        "markdown": "### [DStream::haKeyedSink](https://docs.dolphindb.cn/zh/funcs/d/DStream_haKeyedSink.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nDStream::haKeyedSink(name, keyColumn, raftGroup, cacheLimit, \\[retentionMinutes=1440])\n\n#### 详情\n\n将流数据输出到高可用键值流数据表。\n\n有关最新高可用流数据表的更多信息，请参阅 [haStreamTable](https://docs.dolphindb.cn/zh/funcs/h/haStreamTable.html) 手册。\n\n#### 参数\n\n**name** 字符串，指定目标表名。\n\n**keyColumn** 字符串标量或向量，指定主键列。\n\n**raftGroup** 是一个大于1的整数，或者字符串。\n\n* 当为整数时，表示 Raft 组的 ID。\n* 当为字符串时，表示 Raft 组的别名（需事先通过 *streamingRaftGroupAliases* 配置 ）。\n\n**cacheSize** 是一个正整数，用于指定高可用流数据表在内存中最多保留多少行。如果 *cacheSize* 是小于1000的正整数，它会被自动调整为1000。\n\n**retentionMinutes** 可选参数，整数，用于指定保留大小超过 1GB 的 log 文件的时间（从文件的最后修改时间开始计算），单位是分钟。默认值是1440，即一天。\n\n#### 返回值\n\nDStream 对象。\n"
    },
    "DStream::haSink": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/DStream_haSink.html",
        "signatures": [
            {
                "full": "DStream::haSink(name, raftGroup, cacheLimit, [retentionMinutes=1440])",
                "name": "DStream::haSink",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "raftGroup",
                        "name": "raftGroup"
                    },
                    {
                        "full": "cacheLimit",
                        "name": "cacheLimit"
                    },
                    {
                        "full": "[retentionMinutes=1440]",
                        "name": "retentionMinutes",
                        "optional": true,
                        "default": "1440"
                    }
                ]
            }
        ],
        "markdown": "### [DStream::haSink](https://docs.dolphindb.cn/zh/funcs/d/DStream_haSink.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nDStream::haSink(name, raftGroup, cacheLimit, \\[retentionMinutes=1440])\n\n#### 详情\n\n将流数据输出到高可用流数据表。\n\n有关最新高可用流数据表的更多信息，请参阅 [haStreamTable](https://docs.dolphindb.cn/zh/funcs/h/haStreamTable.html) 手册。\n\n#### 参数\n\n**name** 字符串，指定目标表名。\n\n**raftGroup** 是一个大于1的整数，或者字符串。\n\n* 当为整数时，表示 Raft 组的 ID。\n* 当为字符串时，表示 Raft 组的别名（需事先通过 *streamingRaftGroupAliases* 配置 ）。\n\n**cacheSize** 是一个正整数，用于指定高可用流数据表在内存中最多保留多少行。如果 *cacheSize* 是小于1000的正整数，它会被自动调整为1000。\n\n**retentionMinutes** 可选参数，整数，用于指定保留大小超过 1GB 的 log 文件的时间（从文件的最后修改时间开始计算），单位是分钟。默认值是1440，即一天。\n\n#### 返回值\n\nDStream 对象。\n"
    },
    "Dstream::keyedBuffer": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/DStream_keyedBuffer.html",
        "signatures": [
            {
                "full": "DStream::keyedBuffer(name, keyColumn, [asyncWrite=true], [compress=true], [cacheSize], [retentionMinutes=1440], [flushMode=0], [preCache], [cachePurgeTimeColumn], [cachePurgeInterval], [cacheRetentionTime])",
                "name": "DStream::keyedBuffer",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "keyColumn",
                        "name": "keyColumn"
                    },
                    {
                        "full": "[asyncWrite=true]",
                        "name": "asyncWrite",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[compress=true]",
                        "name": "compress",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[cacheSize]",
                        "name": "cacheSize",
                        "optional": true
                    },
                    {
                        "full": "[retentionMinutes=1440]",
                        "name": "retentionMinutes",
                        "optional": true,
                        "default": "1440"
                    },
                    {
                        "full": "[flushMode=0]",
                        "name": "flushMode",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[preCache]",
                        "name": "preCache",
                        "optional": true
                    },
                    {
                        "full": "[cachePurgeTimeColumn]",
                        "name": "cachePurgeTimeColumn",
                        "optional": true
                    },
                    {
                        "full": "[cachePurgeInterval]",
                        "name": "cachePurgeInterval",
                        "optional": true
                    },
                    {
                        "full": "[cacheRetentionTime]",
                        "name": "cacheRetentionTime",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [Dstream::keyedBuffer](https://docs.dolphindb.cn/zh/funcs/d/DStream_keyedBuffer.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nDStream::keyedBuffer(name, keyColumn, \\[asyncWrite=true], \\[compress=true], \\[cacheSize], \\[retentionMinutes=1440], \\[flushMode=0], \\[preCache], \\[cachePurgeTimeColumn], \\[cachePurgeInterval], \\[cacheRetentionTime])\n\n#### 详情\n\n创建一个持久化键值流数据表，用于存储流计算中间结果。参考 [keyedStreamTable](https://docs.dolphindb.cn/zh/funcs/k/keyedStreamTable.html)。\n\n#### 参数\n\n**name** 表示流表的名称。字符串标量，可以传入完整的流表全限定名（如 \"trading.orca\\_table.trades\"）；也可以仅提供流表名（如 \"trades\"），系统会根据当前的 catalog 设置自动补全为对应的全限定名。\n\n**keyColumn** 字符串标量或向量，指定主键列。\n\n**asyncWrite** 可选参数，是一个布尔值，表示是否异步持久化数据到磁盘。默认值为 true，流数据写入内存即为写入成功，持久化到磁盘的操作将会由另一个线程执行。\n\n**Note:**\n\n持久化数据到磁盘包含两个步骤：\n\n* 写内存数据到操作系统缓存\n\n* 写缓存数据到磁盘（是否开启同步刷盘由参数 *flushMode* 决定）\n\n**compress** 可选参数，是一个布尔值，表示是否以压缩模式模式保存至磁盘。默认值为 true。\n\n**cacheSize** 可选参数，整数，表示流数据表在内存中最多保留多少行。如果未指定该参数，则所有记录行都会保存在内存中。如果 *cacheSize* 小于 1000，它会被自动调整为 1000。\n\n**retentionMinutes** 可选参数，是一个整数，表示文件大小超过 1GB的 log 文件的保留时间(从文件的最后修改时间开始计算)，单位是分钟。默认值是 1440，即一天。如果 log 文件未达 1GB，则会一直保留至大小达到 1GB。\n\n**flushMode** 可选参数，是一个整数，表示是否开启同步刷盘，取值只能为 0 或 1。默认值是 0，表示异步刷盘，内存中的流数据写入操作系统缓存即为写入成功，并进行下一批数据的写入。 若为 1，则表示同步刷盘，当前批次的流数据必须落盘完成，才会进行下一批数据的写入。\n\n**preCache** 可选参数，是一个整数，表示从磁盘加载到内存的记录条数。如果没有指定该参数，重启后实际加载到内存的数据量受 *cacheSize* 限制。\n\n**cachePurgeTimeColumn** 可选参数，字符串标量，需要指定为持久化流表中的时间列名称。\n\n**cachePurgeInterval** 可选参数，DURATION 类型标量，表示触发清理内存中数据的时间间隔。\n\n**cacheRetentionTime** 可选参数，DURATION 类型标量，表示内存中数据的最长保留期限。\n\n#### 返回值\n\n一个 DStream 对象。\n\n#### 例子\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\ng = createStreamGraph(\"indicators\")\n\ng.source(\"trade\", `time`symbol`price`volume, [DATETIME,SYMBOL,DOUBLE,LONG])\n    .timeSeriesEngine(windowSize=60, step=60, metrics=[<first(price) as open>, <max(price) as high>, <min(price) as low>, <last(price) as close>, <sum(volume) as volume>], timeColumn=`time, keyColumn=`symbol)\n    .keyedBuffer(name=\"bufferTable\", keyColumn=\"symbol\")\n```\n"
    },
    "DStream::keyedSink": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/DStream_keyedSink.html",
        "signatures": [
            {
                "full": "DStream::keyedSink(name, keyColumn, [asyncWrite=true], [compress=true], [cacheSize], [retentionMinutes=1440], [flushMode=0], [preCache], [cachePurgeTimeColumn], [cachePurgeInterval], [cacheRetentionTime])",
                "name": "DStream::keyedSink",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "keyColumn",
                        "name": "keyColumn"
                    },
                    {
                        "full": "[asyncWrite=true]",
                        "name": "asyncWrite",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[compress=true]",
                        "name": "compress",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[cacheSize]",
                        "name": "cacheSize",
                        "optional": true
                    },
                    {
                        "full": "[retentionMinutes=1440]",
                        "name": "retentionMinutes",
                        "optional": true,
                        "default": "1440"
                    },
                    {
                        "full": "[flushMode=0]",
                        "name": "flushMode",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[preCache]",
                        "name": "preCache",
                        "optional": true
                    },
                    {
                        "full": "[cachePurgeTimeColumn]",
                        "name": "cachePurgeTimeColumn",
                        "optional": true
                    },
                    {
                        "full": "[cachePurgeInterval]",
                        "name": "cachePurgeInterval",
                        "optional": true
                    },
                    {
                        "full": "[cacheRetentionTime]",
                        "name": "cacheRetentionTime",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [DStream::keyedSink](https://docs.dolphindb.cn/zh/funcs/d/DStream_keyedSink.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nDStream::keyedSink(name, keyColumn, \\[asyncWrite=true], \\[compress=true], \\[cacheSize], \\[retentionMinutes=1440], \\[flushMode=0], \\[preCache], \\[cachePurgeTimeColumn], \\[cachePurgeInterval], \\[cacheRetentionTime])\n\n#### 详情\n\n将流数据输出至持久化键值流数据表。\n\n有关键值流数据表的更多信息，请参阅 [keyedStreamTable](https://docs.dolphindb.cn/zh/funcs/k/keyedStreamTable.html) 手册。\n\n#### 参数\n\n**name** 字符串，指定目标表名。\n\n**keyColumn** 字符串标量或向量，指定主键列。\n\n**asyncWrite** 可选参数，是一个布尔值，表示是否异步持久化数据到磁盘。默认值为 true，流数据写入内存即为写入成功，持久化到磁盘的操作将会由另一个线程执行。\n\n**Note:**\n\n持久化数据到磁盘包含两个步骤：\n\n* 写内存数据到操作系统缓存\n\n* 写缓存数据到磁盘（是否开启同步刷盘由参数 *flushMode* 决定）\n\n**compress** 可选参数，是一个布尔值，表示是否以压缩模式模式保存至磁盘。默认值为 true。\n\n**cacheSize** 可选参数，整数，表示流数据表在内存中最多保留多少行。如果未指定该参数，则所有记录行都会保存在内存中。如果 *cacheSize* 小于 1000，它会被自动调整为 1000。\n\n**retentionMinutes** 可选参数，是一个整数，表示文件大小超过 1GB的 log 文件的保留时间(从文件的最后修改时间开始计算)，单位是分钟。默认值是 1440，即一天。如果 log 文件未达 1GB，则会一直保留至大小达到 1GB。\n\n**flushMode** 可选参数，是一个整数，表示是否开启同步刷盘，取值只能为 0 或 1。默认值是 0，表示异步刷盘，内存中的流数据写入操作系统缓存即为写入成功，并进行下一批数据的写入。 若为 1，则表示同步刷盘，当前批次的流数据必须落盘完成，才会进行下一批数据的写入。\n\n**preCache** 可选参数，是一个整数，表示从磁盘加载到内存的记录条数。如果没有指定该参数，重启后实际加载到内存的数据量受 *cacheSize* 限制。\n\n**cachePurgeTimeColumn** 可选参数，字符串标量，需要指定为持久化流表中的时间列名称。\n\n**cachePurgeInterval** 可选参数，DURATION 类型标量，表示触发清理内存中数据的时间间隔。\n\n**cacheRetentionTime** 可选参数，DURATION 类型标量，表示内存中数据的最长保留期限。\n\n#### 返回值\n\n返回一个 DStream 对象。\n"
    },
    "Dstream::latestKeyedBuffer": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/DStream_latestKeyedBuffer.html",
        "signatures": [
            {
                "full": "DStream::latestKeyedBuffer(name, keyColumn, timeColumn, [asyncWrite=true], [compress=true], [cacheSize], [retentionMinutes=1440], [flushMode=0], [preCache], [cachePurgeTimeColumn], [cachePurgeInterval], [cacheRetentionTime])",
                "name": "DStream::latestKeyedBuffer",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "keyColumn",
                        "name": "keyColumn"
                    },
                    {
                        "full": "timeColumn",
                        "name": "timeColumn"
                    },
                    {
                        "full": "[asyncWrite=true]",
                        "name": "asyncWrite",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[compress=true]",
                        "name": "compress",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[cacheSize]",
                        "name": "cacheSize",
                        "optional": true
                    },
                    {
                        "full": "[retentionMinutes=1440]",
                        "name": "retentionMinutes",
                        "optional": true,
                        "default": "1440"
                    },
                    {
                        "full": "[flushMode=0]",
                        "name": "flushMode",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[preCache]",
                        "name": "preCache",
                        "optional": true
                    },
                    {
                        "full": "[cachePurgeTimeColumn]",
                        "name": "cachePurgeTimeColumn",
                        "optional": true
                    },
                    {
                        "full": "[cachePurgeInterval]",
                        "name": "cachePurgeInterval",
                        "optional": true
                    },
                    {
                        "full": "[cacheRetentionTime]",
                        "name": "cacheRetentionTime",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [Dstream::latestKeyedBuffer](https://docs.dolphindb.cn/zh/funcs/d/DStream_latestKeyedBuffer.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nDStream::latestKeyedBuffer(name, keyColumn, timeColumn, \\[asyncWrite=true], \\[compress=true], \\[cacheSize], \\[retentionMinutes=1440], \\[flushMode=0], \\[preCache], \\[cachePurgeTimeColumn], \\[cachePurgeInterval], \\[cacheRetentionTime])\n\n#### 详情\n\n创建一个最新值键值流数据表，用于存储流计算中间结果。参考 [latestKeyedStreamTable](https://docs.dolphindb.cn/zh/funcs/l/latestkeyedstreamtable.html)。\n\n#### 参数\n\n**name** 表示流表的名称。字符串标量，可以传入完整的流表全限定名（如 \"trading.orca\\_table.trades\"）；也可以仅提供流表名（如 \"trades\"），系统会根据当前的 catalog 设置自动补全为对应的全限定名。\n\n**keyColumn** 是一个字符串或向量，表示主键。主键的数据类型必须属于以下类别：INTEGRAL, TEMPORAL, LITERAL 或 FLOATING。\n\n**timeColumn** 字符串标量或长度为 2 的向量，分别用于指定 1 个或 2 个时间列。当仅指定 1 个时间列时，该列可以为整型或时间类型；当指定 2 个时间列时，第 1 列必须是 DATE 类型，第 2 列则是 TIME, SECOND 或 NANOTIME 类型。通过这两列，可以共同确定唯一的时间值。\n\n**asyncWrite** 可选参数，是一个布尔值，表示是否异步持久化数据到磁盘。默认值为 true，流数据写入内存即为写入成功，持久化到磁盘的操作将会由另一个线程执行。\n\n**Note:**\n\n持久化数据到磁盘包含两个步骤：\n\n* 写内存数据到操作系统缓存\n\n* 写缓存数据到磁盘（是否开启同步刷盘由参数 *flushMode* 决定）\n\n**compress** 可选参数，是一个布尔值，表示是否以压缩模式模式保存至磁盘。默认值为 true。\n\n**cacheSize** 可选参数，整数，表示流数据表在内存中最多保留多少行。如果未指定该参数，则所有记录行都会保存在内存中。如果 *cacheSize* 小于 1000，它会被自动调整为 1000。\n\n**retentionMinutes** 可选参数，是一个整数，表示文件大小超过 1GB的 log 文件的保留时间(从文件的最后修改时间开始计算)，单位是分钟。默认值是 1440，即一天。如果 log 文件未达 1GB，则会一直保留至大小达到 1GB。\n\n**flushMode** 可选参数，是一个整数，表示是否开启同步刷盘，取值只能为 0 或 1。默认值是 0，表示异步刷盘，内存中的流数据写入操作系统缓存即为写入成功，并进行下一批数据的写入。 若为 1，则表示同步刷盘，当前批次的流数据必须落盘完成，才会进行下一批数据的写入。\n\n**preCache** 可选参数，是一个整数，表示从磁盘加载到内存的记录条数。如果没有指定该参数，重启后实际加载到内存的数据量受 *cacheSize* 限制。\n\n**cachePurgeTimeColumn** 可选参数，字符串标量，需要指定为持久化流表中的时间列名称。\n\n**cachePurgeInterval** 可选参数，DURATION 类型标量，表示触发清理内存中数据的时间间隔。\n\n**cacheRetentionTime** 可选参数，DURATION 类型标量，表示内存中数据的最长保留期限。\n\n#### 返回值\n\n返回一个 DStream 对象。\n\n#### 例子\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\ng = createStreamGraph(\"indicators\")\n\ng.source(\"trade\", `time`symbol`price`volume, [DATETIME,SYMBOL,DOUBLE,LONG])\n    .timeSeriesEngine(windowSize=60, step=60, metrics=[<first(price) as open>, <max(price) as high>, <min(price) as low>, <last(price) as close>, <sum(volume) as volume>], timeColumn=`time, keyColumn=`symbol)\n    .latestKeyedBuffer(name=\"bufferTable\", keyColumn=\"symbol\", timeColumn=`time)\n```\n"
    },
    "DStream::latestKeyedSink": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/DStream_latestKeyedSink.html",
        "signatures": [
            {
                "full": "DStream::latestKeyedSink(name, keyColumn, timeColumn, [asyncWrite=true], [compress=true], [cacheSize], [retentionMinutes=1440], [flushMode=0], [preCache], [cachePurgeTimeColumn], [cachePurgeInterval], [cacheRetentionTime])",
                "name": "DStream::latestKeyedSink",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "keyColumn",
                        "name": "keyColumn"
                    },
                    {
                        "full": "timeColumn",
                        "name": "timeColumn"
                    },
                    {
                        "full": "[asyncWrite=true]",
                        "name": "asyncWrite",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[compress=true]",
                        "name": "compress",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[cacheSize]",
                        "name": "cacheSize",
                        "optional": true
                    },
                    {
                        "full": "[retentionMinutes=1440]",
                        "name": "retentionMinutes",
                        "optional": true,
                        "default": "1440"
                    },
                    {
                        "full": "[flushMode=0]",
                        "name": "flushMode",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[preCache]",
                        "name": "preCache",
                        "optional": true
                    },
                    {
                        "full": "[cachePurgeTimeColumn]",
                        "name": "cachePurgeTimeColumn",
                        "optional": true
                    },
                    {
                        "full": "[cachePurgeInterval]",
                        "name": "cachePurgeInterval",
                        "optional": true
                    },
                    {
                        "full": "[cacheRetentionTime]",
                        "name": "cacheRetentionTime",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [DStream::latestKeyedSink](https://docs.dolphindb.cn/zh/funcs/d/DStream_latestKeyedSink.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nDStream::latestKeyedSink(name, keyColumn, timeColumn, \\[asyncWrite=true], \\[compress=true], \\[cacheSize], \\[retentionMinutes=1440], \\[flushMode=0], \\[preCache], \\[cachePurgeTimeColumn], \\[cachePurgeInterval], \\[cacheRetentionTime])\n\n#### 详情\n\n将流数据输出到最新键值流表。该表根据时间戳决定是否更新记录。\n\n有关最新键值流数据表的更多信息，请参阅 [latestKeyedStreamTable](https://docs.dolphindb.cn/zh/funcs/l/latestkeyedstreamtable.html) 手册。\n\n#### 参数\n\n**name** 字符串，指定目标表名。\n\n**keyColumn** 是一个字符串或向量，表示主键。主键的数据类型必须属于以下类别：INTEGRAL, TEMPORAL, LITERAL 或 FLOATING。\n\n**timeColumn** 字符串标量或长度为 2 的向量，分别用于指定 1 个或 2 个时间列。当仅指定 1 个时间列时，该列可以为整型或时间类型；当指定 2 个时间列时，第 1 列必须是 DATE 类型，第 2 列则是 TIME, SECOND 或 NANOTIME 类型。通过这两列，可以共同确定唯一的时间值。\n\n**asyncWrite** 可选参数，是一个布尔值，表示是否异步持久化数据到磁盘。默认值为 true，流数据写入内存即为写入成功，持久化到磁盘的操作将会由另一个线程执行。\n\n**Note:**\n\n持久化数据到磁盘包含两个步骤：\n\n* 写内存数据到操作系统缓存\n\n* 写缓存数据到磁盘（是否开启同步刷盘由参数 *flushMode* 决定）\n\n**compress** 可选参数，是一个布尔值，表示是否以压缩模式模式保存至磁盘。默认值为 true。\n\n**cacheSize** 可选参数，整数，表示流数据表在内存中最多保留多少行。如果未指定该参数，则所有记录行都会保存在内存中。如果 *cacheSize* 小于 1000，它会被自动调整为 1000。\n\n**retentionMinutes** 可选参数，是一个整数，表示文件大小超过 1GB的 log 文件的保留时间(从文件的最后修改时间开始计算)，单位是分钟。默认值是 1440，即一天。如果 log 文件未达 1GB，则会一直保留至大小达到 1GB。\n\n**flushMode** 可选参数，是一个整数，表示是否开启同步刷盘，取值只能为 0 或 1。默认值是 0，表示异步刷盘，内存中的流数据写入操作系统缓存即为写入成功，并进行下一批数据的写入。 若为 1，则表示同步刷盘，当前批次的流数据必须落盘完成，才会进行下一批数据的写入。\n\n**preCache** 可选参数，是一个整数，表示从磁盘加载到内存的记录条数。如果没有指定该参数，重启后实际加载到内存的数据量受 *cacheSize* 限制。\n\n**cachePurgeTimeColumn** 可选参数，字符串标量，需要指定为持久化流表中的时间列名称。\n\n**cachePurgeInterval** 可选参数，DURATION 类型标量，表示触发清理内存中数据的时间间隔。\n\n**cacheRetentionTime** 可选参数，DURATION 类型标量，表示内存中数据的最长保留期限。\n\n#### 返回值\n\n返回一个 DStream 对象。\n"
    },
    "DStream::leftSemiJoinEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/DStream_leftSemiJoinEngine.html",
        "signatures": [
            {
                "full": "DStream::leftSemiJoinEngine(rightStream, metrics, matchingColumn, [garbageSize=5000], [updateRightTable=false])",
                "name": "DStream::leftSemiJoinEngine",
                "parameters": [
                    {
                        "full": "rightStream",
                        "name": "rightStream"
                    },
                    {
                        "full": "metrics",
                        "name": "metrics"
                    },
                    {
                        "full": "matchingColumn",
                        "name": "matchingColumn"
                    },
                    {
                        "full": "[garbageSize=5000]",
                        "name": "garbageSize",
                        "optional": true,
                        "default": "5000"
                    },
                    {
                        "full": "[updateRightTable=false]",
                        "name": "updateRightTable",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [DStream::leftSemiJoinEngine](https://docs.dolphindb.cn/zh/funcs/d/DStream_leftSemiJoinEngine.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nDStream::leftSemiJoinEngine(rightStream, metrics, matchingColumn, \\[garbageSize=5000], \\[updateRightTable=false])\n\n#### 详情\n\n创建流计算左半等值连接引擎。参考：[createLeftSemiJoinEngine](https://docs.dolphindb.cn/zh/funcs/c/createLeftSemiJoinEngine.html)。\n\n#### 参数\n\n**rightStream** DStream 对象，表示输入的右表数据源。\n\n**metrics** 以元代码的格式表示计算指标，支持输入元组。有关元代码的更多信息可参考 [Metaprogramming](https://docs.dolphindb.cn/zh/progr/objs/meta_progr.html)。\n\n* 计算指标可以是一个或多个表达式、系统内置或用户自定义函数、一个常量标量/向量。当指定为常量向量时，对应的输出列必须设置为数组向量类型，例子参见 [createReactiveStateEngine](https://docs.dolphindb.cn/zh/funcs/c/createReactiveStateEngine.html) 中的例4。\n* **metrics** 内支持调用具有多个返回值的函数，且必须指定列名，例如 \\<func(price) as \\`col1\\`col2>。\n\n  若在 *metrics* 指定了 *leftTable* 和 *rightTable* 中具有相同名称的列，默认取左表的列，可以通过 \"tableName.colName\" 指定该列来自哪个表。\n\n  **Note:** *metrics* 中使用的列名大小写不敏感，不需要与输入表的列名大小写保持一致。\n\n**matchingColumn** 表示连接列的字符串标量/向量或字符串向量组成的 tuple，支持 Integral, Temporal 或 Literal(UUID 除外)类型。\n\n1. 只有一个连接列。当左表和右表的连接列名相同时，*matchingColumn* 是一个字符串标量，否则是一个长度为 2 的 tuple。例如：左表连接列名为 sym，右表连接列名为 sym1，则 *matchingColumn* = \\[\\[\\`sym],\\[\\`sym1]]。\n2. 有多个连接列。当左表和右表的连接列名相同时，*matchingColumn* 是一个字符串向量，否则是一个长度为 2 的 tuple。例如：左表连接列名为 timestamp, sym，右表连接列名为 timestamp, sym1，则 *matchingColumn* = \\[\\[\\`timestamp, \\`sym], \\[\\`timestamp,\\`sym1]]。\n\n**garbageSize** 可选参数，正整数，默认值是 5,000（单位为行）。和其他连接引擎不同，该函数的 *garbageSize* 参数只用于清理左表的历史数据。当左表发生过 join 的记录数超过 *garbageSize* 时，系统会触发清理。\n\n**updateRightTable** 可选参数，布尔值，默认为 false，表示右表存在多条相同 *matchingColumn* 的记录时，是保留第一条（false）还是最新一条记录（true）。\n\n#### 返回值\n\n返回一个 DStream 对象。\n\n#### 例子\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\n// 如已存在流图，则先销毁该流图\n// dropStreamGraph('joinEngine')\ng = createStreamGraph('joinEngine')\n\nr = g.source(\"right\", `time`sym1`vol, [TIMESTAMP, SYMBOL, INT])\ng.source(\"left\", `time`sym`price, [TIMESTAMP, SYMBOL, DOUBLE])\n    .leftSemiJoinEngine(r, metrics=<[price, vol,price*vol]>, matchingColumn=[[`time,`sym], [`time,`sym1]], updateRightTable=true)\n    .sink(\"output\")\ng.submit()\n\ngo\n\nv = [1, 5, 10, 15]\ntmp1=table(2012.01.01T00:00:00.000+v as time, take(`AAPL, 4) as sym, rand(100,4) as price)\nappendOrcaStreamTable(\"left\", tmp1)\n\nv = [1, 1, 3, 4, 5, 5, 5, 15]\ntmp2=table(2012.01.01T00:00:00.000+v as time, take(`AAPL, 8) as sym, rand(100,8) as vol)\nappendOrcaStreamTable(\"right\", tmp2)\n\nselect * from orca_table.output\n```\n\n| time                    | sym  | price | vol | price\\_mul |\n| ----------------------- | ---- | ----- | --- | ---------- |\n| 2012.01.01 00:00:00.001 | AAPL | 36    | 62  | 2,232      |\n| 2012.01.01 00:00:00.005 | AAPL | 82    | 35  | 2,870      |\n| 2012.01.01 00:00:00.015 | AAPL | 60    | 23  | 1,380      |\n"
    },
    "DStream::lookupJoinEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/DStream_lookupJoinEngine.html",
        "signatures": [
            {
                "full": "DStream::lookupJoinEngine(rightStream, metrics, matchingColumn, [rightTimeColumn], [checkTimes], [keepDuplicates=false])",
                "name": "DStream::lookupJoinEngine",
                "parameters": [
                    {
                        "full": "rightStream",
                        "name": "rightStream"
                    },
                    {
                        "full": "metrics",
                        "name": "metrics"
                    },
                    {
                        "full": "matchingColumn",
                        "name": "matchingColumn"
                    },
                    {
                        "full": "[rightTimeColumn]",
                        "name": "rightTimeColumn",
                        "optional": true
                    },
                    {
                        "full": "[checkTimes]",
                        "name": "checkTimes",
                        "optional": true
                    },
                    {
                        "full": "[keepDuplicates=false]",
                        "name": "keepDuplicates",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [DStream::lookupJoinEngine](https://docs.dolphindb.cn/zh/funcs/d/DStream_lookupJoinEngine.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nDStream::lookupJoinEngine(rightStream, metrics, matchingColumn, \\[rightTimeColumn], \\[checkTimes], \\[keepDuplicates=false])\n\n#### 详情\n\n创建流计算 lookup join 引擎。参考：[createLookupJoinEngine](https://docs.dolphindb.cn/zh/funcs/c/createLookupJoinEngine.html)。\n\n#### 参数\n\n**rightStream** DStream 对象，表示输入的右表数据源。\n\n**metrics** 可选参数，以元代码的格式表示计算指标，支持输入元组。有关元代码的更多信息可参考 [Metaprogramming](https://docs.dolphindb.cn/zh/progr/objs/meta_progr.html)。\n\n* 计算指标可以是一个或多个表达式、系统内置或用户自定义函数、一个常量标量/向量，但不能是聚合函数。当指定为常量向量时，对应的输出列必须设置为数组向量类型，例子参见 [createReactiveStateEngine](https://docs.dolphindb.cn/zh/funcs/c/createReactiveStateEngine.html) 中的例4。\n* *metrics* 内支持调用具有多个返回值的函数，且必须指定列名，例如 \\<func(price) as \\`col1\\`col2>。\n* 若在 *metrics* 指定了 *leftTable* 和 *rightTable* 中具有相同名称的列，默认取左表的列，可以通过 \"tableName.colName\" 指定该列来自哪个表。\n\n  **Note:** *metrics* 中使用的列名大小写不敏感，不需要与输入表的列名大小写保持一致。\n\n**matchingColumn** 可选参数，表示连接列的字符串标量/向量或字符串向量组成的 tuple，支持 Integral, Temporal 或 Literal(UUID 除外)类型。*matchingColumn* 指定规则：\n\n1. 只有一个连接列。当左表和右表的连接列名相同时，*matchingColumn* 是一个字符串标量，否则是一个长度为 2 的 tuple。例如：左表连接列名为 sym，右表连接列名为 sym1，则 *matchingColumn* = \\[\\[\\`sym],\\[\\`sym1]]。\n2. 有多个连接列。当左表和右表的连接列名相同时，*matchingColumn* 是一个字符串向量，否则是一个长度为 2 的 tuple。例如：左表连接列名为 timestamp, sym，右表连接列名为 timestamp, sym1，则 *matchingColumn* = \\[\\[\\`timestamp, \\`sym], \\[\\`timestamp,\\`sym1]]。\n\n**rightTimeColumn** 可选参数，是字符串标量，表示右表的时间列名称。若设置该参数，右表会根据指定的时间列的时间戳保留最新的数据（若有多行，则取其中最后一行）。若不指定该参数，则根据数据注入系统的时间保留最新数据。\n\n**checkTimes** 可选参数，是一个时间类型向量或 DURATION 的标量。设置后，系统会定时更新 *rightTable* 的数据（只保留 *rightTable* 的最新数据），并将更新后的数据追加到引擎中。当无需更新 *rightTable* 时，则不用设置该参数，但需要在引擎创建后，手动将 *rightTable* 注入到引擎中。\n\n* *checkTimes* 是时间类型向量时，只能为SECOND、TIME 或 NANOTIME 类型。 lookup join 引擎每天根据向量内各元素指定的时间定时更新右表。\n* *checkTimes* 是 DURATION 标量时，表示更新右表的时间间隔。\n\n**keepDuplicates** 可选参数，布尔值，表示是否保留右表各分组内的所有数据。默认值为 false，即在关联时只取右表各分组内的最新一条数据。当设置为 true 时，在关联时则使用右表各分组内的所有数据，此时的连接类型为内连接，即只有左右两表匹配的记录被计算输出。\n\n#### 返回值\n\n返回一个 DStream 对象。\n\n#### 例子\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\n// 如已存在流图，则先销毁该流图\n// dropStreamGraph('joinEngine')\ng = createStreamGraph('joinEngine')\n\nr = g.source(\"right\", `timestamps`sym`val`id, [TIMESTAMP, SYMBOL, DOUBLE, INT])\ng.source(\"left\", `timestamps`sym`price, [TIMESTAMP, SYMBOL, DOUBLE])\n    .lookupJoinEngine(r, metrics=<[price,val,price*val]>, matchingColumn=`sym)\n    .sink(\"output\")\ng.submit()\n\ngo\nn  = 15\ntmp1 = 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)\nappendOrcaStreamTable(\"right\", tmp1)\n\nn = 10\ntmp2 = 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)\nappendOrcaStreamTable(\"left\", tmp2)\n\nselect * from orca_table.output\n```\n\n| sym | price | val | price\\_mul |\n| --- | ----- | --- | ---------- |\n| A   | 10.1  | 13  | 131.30     |\n| B   | 11.1  | 14  | 155.40     |\n| C   | 12.1  | 15  | 181.50     |\n| A   | 13.1  | 13  | 170.30     |\n| B   | 14.1  | 14  | 197.40     |\n| C   | 15.1  | 15  | 226.50     |\n| A   | 16.1  | 13  | 209.30     |\n| B   | 17.1  | 14  | 239.40     |\n| C   | 18.1  | 15  | 271.50     |\n| A   | 19.1  | 13  | 248.30     |\n"
    },
    "DStream::map": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/DStream_map.html",
        "signatures": [
            {
                "full": "DStream::map(func)",
                "name": "DStream::map",
                "parameters": [
                    {
                        "full": "func",
                        "name": "func"
                    }
                ]
            }
        ],
        "markdown": "### [DStream::map](https://docs.dolphindb.cn/zh/funcs/d/DStream_map.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nDStream::map(func)\n\n#### 详情\n\n对流中的数据做映射，将指定函数应用到流数据中的每条消息。适用于无状态的数据处理场景（比如数据过滤）。\n\n#### 参数\n\n**func** 一元函数，入参为流数据消息组成的表。函数返回一个表，后续引擎根据返回的表结构推导处理逻辑。\n\n注意：*func* 必须是纯函数（pure function），即必须满足：\n\n* 对于相同的输入，总是返回相同的输出。\n\n* 不能产生任何副作用，例如：\n\n  * 修改全局变量或函数外部状态。\n\n  * 写入数据库或文件。\n\n  * 调用外部服务（如发送 HTTP 请求）。\n\n  * 修改传入的参数对象（例如对原始表进行原地更改）。\n\n#### 返回值\n\n返回一个 DStream 对象。\n\n#### 例子\n\n定义 `map` 合成 AAPL 标的 K 线：\n\n```\nuse catalog test\n\ng = createStreamGraph(\"graph\")\ng.source(\"trade\", `symbol`datetime`price`volume, [SYMBOL,TIMESTAMP,DOUBLE,INT])\n    .map(msg -> select * from msg where symbol == \"AAPL\")\n    .timeSeriesEngine(60, 60, <[first(price) as open, max(price) as high, min(price) as low, last(price) as close, sum(volume) as volume]>, \"datetime\", false, \"symbol\")\n    .sink(\"output\")\n```\n\n**相关函数：**[DStream::udfEngine](https://docs.dolphindb.cn/zh/funcs/d/DStream_udfEngine.html)\n"
    },
    "DStream::narrowReactiveStateEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/DStream_narrowReactiveStateEngine.html",
        "signatures": [
            {
                "full": "DStream::narrowReactiveStateEngine(metrics, metricNames, keyColumn, [filter], [keepOrder], [keyPurgeFilter], [keyPurgeFreqInSecond=0], [keyCapacity=1024], [parallelism=1])",
                "name": "DStream::narrowReactiveStateEngine",
                "parameters": [
                    {
                        "full": "metrics",
                        "name": "metrics"
                    },
                    {
                        "full": "metricNames",
                        "name": "metricNames"
                    },
                    {
                        "full": "keyColumn",
                        "name": "keyColumn"
                    },
                    {
                        "full": "[filter]",
                        "name": "filter",
                        "optional": true
                    },
                    {
                        "full": "[keepOrder]",
                        "name": "keepOrder",
                        "optional": true
                    },
                    {
                        "full": "[keyPurgeFilter]",
                        "name": "keyPurgeFilter",
                        "optional": true
                    },
                    {
                        "full": "[keyPurgeFreqInSecond=0]",
                        "name": "keyPurgeFreqInSecond",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[keyCapacity=1024]",
                        "name": "keyCapacity",
                        "optional": true,
                        "default": "1024"
                    },
                    {
                        "full": "[parallelism=1]",
                        "name": "parallelism",
                        "optional": true,
                        "default": "1"
                    }
                ]
            }
        ],
        "markdown": "### [DStream::narrowReactiveStateEngine](https://docs.dolphindb.cn/zh/funcs/d/DStream_narrowReactiveStateEngine.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nDStream::narrowReactiveStateEngine(metrics, metricNames, keyColumn, \\[filter], \\[keepOrder], \\[keyPurgeFilter], \\[keyPurgeFreqInSecond=0], \\[keyCapacity=1024], \\[parallelism=1])\n\n#### 详情\n\n创建流计算生成窄表的响应式状态引擎。参考：[createNarrowReactiveStateEngine](https://docs.dolphindb.cn/zh/funcs/c/createnarrowreactivestateengine.html)。\n\n#### 参数\n\n**metrics** 以元代码的格式表示计算指标，支持输入元组，表示需要输出到 outputTable 中的除 keyColumn 外的输入表中的列或计算指标。注意：这里不要求必须指定除 keyColumn 外的列，但必须指定计算指标，且计算指标必须与 *metricNames* 指定的名称一一对应。\n\n**metricNames** 字符串标量或向量，表示输出到 *outputTable*中的指标的名称。\n\n**keyColumn** 可选参数，字符串标量或向量表示分组列名。若指定该参数，计算将在各分组进行。\n\n**filter** 可选参数，以元代码的形式表示过滤条件。过滤条件只能是一个表达式，并且只能包含 *dummyTable*中的列。设置多个条件时，用逻辑运算符（and, or）连接。引擎会先计算指标，然后根据 *filter*指定的过滤条件，输出满足条件的输入数据对应的计算结果。\n\n**keepOrder** 可选参数，表示输出表数据是否按照输入时的顺序排序。设置 *keepOrder* = true，表示输出表按照输入时的顺序排序。当 *keyColumn* 包含有时间列时，*keepOrder* 默认值为 true，否则默认值为 false。\n\n**keyPurgeFilter** 可选参数，是一个由布尔表达式组成的元代码，表示清理条件。各表达式只能引用 *outputTable* 中的字段。必须指定 *keyColumn* 才能使用该参数。\n\n**keyPurgeFreqInSecond** 正整数，表示触发数据清理需要满足的时间间隔（以秒为单位）。必须指定 *keyColumn* 才能使用该参数。\n\n响应式状态引擎提供了 *keyPurgeFilter*, *keyPurgeFreqInSecond* 两个参数，用来清理不再需要的分组数据。每次数据注入时，系统会依次根据以下条件决定是否触发数据清理：\n\n1. 检测本次数据注入与上一次数据注入的时间间隔是否大于等于 *keyPurgeFreqInSecond* （第一次数据注入时，检测注入时间和引擎创建时间的间隔）；\n2. 若满足上述条件，系统将根据 *keyPurgeFilter* 指定的条件，过滤出待清理的数据；\n3. 若待清理的数据所属的分组数大于等于所有分组数的 10%，则触发清理。\n\n若需要查看清理前后的状态，可以通过调用 [getStreamEngineStat](https://docs.dolphindb.cn/zh/funcs/g/getStreamEngineStat.html) 函数查看 ReactiveStreamEngine 引擎状态的 numGroups 列，来对比响应式状态引擎清理前后分组数的变化。\n\n**keyCapacity** 正整数，可选参数，表示建表时系统为该表预分配的 key 分组数量，用于调整状态表中 key 的函数。通过该参数的合理设置，能够降低在 key 分组较多时可能出现的延迟。\n\n**parallelism** 不超过63的正整数，可选参数，表示并行计算的工作线程数，默认值为 1。在计算量较大时，合理地调整该参数能够有效利用计算资源，降低计算耗时。\n\n**Note:** *parallelism* 不能超过 min(许可核数, 逻辑核数)-1。\n\n#### 返回值\n\n返回一个 DStream 对象。\n\n#### 例子\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\n// 如已存在流图，则先销毁该流图\n// dropStreamGraph('engine')\ng = createStreamGraph('engine')\n\nfactor = [<createTime>, <updateTime>,<cumsum(qty)>,<cumavg(upToDatePrice)>]\n\ng.source(\"trades\", [\"securityID1\",\"securityID2\",\"securityID3\",\"createTime\",\"updateTime\",\"upToDatePrice\",\"qty\",\"value\"], [STRING,STRING,STRING,TIMESTAMP,TIMESTAMP,DOUBLE,DOUBLE,INT])\n.narrowReactiveStateEngine(metrics=factor,metricNames=[\"factor1\",\"factor2\"], keyColumn=[\"securityID1\",\"securityID2\",\"securityID3\"])\n.sink(\"output\")\ng.submit()\ngo\n\ndates=take(2012.01.01, 10) join take(2012.01.02, 4)\ntimes=[09:00:00.030, 09:00:00.030, 09:00:00.031, 09:00:00.031, 09:00:00.031, 09:00:00.033, 09:00:00.033, 09:00:00.034, 09:00:00.034, 09:00:00.035, 09:00:00.031, 09:00:00.032, 09:00:00.032, 09:00:00.040]\nsyms=[`a, `a, `b, `a, `a, `b, `a, `b, `b, `a, `b, `a, `b, `c]\nmarkets=['B', 'B', 'A', 'B', 'A', 'B', 'A', 'A', 'A', 'A', 'A', 'B', 'B', 'B']\nprices=[10.65, 10.59, 10.59, 10.65, 10.59, 10.59, 10.59, 10.59, 10.22, 11.0, 10.22, 11.0, 15.6, 13.2]\nqtys=[1500, 2500, 2500, 1500, 2500, 2500, 2500, 2500, 1200, 2500, 1200, 2500, 1300, 2000]\ntmp=table(dates as date, times as time, syms as sym, markets as market, prices as price, qtys as qty)\n\nnum = 5\ntmp = table(take(\"A\" + lpad(string(1..4),4,\"0\"),num) as securityID1,take(\"CC.HH\" + lpad(string(21..34),4,\"0\"),num) as securityID2,take(\"FFICE\" + lpad(string(13..34),4,\"0\"),num) as securityID3, 2023.09.01 00:00:00+(1..num) as createTime, 2023.09.01 00:00:00+take(1..num, num).sort() as updateTime,take(rand(100.0,num) join take(int(),30),num) as upToDatePrice,take(take(100.0,num) join take(int(),30),num)+30 as qty,take(1..20 join take(int(),5),num) as value)\n\nappendOrcaStreamTable(\"trades\", tmp)\n\nselect * from orca_table.output\n```\n\n| securityID1 | securityID2 | securityID3 | createTime              | updateTime              | metricName | metricValue        |\n| ----------- | ----------- | ----------- | ----------------------- | ----------------------- | ---------- | ------------------ |\n| A0001       | CC.HH0021   | FFICE0013   | 2023.09.01 00:00:01.000 | 2023.09.01 00:00:01.000 | factor1    | 130                |\n| A0001       | CC.HH0021   | FFICE0013   | 2023.09.01 00:00:01.000 | 2023.09.01 00:00:01.000 | factor2    | 5.729826227745667  |\n| A0002       | CC.HH0022   | FFICE0014   | 2023.09.01 00:00:02.000 | 2023.09.01 00:00:02.000 | factor1    | 130                |\n| A0002       | CC.HH0022   | FFICE0014   | 2023.09.01 00:00:02.000 | 2023.09.01 00:00:02.000 | factor2    | 40.09022097935429  |\n| A0003       | CC.HH0023   | FFICE0015   | 2023.09.01 00:00:03.000 | 2023.09.01 00:00:03.000 | factor1    | 130                |\n| A0003       | CC.HH0023   | FFICE0015   | 2023.09.01 00:00:03.000 | 2023.09.01 00:00:03.000 | factor2    | 40.181519178922024 |\n| A0004       | CC.HH0024   | FFICE0016   | 2023.09.01 00:00:04.000 | 2023.09.01 00:00:04.000 | factor1    | 130                |\n| A0004       | CC.HH0024   | FFICE0016   | 2023.09.01 00:00:04.000 | 2023.09.01 00:00:04.000 | factor2    | 21.328769097950172 |\n| A0001       | CC.HH0025   | FFICE0017   | 2023.09.01 00:00:05.000 | 2023.09.01 00:00:05.000 | factor1    | 130                |\n| A0001       | CC.HH0025   | FFICE0017   | 2023.09.01 00:00:05.000 | 2023.09.01 00:00:05.000 | factor2    | 50.23656470375805  |\n"
    },
    "DStream::nearestJoinEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/DStream_nearestJoinEngine.html",
        "signatures": [
            {
                "full": "DStream::nearestJoinEngine(rightStream, kNearest, metrics, matchingColumn, [timeColumn], [useSystemTime=false], [garbageSize = 5000], [maxDelayedTime], [nullFill], [cachedTableCapacity=1024])",
                "name": "DStream::nearestJoinEngine",
                "parameters": [
                    {
                        "full": "rightStream",
                        "name": "rightStream"
                    },
                    {
                        "full": "kNearest",
                        "name": "kNearest"
                    },
                    {
                        "full": "metrics",
                        "name": "metrics"
                    },
                    {
                        "full": "matchingColumn",
                        "name": "matchingColumn"
                    },
                    {
                        "full": "[timeColumn]",
                        "name": "timeColumn",
                        "optional": true
                    },
                    {
                        "full": "[useSystemTime=false]",
                        "name": "useSystemTime",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[garbageSize = 5000]",
                        "name": "[garbageSize = 5000]"
                    },
                    {
                        "full": "[maxDelayedTime]",
                        "name": "maxDelayedTime",
                        "optional": true
                    },
                    {
                        "full": "[nullFill]",
                        "name": "nullFill",
                        "optional": true
                    },
                    {
                        "full": "[cachedTableCapacity=1024]",
                        "name": "cachedTableCapacity",
                        "optional": true,
                        "default": "1024"
                    }
                ]
            }
        ],
        "markdown": "### [DStream::nearestJoinEngine](https://docs.dolphindb.cn/zh/funcs/d/DStream_nearestJoinEngine.html)\n\n首发版本：3.00.4，3.00.3.1\n\n\n\n#### 语法\n\nDStream::nearestJoinEngine(rightStream, kNearest, metrics, matchingColumn, \\[timeColumn], \\[useSystemTime=false], \\[garbageSize = 5000], \\[maxDelayedTime], \\[nullFill], \\[cachedTableCapacity=1024])\n\n#### 详情\n\n创建流计算最近邻关联引擎。参考：[createNearestJoinEngine](https://docs.dolphindb.cn/zh/funcs/c/createNearestJoinEngine.html)。\n\n#### 参数\n\n**rightStream**DStream 对象，表示输入的右表数据源。\n\n**kNearest**一个正整数，表示记录的条数。对于每条左表记录，关联右表中时间戳不大于该记录时间戳的最近 k 条记录。\n\n**metrics** 以元代码的格式表示计算指标，支持输入元组。有关元代码的更多信息可参考 [元编程](https://docs.dolphindb.cn/zh/progr/objs/meta_progr.html)。\n\n* 计算指标可以是一个或多个表达式、系统内置或用户自定义函数。\n\n* *metrics* 内支持调用具有多个返回值的函数，且必须指定列名，例如 \\<func(price) as \\`col1\\`col2>。\n\n  若在 *metrics* 指定了 *leftTable* 和 *rightTable* 中具有相同名称的列，默认取左表的列，可以通过 \"tableName.colName\" 指定该列来自哪个表。\n\n* 支持使用 `toArray` 函数将右表字段聚合为 array vector 类型，例如：`<toArray(price)>`，其中 price 为右表中的普通列。\n\n**注意：**\n\n* *metrics* 中使用的列名大小写不敏感，不要求与输入表的列名大小写保持一致。\n\n* 当以下函数只计算 *rightTable* 中的数据列时，最近邻关联引擎对它们进行了优化：sum, sum2, avg, std, var, corr, covar, wavg, wsum, beta, max, min, last, first, med, percentile。\n\n**matchingColumn** 表示连接列的字符串标量/向量/tuple，支持 Integral, Temporal 或 Literal（UUID 除外）类型。*matchingColumn* 指定规则为：\n\n1. 只有一个连接列：当左表和右表的连接列名相同时，*matchingColumn* 是一个字符串标量，否则是一个长度为 2 的 tuple，例如：左表连接列名为 sym，右表连接列名为 sym1，则 *matchingColumn* = \\[\\[\\`sym],\\[\\`sym1]]。\n2. 有多个连接列：当左表和右表的连接列名相同时，*matchingColumn* 是一个字符串向量，否则是一个长度为 2 的 tuple，例如：左表连接列名为 timestamp, sym，右表连接列名为 timestamp, sym1，则 *matchingColumn* = \\[\\[\\`timestamp, \\`sym], \\[\\`timestamp,\\`sym1]]。\n\n**timeColumn** 可选参数，当 *useSystemTime* = false时，指定要连接的两个表中时间列的名称。*leftTable* 和 *rightTable* 时间列名称可以不同，但数据类型需保持一致。当 *leftTable* 和 *rightTable* 时间列名称不同时，*timeColumn* 为一个长度为2的字符串向量。\n\n**useSystemTime** 可选参数，表示 *outputTable* 中第一列（时间列）为系统当前时间（*useSystemTime* = true）或左表的时间列（*useSystemTime* = false）。\n\n**garbageSize** 可选参数，是正整数，默认值是5,000（单位为行）。随着订阅的流数据不断积累进入 window join 引擎，存放在内存中的数据会越来越多，这时需要清理不再需要的历史数据。当左/右两表各个分组内的数据行数超过 *garbageSize* 值时，系统会清理本次计算不需要的历史数据。\n\n**maxDelayedTime** 可选参数，是正整数，用于触发引擎中长时间未输出的分组数据进行计算。 具体来说，若`(某个分组中未发生计算的窗口右边界) + (maxDelayedTime) < (右表最新收到的任意一个分组数据的时间戳)`，则这条数据会触发该窗口计算输出。\n\n**注：** 请合理设置 *maxDelayedTime* 参数。当左表数据较少而右表数据频率较高时，若 *maxDelayedTime* 设置过小，系统可能在未触发某些分组计算之前，就清理掉右表中过早的数据。\n\n**nullFill** 和输出表列字段等长且类型一一对应的元组，用于填充以下列中的空值：输出表中包含的左表列、右表列、右表列被聚合计算后的计算结果列。\n\n**cachedTableCapacity**可选参数，为正整数，表示引擎为每个不同的分组分别创建的左缓存表和右缓存表的初始容量（以数据条数计）。默认值为 1024。\n\n#### 返回值\n\n返回一个 DStream 对象。\n\n#### 例子\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\n// 如已存在流图，则先销毁该流图\n// dropStreamGraph('nearestEngine')\ng = createStreamGraph('nearestEngine')\n\nleftStream = g.source(\"leftTable\", `time`sym`price, [TIMESTAMP, SYMBOL, DOUBLE])\nrightStream  = g.source(\"rightTable\", `time`sym`val, [TIMESTAMP, SYMBOL, DOUBLE])\nleftStream.nearestJoinEngine(rightStream=rightStream,kNearest=8, metrics=<[price,toArray(val),sum(val)]>, matchingColumn=`sym, timeColumn=`time, useSystemTime=NULL)\n\t\t.sink(\"output\")\ng.submit()\ngo\n\nn=10\ntp2=table(take(2012.01.01T00:00:00.000+0..10, 2*n) as time, take(`A, n) join take(`B, n) as sym, take(double(1..10),2*n) as val)\ntp2.sortBy!(`time)\nappendOrcaStreamTable(`rightTable, tp2)\ntp1=table(take(2012.01.01T00:00:00.003+0..10, 2*n) as time, take(`A, n) join take(`B, n) as sym, take(NULL join rand(10.0, n-1),2*n) as price)\ntp1.sortBy!(`time)\n\nappendOrcaStreamTable(`leftTable, tp1)\n\nselect * from orca_table.output\n```\n\n| time                    | sym | price              | toArray\\_val              | sum\\_val |\n| ----------------------- | --- | ------------------ | ------------------------- | -------- |\n| 2012.01.01 00:00:00.003 | A   |                    | \\[1, 2, 3, 4]             | 10       |\n| 2012.01.01 00:00:00.004 | A   | 3.4822947595856824 | \\[1, 2, 3, 4, 5]          | 15       |\n| 2012.01.01 00:00:00.005 | A   | 7.86139521284484   | \\[1, 2, 3, 4, 5, 6]       | 21       |\n| 2012.01.01 00:00:00.006 | A   | 3.1722617468716185 | \\[1, 2, 3, 4, 5, 6, 7]    | 28       |\n| 2012.01.01 00:00:00.007 | A   | 5.3532539582956415 | \\[1, 2, 3, 4, 5, 6, 7, 8] | 36       |\n| 2012.01.01 00:00:00.008 | A   | 6.732663744145904  | \\[2, 3, 4, 5, 6, 7, 8, 9] | 44       |\n| 2012.01.01 00:00:00.003 | B   | 3.4822947595856824 | \\[2, 3, 4, 5]             | 14       |\n| 2012.01.01 00:00:00.004 | B   | 7.86139521284484   | \\[2, 3, 4, 5, 6]          | 20       |\n| 2012.01.01 00:00:00.005 | B   | 3.1722617468716185 | \\[2, 3, 4, 5, 6, 7]       | 27       |\n| 2012.01.01 00:00:00.006 | B   | 5.3532539582956415 | \\[2, 3, 4, 5, 6, 7, 8]    | 35       |\n"
    },
    "DStream::orderBookSnapshotEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/DStream_orderBookSnapshotEngine.html",
        "signatures": [
            {
                "full": "DStream::orderBookSnapshotEngine(exchange, orderbookDepth, intervalInMilli, date, startTime, prevClose, inputColMap, [outputColMap], [outputCodeMap], [outputIntervalOffsetMap], [checkRestrict], [maxPrice], [minPrice], [userDefinedMetrics], [priceNullFill], [triggerType], [forceTriggerTime], [precision], [orderBySeq], [skipCrossedMarket=true], [orderBookDetailDepth=0], [orderBookAsArray=false], [useSystemTime=false],[independentForceTriggerTime])",
                "name": "DStream::orderBookSnapshotEngine",
                "parameters": [
                    {
                        "full": "exchange",
                        "name": "exchange"
                    },
                    {
                        "full": "orderbookDepth",
                        "name": "orderbookDepth"
                    },
                    {
                        "full": "intervalInMilli",
                        "name": "intervalInMilli"
                    },
                    {
                        "full": "date",
                        "name": "date"
                    },
                    {
                        "full": "startTime",
                        "name": "startTime"
                    },
                    {
                        "full": "prevClose",
                        "name": "prevClose"
                    },
                    {
                        "full": "inputColMap",
                        "name": "inputColMap"
                    },
                    {
                        "full": "[outputColMap]",
                        "name": "outputColMap",
                        "optional": true
                    },
                    {
                        "full": "[outputCodeMap]",
                        "name": "outputCodeMap",
                        "optional": true
                    },
                    {
                        "full": "[outputIntervalOffsetMap]",
                        "name": "outputIntervalOffsetMap",
                        "optional": true
                    },
                    {
                        "full": "[checkRestrict]",
                        "name": "checkRestrict",
                        "optional": true
                    },
                    {
                        "full": "[maxPrice]",
                        "name": "maxPrice",
                        "optional": true
                    },
                    {
                        "full": "[minPrice]",
                        "name": "minPrice",
                        "optional": true
                    },
                    {
                        "full": "[userDefinedMetrics]",
                        "name": "userDefinedMetrics",
                        "optional": true
                    },
                    {
                        "full": "[priceNullFill]",
                        "name": "priceNullFill",
                        "optional": true
                    },
                    {
                        "full": "[triggerType]",
                        "name": "triggerType",
                        "optional": true
                    },
                    {
                        "full": "[forceTriggerTime]",
                        "name": "forceTriggerTime",
                        "optional": true
                    },
                    {
                        "full": "[precision]",
                        "name": "precision",
                        "optional": true
                    },
                    {
                        "full": "[orderBySeq]",
                        "name": "orderBySeq",
                        "optional": true
                    },
                    {
                        "full": "[skipCrossedMarket=true]",
                        "name": "skipCrossedMarket",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[orderBookDetailDepth=0]",
                        "name": "orderBookDetailDepth",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[orderBookAsArray=false]",
                        "name": "orderBookAsArray",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[useSystemTime=false]",
                        "name": "useSystemTime",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[independentForceTriggerTime]",
                        "name": "independentForceTriggerTime",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [DStream::orderBookSnapshotEngine](https://docs.dolphindb.cn/zh/funcs/d/DStream_orderBookSnapshotEngine.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nDStream::orderBookSnapshotEngine(exchange, orderbookDepth, intervalInMilli, date, startTime, prevClose, inputColMap, \\[outputColMap], \\[outputCodeMap], \\[outputIntervalOffsetMap], \\[checkRestrict], \\[maxPrice], \\[minPrice], \\[userDefinedMetrics], \\[priceNullFill], \\[triggerType], \\[forceTriggerTime], \\[precision], \\[orderBySeq], \\[skipCrossedMarket=true], \\[orderBookDetailDepth=0], \\[orderBookAsArray=false], \\[useSystemTime=false],\\[independentForceTriggerTime])\n\n#### 详情\n\n创建一个订单簿引擎。参考：[createOrderBookSnapshotEngine](https://docs.dolphindb.cn/zh/funcs/c/createorderbooksnapshotengine.html)。\n\n#### 参数\n\n**exchange** 字符串标量，用于指定交易所及标的类别。可选参数：\n\n* \"XSHE\" 或 \"XSHESTOCK\"：深交所股票\n* \"XSHEBOND\"：深交所债券\n* \"XSHEFUND\"：深交所基金\n* \"XSHG\" 或 \"XSHGSTOCK\"：上交所股票\n* \"XSHGBOND\"：上交所债券\n* \"XSHGFUND\"：上交所基金\n\n**orderbookDepth** 正整数，表示 orderbook 中最多能够显示的买卖报价的档位。\n\n**intervalInMilli** 正整数，表示触发输出数据的时间间隔，即合成快照的时间频率，单位为毫秒。\n\n**date** DATE 类型标量，表示交易日期。该参数和窗口右边界组合成输出表的 TIMESTAMP 列。\n\n**startTime** TIME 类型标量，表示触发输出数据的起始时刻。引擎只会输出该参数指定时刻（规整后）之后的数据。\n\n**prevClose** 字典，其 key 为字符串标量或向量，表示股票代码；其 value 为数值类型，表示对应于股票代码的上一个交易日的收盘价格。注意：若 value 为浮点型，则认为是真实价格，引擎处理过程中会乘以 *priceScale*，以匹配输入表中 priceColumn 字段的精度。若为整型，则视为已和 priceColumn 具备相同精度，不再进行缩放。\n\n**inputColMap** 字典，将输入表中列字段的名称映射为引擎计算所需要的列。其中：\n\n* key 为字符串类型，表示引擎所需要的固定的输入字段。具体字段名和含义见下表。注意，这些 key 区分大小写，必须全部指定，但顺序可以不固定。\n* value 为字符串类型，表示输入表中对应的列名称。\n\n<table id=\"inputTable\"><thead><tr><th>\n\nkey\n\n</th><th>\n\nvalue 对应的字段类型\n\n</th><th>\n\n含义\n\n</th></tr></thead><tbody><tr><td>\n\n\"codeColumn\"\n\n</td><td>\n\nSYMBOL\n\n</td><td>\n\n标的代码（如300010.SZ）\n\n</td></tr><tr><td>\n\n\"timeColumn\"\n\n</td><td>\n\nTIME\n\n</td><td>\n\n交易时间\n\n</td></tr><tr><td>\n\n\"typeColumn\"\n\n</td><td>\n\nINT\n\n</td><td>\n\n交易类型：-   如果是逐笔委托单，则：1 表示市价；2 表示限价；3 表示本方最优；10 表示撤单（仅上交所）；11 市场状态（仅上交所）\n\n* 如果是逐笔成交单，则：0 表示成交；1 表示撤单（仅深交所）\n\n</td></tr><tr><td>\n\n\"priceColumn\"\n\n</td><td>\n\nLONG\n\n</td><td>\n\n价格，由 *priceScale* 决定，默认是真实价格\\*10000\n\n</td></tr><tr><td>\n\n\"qtyColumn\"\n\n</td><td>\n\nLONG\n\n</td><td>\n\n数量（股数）\n\n</td></tr><tr><td>\n\n\"buyOrderColumn\"\n\n</td><td>\n\nLONG\n\n</td><td>\n\n* 逐笔成交：对应其原始成交中的买方委托序号。\n* 逐笔委托：\n  * 上交所：填充原始委托中的原始订单号，即上交所在新增、删除订单时用以标识订单的唯一编号（OrderNo 字段）\n  * 深交所：填充 0。此字段为深交所为了补全上交所数据格式而增加的冗余列\n\n</td></tr><tr><td>\n\n\"sellOrderColumn\"\n\n</td><td>\n\nLONG\n\n</td><td>\n\n* 逐笔成交：对应其原始成交中的卖方委托序号。\n* 逐笔委托：\n  * 上交所：填充原始委托中的原始订单号，即上交所在新增、删除订单时用以标识订单的唯一编号（OrderNo 字段）\n  * 深交所：填充 0。此字段深交所为了补全上交所数据格式而增加的冗余列\n\n</td></tr><tr><td>\n\n\"sideColumn\"\n\n</td><td>\n\nINT\n\n</td><td>\n\n买卖方向：1 表示买单；2 表示卖单说明：\n\n* 委托单的 BSFlag，必填\n* 撤单的 BSFlag 由原始委托单决定买卖方向，必填\n* 成交单的 BSFlag，不影响结果，非必填\n\n</td></tr><tr><td>\n\n\"msgTypeColumn\"\n\n</td><td>\n\nINT\n\n</td><td>\n\n数据类型：-   0 表示逐笔委托；\n\n* 1 表示逐笔成交；\n* -1 表示产品状态。\n\n</td></tr><tr><td>\n\n\"seqColumn\"\n\n</td><td>\n\nLONG\n\n</td><td>\n\n一个通道内从 1 开始递增的逐笔数据序号。深交所为 appseqlnum 字段，若深交所数据中包含 index 字段，也可以使用 index；上交所为 bizIndex 字段。\n\n</td></tr><tr><td>\n\n\"receiveTime\"\n\n</td><td>\n\nNANOTIMESTAMP\n\n</td><td>\n\n逐笔数据的接收时间\n\n</td></tr></tbody>\n</table>**Note:** 引擎规范了枚举类型中各枚举值的具体含义。输入表对应的枚举值必须遵守这个规范。比如枚举类型字段 sideColumn 所对应的输入表中的字段必须使用 1 代表买方向，2 代表卖方向。\n\n**outputColMap** 可选参数，字符串向量，用于指定需要输出的字段名称，不区分大小写。为方便指定 *outputColMap*，用户可通过 `genOutputColumnsForOBSnapshotEngine` 函数生成需要输出的字段名称，将返回值的第一个元素赋值给 *outputColMap* 即可。\n\n**Note:** `genOutputColumnsForOBSnapshotEngine`函数生成的字段列表中不包含以下字段：\n\n* tradeDetail（成交明细）中的 tradeBuyOrderTypeList 和 tradeSellOrderTypeList。\n\n* withdrawDetail（撤单明细）中的 withdrawBuyOrderNoList和withdrawSellOrderNoList。\n\n* residualDetail（剩余委托明细）中的 ResidualBidOrderNoList 和 ResidualAskOrderNoList。\n\n如需要输出上述字段，请在 *outputColMap* 中手动添加。\n\n**outputCodeMap** 可选参数，字符串向量，表示股票代码，例如：\"000803.SZ\"。指定该参数后，将只输出指定股票对应的数据。\n\n**outputIntervalOffsetMap** 可选参数，向量或字典，用于指定输出表中股票被触发计算的时间偏移量（单位：毫秒）。\n\n* **计算逻辑**：引擎会根据偏移量重新定义各股票的快照边界。第一个窗口会自动包含从 *startTime* 到 *startTime + intervalInMilli + offset* 之间的所有逐笔数据，从而确保偏移期间产生的数据被纳入当条快照计算。\n* **向量形式**：引擎将根据输入的股票数量自动将这些股票均匀分配到这些偏移量上。例如，`outputIntervalOffsetMap = [400, 500]`，表示引擎将自动将输入的股票均匀分成两部分，经过 intervalInMilli + 400(ms) 后触发其中一部分股票的数据输出；经过 intervalInMilli + 500(ms) 后触发另一部分股票的数据输出。\n* **字典形式**： key 为字符串类型，表示股票代码；其 value 为整型，表示时间偏移量。例如：`outputIntervalOffsetMap =dict([\"127053.sz\",\"123082.SZ\"],[400, 500])`，表示经过 intervalInMilli + 400(ms) 后触发 127053.sz 股票的数据输出；经过 intervalInMilli + 500(ms) 后触发 123082.SZ 股票的数据输出。\n\n**checkRestrict** 可选参数，布尔值，默认值为 true，表示开启价格笼子机制；若设置为 false，则关闭笼子机制，此时会取消对股票交易的限制，创业板合成出的快照可能不正确。\n\n**Note:** 深交所对创业板标的（标的代码以 3 开头）设定了价格笼子。在 *checkRestrict*=true 时，引擎只会将标的代码的首字符是否为 3 作为是否执行价格笼子的判断标准。因此，在向引擎输入创业板数据时，标的代码必须以 3 开头。\n\n**maxPrice** 可选参数，字典。其 key 为字符串类型，表示标的代码；其 value 为 DOUBLE 或 INT 类型，表示涨停价格。注意：若 *maxPrice* 为浮点型，则认为是真实价格，引擎处理过程中会乘以 *priceScale*，以匹配输入表中 priceColumn 字段的精度。若为整型，则视为已和 priceColumn 具备相同精度，不再进行缩放。\n\n**minPrice** 可选参数，字典。其 key 为字符串类型，表示标的代码；其 value 为 DOUBLE 或 INT 类型，表示跌停价格。注意：若 *minPrice* 为浮点型，则认为是真实价格，引擎处理过程中会乘以 *priceScale*，以匹配输入表中 priceColumn 字段的精度。若为整型，则视为已和 priceColumn 具备相同精度，不再进行缩放。\n\n**userDefinedMetrics** 可选参数，一元函数。\n\n* 函数的入参是一个表，表的每一行是一个标的，每一列是标的对应的快照。若指定 *outputColMap*，则表中数据为 *outputColMap*设置的字段；否则表中数据为基础字段和报价/询价的价格和数量。\n\n* 函数的返回值是一个元组，元组的每一个元素是一个常规向量，代表每个标的经对应指标计算后的结果。\n\n**priceNullFill** 一个数字。该参数值用于填充输出表中多档买/卖价格中缺失档位的价格。例如涨停后卖单的价格都为 NULL，此时如有指定卖单价格为 0 的需求，可以设置 priceNullFill=0。\n\n**triggerType** 可选参数，字符串标量，表示触发方式。可选值为：\n\n* \"mutual\"（默认值）：新收到任意一条逐笔数据，当其时间戳大于窗口右边界时，就会触发所有股票未计算的快照合成输出。触发计算的数据并不会参与该次计算。\n* \"independent\"：新收到任意一条逐笔数据，当其时间戳大于窗口右边界时，只触发该条数据对应股票未计算的快照合成输出。触发计算的数据并不会参与该次计算。\n* \"perRow\"：每收到一行逐笔数据都会触发该条数据对应股票计算并输出，触发计算的数据并参与该次计算。\n\n**forceTriggerTime** 可选参数，是非负整数，单位为毫秒。除了正常触发合成快照外，有时会出现一些数据因乱序不能触发合成快照，而是被缓存在引擎中。在这种情况下，可通过该参数设置强制触发引擎中长时间未处理的逐笔数据合成快照。触发规则为：\n\n1. 最新收到的逐笔数据的时间戳（t ）减去最后一条已经处理的交易数据的时间戳（t0 ）大于或等于 *forceTriggerTime*，则触发未处理的数据中序号最小的那条数据合成快照，并更新已经处理的交易数据的时间戳（t1）。\n2. 重复上述操作，若判断 t-t1 >= *forceTriggerTime*，则触发未处理的数据中序号最小的那条数据合成快照，并更新已经处理的交易数据的时间戳（t2）；直到两个时间戳的差值小于 *forceTriggerTime*时，停止触发快照合成。\n\n**precision** 可选参数，整数，表示小数位数，取值范围为\\[-1,4]。\n\n* 当 *precision*=-1 时，引擎输出的价格相关字段为整型。注意：输出表中相应的字段可以是整型或非整型。\n* 当 *precision* 取 \\[0, 4] 中的值时，表示小数位数。输出表中所有的价格将按照指定的位数进行四舍五入。否则，按照原始结果输出。\n\n**orderBySeq** 可选参数，布尔值或元组。\n\n* 指定该参数值为布尔值时，表示是否按照逐笔数据中的 seqColumn 列中值的大小顺序处理数据。当 *exchange*=\"XSHG\" 或 \"XSHGFUND\" 时，默认值为 true；在其他情况下，默认值为 false。\n  * 当 *orderBySeq*=true 时，会根据逐笔数据的序号有序处理数据，并计算输出。例如引擎先后收到序号为1，3的数据，因为缺少序号为2的数据，引擎先将1和3的数据缓存，待收到序号2的数据时，再进行计算输出。此时也可以指定 *forceTriggerTime*强制触发计算输出。\n  * 当 *orderBySeq*=false 时，每接收到一条数据都会立即进行计算并输出，此时不可设置 *forceTriggerTime*。\n* 指定该参数值为元组时，以（BOOL, INTEGER, \\[STRING]）的形式表示，其中：\n  * 第一个元素为布尔值，表示是否按照逐笔数据的序号有序输出结果的布尔值，作用同上。\n  * 第二个元素为正整数，表示记录缓存输入数据量的时间间隔，单位为毫秒（ms）。\n  * 第三个元素为指定输出日志级别的字符串标量，可选参数，其可用值为 DEBUG （默认值）和 INFO，分别对应 Debug 和 Info 级别的日志输出。\n\n**orderBookDetailDepth** 可选参数，整型标量，表示 orderbook 明细的深度。默认值为0，表示不输出。该参数必须和 *outputColMap* 中 orderBookDetailDepth 字段的值保持一致。\n\n**orderBookAsArray** 可选参数，布尔值，表示是否以数组向量形式输出报价/询价的价格和数量。默认值为 false，价格和数量将以多列形式输出。\n\n**useSystemTime** 可选参数，布尔值，表示是否使用系统时间来触发快照输出。\n\n* 当 *useSystemTime* = true 时，交易时段内，引擎将基于当前的系统时间，按照 *intervalInMilli* 设置的时间间隔触发快照输出。此时，休盘时段（(11:30:00.000，13:00:00.000]）不输出数据，下午盘第一个输出窗口时间戳为 13:00:00.000+*intervalInMilli*。注意，若设置 *useSystemTime* = true，则不能指定 *forceTriggerTime*；可以不指定 *triggerType*，或者指定为 *triggerType*=\"mutual\"\n* 当 *useSystemTime* = false（缺省值）时，引擎根据事件时间来触发快照输出。\n\n**independentForceTriggerTime** 可选参数，非负整数，单位为毫秒。该参数用于设置在长时间未触发快照输出的分组中，强制输出快照的时间间隔。仅当设置 *triggerType*=\"independent\" 时，该参数才会生效。\n\n#### 返回值\n\n返回一个 DStream 对象。\n\n#### 例子\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\n// 如已存在流图，则先销毁该流图\n// dropStreamGraph('engine')\ng = createStreamGraph('engine')\n\ncolNames = `SecurityID`Date`Time`SecurityIDSource`SecurityType`Index`SourceType`Type`Price`Qty`BSFlag`BuyNo`SellNo`ApplSeqNum`ChannelNo\ncolTypes = [SYMBOL, DATE, TIME, SYMBOL, SYMBOL, LONG, INT, INT, LONG, LONG, INT, LONG, LONG, LONG, INT]\n\ninputColMap = dict(`codeColumn`timeColumn`typeColumn`priceColumn`qtyColumn`buyOrderColumn`sellOrderColumn`sideColumn`msgTypeColumn`seqColumn, `SecurityID`Time`Type`Price`Qty`BuyNo`SellNo`BSFlag`SourceType`ApplSeqNum)\n\nprevClose = dict(`000587.SZ`002694.SZ`002822.SZ`000683.SZ`301063.SZ`300459.SZ`300057.SZ`300593.SZ`301035.SZ`300765.SZ, [1.66, 6.56, 6.10, 8.47, 38.10, 5.34, 9.14, 48.81, 60.04, 16.52])\n\ng.source(\"trades\", colNames, colTypes)\n.orderBookSnapshotEngine(exchange=\"XSHE\", orderbookDepth=10, intervalInMilli = 1000, date=2024.01.10, startTime=09:15:00.000, prevClose=prevClose, inputColMap=inputColMap)\n.sink(\"output\")\ng.submit()\n```\n"
    },
    "DStream::parallelize": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/DStream_parallelize.html",
        "signatures": [
            {
                "full": "DStream::parallelize(columnName, count)",
                "name": "DStream::parallelize",
                "parameters": [
                    {
                        "full": "columnName",
                        "name": "columnName"
                    },
                    {
                        "full": "count",
                        "name": "count"
                    }
                ]
            }
        ],
        "markdown": "### [DStream::parallelize](https://docs.dolphindb.cn/zh/funcs/d/DStream_parallelize.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nDStream::parallelize(columnName, count)\n\n#### 详情\n\n基于指定分区列对流数据进行哈希分区，生成多个并行的 DStream 处理分支。系统会过滤分区列包含的空值。\n\n注意：`DStream::parallelize` 和 `DStream::sync` 接口必须同时调用。\n\n#### 参数\n\n**columnName** 字符串，指定分区列。\n\n**count** 整数，指定并行度。\n\n#### 返回值\n\n返回一个 DStream 对象。\n\n#### 例子\n\n基于 symbol 列拆分 4 个分区，分别执行计算任务：\n\n```\nuse catalog test\n\ng = createStreamGraph(\"graph\")\ng.source(\"trade\", `symbol`datetime`price`volume, [SYMBOL, TIMESTAMP,DOUBLE, INT])\n  .parallelize(\"symbol\", 4)\n  .timeSeriesEngine(60*1000, 60*1000, <[first(price),max(price),min(price),last(price),sum(volume)]>, \"datetime\", false, \"symbol\")\n  .reactiveStateEngine(<[datetime, first_price, max_price, min_price, last_price, sum_volume, mmax(max_price, 5), mavg(sum_volume, 5)]>, `symbol)\n  .sync()\n  .sink(\"output\")\ng.submit()\n```\n"
    },
    "DStream::reactiveStateEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/DStream_reactiveStateEngine.html",
        "signatures": [
            {
                "full": "DStream::reactiveStateEngine(metrics, [keyColumn], [filter], [keepOrder], [keyPurgeFilter], [keyPurgeFreqInSecond=0], [keyCapacity=1024], [parallelism=1])",
                "name": "DStream::reactiveStateEngine",
                "parameters": [
                    {
                        "full": "metrics",
                        "name": "metrics"
                    },
                    {
                        "full": "[keyColumn]",
                        "name": "keyColumn",
                        "optional": true
                    },
                    {
                        "full": "[filter]",
                        "name": "filter",
                        "optional": true
                    },
                    {
                        "full": "[keepOrder]",
                        "name": "keepOrder",
                        "optional": true
                    },
                    {
                        "full": "[keyPurgeFilter]",
                        "name": "keyPurgeFilter",
                        "optional": true
                    },
                    {
                        "full": "[keyPurgeFreqInSecond=0]",
                        "name": "keyPurgeFreqInSecond",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[keyCapacity=1024]",
                        "name": "keyCapacity",
                        "optional": true,
                        "default": "1024"
                    },
                    {
                        "full": "[parallelism=1]",
                        "name": "parallelism",
                        "optional": true,
                        "default": "1"
                    }
                ]
            }
        ],
        "markdown": "### [DStream::reactiveStateEngine](https://docs.dolphindb.cn/zh/funcs/d/DStream_reactiveStateEngine.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nDStream::reactiveStateEngine(metrics, \\[keyColumn], \\[filter], \\[keepOrder], \\[keyPurgeFilter], \\[keyPurgeFreqInSecond=0], \\[keyCapacity=1024], \\[parallelism=1])\n\n#### 详情\n\n创建流计算响应式状态引擎。参考：[createReactiveStateEngine](https://docs.dolphindb.cn/zh/funcs/c/createReactiveStateEngine.html)。\n\n#### 参数\n\n**metrics** 以元代码的形式表示计算公式，可以是一个或多个表达式、系统内置或用户自定义函数、一个常量标量/向量。当指定为常量向量时，对应的输出列应该设置为数组向量类型。有关元代码的详情可参考 [Metaprogramming](https://docs.dolphindb.cn/zh/progr/objs/meta_progr.html)。若需使用用户自定义函数，请注意以下事项：\n\n1. 需在定义前添加声明 \"@state\"。状态函数只能包含赋值语句和 return 语句。\n\n   自 2.00.9 版本起，支持使用 if-else 条件语句，且条件只能是标量。\n\n   自2.00.11 版本起，支持使用 for 循环（包含 break, continue 语句），请注意不支持嵌套 for 循环，且循环次数须小于 100 次。\n\n2. 状态引擎中可以使用无状态函数或者状态函数。但不允许在无状态函数中嵌套使用状态函数。\n\n3. 若赋值语句的右值是一个多返回值的函数（内置函数或自定义函数），则需要将多个返回值同时赋予多个变量。例如：两个返回值的函数 linearTimeTrend 应用于自定义状态函数中，正确写法为：\n\n   ```\n   @state\n   def forcast2(S, N){\n         linearregIntercept, linearregSlope = linearTimeTrend(S, N)\n         return (N - 1) * linearregSlope + linearregIntercept\n   }\n   ```\n\n4. 在响应式状态引擎中，自定义状态函数不允许包含自赋值语句，如 `a=a+b`。以下示例中，当条件为 false 时，`iif` 表达式会返回 out，从而导致自赋值（`out = out`）并报错。\n\n   ```\n   out = iif((p1 > 0) and (p2 == 0), p1, out)\n   // An assignment statement in state function 'xxx' can't use self reference\n   ```\n\n**keyColumn** 可选参数，字符串标量或向量表示分组列名。若指定该参数，计算将在各分组进行。\n\n**filter** 可选参数，以元代码的形式表示过滤条件。过滤条件只能是一个表达式，并且只能包含 *dummyTable*中的列。设置多个条件时，用逻辑运算符（and, or）连接。引擎会先计算指标，然后根据 *filter*指定的过滤条件，输出满足条件的输入数据对应的计算结果。\n\n**keepOrder** 可选参数，表示输出表数据是否按照输入时的顺序排序。设置 *keepOrder* = true，表示输出表按照输入时的顺序排序。当 *keyColumn* 包含有时间列时，*keepOrder* 默认值为 true，否则默认值为 false。\n\n**keyPurgeFilter** 可选参数，是一个由布尔表达式组成的元代码，表示清理条件。各表达式只能引用 *outputTable* 中的字段。必须指定 *keyColumn* 才能使用该参数。\n\n**keyPurgeFreqInSecond** 正整数，表示触发数据清理需要满足的时间间隔（以秒为单位）。必须指定 *keyColumn* 才能使用该参数。\n\n**keyCapacity** 正整数，可选参数，表示建表时系统为该表预分配的 key 分组数量，用于调整状态表中 key 的函数。通过该参数的合理设置，能够降低在 key 分组较多时可能出现的延迟。\n\n**parallelism** 不超过63的正整数，可选参数，表示并行计算的工作线程数，默认值为 1。在计算量较大时，合理地调整该参数能够有效利用计算资源，降低计算耗时。\n\n**Note:** *parallelism* 不能超过 min(许可核数, 逻辑核数)-1。\n\n#### 返回值\n\n返回一个 DStream 对象。\n\n#### 例子\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\n// 如已存在流图，则先销毁该流图\n// dropStreamGraph('engine')\ng = createStreamGraph('engine')\n\ng.source(\"trades\", `date`time`sym`market`price`qty, [DATE, TIME, SYMBOL, CHAR, DOUBLE, INT])\n.reactiveStateEngine(metrics=<mavg(price, 3)>, keyColumn=[\"date\",\"sym\"], filter=<date between 2012.01.01 : 2012.01.03>, keepOrder=true)\n.sink(\"output\")\ng.submit()\ngo\n\nn=100\ntmp = table(rand(2012.01.01..2012.01.10, n) as date, rand(09:00:00.000..15:59:59.999, n) as time, rand(\"A\"+string(1..10), n) as sym, rand(['B', 'S'], n) as market, rand(100.0, n) as price, rand(1000..2000, n) as qty)\n\nappendOrcaStreamTable(\"trades\", tmp)\n```\n"
    },
    "DStream::reactiveStatelessEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/DStream_reactiveStatelessEngine.html",
        "signatures": [
            {
                "full": "DStream::reactiveStatelessEngine(metrics, [filter], [keyColumn], [timeColumn])",
                "name": "DStream::reactiveStatelessEngine",
                "parameters": [
                    {
                        "full": "metrics",
                        "name": "metrics"
                    },
                    {
                        "full": "[filter]",
                        "name": "filter",
                        "optional": true
                    },
                    {
                        "full": "[keyColumn]",
                        "name": "keyColumn",
                        "optional": true
                    },
                    {
                        "full": "[timeColumn]",
                        "name": "timeColumn",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [DStream::reactiveStatelessEngine](https://docs.dolphindb.cn/zh/funcs/d/DStream_reactiveStatelessEngine.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nDStream::reactiveStatelessEngine(metrics, \\[filter], \\[keyColumn], \\[timeColumn])\n\n#### 详情\n\n创建流计算响应式无状态引擎。参考：[createReactiveStatelessEngine](https://docs.dolphindb.cn/zh/funcs/c/createReactiveStatelessEngine.html)。\n\n#### 参数\n\n**metrics** 可以是表或字典数组，表示规则集合。\n\n* 当 *metrics* 为表时：必须以下四列：\n\n  * formula：STRING 类型，表示计算逻辑。其中的变量采用 *keyColumn* 指定的列中的值标识，*keyColumn* 如不止一列，则使用 `:` 连接各值。\n\n  * outputMetricKey：STRING 类型，为该计算指定指标名。\n\n  * triggerOn：STRING 类型，表示触发该计算的数据标识，即 *keyColumn* 指定的列为该值时触发计算，*keyColumn* 如不止一列，则使用 `:` 连接各值 。\n\n  * filter：一个数据对，表示计算结果的限定范围，属于该范围的结果才会被输出。\n\n* 当 *metrics* 为字典数组时：每个字典表示一条规则，包含键值 *outputName*，formula 以及可选键值 triggerOn，filter。\n\n**filter** 可选参数，一个数据对，表示引擎级整体输出过滤范围。仅当 *metrics* 中没有设置为空时才使用该整体过滤。\n\n**keyColumn** 可选参数，字符串标量或向量，表示输入表中用于标识数据的列名。\n\n**timeColumn** 可选参数，字符串标量或向量，表示输入表的时间戳列名。配置后输出表包含对应时间列，其值为触发本次计算的数据时间；若多个计算触发同时触发，取最大时间。\n\n#### 返回值\n\n返回一个 DStream 对象。\n\n#### 例子\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\n\n// 如已存在流图，则先销毁该流图\n// dropStreamGraph('engine')\n\ng = createStreamGraph('engine')\n\nmetrics = array(ANY, 0, 0)\nmetric1 = dict(STRING,ANY)\n// 依赖关系 product_B:value=product_A:factor1+product_A:factor2+product_B:factor1\nmetric1[\"outputName\"] = `product_B:`value\nmetric1[\"formula\"] = <A+B+C>\nmetric1[\"A\"] = `product_A:`factor1\nmetric1[\"B\"] = `product_A:`factor2\nmetric1[\"C\"] = `product_B:`factor1\nmetrics.append!(metric1)\n// 依赖关系 product_C:value=product_B:value*product_C:factor1\nmetric2 = dict(STRING, ANY)\nmetric2[\"outputName\"] =`product_C:`value\nmetric2[\"formula\"] = <A*B>\nmetric2[\"A\"] = `product_B:`value \nmetric2[\"B\"] = `product_C:`factor1\nmetrics.append!(metric2)\n\ng.source(\"input\", `product`factor`value, [STRING, STRING, DOUBLE])\n.reactiveStatelessEngine(metrics)\n.sink(\"output\")\ng.submit()\ngo\n\nproducts = take(\"product_A\", 2)\nfactors = [\"factor1\", \"factor2\"]\nvalues = [1.0, 2.0]\ntmp = table(products as product, factors as factor, values as value)\nappendOrcaStreamTable(\"input\", tmp)\n\nproducts = take(\"product_B\", 1)\nfactors = take(\"factor1\", 1)\nvalues = take(1.0, 1)\ntmp = table(products as product, factors as factor, values as value)\nappendOrcaStreamTable(\"input\", tmp)\n\n\nselect * from orca_table.output\n```\n\n| productName | metricName | metricsResults |\n| ----------- | ---------- | -------------- |\n| product\\_B  | value      |                |\n| product\\_C  | value      |                |\n| product\\_B  | value      | 4              |\n| product\\_C  | value      |                |\n"
    },
    "DStream::ruleEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/DStream_ruleEngine.html",
        "signatures": [
            {
                "full": "DStream::ruleEngine(ruleSets, outputColumns, [policy], [ruleSetColumn], [callback])",
                "name": "DStream::ruleEngine",
                "parameters": [
                    {
                        "full": "ruleSets",
                        "name": "ruleSets"
                    },
                    {
                        "full": "outputColumns",
                        "name": "outputColumns"
                    },
                    {
                        "full": "[policy]",
                        "name": "policy",
                        "optional": true
                    },
                    {
                        "full": "[ruleSetColumn]",
                        "name": "ruleSetColumn",
                        "optional": true
                    },
                    {
                        "full": "[callback]",
                        "name": "callback",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [DStream::ruleEngine](https://docs.dolphindb.cn/zh/funcs/d/DStream_ruleEngine.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nDStream::ruleEngine(ruleSets, outputColumns, \\[policy], \\[ruleSetColumn], \\[callback])\n\n#### 详情\n\n创建流计算规则引擎。参考：[createRuleEngine](https://docs.dolphindb.cn/zh/funcs/c/createRuleEngine.html)。\n\n#### 参数\n\n**ruleSets** 是一个字典，表示规则集。字典的 key 是 STRING 或 INT 类型，value 是一个包含元代码的元组。如果 key 为NULL，表示此条为默认规则。如果未指定 *ruleSetColumn*，或数据未命中任何规则，将采用默认规则检查数据。一个规则集必须包含默认规则。\n\n**outputColumns** 一个 STRING 类型向量，表示输入表中需要保留到输出表的列。\n\n**policy** 是一个字符串标量，表示规则检查策略。可取以下值：\n\n* \"shortcut\" 是默认值，代表短路逻辑。当检查到任一规则不符合（计算结果为 false）时，规则引擎立即停止检查并返回该规则的 index（从 0 开始）；如果所有规则都符合，则返回 NULL。比如数据匹配到如下规则，当 age 字段的值小于 18 时，计算结果为 false，规则引擎停止检查并返回 0 （规则的 index）到输出表中。\n\n  ```\n  (< age > 18 >,< income > 5000 >,< debtRatio < 0.5 >)\n  ```\n\n* \"all\" 代表检查全部规则，返回规则集的检查结果，布尔类型。比如数据匹配到如下规则，当 `voltage=220`、`current=37.11`、`temperature=39`，检查结果为 `[false, false, false]`。\n\n  ```\n  (< voltage > 221.86 >,< current > 39.96 >,< temperature > 44.43 >)\n  ```\n\n**ruleSetColumn** 是一个 STRING 类型标量，为输入表的某一列名，如果没有定义或者输入数据中的该列数据没有命中任何一个规则集，则使用默认规则，即规则集中 key 为 NULL 时所指示的规则。\n\n**callback** 是一个函数，其参数为一个元组，是引擎输出的一行。若设置此参数，引擎每处理一行，在将引擎处理结果输出到输出表的同时，会将该结果作为入参调用此函数。\n\n#### 返回值\n\n返回一个 DStream 对象。\n\n#### 例子\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\n// 如已存在流图，则先销毁该流图\n// dropStreamGraph('engine')\ng = createStreamGraph('engine')\n\n// 设置规则集\nx = [1, 2, NULL]\ny = [ [ < value > 1 > ], [ < price < 2 >, < price > 6 > ], [ < value*price > 10 > ] ]\nruleSets = dict(x, y)\n\n// 创建分布式表，用于回调函数写入数据\nif(existsDatabase(\"dfs://temp\")){\n    dropDatabase(\"dfs://temp\")\n}\ndb = database(\"dfs://temp\", VALUE, 1..3)\nt1 = table(1:0, `sym`value`price, [INT,DOUBLE,DOUBLE])\npt = db.createPartitionedTable(t1,`pt,`sym)\n\n// 创建回调函数，根据检测结果，将数据写入分布式表\ndef writeBack(result){\n    if(result.rule[0]==false){\n        temp = select sym,value,price from result\n        loadTable(\"dfs://temp\",`pt).append!(temp)\n    }\n}\n\ng.source(\"trades\", `sym`value`price`quantity, [INT, DOUBLE, DOUBLE, DOUBLE])\n.ruleEngine(ruleSets=ruleSets, outputColumns=[\"sym\",\"value\",\"price\"], policy=\"all\", ruleSetColumn=\"sym\", callback=writeBack)\n.sink(\"output\")\ng.submit()\ngo\n\ntmp=table(1 1 as sym, 0 2 as value, 2 2 as price, 3 3 as quantity)\nappendOrcaStreamTable(\"trades\", tmp)\n\nselect * from orca_table.output\n```\n\n| sym | value | price | rule     |\n| --- | ----- | ----- | -------- |\n| 1   | 0     | 2     | \\[false] |\n| 1   | 2     | 2     | \\[true]  |\n"
    },
    "DStream::sessionWindowEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/DStream_sessionWindowEngine.html",
        "signatures": [
            {
                "full": "DStream::sessionWindowEngine(sessionGap, metrics, [timeColumn], [useSystemTime=false], [keyColumn], [updateTime], [useSessionStartTime=true], [forceTriggerTime])",
                "name": "DStream::sessionWindowEngine",
                "parameters": [
                    {
                        "full": "sessionGap",
                        "name": "sessionGap"
                    },
                    {
                        "full": "metrics",
                        "name": "metrics"
                    },
                    {
                        "full": "[timeColumn]",
                        "name": "timeColumn",
                        "optional": true
                    },
                    {
                        "full": "[useSystemTime=false]",
                        "name": "useSystemTime",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[keyColumn]",
                        "name": "keyColumn",
                        "optional": true
                    },
                    {
                        "full": "[updateTime]",
                        "name": "updateTime",
                        "optional": true
                    },
                    {
                        "full": "[useSessionStartTime=true]",
                        "name": "useSessionStartTime",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[forceTriggerTime]",
                        "name": "forceTriggerTime",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [DStream::sessionWindowEngine](https://docs.dolphindb.cn/zh/funcs/d/DStream_sessionWindowEngine.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nDStream::sessionWindowEngine(sessionGap, metrics, \\[timeColumn], \\[useSystemTime=false], \\[keyColumn], \\[updateTime], \\[useSessionStartTime=true], \\[forceTriggerTime])\n\n#### 详情\n\n创建流计算会话窗口引擎。参考：[createSessionWindowEngine](https://docs.dolphindb.cn/zh/funcs/c/createSessionWindowEngine.html)。\n\n#### 参数\n\n**sessionGap** 必选参数，正整数标量，是判断窗口结束的时间指标，表示某条数据到来后若等待该时间仍无更新的数据到来，就终止当前窗口。此参数的时间精度取决于 *useSystemTime* 参数。\n\n**metrics** 以元代码的格式表示计算指标，支持输入元组。有关元代码的更多信息可参考 [元编程](https://docs.dolphindb.cn/zh/progr/objs/meta_progr.html)。\n\n* 计算指标可以是一个或多个系统内置或用户自定义的聚合函数（使用 defg 关键字定义），如 <\\[sum(volume), avg(price)]>；可以对聚合结果使用表达式，如 <\\[avg(price1)-avg(price2)]>；也可对列与列的计算结果进行聚合计算，如 <\\[std(price1-price2)]>。\n\n* *metrics* 内支持调用具有多个返回值的函数，例如 \\<func(price) as \\`col1\\`col2>（可不指定列名）。\n\n* 支持指定为一个常量标量或向量，例如 <1>，<\\[1, 2, 3]> 。当指定为常量向量时，对应的输出列必须设置为数组向量类型。\n\n* 若 *windowSize* 为向量， *windowSize* 每个值可对应 *metrics* 中多个计算指标。例如，*windowSize* 为\\[10,20]时，metrics可为 (<\\[min(volume), max(volume)]>, \\<sum(volume)>)。 *metrics* 也可以嵌套输入元组向量。例如：\\[\\[<\\[min(volume), max(volume)]>, \\<sum(volume)>], \\[\\<avg(volume)>]]\n\n  **Note:**\n\n  * *metrics* 中使用的列名大小写不敏感，不需要与输入表的列名大小写保持一致。\n  * *metrics* 中不可使用嵌套聚合函数。\n\n**timeColumn** 可选参数，字符串标量或向量。当 *useSystemTime* = false 时，必须指定该参数。 该参数用于指定订阅的流数据表中时间列的名称。\n\n**Note:** 字符串向量必须是 date 和 time 组成的向量，date 类型为 DATE，time 类型为 TIME, SECOND 或 NANOTIME。此时，输出表第一列的时间类型必须与 [concatDateTime(date, time)](https://docs.dolphindb.cn/zh/funcs/c/concatDateTime.html) 的类型一致。\n\n**useSystemTime** 可选参数，布尔值，表示是否使用数据注入引擎时的系统时间作为时间列进行计算。\n\n* 当 *useSystemTime* = true时，时间序列引擎会按照数据注入时间序列引擎的时刻（毫秒精度的本地系统时间，与数据中的时间列无关），每隔固定时间截取固定长度窗口的流数据进行计算。只要一个数据窗口中含有数据，数据窗口结束后就会自动进行计算。结果中的第一列为计算发生的时间戳，与数据中的时间无关。\n\n* 当 *useSystemTime* = false（缺省值）时，时间序列引擎根据流数据中的 *timeColumn* 列来截取数据窗口。一个数据窗口结束后的第一条新数据才会触发该数据窗口的计算。请注意，触发计算的数据并不会参与该次计算。\n\n  例如，一个数据窗口从 10:10:10 到 10:10:19。若 *useSystemTime* = true，则只要该窗口中至少有一条数据，该窗口的计算会在窗口结束后的 10:10:20 触发。若 *useSystemTime* = false，且 10:10:19 后的第一条数据为 10:10:25，则该窗口的计算会在 10:10:25 触发。\n\n**keyColumn** 可选参数，字符串标量或向量，表示分组列名。若设置，则分组进行聚合计算，例如以每支股票为一组进行聚合计算。\n\n**updateTime** 可选参数，非负整数，单位与 timeColumn 的时间精度一致。用于指定比 *step* 更短的计算时间间隔。*step* 必须是 *updateTime* 的整数倍。要设置 *updateTime*， *useSystemTime* 必须设为 false。\n\n* updateTime 指定为正整数值时：\n\n  * 从当前窗口的左边界开始，每隔 *updateTime* 时间，若有新的数据到来，则对当前窗口内该数据之前的所有数据进行计算。\n\n  * 如果系统经过 2 \\* *updateTime* （至少2秒）后仍有未被处理的数据，则触发对当前窗口内所有数据的计算。\n\n  * 若分组计算，则每组内进行上述操作。\n\n* updateTime 指定为 0 时：在新的数据到来后，立即对当前窗口的最新数据计算并输出。\n\n**useSessionStartTime**: 可选参数，布尔值，默认值为 true，表示输出表中的时刻为数据窗口起始时刻，即每个窗口中第一条数据的时间戳。若设置为 false，则表示输出表中的时刻为数据窗口结束时刻，即每个窗口中最后一条数据的时刻+ *sessionGap*。如果指定 *updateTime* ，*useSessionStartTime* 必须为 true。\n\n**forceTriggerTime** 可选参数，非负整数，单位与 *timeColumn* 的时间精度一致。该参数仅在设置 *useSystemTime* = false 时起效。当系统收到最后一条数据后，经过 *forceTriggerTime* 时间，将强制触发未计算的窗口进行计算。\n\n#### 返回值\n\n返回一个 DStream 对象。\n\n#### 例子\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\n// 如已存在流图，则先销毁该流图\n// dropStreamGraph('engine')\ng = createStreamGraph('engine')\n\ng.source(\"trades\", `time`sym`volume, [TIMESTAMP, SYMBOL, INT])\n.sessionWindowEngine(sessionGap = 5, metrics = <sum(volume)>, timeColumn = `time, keyColumn=`sym)\n.sink(\"output\")\ng.submit()\ngo\n\nn = 5\ntime = 2018.10.12T10:01:00.000 + (1..n)\nsym = take(`A`B`C, n)\nvolume = (1..n) % 1000\ntmp = table(time as time, sym as sym, volume as volume)\nappendOrcaStreamTable(\"trades\", tmp)\n\nn = 5\ntime = 2018.10.12T10:01:00.010 + (1..n)\nsym = take(`A`B`C, n)\nvolume = (1..n) % 1000\ntmp = table(time as time, sym as sym, volume as volume)\nappendOrcaStreamTable(\"trades\", tmp)\n\nn = 6\ntime = 2018.10.12T10:01:00.020 + 1 2 3 8 14 20\nsym = take(`A`B`C, n)\nvolume = (1..n) % 1000\ntmp = table(time as time, sym as sym, volume as volume)\nappendOrcaStreamTable(\"trades\", tmp)\n\nselect * from orca_table.output\n```\n\n| time                    | sym | volume |\n| ----------------------- | --- | ------ |\n| 2018.10.12 10:01:00.001 | A   | 5      |\n| 2018.10.12 10:01:00.002 | B   | 7      |\n| 2018.10.12 10:01:00.003 | C   | 3      |\n| 2018.10.12 10:01:00.011 | A   | 5      |\n| 2018.10.12 10:01:00.012 | B   | 7      |\n| 2018.10.12 10:01:00.013 | C   | 3      |\n| 2018.10.12 10:01:00.021 | A   | 1      |\n| 2018.10.12 10:01:00.022 | B   | 2      |\n| 2018.10.12 10:01:00.023 | C   | 3      |\n"
    },
    "DStream::setEngineName": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/DStream_setEngineName.html",
        "signatures": [
            {
                "full": "DStream::setEngineName(name)",
                "name": "DStream::setEngineName",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    }
                ]
            }
        ],
        "markdown": "### [DStream::setEngineName](https://docs.dolphindb.cn/zh/funcs/d/DStream_setEngineName.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nDStream::setEngineName(name)\n\n#### 详情\n\n为当前流引擎设置名称。如果系统中已存在同名引擎，则会抛出异常。\n\n#### 参数\n\n**name** 表示引擎名称。字符串标量，可以传入完整的全限定名（如 \"catalog\\_name.orca\\_engine.engine\\_name\"）；或引擎名（如 \"engine\\_name\"），系统会根据当前的 catalog 设置自动补全为对应的全限定名。\n\n#### 返回值\n\n返回一个 DStream 对象。\n"
    },
    "DStream::sharedDict": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/dstream_shareddict.html",
        "signatures": [
            {
                "full": "DStream::sharedDict(name, keyObj, valueObj, [ordered=false])",
                "name": "DStream::sharedDict",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "keyObj",
                        "name": "keyObj"
                    },
                    {
                        "full": "valueObj",
                        "name": "valueObj"
                    },
                    {
                        "full": "[ordered=false]",
                        "name": "ordered",
                        "optional": true,
                        "default": "false"
                    }
                ]
            },
            {
                "full": "DStream::sharedDict(name, keyType, valueType, [ordered=false])",
                "name": "DStream::sharedDict",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "keyType",
                        "name": "keyType"
                    },
                    {
                        "full": "valueType",
                        "name": "valueType"
                    },
                    {
                        "full": "[ordered=false]",
                        "name": "ordered",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [DStream::sharedDict](https://docs.dolphindb.cn/zh/funcs/d/dstream_shareddict.html)\n\n\n\n#### 语法\n\nDStream::sharedDict(name, keyObj, valueObj, \\[ordered=false])\n\n或\n\nDStream::sharedDict(name, keyType, valueType, \\[ordered=false])\n\n#### 详情\n\n在 Orca 中创建一个共享字典，仅支持在 `DStream::udfEngine` 中使用。关于字典的说明参见 [dict](https://docs.dolphindb.cn/zh/funcs/d/dict.html)。\n\n#### 参数\n\n**name** 字符串标量，表示共享字典的名称。\n\n对于第一种情形，**keyObj** 是表示键的向量，**valueObj** 是表示值的向量。\n\n对于第二种情形，**keyType** 是字典键的数据类型，**valueType** 是字典值的数据类型。系统支持以下键的数据类型：Literal、Integral（COMPRESS 除外）、Floating 和 Temporal。字典中的值不支持 COMPLEX，POINT 和 Decimal 类别。\n\n**ordered** 一个布尔值，默认为 false，表示创建一个无序字典。当 *ordered* = true 时，创建一个有序字典。无序字典在输出或进行遍历时，其键值对不保留输入时的顺序；有序字典在输出或进行遍历时，键值对的顺序与输入顺序保持一致。\n\n#### 返回值\n\n一个字典。\n\n#### 例子\n\n本例结合 `DStream::sharedDict` 与 `DStream::udfEngine`，实现计数并触发条件告警的功能。具体实现为，使用 `DStream::sharedDict` 统计每个键（key）的出现次数。当某个键的累计计数超过预设阈值时，自定义函数将向下游输出一条告警消息。\n\n```\nif(existsCatalog(\"orcaCatalog\")) dropCatalog(\"orcaCatalog\")\ncreateCatalog(\"orcaCatalog\")\ngo\nuse catalog orcaCatalog\n// 创建流图\ng = createStreamGraph(\"counter\")\ng.sharedDict(\"counts\", STRING, LONG)\ng.source(\"items\", [\"key\"], [STRING])\n  .udfEngine(def(msg) {\n    counts = orcaObj(\"counts\")\n    triggered = table(100:0, `key`count, [STRING, LONG])\n    for(i in 0:msg.size()) {\n        keyVal = msg.key[i]\n        // 读取当前计数\n        current = 0\n        if (keyVal in counts) {\n            current = counts[keyVal]\n        }\n        newCount = current + 1\n        // 更新计数\n        counts[keyVal] = newCount\n        // 判断条件\n        if(newCount >= 3) {\n            triggered.append!(table(keyVal as key, newCount as count))\n        }\n    }\n    return triggered\n  })\n  .sink(\"alerts\")\ng.submit()\ngo\n// 生成模拟数据\nkeys = [\"A\", \"B\", \"A\", \"C\", \"B\", \"A\", \"B\", \"B\", \"C\", \"C\"]\nmockData1 = table(take(keys[0:3], 3) as key)\nmockData2 = table(take(keys[3:6], 3) as key)\nmockData3 = table(take(keys[6:10], 4) as key)\n// 插入数据\nappendOrcaStreamTable(\"orcaCatalog.orca_table.items\", mockData1)\nappendOrcaStreamTable(\"orcaCatalog.orca_table.items\", mockData2) \nappendOrcaStreamTable(\"orcaCatalog.orca_table.items\", mockData3)\n// 等待处理并查看结果\nsleep(1000)\nselect * from orcaCatalog.orca_table.alerts;\n```\n\n| key | count |\n| --- | ----- |\n| A   | 3     |\n| B   | 3     |\n| B   | 4     |\n| C   | 3     |\n"
    },
    "DStream::sharedKeyedTable": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/dstream_sharedkeyedtable.html",
        "signatures": [
            {
                "full": "DStream::sharedKeyedTable(name, keyColumns, X, [X1], [X2], .....)",
                "name": "DStream::sharedKeyedTable",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "keyColumns",
                        "name": "keyColumns"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[X1]",
                        "name": "X1",
                        "optional": true
                    },
                    {
                        "full": "[X2]",
                        "name": "X2",
                        "optional": true
                    },
                    {
                        "full": ".....",
                        "name": "....."
                    }
                ]
            },
            {
                "full": "DStream::sharedKeyedTable(name, keyColumns, capacity:size, colNames, colTypes)",
                "name": "DStream::sharedKeyedTable",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "keyColumns",
                        "name": "keyColumns"
                    },
                    {
                        "full": "capacity:size",
                        "name": "capacity:size"
                    },
                    {
                        "full": "colNames",
                        "name": "colNames"
                    },
                    {
                        "full": "colTypes",
                        "name": "colTypes"
                    }
                ]
            },
            {
                "full": "DStream::sharedKeyedTable(name, keyColumns, table)",
                "name": "DStream::sharedKeyedTable",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "keyColumns",
                        "name": "keyColumns"
                    },
                    {
                        "full": "table",
                        "name": "table"
                    }
                ]
            }
        ],
        "markdown": "### [DStream::sharedKeyedTable](https://docs.dolphindb.cn/zh/funcs/d/dstream_sharedkeyedtable.html)\n\n\n\n#### 语法\n\nDStream::sharedKeyedTable(name, keyColumns, X, \\[X1], \\[X2], .....)\n\n或\n\nDStream::sharedKeyedTable(name, keyColumns, capacity:size, colNames, colTypes)\n\n或\n\nDStream::sharedKeyedTable(name, keyColumns, table)\n\n#### 详情\n\n在 Orca 中创建一个共享键值内存表，仅支持在 `DStream::udfEngine` 中使用。关于键值内存表的说明参见 [keyedTable](https://docs.dolphindb.cn/zh/funcs/k/keyedTable.html)。\n\n#### 参数\n\n**name** 字符串标量，表示共享键值内存表的名称。\n\n**keyColumns** 是一个字符串标量或向量，表示主键。主键的数据类型必须属于以下类别： INTEGRAL, TEMPORAL 或 LITERAL。\n\n第一种用法中，**X**, **X1**, **X2** ... 可以是向量、数组向量、矩阵或元组。每个向量、元组、数组向量的长度，以及矩阵中每列长度都必须相同。**当 Xk 是元组时：**\n\n* 若 Xk 的元素是等长的向量，\\*\\*元组的每个元素将作为表的一列。\\*\\*元组的长度必须等于表的行数。\n\n* 若 Xk 包含不同类型或不等长元素，\\*\\*则将单独作为表的一列（列类型为 ANY），其每个元素将作为该列每行的元素值。\\*\\*Xk 的长度仍然必须和表的行数保持一致。\n\n第二种用法中：\n\n* **capacity** 是正整数，表示建表时系统为该表分配的内存（以记录数为单位）。当记录数超过 *capacity* 时，系统首先会分配 *capacity* 1.2\\~2倍的新的内存空间，然后复制数据到新的内存空间，最后释放原来的内存。对于规模较大的表，此类操作的内存占用会很高。因此，建议建表时预先分配一个合理的 *capacity*。\n\n* **size** 是整数，表示该表新建时的行数。若 *size* =0，创建一个空表。 若 *size*>0，则建立一个只包含 size 条记录的表，记录初始值如下：\n\n  * BOOL 类型默认值为 false；\n\n  * 数值类型、时间类型、IPADDR、COMPLEX、POINT 的默认值为 0；\n\n  * Literal, INT128 类型的默认值为 NULL。\n\n  **Note:** 如果 *colTypes* 指定为数组向量， *size* 必须为0。\n\n* **colNames** 是一个向量，表示列名。\n\n* **colTypes** 是一个向量，表示每列的数据类型，允许主键外的其它列指定为数组向量类型或元组（ANY）类型。可使用表示数据类型的系统保留字或相应的字符串。\n\n第三种用法中，`table` 是一个表。注意，*table* 中的 *keyColumns* 不能包含重复值。\n\n#### 返回值\n\n一个键值内存表。\n\n#### 例子\n\n下面通过 `DStream::sharedKeyedTable` 与 `DStream::udfEngine` 的结合，实现计算历史差值的功能。\n\n在本示例中，使用 `DStream::sharedKeyedTable` 存储已处理数据的历史记录，对每个 id 仅保留最新的一条记录。当新数据到达时，若该 id 已存在于表中，则输出新值与历史值之间的差值；否则，仅将新数据存入表中，不输出。\n\n```\nif(existsCatalog(\"orcaCatalog\")) dropCatalog(\"orcaCatalog\")\ncreateCatalog(\"orcaCatalog\")\ngo\nuse catalog orcaCatalog\n// 创建流图\ng = createStreamGraph(\"compare\")\ng.sharedKeyedTable(\"history\", \"id\", 1:0, `id`value, [INT, DOUBLE])\ng.source(\"data\", `id`value`time, [INT, DOUBLE, TIMESTAMP])\n  .udfEngine(def(msg) {\n    history = orcaObj(\"history\")\n    diffTable = table(100:0, `id`diff, [INT, DOUBLE])\n    for(i in 0:msg.size()) {\n        idVal = msg.id[i]\n        valueVal = msg.value[i]\n        // 读取历史值\n        old = select value from history where id = idVal\n        // 写入新值\n        newRow = table(idVal as id, valueVal as value)\n        history.append!(newRow)\n        // 计算差值\n        if(old.size() > 0) {\n            diffTable.append!(table(idVal as id, (valueVal - old.value[0]) as diff))\n        }\n    }\n    return diffTable\n  })\n  .sink(\"comparison\")\ng.submit()\ngo\n// 生成模拟数据\nmockData = table(1..5 as id, rand(100.0, 5) as value, now() + 1..5 as time)\n// 插入数据\nappendOrcaStreamTable(\"orcaCatalog.orca_table.data\", mockData)\n// 生成id重复的数据\nmockData = table(1..5 as id, rand(100.0, 5) as value, now() + 1..5 as time)\n// 插入数据\nappendOrcaStreamTable(\"orcaCatalog.orca_table.data\", mockData)\n// 等待处理并查看结果\nsleep(1000)\nselect * from orcaCatalog.orca_table.comparison\n```\n\n| id | diff                |\n| -- | ------------------- |\n| 1  | 35.55946895749296   |\n| 2  | -3.4362593906550387 |\n| 3  | 36.283468999034596  |\n| 4  | 68.97968558337999   |\n| 5  | -91.64246928217878  |\n"
    },
    "DStream::sharedTable": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/dstream_sharedtable.html",
        "signatures": [
            {
                "full": "DStream::sharedTable(name, X, [X1], [X2], .....)",
                "name": "DStream::sharedTable",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[X1]",
                        "name": "X1",
                        "optional": true
                    },
                    {
                        "full": "[X2]",
                        "name": "X2",
                        "optional": true
                    },
                    {
                        "full": ".....",
                        "name": "....."
                    }
                ]
            },
            {
                "full": "DStream::sharedTable(name, capacity:size, colNames, colTypes)",
                "name": "DStream::sharedTable",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "capacity:size",
                        "name": "capacity:size"
                    },
                    {
                        "full": "colNames",
                        "name": "colNames"
                    },
                    {
                        "full": "colTypes",
                        "name": "colTypes"
                    }
                ]
            }
        ],
        "markdown": "### [DStream::sharedTable](https://docs.dolphindb.cn/zh/funcs/d/dstream_sharedtable.html)\n\n\n\n#### 语法\n\nDStream::sharedTable(name, X, \\[X1], \\[X2], .....)\n\n或\n\nDStream::sharedTable(name, capacity:size, colNames, colTypes)\n\n#### 详情\n\n在 Orca 中创建一个共享内存表，仅支持在 `DStream::udfEngine` 中使用。关于内存表的说明参见 [table](https://docs.dolphindb.cn/zh/funcs/t/table.html)。\n\n#### 参数\n\n**name** 字符串标量，表示共享键值内存表的名称。\n\n第一种用法中，**X**, **X1**, **X2** ... 可以是向量、数组向量、矩阵或元组。每个向量、元组、数组向量的长度，以及矩阵中每列长度都必须相同。**当 Xk 是元组时：**\n\n* 若 Xk 的元素是等长的向量，\\*\\*元组的每个元素将作为表的一列。\\*\\*元组的长度必须等于表的行数。\n\n* 若 Xk 包含不同类型或不等长元素，\\*\\*则将单独作为表的一列（列类型为 ANY），其每个元素将作为该列每行的元素值。\\*\\*Xk 的长度仍然必须和表的行数保持一致。\n\n第二种用法中：\n\n* **capacity** 是正整数，表示建表时系统为该表分配的内存（以记录数为单位）。当记录数超过 *capacity* 时，系统首先会分配 *capacity* 1.2\\~2倍的新的内存空间，然后复制数据到新的内存空间，最后释放原来的内存。对于规模较大的表，此类操作的内存占用会很高。因此，建议建表时预先分配一个合理的 *capacity*。\n\n* **size** 是整数，表示该表新建时的行数。若 *size* =0，创建一个空表。 若 *size*>0，则建立一个只包含 size 条记录的表，记录初始值如下：\n\n  * BOOL 类型默认值为 false；\n\n  * 数值类型、时间类型、IPADDR、COMPLEX、POINT 的默认值为 0；\n\n  * Literal, INT128 类型的默认值为 NULL。\n\n  **Note:** 如果 *colTypes* 指定为数组向量， *size* 必须为0。\n\n* **colNames** 是一个向量，表示列名。\n\n* **colTypes** 是一个向量，表示每列的数据类型，支持数组向量类型和元组（ANY）类型。可使用表示数据类型的系统保留字或相应的字符串。\n\n#### 返回值\n\n一个表。\n\n#### 例子\n\n本例结合 `DStream::sharedTable` 与 `DStream::udfEngine`，实现实时计算并输出当前平均值的功能。`DStream::sharedTable` 用于持续保存每次计算得到的历史平均值。每次处理新数据时，UDF 会基于最新数据重新计算平均值，将其追加到 `DStream::sharedTable` 中，并仅将最新一行（即当前最新的平均值）输出至下游。\n\n```\nif(existsCatalog(\"orcaCatalog\")) dropCatalog(\"orcaCatalog\")\ncreateCatalog(\"orcaCatalog\")\ngo\nuse catalog orcaCatalog\n\n// 创建流图\ng = createStreamGraph(\"avgCalc\")\ng.sharedTable(\"stats\", 1:0, `sum`count, [DOUBLE, LONG])\n\ng.source(\"numbers\", [\"value\"], [DOUBLE])\n  .udfEngine(def(msg) {\n    stats = orcaObj(\"stats\")\n    \n    // 读取历史统计值\n    if(stats.size() > 0) {\n        lastSum = exec last(sum) from stats\n        lastCount = exec last(count) from stats\n    } else {\n        lastSum = 0.0\n        lastCount = 0\n    }\n    \n    // 计算新值\n    newSum = lastSum + sum(msg.value)\n    newCount = lastCount + msg.size()\n    if (newCount > 0) {\n        avgValue = newSum / newCount\n    } else {\n        avgValue = 0.0\n    }\n    \n    // 写入新值\n    newRow = table(newSum as sum, newCount as count)\n    stats.append!(newRow)\n    \n    // 返回计算结果\n    return table(newSum as total, newCount as count, avgValue as avg)\n  })\n  .sink(\"output\")\n\ng.submit()\ngo\n// 生成模拟数据\nmockData1 = table(rand(10.0, 3) as value)\nmockData2 = table(rand(10.0, 5) as value)\nmockData3 = table(rand(10.0, 2) as value)\n\n// 插入数据,等待处理并查看结果\nappendOrcaStreamTable(\"orcaCatalog.orca_table.numbers\", mockData1)\nselect * from orcaCatalog.orca_table.numbers;\nselect * from orcaCatalog.orca_table.output;\nappendOrcaStreamTable(\"orcaCatalog.orca_table.numbers\", mockData2)\nselect * from orcaCatalog.orca_table.numbers;\nselect * from orcaCatalog.orca_table.output;\nappendOrcaStreamTable(\"orcaCatalog.orca_table.numbers\", mockData3)\nselect * from orcaCatalog.orca_table.numbers;\nselect * from orcaCatalog.orca_table.output;\n```\n"
    },
    "DStream::sink": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/DStream_sink.html",
        "signatures": [
            {
                "full": "DStream::sink(dest|name, [asyncWrite=true], [compress=true], [cacheSize], [retentionMinutes=1440], [flushMode=0], [preCache], [cachePurgeTimeColumn], [cachePurgeInterval], [cacheRetentionTime])",
                "name": "DStream::sink",
                "parameters": [
                    {
                        "full": "dest|name",
                        "name": "dest|name"
                    },
                    {
                        "full": "[asyncWrite=true]",
                        "name": "asyncWrite",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[compress=true]",
                        "name": "compress",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[cacheSize]",
                        "name": "cacheSize",
                        "optional": true
                    },
                    {
                        "full": "[retentionMinutes=1440]",
                        "name": "retentionMinutes",
                        "optional": true,
                        "default": "1440"
                    },
                    {
                        "full": "[flushMode=0]",
                        "name": "flushMode",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[preCache]",
                        "name": "preCache",
                        "optional": true
                    },
                    {
                        "full": "[cachePurgeTimeColumn]",
                        "name": "cachePurgeTimeColumn",
                        "optional": true
                    },
                    {
                        "full": "[cachePurgeInterval]",
                        "name": "cachePurgeInterval",
                        "optional": true
                    },
                    {
                        "full": "[cacheRetentionTime]",
                        "name": "cacheRetentionTime",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [DStream::sink](https://docs.dolphindb.cn/zh/funcs/d/DStream_sink.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nDStream::sink(dest|name, \\[asyncWrite=true], \\[compress=true], \\[cacheSize], \\[retentionMinutes=1440], \\[flushMode=0], \\[preCache], \\[cachePurgeTimeColumn], \\[cachePurgeInterval], \\[cacheRetentionTime])\n\n#### 详情\n\n在 Orca 中，`sink` 接口是声明式 API（DStream API）中的终止节点，用于定义流图的输出目标，将流数据输出到持久化共享流数据表、DFS 表或函数。\n\n当 sink 目标为流表时，如果该表尚未创建，则会在首次写入数据时根据输入数据结构自动创建，并完成 schema 推导。\n\n对同一流表的多个 sink 写入操作，必须保持 schema 一致；否则系统将抛出 schema 冲突错误。\n\n有关持久化流数据表的更多信息，请参阅 [enableTableShareAndPersistence](https://docs.dolphindb.cn/zh/funcs/e/enableTableShareAndPersistence.html) 手册。\n\n#### 参数\n\n**dest | name** 流数据的输出目标，可以是：\n\n* 字符串标量，指定目标流表或 DFS 表全限定名（如 \"catalog\\_name.orca\\_table.table\\_name\"）或 DFS 表路径（如 \"dfs\\://dbName/tableName\"）。\n* 一元函数，入参为流数据消息组成的表，忽略返回值。\n\n**asyncWrite** 可选参数，是一个布尔值，表示是否异步持久化数据到磁盘。默认值为 true，流数据写入内存即为写入成功，持久化到磁盘的操作将会由另一个线程执行。\n\n**Note:**\n\n持久化数据到磁盘包含两个步骤：\n\n* 写内存数据到操作系统缓存\n\n* 写缓存数据到磁盘（是否开启同步刷盘由参数 *flushMode* 决定）\n\n**compress** 可选参数，是一个布尔值，表示是否以压缩模式模式保存至磁盘。默认值为 true。\n\n**cacheSize** 可选参数，整数，表示流数据表在内存中最多保留多少行。如果未指定该参数，则所有记录行都会保存在内存中。如果 *cacheSize* 小于 1000，它会被自动调整为 1000。\n\n**retentionMinutes** 可选参数，是一个整数，表示文件大小超过 1GB的 log 文件的保留时间(从文件的最后修改时间开始计算)，单位是分钟。默认值是 1440，即一天。如果 log 文件未达 1GB，则会一直保留至大小达到 1GB。\n\n**flushMode** 可选参数，是一个整数，表示是否开启同步刷盘，取值只能为 0 或 1。默认值是 0，表示异步刷盘，内存中的流数据写入操作系统缓存即为写入成功，并进行下一批数据的写入。 若为 1，则表示同步刷盘，当前批次的流数据必须落盘完成，才会进行下一批数据的写入。\n\n**preCache** 可选参数，是一个整数，表示从磁盘加载到内存的记录条数。如果没有指定该参数，重启后实际加载到内存的数据量受 *cacheSize* 限制。\n\n**cachePurgeTimeColumn** 可选参数，字符串标量，需要指定为持久化流表中的时间列名称。\n\n**cachePurgeInterval** 可选参数，DURATION 类型标量，表示触发清理内存中数据的时间间隔。\n\n**cacheRetentionTime** 可选参数，DURATION 类型标量，表示内存中数据的最长保留期限。\n\n#### 返回值\n\n返回一个 DStream 对象。\n"
    },
    "DStream::snapshotJoinEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/DStream_snapshotJoinEngine.html",
        "signatures": [
            {
                "full": "DStream::snapshotJoinEngine(rightStream, metrics, matchingColumn, [timeColumn], [keepLeftDuplicates=false], [keepRightDuplicates=false], [isInnerJoin=true])",
                "name": "DStream::snapshotJoinEngine",
                "parameters": [
                    {
                        "full": "rightStream",
                        "name": "rightStream"
                    },
                    {
                        "full": "metrics",
                        "name": "metrics"
                    },
                    {
                        "full": "matchingColumn",
                        "name": "matchingColumn"
                    },
                    {
                        "full": "[timeColumn]",
                        "name": "timeColumn",
                        "optional": true
                    },
                    {
                        "full": "[keepLeftDuplicates=false]",
                        "name": "keepLeftDuplicates",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[keepRightDuplicates=false]",
                        "name": "keepRightDuplicates",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[isInnerJoin=true]",
                        "name": "isInnerJoin",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [DStream::snapshotJoinEngine](https://docs.dolphindb.cn/zh/funcs/d/DStream_snapshotJoinEngine.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nDStream::snapshotJoinEngine(rightStream, metrics, matchingColumn, \\[timeColumn], \\[keepLeftDuplicates=false], \\[keepRightDuplicates=false], \\[isInnerJoin=true])\n\n#### 详情\n\n创建流计算快照连接引擎。参考：[createSnapshotJoinEngine](https://docs.dolphindb.cn/zh/funcs/c/createsnapshotjoinengine.html)。\n\n#### 参数\n\n**rightStream** DStream 对象，表示输入的右表数据源。\n\n**metrics**：以元代码的格式表示计算指标，支持输入元组。有关元代码的更多信息可参考 [Metaprogramming](https://docs.dolphindb.cn/zh/progr/objs/meta_progr.html)。\n\n* 计算指标可以是一个或多个表达式、系统内置或用户自定义函数，但不能是聚合函数。\n\n* *metrics* 内支持调用具有多个返回值的函数，且必须指定列名，例如 \\<func(price) as \\`col1\\`col2>。\n\n* 若在 *metrics* 指定了 *leftTable* 和 *rightTable* 中具有相同名称的列，默认取左表的列，可以通过 \"tableName.colName\" 指定该列来自哪个表。\n\n  **注：** *metrics* 中使用的列名大小写不敏感，不需要与输入表的列名大小写保持一致。\n\n\\*\\*matchingColumn：\\*\\*表示连接列的字符串标量/向量或字符串向量组成的 tuple，支持 Integral, Temporal 或 Literal(UUID 除外)类型。*matchingColumn* 指定规则：\n\n1. 只有一个连接列。当左表和右表的连接列名相同时，*matchingColumn* 是一个字符串标量，否则是一个长度为 2 的 tuple。例如：左表连接列名为 sym，右表连接列名为 sym1，则 *matchingColumn* = \\[\\[\\`sym],\\[\\`sym1]]。\n\n2. 有多个连接列。当左表和右表的连接列名相同时，*matchingColumn* 是一个字符串向量，否则是一个长度为 2 的 tuple。例如：左表连接列名为 timestamp, sym，右表连接列名为 timestamp, sym1，则 *matchingColumn* = \\[\\[\\`timestamp, \\`sym], \\[\\`timestamp,\\`sym1]]。\n\n\\*\\*timeColumn:\\*\\*字符串标量或向量，可选参数。用于指定 leftTable 和 rightTable 中时间列的名称。两表的时间列名称可以不同，但数据类型需保持一致。当 leftTable 和 rightTable 时间列名称相同时，timeColumn 是字符串标量，否则，timeColumn 是长度为2的字符串向量。\n\n**keepLeftDuplicates**：布尔值，可选参数，表示在进行右连接时，是否匹配左表各分组内的所有数据。\n\n* 若设置为 false（默认值）：仅匹配左表各分组内的最新一条数据。\n\n* 若设置为 true：匹配左表各分组内的所有数据。\n\n**keepRightDuplicates**：布尔值，可选参数，表示在进行左连接时，是否保留右表各分组内的所有数据。\n\n* 若设置为 false（默认值）：仅匹配右表各分组内的最新一条数据。\n\n* 若设置为 true：匹配右表各分组内的所有数据。\n\n\\*\\*isInnerJoin：\\*\\*布尔值，可选参数，表示是否进行内连接。\n\n* 若设置为 true（默认值）：进行内连接，只有左右两表匹配的记录被计算输出。\n\n* 若设置为 false：进行左连接或右连接，保留两个表中的所有记录。对于左右两表中匹配的记录进行计算，而未匹配的记录输出空值。\n\n#### 返回值\n\n返回一个 DStream 对象。\n\n#### 例子\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\n\n// 如已存在流图，则先销毁该流图\n// dropStreamGraph('joinEngine')\n\ng = createStreamGraph('joinEngine')\nr = g.source(\"right\", `timestamp`sym2`id`price`qty, [TIMESTAMP, SYMBOL, INT, DOUBLE, DOUBLE])\ng.source(\"left\", `timestamp`sym1`id`price`val, [TIMESTAMP, SYMBOL, INT, DOUBLE, DOUBLE])\n    .snapshotJoinEngine(r, metrics=[<val*10>, <qty>], matchingColumn = [[\"id\",\"sym1\"],[\"id\",\"sym2\"]], \ntimeColumn = `timestamp, isInnerJoin=true, keepLeftDuplicates=true,keepRightDuplicates=true)\n    .sink(\"output\")\ng.submit()\ngo\n\ntimestamp = 2024.10.10T15:12:01.507+1..10\nsym = take([\"a\",\"b\",\"c\",\"d\"],10)\nid = [1,1,2,1,5,2,4,4,1,4]\nprice = [2.53,7.61,8.07,7.87,7.29,9.39,5.98,9.49,9.20,9.17]\nval = [101,108,101,109,104,100,108,100,107,104]\ntmp1 = table(timestamp as timestamp,sym as sym1,id as id,price as price,val as val)\nappendOrcaStreamTable(\"left\", tmp1)\n\nid = [1,2,4,3,5,5,4,2,5,5]\nprice =  [1.08,9.08,9.97,7.60,1.91,6.77,7.81,8.81,0.61,5.92]\nqty =  [208,200,203,202,204,201,206,207,205,205]\ntmp2 = table(timestamp as timestamp,sym as sym2,id as id,price as price,qty as qty)\nappendOrcaStreamTable(\"right\", tmp2)\n\nselect * from orca_table.output\n```\n\n| id | sym1 | timestamp               | right\\_timestamp        | val\\_mul | qty |\n| -- | ---- | ----------------------- | ----------------------- | -------- | --- |\n| 0  | a    | 2024.10.10 15:12:01.508 | 2024.10.10 15:12:01.508 | 1,010    | 208 |\n| 1  | a    | 2024.10.10 15:12:01.512 | 2024.10.10 15:12:01.512 | 1,040    | 204 |\n| 2  | a    | 2024.10.10 15:12:01.512 | 2024.10.10 15:12:01.516 | 1,040    | 205 |\n| 3  | b    | 2024.10.10 15:12:01.513 | 2024.10.10 15:12:01.509 | 1,000    | 200 |\n| 4  | c    | 2024.10.10 15:12:01.514 | 2024.10.10 15:12:01.510 | 1,080    | 203 |\n| 5  | c    | 2024.10.10 15:12:01.514 | 2024.10.10 15:12:01.514 | 1,080    | 206 |\n| 6  | a    | 2024.10.10 15:12:01.516 | 2024.10.10 15:12:01.508 | 1,070    | 208 |\n"
    },
    "DStream::sparseReactiveStateEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/DStream_SparseReactiveStateEngine.html",
        "signatures": [
            {
                "full": "DStream::sparseReactiveStateEngine(metrics, keyColumn, [extraColumn])",
                "name": "DStream::sparseReactiveStateEngine",
                "parameters": [
                    {
                        "full": "metrics",
                        "name": "metrics"
                    },
                    {
                        "full": "keyColumn",
                        "name": "keyColumn"
                    },
                    {
                        "full": "[extraColumn]",
                        "name": "extraColumn",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [DStream::sparseReactiveStateEngine](https://docs.dolphindb.cn/zh/funcs/d/DStream_SparseReactiveStateEngine.html)\n\n首发版本：3.00.5\n\n\n\n#### 语法\n\nDStream::sparseReactiveStateEngine(metrics, keyColumn, \\[extraColumn])\n\n#### 详情\n\n创建流计算稀疏响应式状态引擎。参考：[createSparseReactiveStateEngine](https://docs.dolphindb.cn/zh/funcs/c/createSparseReactiveStateEngine.html)。\n\n#### 参数\n\n**metrics** 是一个表，表示稀疏状态计算规则集合。该表至少包含 3 列：\n\n* 前若干列为特定数据的标识列，与 *keyColumn* 指定的列名和顺序一致。\n\n* formula：可以是字符串或元代码，表示该特定数据到达时触发的计算表达式。\n\n* outputMetricKey：字符串标量，为该计算指定指标名。\n\n**注**：Orca 中包含自定义函数的 formula 仅支持 `<>` 格式的元代码。\n\n**keyColumn** 字符串标量或向量，表示输入表中标识特定数据的主键列名。\n\n**extraColumn** 可选参数，字符串标量或向量，表示输入表中需要保留到输出表的列名。\n\n#### 返回值\n\n返回一个 DStream 对象。\n\n#### 例子\n\n```\n// 若 catalog 不存在则创建\nif (!existsCatalog(\"orca\")) {  \n    createCatalog(\"orca\")  \n}  \ngo  \nuse catalog orca  \n  \n// 如已存在流图，则先销毁该流图\n// dropStreamGraph(\"sparseGraph\")\ng = createStreamGraph(\"sparseGraph\")\n\n// 定义输入流表结构与输出表结构、稀疏响应式状态引擎\n\nbaseStream = g.source(\"trade\", `timestamp`date`deviceId1`deviceId2`deviceId3`value1`value2`value3, [TIMESTAMP, DATE, STRING, STRING, STRING, DOUBLE, DOUBLE, DOUBLE])\nformulas = [<cumsumTopN(value1, value2, 5)>, <cumavgTopN(value1, value2, 10)>, <cumstdTopN(value1, value2, 15)>, <cumstdpTopN(value1, value2, 20)>, <cumvarTopN(value1, value2, 5)>, <cumvarpTopN(value1, value2, 10)>, <cumskewTopN(value1, value2, 10)>, <cumkurtosisTopN(value1, value2, 10)>, <cumbetaTopN(value1, value2, value3, 10)>, <cumcorrTopN(value1, value2, value3, 10)>, <cumcovarTopN(value1, value2, value3, 10)>, <cumwsumTopN(value1, value2, value3, 10)>]\nkeys = \"A\"+string(1..size(formulas))\nkeys1 = keys.shuffle()\nkeys2 = keys.shuffle()\noutKeys = \"event\"+string(1..size(formulas))\nmetrics = table(\n    keys1 as deviceId1,\n    keys2 as deviceId2,\n    formulas as formula,\n    outKeys as outputMetricKey\n)\nbaseStream.sparseReactiveStateEngine(metrics, `deviceId1`deviceId2, `timestamp`date)\n.setEngineName(\"srsEngine\")\n.sink(\"output\")\ng.submit()\ngo\n\n\n// 写入数据到 Orca 流表\nn = 10000\nfor(i in 1..5){\n    data = table(rand(timestamp(1..1000), n) as timestamp, rand(date(1..1000), n) as date, rand(keys, n) as deviceId1, rand(keys, n) as deviceId2, take(keys, n) as deviceId3, rand(rand(-1000.0:1000.0, n) join take(double(), n/5), n) as value1, rand(rand(-1000.0:1000.0, n) join take(double(), n/5), n) as value2, rand(rand(-1000.0:1000.0, n) join take(double(), n/5), n) as value3)\n    appendOrcaStreamTable(\"trade\", data)\n}\nsleep(3000)\nres = select * from orca_table.output\n```\n\n**相关函数**：[createSparseReactiveStateEngine](https://docs.dolphindb.cn/zh/funcs/c/createSparseReactiveStateEngine.html)\n"
    },
    "DStream::sync": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/DStream_sync.html",
        "signatures": [
            {
                "full": "DStream::sync()",
                "name": "DStream::sync",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [DStream::sync](https://docs.dolphindb.cn/zh/funcs/d/DStream_sync.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nDStream::sync()\n\n#### 详情\n\n等待所有并行任务完成再进行后续处理（用于汇合并行路径）。\n\n注意：`DStream::parallelize` 和 `DStream::sync` 接口必须同时调用。\n\n#### 参数\n\n无\n\n#### 返回值\n\n返回一个 DStream 对象。\n\n#### 例子\n\n基于 symbol 列拆分 4 个分区，分别执行计算任务：\n\n```\nuse catalog test\n\ng = createStreamGraph(\"graph\")\ng.source(\"trade\", `symbol`datetime`price`volume, [SYMBOL, TIMESTAMP,DOUBLE, INT])\n  .parallelize(\"symbol\", 4)\n  .timeSeriesEngine(60*1000, 60*1000, <[first(price),max(price),min(price),last(price),sum(volume)]>, \"datetime\", false, \"symbol\")\n  .reactiveStateEngine(<[datetime, first_price, max_price, min_price, last_price, sum_volume, mmax(max_price, 5), mavg(sum_volume, 5)]>, `symbol)\n  .sync()\n  .sink(\"output\")\ng.submit()\n```\n"
    },
    "DStream::timeBucketEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/DStream_timeBucketEngine.html",
        "signatures": [
            {
                "full": "DStream::timeBucketEngine(timeCutPoints, metrics, timeColumn, [keyColumn], [useWindowStartTime], [closed='left'], [fill='none'], [keyPurgeFreqInSecond=-1], [parallelism=1])",
                "name": "DStream::timeBucketEngine",
                "parameters": [
                    {
                        "full": "timeCutPoints",
                        "name": "timeCutPoints"
                    },
                    {
                        "full": "metrics",
                        "name": "metrics"
                    },
                    {
                        "full": "timeColumn",
                        "name": "timeColumn"
                    },
                    {
                        "full": "[keyColumn]",
                        "name": "keyColumn",
                        "optional": true
                    },
                    {
                        "full": "[useWindowStartTime]",
                        "name": "useWindowStartTime",
                        "optional": true
                    },
                    {
                        "full": "[closed='left']",
                        "name": "closed",
                        "optional": true,
                        "default": "'left'"
                    },
                    {
                        "full": "[fill='none']",
                        "name": "fill",
                        "optional": true,
                        "default": "'none'"
                    },
                    {
                        "full": "[keyPurgeFreqInSecond=-1]",
                        "name": "keyPurgeFreqInSecond",
                        "optional": true,
                        "default": "-1"
                    },
                    {
                        "full": "[parallelism=1]",
                        "name": "parallelism",
                        "optional": true,
                        "default": "1"
                    }
                ]
            }
        ],
        "markdown": "### [DStream::timeBucketEngine](https://docs.dolphindb.cn/zh/funcs/d/DStream_timeBucketEngine.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nDStream::timeBucketEngine(timeCutPoints, metrics, timeColumn, \\[keyColumn], \\[useWindowStartTime], \\[closed='left'], \\[fill='none'], \\[keyPurgeFreqInSecond=-1], \\[parallelism=1])\n\n#### 详情\n\n创建流计算自定义窗口长度（长度相同或不同）的时间序列聚合引擎，支持基于该引擎定义后续处理逻辑。\n\n#### 参数\n\n**timeCutPoints** MINUTE 或 SECOND 类型向量，且不能包含空值。由 *timeCutPoints* 向量的任意两个相邻元素确定窗口的左、右边界。注意：\n\n* *timeCutPoints* 指定的时间精度必须不高于 *timeColumn* 列的精度。\n\n* *timeCutPoints* 指定的时间精度决定关闭窗口右边界的时间精度。如果 *timeCutPoints* 是 MINUTE 类型，则窗口右边界的时间精度是分；如果 *timeCutPoints* 是 SECOND 类型，则窗口右边界的时间精度是秒。\n\n**metrics** 以元代码的格式表示计算指标，支持输入元组。有关元代码的更多信息可参考 [元编程](https://docs.dolphindb.cn/zh/progr/objs/meta_progr.html)。\n\n* 计算指标可以是一个或多个系统内置或用户自定义的聚合函数（使用 defg 关键字定义），如 <\\[sum(volume), avg(price)]>；可以对聚合结果使用表达式，如 <\\[avg(price1)-avg(price2)]>；也可对列与列的计算结果进行聚合计算，如 <\\[std(price1-price2)]>。\n\n* *metrics* 内支持调用具有多个返回值的函数，例如 \\<func(price) as \\`col1\\`col2>（可不指定列名）。\n\n* 支持指定为一个常量标量或向量，例如 <1>，<\\[1, 2, 3]> 。当指定为常量向量时，对应的输出列必须设置为数组向量类型。\n\n* 若 *windowSize* 为向量， *windowSize* 每个值可对应 *metrics* 中多个计算指标。例如，*windowSize* 为\\[10,20]时，metrics可为 (<\\[min(volume), max(volume)]>, \\<sum(volume)>)。 *metrics* 也可以嵌套输入元组向量。例如：\\[\\[<\\[min(volume), max(volume)]>, \\<sum(volume)>], \\[\\<avg(volume)>]]\n\n  **Note:**\n\n  * *metrics* 中使用的列名大小写不敏感，不需要与输入表的列名大小写保持一致。\n  * *metrics* 中不可使用嵌套聚合函数。\n\n**timeColumn** 字符串标量或长度为2的向量，用于输入表中时间列的名称。\n\n**keyColumn** 可选参数，字符串标量或向量，表示分组列名。若设置，则分组进行聚合计算，例如以每支股票为一组进行聚合计算。\n\n**useWindowStartTime** 可选参数。布尔值，表示输出表中的时间是否为数据窗口起始时间。默认值为 false，表示输出表中的时间为窗口结束时间。\n\n**closed** 字符串，用于确定滑动窗口边界的开闭情况。可选值为 'left' 或 'right'，默认值为 'left'。\n\n* closed = 'left'： 窗口左闭右开。\n\n* closed = 'right'： 窗口左开右闭。\n\n**fill** 可选参数，一个标量或向量，指定某个分组的某个窗口无数据时的处理方法。可取以下值：\n\n* 'none': 不输出结果。\n* 'null': 输出结果为 NULL。\n* 'ffill': 输出上一个有数据的窗口的结果。\n* '具体数值'：该值的数据类型需要和对应的 *metrics* 计算结果的类型保持一致。\n\n*fill* 可以输入向量，长度与 *metrics* 元素个数保持一致，表示为每个 *metrics* 指定不同的 *fill* 方式。若为向量，向量中各项只能是 'null', 'ffill' 或一个数值，不能是 'none'。\n\n**keyPurgeFreqInSec** 正整数，表示清理窗口数据为空的分组的时间间隔，单位为秒。指定该参数后，若当前数据注入时间与上一次清理时间的间隔大于等于 *keyPurgeFreqInSec*，则触发对当前窗口数据为空的分组信息的清理。若指定该参数，则必须指定 *keyColumn*，且不能指定 *fill。*\n\n**parallelism** 为不超过 63 的正整数，可选参数，表示并行计算的工作线程数，默认值为 1。在计算量较大时，合理地调整该参数能够有效利用计算资源，降低计算耗时。建议小于机器核数，推荐值为 4 到 8 。\n\n#### 返回值\n\n返回一个 DStream 对象。\n\n#### 例子\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\n// 如已存在流图，则先销毁该流图\n// dropStreamGraph('engine')\ng = createStreamGraph('engine')\n\ng.source(\"trades\", `time`sym`price`volume, [TIMESTAMP, SYMBOL, DOUBLE, INT])\n.timeSeriesEngine(windowSize=60000, step=60000, metrics=<[first(price), max(price), min(price), last(price), sum(volume)]>, timeColumn=`time, useSystemTime=false, keyColumn=`sym, useWindowStartTime=false)\n.timeBucketEngine(timeCutPoints=[10:00m, 10:05m, 10:10m, 10:15m], metrics=<[first(first_price), max(max_price), min(min_price), last(last_price), sum(sum_volume)]>, timeColumn=`time,  keyColumn=`sym)\n.sink(\"output\")\ng.submit()\ngo\n\ntimes = [2024.10.08T10:01:01.785, 2024.10.08T10:01:02.125, 2024.10.08T10:01:12.457, 2024.10.08T10:03:10.789, 2024.10.08T10:03:12.005, 2024.10.08T10:08:02.236, 2024.10.08T10:08:04.412, 2024.10.08T10:08:05.152, 2024.10.08T10:08:30.021, 2024.10.08T10:10:20.123, 2024.10.08T10:11:02.236, 2024.10.08T10:13:04.412, 2024.10.08T10:15:12.005]\nsyms = [`A, `B, `A, `A, `B, `A, `B, `B, `A, `A, `A, `B, `B]\nprices = [10.83, 21.73, 10.79, 11.81, 22.96, 11.25, 23.03, 23.18, 11.04, 11.85, 11.06, 23.15, 22.06]\nvolumes = [2110, 1600, 2850, 2250, 1980, 2400, 2130, 1900, 2300, 2200, 2200, 1880, 2100]\ntmp = table(times as time, syms as sym, prices as price, volumes as volume)\nappendOrcaStreamTable(\"trades\", tmp)\n\nselect * from orca_table.output\n```\n\n| time                    | sym | first\\_first\\_price | max\\_max\\_price | min\\_min\\_price | last\\_last\\_price | sum\\_sum\\_volume |\n| ----------------------- | --- | ------------------- | --------------- | --------------- | ----------------- | ---------------- |\n| 2024.10.08 10:05:00.000 | A   | 10.83               | 11.81           | 10.79           | 11.81             | 7,210            |\n| 2024.10.08 10:05:00.000 | B   | 21.73               | 22.96           | 21.73           | 22.96             | 3,580            |\n| 2024.10.08 10:10:00.000 | A   | 11.25               | 11.25           | 11.04           | 11.04             | 4,700            |\n| 2024.10.08 10:10:00.000 | B   | 23.03               | 23.18           | 23.03           | 23.18             | 4,030            |\n| 2024.10.08 10:15:00.000 | B   | 23.15               | 23.15           | 23.15           | 23.15             | 1,880            |\n"
    },
    "DStream::timerEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/DStream_timerEngine.html",
        "signatures": [
            {
                "full": "DStream::timerEngine(interval, func, args...)",
                "name": "DStream::timerEngine",
                "parameters": [
                    {
                        "full": "interval",
                        "name": "interval"
                    },
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "args...",
                        "name": "args..."
                    }
                ]
            }
        ],
        "markdown": "### [DStream::timerEngine](https://docs.dolphindb.cn/zh/funcs/d/DStream_timerEngine.html)\n\n\n\n#### 语法\n\nDStream::timerEngine(interval, func, args...)\n\n#### 详情\n\n定义一个时间触发引擎，以间隔 *interval* 周期性地执行 *func*。执行该任务不会阻塞或修改流图的数据流。\n\n#### 参数\n\n**interval** 整型标量，表示任务执行的时间间隔，单位为秒。\n\n**func** FUNCTIONDEF 标量，表示定时执行的任务。\n\n**args…** 传递给 *func*的参数，使用方式类似于远程过程调用函数 [rpc](https://docs.dolphindb.cn/zh/funcs/r/rpc.html) 的 *args…* 参数。当 *func* 为无参函数时可省略。\n\n#### 返回值\n\n返回一个 DStream 对象。\n\n#### 例子\n\n提交任务\n\n```\nif (!existsCatalog(\"test\")) {\n\tcreateCatalog(\"test\")\t\n}\ngo\nuse catalog test\n\n// 定义任务\ndef myFunc(x,y,z){\n    writeLog(x,y,z)\n}\n\n// 定义参数\na = \"aaa\"\nb = \"bbb\"\nc = \"ccc\"\n\n// 提交流图\ng = createStreamGraph(\"timerEngineDemo\")\ng.source(\"trade\", `id`price, [INT, DOUBLE])\n .timerEngine(3, myFunc, a, b, c)\n .setEngineName(\"myJob\")\n .sink(\"result\")\ng.submit()\n```\n\n暂停任务执行\n\n```\nuseOrcaStreamEngine(\"myJob\", stopTimerEngine)\n```\n\n继续执行任务\n\n```\nuseOrcaStreamEngine(\"myJob\", resumeTimerEngine)\n```\n\n**相关函数：**[resumeTimerEngine](https://docs.dolphindb.cn/zh/funcs/r/resumeTimerEngine.html), [stopTimerEngine](https://docs.dolphindb.cn/zh/funcs/s/stopTimerEngine.html)\n"
    },
    "DStream::timeSeriesEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/DStream_timeSeriesEngine.html",
        "signatures": [
            {
                "full": "DStream::timeSeriesEngine(windowSize, step, metrics, [timeColumn], [useSystemTime=false], [keyColumn], [updateTime], [useWindowStartTime], [roundTime=true], [fill='none'], [forceTriggerTime], [keyPurgeFreqInSecond=-1], [closed='left'], [subWindow], [parallelism=1], [acceptedDelay=0])",
                "name": "DStream::timeSeriesEngine",
                "parameters": [
                    {
                        "full": "windowSize",
                        "name": "windowSize"
                    },
                    {
                        "full": "step",
                        "name": "step"
                    },
                    {
                        "full": "metrics",
                        "name": "metrics"
                    },
                    {
                        "full": "[timeColumn]",
                        "name": "timeColumn",
                        "optional": true
                    },
                    {
                        "full": "[useSystemTime=false]",
                        "name": "useSystemTime",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[keyColumn]",
                        "name": "keyColumn",
                        "optional": true
                    },
                    {
                        "full": "[updateTime]",
                        "name": "updateTime",
                        "optional": true
                    },
                    {
                        "full": "[useWindowStartTime]",
                        "name": "useWindowStartTime",
                        "optional": true
                    },
                    {
                        "full": "[roundTime=true]",
                        "name": "roundTime",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[fill='none']",
                        "name": "fill",
                        "optional": true,
                        "default": "'none'"
                    },
                    {
                        "full": "[forceTriggerTime]",
                        "name": "forceTriggerTime",
                        "optional": true
                    },
                    {
                        "full": "[keyPurgeFreqInSecond=-1]",
                        "name": "keyPurgeFreqInSecond",
                        "optional": true,
                        "default": "-1"
                    },
                    {
                        "full": "[closed='left']",
                        "name": "closed",
                        "optional": true,
                        "default": "'left'"
                    },
                    {
                        "full": "[subWindow]",
                        "name": "subWindow",
                        "optional": true
                    },
                    {
                        "full": "[parallelism=1]",
                        "name": "parallelism",
                        "optional": true,
                        "default": "1"
                    },
                    {
                        "full": "[acceptedDelay=0]",
                        "name": "acceptedDelay",
                        "optional": true,
                        "default": "0"
                    }
                ]
            }
        ],
        "markdown": "### [DStream::timeSeriesEngine](https://docs.dolphindb.cn/zh/funcs/d/DStream_timeSeriesEngine.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nDStream::timeSeriesEngine(windowSize, step, metrics, \\[timeColumn], \\[useSystemTime=false], \\[keyColumn], \\[updateTime], \\[useWindowStartTime], \\[roundTime=true], \\[fill='none'], \\[forceTriggerTime], \\[keyPurgeFreqInSecond=-1], \\[closed='left'], \\[subWindow], \\[parallelism=1], \\[acceptedDelay=0])\n\n#### 详情\n\n创建流计算时间序列聚合引擎。参考：[createTimeSeriesEngine](https://docs.dolphindb.cn/zh/funcs/c/createTimeSeriesEngine.html)。\n\n#### 参数\n\n**windowSize** 正整数标量或向量，表示滑动窗口的长度。\n\n**step** 正整数标量，表示滑动窗口移动的步长。 *windowSize* 必须是 *step* 的整数倍，否则会抛出异常。*windowSize* 和 *step* 的单位与 *useSystemTime* 有关：\n\n* 若 *useSystemTime* 为 true，则 *windowSize* 和 *step* 的单位为毫秒。\n\n* 若 *useSystemTime* 为 false，则 *windowSize* 和 *step* 的单位与 *timeColumn* 的时间精度一致。\n\n**metrics** 以元代码的格式表示计算指标，支持输入元组。有关元代码的更多信息可参考 [元编程](https://docs.dolphindb.cn/zh/progr/objs/meta_progr.html)。\n\n* 计算指标可以是一个或多个系统内置或用户自定义的聚合函数（使用 defg 关键字定义），如 <\\[sum(volume), avg(price)]>；可以对聚合结果使用表达式，如 <\\[avg(price1)-avg(price2)]>；也可对列与列的计算结果进行聚合计算，如 <\\[std(price1-price2)]>。\n\n* *metrics* 内支持调用具有多个返回值的函数，例如 \\<func(price) as \\`col1\\`col2>（可不指定列名）。\n\n* 支持指定为一个常量标量或向量，例如 <1>，<\\[1, 2, 3]> 。当指定为常量向量时，对应的输出列必须设置为数组向量类型。\n\n* 若 *windowSize* 为向量， *windowSize* 每个值可对应 *metrics* 中多个计算指标。例如，*windowSize* 为\\[10,20]时，metrics可为 (<\\[min(volume), max(volume)]>, \\<sum(volume)>)。 *metrics* 也可以嵌套输入元组向量。例如：\\[\\[<\\[min(volume), max(volume)]>, \\<sum(volume)>], \\[\\<avg(volume)>]]\n\n  **Note:**\n\n  * *metrics* 中使用的列名大小写不敏感，不需要与输入表的列名大小写保持一致。\n  * *metrics* 中不可使用嵌套聚合函数。\n\n**timeColumn** 可选参数，字符串标量或向量。当 *useSystemTime* = false 时，必须指定该参数。 该参数用于指定订阅的流数据表中时间列的名称。\n\n**Note:** 字符串向量必须是 date 和 time 组成的向量，date 类型为 DATE，time 类型为 TIME, SECOND 或 NANOTIME。此时，输出表第一列的时间类型必须与 [concatDateTime(date, time)](https://docs.dolphindb.cn/zh/funcs/c/concatDateTime.html) 的类型一致。\n\n**useSystemTime** 可选参数，布尔值，表示是否使用数据注入引擎时的系统时间作为时间列进行计算。\n\n* 当 *useSystemTime* = true时，时间序列引擎会按照数据注入时间序列引擎的时刻（毫秒精度的本地系统时间，与数据中的时间列无关），每隔固定时间截取固定长度窗口的流数据进行计算。只要一个数据窗口中含有数据，数据窗口结束后就会自动进行计算。结果中的第一列为计算发生的时间戳，与数据中的时间无关。\n\n* 当 *useSystemTime* = false（缺省值）时，时间序列引擎根据流数据中的 *timeColumn* 列来截取数据窗口。一个数据窗口结束后的第一条新数据才会触发该数据窗口的计算。请注意，触发计算的数据并不会参与该次计算。\n\n  例如，一个数据窗口从 10:10:10 到 10:10:19。若 *useSystemTime* = true，则只要该窗口中至少有一条数据，该窗口的计算会在窗口结束后的 10:10:20 触发。若 *useSystemTime* = false，且 10:10:19 后的第一条数据为 10:10:25，则该窗口的计算会在 10:10:25 触发。\n\n**keyColumn** 可选参数，字符串标量或向量，表示分组列名。若设置，则分组进行聚合计算，例如以每支股票为一组进行聚合计算。\n\n**updateTime** 可选参数，非负整数，单位与 timeColumn 的时间精度一致。用于指定比 *step* 更短的计算时间间隔。*step* 必须是 *updateTime* 的整数倍。要设置 *updateTime*， *useSystemTime* 必须设为 false。\n\n* updateTime 指定为正整数值时：\n\n  * 从当前窗口的左边界开始，每隔 *updateTime* 时间，若有新的数据到来，则对当前窗口内该数据之前的所有数据进行计算。\n\n  * 如果系统经过 2 \\* *updateTime* （至少2秒）后仍有未被处理的数据，则触发对当前窗口内所有数据的计算。\n\n  * 若分组计算，则每组内进行上述操作。\n\n* updateTime 指定为 0 时：在新的数据到来后，立即对当前窗口的最新数据计算并输出。\n\n**useWindowStartTime** 可选参数，布尔值，表示输出表中的时间是否为数据窗口起始时间。默认值为 false，表示输出表中的时间为数据窗口起始时间 + *windowSize* 。若 *windowSize* 是向量， *useWindowStartTime* 必须为 false。\n\n**roundTime** 可选参数，布尔值，表示若数据时间精度为毫秒或者秒且 *step* > 一分钟，如何对窗口边界值进行规整处理。默认值为 true，表示按照既定的多分钟规则进行规整。若为 false，则按一分钟规则进行窗口规整。\n\n**fill** 可选参数，一个标量或向量，指定某个分组的某个窗口无数据时的处理方法。可取以下值：\n\n* 'none': 不输出结果。\n* 'null': 输出结果为 NULL。\n* 'ffill': 输出上一个有数据的窗口的结果。\n* '具体数值'：该值的数据类型需要和对应的 *metrics* 计算结果的类型保持一致。\n\n*fill* 可以输入向量，长度与 *metrics* 元素个数保持一致，表示为每个 *metrics* 指定不同的 *fill* 方式。若为向量，向量中各项只能是 'null', 'ffill' 或一个数值，不能是 'none'。\n\n**forceTriggerTime** 可选参数，是非负整数，单位与 *timeColumn* 的时间精度一致。用于强制触发各个分组未计算的窗口进行计算。要设置 *forceTriggerTime*， *useSystemTime* 必须设置为 false，且不能指定 *updateTime*。强制触发计算及输出规则如下：\n\n1. 未被触发计算的窗口结束后（窗口结束时刻为 t），若收到了其他分组的数据（时间戳为 t1），且满足 t1-t ≥ *forceTriggerTime*，则该窗口将被触发计算。\n\n2. 如果某个分组在最后一个窗口被强制触发计算后，没有再收到新的数据，但其他分组仍然收到了新的数据，那么通过 *fill* 来填充该分组的所有缺失窗口，可以确保在最新时间截面上仍然输出该分组的窗口。如果不指定 *fill*，则最后一个窗口被触发计算后，该分组不会产生新的窗口。\n\n设置 *forceTriggerTime* 或 *updateTime* 时需注意以下几点：\n\n* 设置 *updateTime*，计算发生后仍有属于当前窗口的数据到达时，当前窗口计算结果会再次更新；\n\n* 设置 *forceTriggerTime*，则触发计算之后收到的数据会被丢弃，建议不要设置太小的 *forceTriggerTime*。\n\n* 如果 *timeColumn* 指定的时间为 TIME 类型，数据跨天后无法仅凭时间判断数据的先后顺序，因此会出现跨天无法强制触发的情况。*timeColumn* 的时间需要加上日期。\n\n**keyPurgeFreqInSec** 正整数，单位为秒。用于控制定期清理“窗口数据已为空”的分组对应的 key，从而避免 key 持续增长带来的内存占用。指定该参数后，如果当前数据注入时间与上一次清理时间的间隔 ≥ *keyPurgeFreqInSec*，则会删除当前窗口数据为空的分组及其对应的 key。\n\n**Note:**\n\n* 若需指定该参数，必须指定 *forceTriggerTime*，且不能指定 *fill*。\n\n* 可以通过调用 [getStreamEngineStat](https://docs.dolphindb.cn/zh/funcs/g/getStreamEngineStat.html) 函数查看 TimeSeriesEngine 引擎状态的 numGroups 列，来对比响应式状态引擎清理前后分组数的变化。\n\n**closed** 字符串，用于确定滑动窗口边界的开闭情况。可选值为 'left' 或 'right'，默认值为 'left'。\n\n* closed = 'left'： 窗口左闭右开。\n\n* closed = 'right'： 窗口左开右闭。\n\n**subWindow**整型或者 DURATION 数据对。在滑动窗口内指定子窗口，仅计算子窗口内的数据。子窗口边界的开闭情况由参数 *closed* 决定。子窗口结束后收到第一条数据触发对子窗口内数据的计算（参考例4）。当 *subWindow*为整型数据对时，其单位与 *timeColumn* 的时间精度一致。若指定 *subWindow*，则：\n\n* *windowSize*和 *step*必须相等。\n* 不可设置 *updateTime*>0和 *useSystemTime*=true。\n\n**parallelism** 为不超过 63 的正整数，可选参数，表示并行计算的工作线程数，默认值为 1。在计算量较大时，合理地调整该参数能够有效利用计算资源，降低计算耗时。建议小于机器核数，推荐值为 4 到 8 。\n\n**acceptedDelay** 正整数，可选参数。指定每个窗口接收数据的最大延迟，默认值为 0。若设置该参数，则不能设置 *forceTriggerTime* 或 *updateTime*。\n\n* 当 useSystemTime= true 时，*acceptedDelay* 必须小于等于 *windowSize*。在窗口结束后的 *acceptedDelay* 时间内接收到的数据，仍然属于此窗口并参与计算，而不会参与下一个窗口的计算。\n\n* 当 useSystemTime= false 时，该参数用于处理乱序数据。假设当前窗口结束的时间戳为 t ，若收到一条时间戳大于等于 t+*acceptedDelay*的数据，则触发在此之前收到的所有属于当前窗口的数据进行计算输出，并关闭该窗口。\n\n#### 返回值\n\n返回一个 DStream 对象。\n\n#### 例子\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\n// 如已存在流图，则先销毁该流图\n// dropStreamGraph('engine')\ng = createStreamGraph('engine')\n\ng.source(\"trades\", [\"time\",\"sym\",\"volume\"], [TIMESTAMP, SYMBOL, INT])\n.timeSeriesEngine(windowSize=60000, step=60000, metrics=<[sum(volume)]>, timeColumn=\"time\", useSystemTime=false, keyColumn=\"sym\", useWindowStartTime=false)\n.sink(\"output\")\ng.submit()\ngo\n\ntimes = [2018.10.08T01:01:01.785, 2018.10.08T01:01:02.125, 2018.10.08T01:01:10.263, 2018.10.08T01:01:12.457, 2018.10.08T01:02:10.789, 2018.10.08T01:02:12.005, 2018.10.08T01:02:30.021, 2018.10.08T01:04:02.236, 2018.10.08T01:04:04.412, 2018.10.08T01:04:05.152]\nsyms = [`A, `B, `B, `A, `A, `B, `A, `A, `B, `B]\nvolumes = [10, 26, 14, 28, 15, 9, 10, 29, 32, 23]\n\ntmp = table(times as time, syms as sym, volumes as volume)\nappendOrcaStreamTable(\"trades\", tmp)\n\n\nselect * from orca_table.output\n```\n\n<table id=\"table_slb_dp3_3fc\"><thead><tr><th align=\"left\">\n\ntime\n\n</th><th align=\"left\">\n\nsym\n\n</th><th align=\"left\">\n\nsum\\_volume\n\n</th></tr></thead><tbody><tr><td align=\"left\">\n\n2018.10.08 01:02:00.000\n\n</td><td align=\"left\">\n\nA\n\n</td><td align=\"left\">\n\n38\n\n</td></tr><tr><td align=\"left\">\n\n2018.10.08 01:02:00.000\n\n</td><td align=\"left\">\n\nB\n\n</td><td align=\"left\">\n\n40\n\n</td></tr><tr><td align=\"left\">\n\n2018.10.08 01:03:00.000\n\n</td><td align=\"left\">\n\nA\n\n</td><td align=\"left\">\n\n25\n\n</td></tr><tr><td align=\"left\">\n\n2018.10.08 01:03:00.000\n\n</td><td align=\"left\">\n\nB\n\n</td><td align=\"left\">\n\n9\n\n</td></tr></tbody>\n</table>\n"
    },
    "DStream::udfEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/DStream_udfEngine.html",
        "signatures": [
            {
                "full": "DStream::udfEngine(func)",
                "name": "DStream::udfEngine",
                "parameters": [
                    {
                        "full": "func",
                        "name": "func"
                    }
                ]
            }
        ],
        "markdown": "### [DStream::udfEngine](https://docs.dolphindb.cn/zh/funcs/d/DStream_udfEngine.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\nDStream::udfEngine(func)\n\n#### 详情\n\n`DStream::udfEngine` 是 Orca 流图中用于执行用户自定义处理逻辑的扩展引擎。当内置流计算引擎无法满足特定业务需求时，用户可通过 `DStream::udfEngine` 设置自定义函数，对每条流消息进行映射处理。\n\n为支持有状态计算，自定义函数可访问由 `DStream::sharedTable`、`DStream::sharedDict` 或 `DStream::sharedKeyedTable` 声明的共享变量。这些变量可在同一流图内的多个 udfEngine 实例和 task 之间共享，其状态由 Orca 通过 Checkpoint 机制自动持久化，并在故障恢复时重建。\n\n\\*\\*注意：\\*\\*自定义函数中禁止访问任何外部变量。仅允许使用局部变量，或通过 `orcaObj(\"name\")` 引用已声明的共享变量。\n\n**共享变量使用约束**：\n\n* 共享变量必须先通过 `DStream::sharedTable`、`DStream::sharedDict` 或 `DStream::sharedKeyedTable` 声明；在 `udfEngine` 的 自定义函数中，通过 `orcaObj(\"name\")` 引用。注意：`orcaObj` 仅在自定义函数执行上下文中有效。\n\n* 每个共享变量仅支持单写多读：只能有一个 udfEngine 实例写入，但允许多个实例并发读取。\n\n* 访问同一共享变量的所有任务会被 Orca 调度到同一个物理节点，以保证本地访问和一致性。\n\n#### 参数\n\n**func** 用户定义函数，只有一个参数，为流数据表。该参数不可被原地修改或作为可变对象操作。函数内部可读写由 `DStream::sharedTable`、`DStream::sharedDict` 或 `DStream::sharedKeyedTable` 定义的共享变量，实现状态更新。若函数有返回值，类型必须为字典或表。\n\n#### 返回值\n\n返回一个 DStream 对象。\n\n#### 例子\n\n下面通过 `DStream::sharedKeyedTable` 与 `DStream::udfEngine` 的结合，实现计算历史差值的功能。\n\n在本示例中，使用 `DStream::sharedKeyedTable` 存储已处理数据的历史记录，对每个 id 仅保留最新的一条记录。当新数据到达时，若该 id 已存在于表中，则输出新值与历史值之间的差值；否则，仅将新数据存入表中，不输出。\n\n```\nif(existsCatalog(\"orcaCatalog\")) dropCatalog(\"orcaCatalog\")\ncreateCatalog(\"orcaCatalog\")\ngo\nuse catalog orcaCatalog\n// 创建流图\ng = createStreamGraph(\"compare\")\ng.sharedKeyedTable(\"history\", \"id\", 1:0, `id`value, [INT, DOUBLE])\ng.source(\"data\", `id`value`time, [INT, DOUBLE, TIMESTAMP])\n  .udfEngine(def(msg) {\n    history = orcaObj(\"history\")\n    diffTable = table(100:0, `id`diff, [INT, DOUBLE])\n    for(i in 0:msg.size()) {\n        idVal = msg.id[i]\n        valueVal = msg.value[i]\n        // 读取历史值\n        old = select value from history where id = idVal\n        // 写入新值\n        newRow = table(idVal as id, valueVal as value)\n        history.append!(newRow)\n        // 计算差值\n        if(old.size() > 0) {\n            diffTable.append!(table(idVal as id, (valueVal - old.value[0]) as diff))\n        }\n    }\n    return diffTable\n  })\n  .sink(\"comparison\")\ng.submit()\n// 生成模拟数据\nmockData = table(1..5 as id, rand(100.0, 5) as value, now() + 1..5 as time)\n// 插入数据\nappendOrcaStreamTable(\"orcaCatalog.orca_table.data\", mockData)\n// 生成id重复的数据\nmockData = table(1..5 as id, rand(100.0, 5) as value, now() + 1..5 as time)\n// 插入数据\nappendOrcaStreamTable(\"orcaCatalog.orca_table.data\", mockData)\n// 等待处理并查看结果\nsleep(1000)\nselect * from orcaCatalog.orca_table.comparison\n```\n\n| id | diff                |\n| -- | ------------------- |\n| 1  | 35.55946895749296   |\n| 2  | -3.4362593906550387 |\n| 3  | 36.283468999034596  |\n| 4  | 68.97968558337999   |\n| 5  | -91.64246928217878  |\n\n**相关函数：**[DStream::map](https://docs.dolphindb.cn/zh/funcs/d/DStream_map.html), [getUdfEngineVariable](https://docs.dolphindb.cn/zh/funcs/g/getUdfEngineVariable.html)\n"
    },
    "DStream::windowJoinEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/DStream_windowJoinEngine.html",
        "signatures": [
            {
                "full": "DStream::windowJoinEngine(rightStream, window, metrics, matchingColumn, [timeColumn], [useSystemTime=false], [garbageSize], [maxDelayedTime], [nullFill], [sortByTime], [closed])",
                "name": "DStream::windowJoinEngine",
                "parameters": [
                    {
                        "full": "rightStream",
                        "name": "rightStream"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "metrics",
                        "name": "metrics"
                    },
                    {
                        "full": "matchingColumn",
                        "name": "matchingColumn"
                    },
                    {
                        "full": "[timeColumn]",
                        "name": "timeColumn",
                        "optional": true
                    },
                    {
                        "full": "[useSystemTime=false]",
                        "name": "useSystemTime",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[garbageSize]",
                        "name": "garbageSize",
                        "optional": true
                    },
                    {
                        "full": "[maxDelayedTime]",
                        "name": "maxDelayedTime",
                        "optional": true
                    },
                    {
                        "full": "[nullFill]",
                        "name": "nullFill",
                        "optional": true
                    },
                    {
                        "full": "[sortByTime]",
                        "name": "sortByTime",
                        "optional": true
                    },
                    {
                        "full": "[closed]",
                        "name": "closed",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [DStream::windowJoinEngine](https://docs.dolphindb.cn/zh/funcs/d/DStream_windowJoinEngine.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nDStream::windowJoinEngine(rightStream, window, metrics, matchingColumn, \\[timeColumn], \\[useSystemTime=false], \\[garbageSize], \\[maxDelayedTime], \\[nullFill], \\[sortByTime], \\[closed])\n\n#### 详情\n\n创建流计算窗口连接引擎。参考：[createWindowJoinEngine](https://docs.dolphindb.cn/zh/funcs/c/createWindowJoinEngine.html) 。\n\n\\*\\*注意：\\*\\*Orca 中的输出表会自动推断列类型：\n\n* window = 0:0（特殊窗口）：对于非聚合结果，默认推断为 array vector；若结果类型不支持 array vector，则自动转换为列式元组（columnar tuple）。\n* window ≠ 0:0（普通窗口）：必须显式指定 `toArray`，结果才会输出为 array vector。\n\n#### 参数\n\n**rightStream** DStream 对象，表示输入的右表数据源。\n\n**window** 必选参数，表示滑动窗口区间的整型或 DURATION 数据对，其中左右边界都包含在内。\n\n**metrics** 以元代码的格式表示计算指标，支持输入元组。有关元代码的更多信息可参考 [元编程](https://docs.dolphindb.cn/zh/progr/objs/meta_progr.html)。\n\n* 计算指标可以是一个或多个表达式、系统内置或用户自定义函数。\n* *metrics* 内支持调用具有多个返回值的函数，且必须指定列名，例如 \\<func(price) as \\`col1\\`col2>。\n\n  若在 *metrics* 指定了 *leftTable* 和 *rightTable* 中具有相同名称的列，默认取左表的列，可以通过 \"tableName.colName\" 指定该列来自哪个表。\n\n  **Note:**\n\n  * *metrics* 中使用的列名大小写不敏感，不要求与输入表的列名大小写保持一致。\n  * 在需要输出 array vector 类型结果时，需要显式指定 `toArray` 函数转换类型。\n  * 支持使用 `toColumnarTuple` 函数，将非聚合计算结果转换为列式元组（columnar tuple）。\n  * 当以下函数只计算 *rightTable* 中的数据列时，window join 引擎对它们进行了优化：sum, sum2, avg, std, var, corr, covar, wavg, wsum, beta, max, min, last, first, med, percentile。\n\n**matchingColumn** 表示连接列的字符串标量/向量/tuple，支持 Integral, Temporal 或 Literal（UUID 除外）类型。*matchingColumn* 指定规则为：\n\n1. 只有一个连接列：当左表和右表的连接列名相同时，*matchingColumn* 是一个字符串标量，否则是一个长度为 2 的 tuple，例如：左表连接列名为 sym，右表连接列名为 sym1，则 *matchingColumn* = \\[\\[\\`sym],\\[\\`sym1]]。\n2. 有多个连接列：当左表和右表的连接列名相同时，*matchingColumn* 是一个字符串向量，否则是一个长度为 2 的 tuple，例如：左表连接列名为 timestamp, sym，右表连接列名为 timestamp, sym1，则 *matchingColumn* = \\[\\[\\`timestamp, \\`sym], \\[\\`timestamp,\\`sym1]]。\n\n**timeColumn** 可选参数，当 *useSystemTime* = false 时，指定要连接的两个表中时间列的名称。*leftTable* 和 *rightTable* 时间列名称可以不同，但数据类型需保持一致。当 *leftTable* 和 *rightTable* 时间列名称不同时，*timeColumn* 为一个长度为2的字符串向量。\n\n**useSystemTime** 可选参数，表示 *outputTable* 中第一列（时间列）为系统当前时间（*useSystemTime* = true）或左表的时间列（*useSystemTime* = false）。\n\n**garbageSize** 可选参数，是正整数，默认值是5,000（单位为行）。随着订阅的流数据不断积累进入 window join 引擎，存放在内存中的数据会越来越多，这时需要清理不再需要的历史数据。当左/右两表各个分组内的数据行数超过 *garbageSize* 值时，系统会清理本次计算不需要的历史数据。\n\n**maxDelayedTime** 可选参数，是正整数，用于触发引擎中长时间未输出的分组数据进行计算。 具体来说，若`(某个分组中未发生计算的窗口右边界) + (maxDelayedTime) < (右表最新收到的任意一个分组数据的时间戳)`，则这条数据会触发该窗口计算输出。\n\n**nullFill** 和输出表列字段等长且类型一一对应的元组，用于填充以下列中的空值：输出表中包含的左表列、右表列、右表列被聚合计算后的计算结果列。\n\n**sortByTime** 布尔值，表示是否按全局时间顺序输出数据。默认值为 false，表示不按全局时间输出数据，仅在组内按时间顺序输出数据。注意：当设置 sortByTime=true 时，必须保证输入的左表和右表的数据全局有序，且不可设置 *maxDelayedTime*。\n\n**closed** 字符串，用于确定窗口边界的开闭情况，仅当 *window*为 0:0 时有效 。可选值为 ‘left’ 或 ‘right’，默认值为 ‘left’。\n\n* closed = ‘left’： 窗口左闭右开。\n* closed = ‘right’： 窗口左开右闭。此时必须设置 useSystemTime=false 。\n\n#### 返回值\n\n返回一个 DStream 对象。\n\n#### 例子\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\n// 如已存在流图，则先销毁该流图\n// dropStreamGraph('joinEngine')\ng = createStreamGraph('joinEngine')\n\nr = g.source(\"right\", `time`sym`val, [TIMESTAMP, SYMBOL, DOUBLE])\ng.source(\"left\", `time`sym`price, [TIMESTAMP, SYMBOL, DOUBLE])\n    .windowJoinEngine(r, window=-2:2, metrics=<[price,val,sum(val)]>, matchingColumn=`sym, timeColumn=`time, useSystemTime=false,nullFill=[2012.01.01T00:00:00.000, `NONE, 0.0, 0.0, 0.0])\n    .sink(\"output\")\ng.submit()\n\ngo\n\nn=10\ntp1=table(take(2012.01.01T00:00:00.000+0..10, 2*n) as time, take(`A, n) join take(`B, n) as sym, take(NULL join rand(10.0, n-1),2*n) as price)\ntp1.sortBy!(`time)\nappendOrcaStreamTable(\"left\", tp1)\n\ntp2=table(take(2012.01.01T00:00:00.000+0..10, 2*n) as time, take(`A, n) join take(`B, n) as sym, take(double(1..n),2*n) as val)\ntp2.sortBy!(`time)\nappendOrcaStreamTable(\"right\", tp2)\n\n\nselect * from orca_table.output\n```\n"
    },
    "dumpHeapSample": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/dumpheapsample.html",
        "signatures": [
            {
                "full": "dumpHeapSample(filename)",
                "name": "dumpHeapSample",
                "parameters": [
                    {
                        "full": "filename",
                        "name": "filename"
                    }
                ]
            }
        ],
        "markdown": "### [dumpHeapSample](https://docs.dolphindb.cn/zh/funcs/d/dumpheapsample.html)\n\n\n\n#### 语法\n\ndumpHeapSample(filename)\n\n#### 详情\n\n生成当前堆内存的快照。调用此函数后，系统会记录当前的内存使用情况，包括已分配的内存块、它们的大小和状态等信息。仅管理员可执行该函数。\n\n#### 参数\n\n**filename** 字符串标量，表示堆内存快照的路径。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n对内存使用情况进行分析的流程如下：\n\n1. 启用堆内存采样：可在启动 DolphinDB 前，设置环境变量 TCMALLOC\\_SAMPLE\\_PARAMETER 为1-524288之间的值（建议值 524288）；或通过函数 `startHeapSample` 动态开启。\n\n2. 在可能发生内存泄漏的操作前、后分别执行 `dumpHeapSample`，保存两个不同的文件。通过对比两个文件，确认操作涉及到的内存分配和使用情况。\n\n3. 关闭堆内存采样。\n\n```\nstartHeapSample(524288)\n\ndumpHeapSample(\"/DolphinDB/Data/heap1\")\ndumpHeapSample(\"/DolphinDB/Data/heap2\")\n\nstopHeapSample()\n```\n\n相关函数：[startHeapSample](https://docs.dolphindb.cn/zh/funcs/s/startheapsample.html), [stopHeapSample](https://docs.dolphindb.cn/zh/funcs/s/stopheapsample.html)\n"
    },
    "duration": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/duration.html",
        "signatures": [
            {
                "full": "duration(X)",
                "name": "duration",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [duration](https://docs.dolphindb.cn/zh/funcs/d/duration.html)\n\n\n\n#### 语法\n\nduration(X)\n\n#### 详情\n\n将一个字符串标量转换为 DURATION 类型。表示一个时间区间。\n\n**Note:**\n\n* 用于分组的时间区间单位应需不小于时间列的单位。\n\n* 时间单位区分大小写，例如：M 表示月份，m 表示分钟；若分组的时间区间单位为 M，时间列需要通过函数 [month](https://docs.dolphindb.cn/zh/funcs/m/month.html) 转换为对应月份。\n\n* DURATION 类型数据之间不能进行任何运算。例如，不能进行比较运算：`duration('20ms') >= duration('10ms')`。\n\n#### 参数\n\n**X** 是一个字符串，为一个数字与时间单位所组成。支持以下时间单位：y, M, w, d, B, H, m, s, ms, us, ns和由四个大写英文字母构成的交易日历标识，例如：\"2y\", \"3M\", \"30m\", \"100ms\", \"3XNYS\"等。对于交易日历标识，支持所有存放于*marketHolidayDir*文件夹下的交易日历。\n\n#### 返回值\n\nDURATION 类型标量。\n\n#### 例子\n\n```\ny=duration(\"20H\")\ny\n```\n\n返回：20H\n\n```\ntypestr(y)\n```\n\n返回：DURATION\n\n```\nduration(\"3XNYS\")\n```\n\n返回：3XNYS\n\n不指定时间单位，取时间列 time 的单位 s：\n\n```\nt=table(take(2018.01.01T01:00:00+1..10,10) join take(2018.01.01T02:00:00+1..10,10) join take(2018.01.01T08:00:00+1..10,10) as time, rand(1.0, 30) as x);\nselect max(x) from t group by bar(time, 5);\n```\n\n| bar\\_time           | max\\_x |\n| ------------------- | ------ |\n| 2018.01.01T01:00:00 | 0.8824 |\n| 2018.01.01T01:00:05 | 0.8027 |\n| 2018.01.01T01:00:10 | 0.572  |\n| 2018.01.01T02:00:00 | 0.8875 |\n| 2018.01.01T02:00:05 | 0.8542 |\n| 2018.01.01T02:00:10 | 0.4287 |\n| 2018.01.01T08:00:00 | 0.9294 |\n| 2018.01.01T08:00:05 | 0.9804 |\n| 2018.01.01T08:00:10 | 0.2147 |\n\n指定单位为 m，对时间列按照1分钟进行分组：\n\n```\nselect max(x) from t group by bar(time, 1m);\n```\n\n| bar\\_time           | max\\_x |\n| ------------------- | ------ |\n| 2018.01.01T01:00:00 | 0.8824 |\n| 2018.01.01T02:00:00 | 0.8875 |\n| 2018.01.01T08:00:00 | 0.9804 |\n\n**Related information**\n\n[交易日历](https://docs.dolphindb.cn/zh/modules/MarketHoliday/mkt_calendar.html)\n"
    },
    "dynamicGroupCumcount": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/dynamicGroupCumcount.html",
        "signatures": [
            {
                "full": "dynamicGroupCumcount(membership, prevMembership, groupCount)",
                "name": "dynamicGroupCumcount",
                "parameters": [
                    {
                        "full": "membership",
                        "name": "membership"
                    },
                    {
                        "full": "prevMembership",
                        "name": "prevMembership"
                    },
                    {
                        "full": "groupCount",
                        "name": "groupCount"
                    }
                ]
            }
        ],
        "markdown": "### [dynamicGroupCumcount](https://docs.dolphindb.cn/zh/funcs/d/dynamicGroupCumcount.html)\n\n\n\n#### 语法\n\ndynamicGroupCumcount(membership, prevMembership, groupCount)\n\n#### 详情\n\n通常一个事件的类别和属性是固定的。但在某些场景下，事件的类别会动态发生变化。如：在实时处理逐笔数据时，进行大小单的统计以对资金流进行分析。用户期望根据某个订单（事件的属性）的累计交易量来判断该订单是大单还是小单（事件的类别）。随着实时数据不断流入，交易量的不断增加，该订单的类别可能从一个小单变成大单。\n\n`dynamicGroupCumcount` 即可应用在这类场景下，用于统计在一个时间序列下，不同类别的累计事件数。\n\n具体算法如下：\n\n* 若 *membership* = *prevMembership*，统计量不变。\n\n* 若 *membership* ≠ *prevMembership*，*membership* 对应组的统计量加1，*prevMembership* 对应的组统计量减1。\n\n* 若 *prevMembership* 为空值（对应序列的第一条记录），*membership* 对应组的统计量加1，*prevMembership* 无对应组，无需处理。\n\n#### 参数\n\n**membership** 整型向量，其元素必须是 \\[0, groupCount) 范围内的整数。用于记录事件在每个时间戳上对应的标签。\n\n**prevMembership** 整型向量，其元素可以为空值（对应序列的第一条记录）。用于记录事件在前一个时间戳上对应的标签。\n\n**groupCount** \\[2, 8] 之间的一个整数。表示函数返回值（元组）的长度，即需要统计的标签数。\n\n#### 返回值\n\n返回一个长度为 *groupCount* 的元组，其每个元素是一个与 *membership* 等长的向量，依次记录了各标签统计的累积记录数。\n\n**Note:** 元组的下标与标签号一一对应，即标签为 0 的统计结果将输出至元组下标为 0 的向量。\n\n#### 例子\n\n数据预处理：\n\n```\n# 打标签函数\ndef tag_func(v){\n\n  return iif(v <= 5, 0, iif(v <= 10 and v > 5, 1, 2))\n// output\n}\n# 原始数据表\ntime = take(2022.01.01T09:00:00.000 + 1..3, 6)\nsym=`st0`st0`st0`st1`st1`st1\norderNo = `10001`10002`10001`10002`10003`10002\nvolume = 2 4 6 3 2 9\nt = table(sym, time, orderNo, volume)\n\n# 计算累计和并根据阈值打标签\nt1 = select *, cumsum(volume) as sumVolume from t context by sym, orderNo\nt2 = lj(t, t1,`sym`time`orderNo)\nt3 = select sym, time, orderNo, volume, sumVolume, tag_func(sumVolume) as groupId from t2\n```\n\n对于历史数据，可以使用 SQL 语句计算不同组的累计记录数：\n\n```\nt4 = select sym, time, orderNo, prev(groupId) as prevGroupId from t3 context by sym,orderNo\nt5 = lj(t3, t4,`sym`time`orderNo)\nre = select sym, time, orderNo, dynamicGroupCumcount(groupId, prevGroupId, 3) as `groupId0`groupId1`groupId2 from t5 context by sym\nre\n```\n\n| sym | time                    | orderNo | groupId0 | groupId1 | groupId2 |\n| --- | ----------------------- | ------- | -------- | -------- | -------- |\n| st0 | 2022.01.01T09:00:00.001 | 10001   | 1        | 0        | 0        |\n| st0 | 2022.01.01T09:00:00.002 | 10002   | 2        | 0        | 0        |\n| st0 | 2022.01.01T09:00:00.003 | 10001   | 1        | 1        | 0        |\n| st1 | 2022.01.01T09:00:00.001 | 10002   | 1        | 0        | 0        |\n| st1 | 2022.01.01T09:00:00.002 | 10003   | 2        | 0        | 0        |\n| st1 | 2022.01.01T09:00:00.003 | 10002   | 1        | 0        | 1        |\n\n对于实时数据，可以使用流数据引擎计算不同组的累计记录数：\n\n```\nresult = table(1000:0, `sym`time`orderNo`groupId0`groupId1`groupId2, [SYMBOL, TIME, SYMBOL,INT,INT,INT])\nfactor0 = [<time>,  <prev(groupId) as prevGroupId>, <groupId>, <volume>]\nfactor1 = [<time>, <orderNo>, <dynamicGroupCumcount(groupId, prevGroupId, 3)>]\ndm1 = table(1000:0, `sym`time`orderNo`volume`sumVolume`groupId, [SYMBOL, TIME, SYMBOL,INT, INT,INT])\ndm2 = table(1000:0, `sym`orderNo`time`prevGroupId`groupId`volume, [SYMBOL, SYMBOL, TIME, INT,INT,INT])\nres1 = createReactiveStateEngine(name=\"reactive_ccnt\", metrics =factor1, dummyTable=dm2, outputTable=result, keyColumn=`sym, keepOrder=true)\nres0 = createReactiveStateEngine(name=\"reactive_prev\", metrics =factor0, dummyTable=dm1, outputTable=res1, keyColumn=`sym`orderNo, keepOrder=true)\nres0.append!(t3)\n\nselect * from result\n```\n\n| sym | time                    | orderNo | groupId0 | groupId1 | groupId2 |\n| --- | ----------------------- | ------- | -------- | -------- | -------- |\n| st0 | 2022.01.01T09:00:00.001 | 10001   | 1        | 0        | 0        |\n| st0 | 2022.01.01T09:00:00.002 | 10002   | 2        | 0        | 0        |\n| st0 | 2022.01.01T09:00:00.003 | 10001   | 1        | 1        | 0        |\n| st1 | 2022.01.01T09:00:00.001 | 10002   | 1        | 0        | 0        |\n| st1 | 2022.01.01T09:00:00.002 | 10003   | 2        | 0        | 0        |\n| st1 | 2022.01.01T09:00:00.003 | 10002   | 1        | 0        | 1        |\n\n```\ndropStreamEngine(\"reactive_ccnt\")\ndropStreamEngine(\"reactive_prev\")\n```\n\n相关函数：[dynamicGroupCumsum](https://docs.dolphindb.cn/zh/funcs/d/dynamicGroupCumsum.html)\n"
    },
    "dynamicGroupCumsum": {
        "url": "https://docs.dolphindb.cn/zh/funcs/d/dynamicGroupCumsum.html",
        "signatures": [
            {
                "full": "dynamicGroupCumsum(cumValue, prevCumValue, membership, prevMembership, groupCount)",
                "name": "dynamicGroupCumsum",
                "parameters": [
                    {
                        "full": "cumValue",
                        "name": "cumValue"
                    },
                    {
                        "full": "prevCumValue",
                        "name": "prevCumValue"
                    },
                    {
                        "full": "membership",
                        "name": "membership"
                    },
                    {
                        "full": "prevMembership",
                        "name": "prevMembership"
                    },
                    {
                        "full": "groupCount",
                        "name": "groupCount"
                    }
                ]
            }
        ],
        "markdown": "### [dynamicGroupCumsum](https://docs.dolphindb.cn/zh/funcs/d/dynamicGroupCumsum.html)\n\n\n\n#### 语法\n\ndynamicGroupCumsum(cumValue, prevCumValue, membership, prevMembership, groupCount)\n\n#### 详情\n\n通常一个事件的类别和属性是固定的。但在某些场景下，事件的类别会动态发生变化。如：在实时处理逐笔数据时，进行大小单的统计以对资金流进行分析。用户期望根据某个订单（事件的属性）的累计交易量来判断该订单是大单还是小单（事件的类别）。随着实时数据不断流入，交易量的不断增加，该订单的类别可能从一个小单变成大单。\n\n`dynamicGroupCumsum` 即可应用在这类场景下，用于统计在一个时间序列下，某个事件指标在不同类别下的累计值。\n\n具体算法如下：\n\n* 若 *membership* = *prevMembership*，统计量不变。\n\n* 若 *membership* ≠ *prevMembership*，*membership* 对应组的统计量加 *cumValue*，*prevMembership* 对应的组统计量减 prevCumValue。\n\n* 若 *prevMembership* 为空值（对应序列的第一条记录），*membership* 对应组的统计量加 *cumValue*，*prevMembership* 无对应组，无需处理。\n\n#### 参数\n\n**cumValue** 数值型向量，用于记录事件在每个时间戳上对应的累计值。\n\n**prevCumValue** 数值型向量，其元素可以为空值（对应序列的第一条记录）。用于记录事件在前一个时间戳上对应的累计值。\n\n**membership** 整型向量，其元素必须是 \\[0, groupCount) 范围内的整数。用于记录事件在每个时间戳上对应的标签。\n\n**prevMembership** 整型向量，其元素可以为空值（对应序列的第一条记录）。用于记录事件在前一个时间戳上对应的标签。\n\n**groupCount** \\[2, 8] 之间的一个整数。表示函数返回值（元组）的长度，即需要统计的标签数。\n\n#### 返回值\n\n返回一个长度为 *groupCount* 的元组，其每个元素是一个与 *membership* 等长的向量，依次记录了某指标（*cumValue* 对应的列）在各标签下的累积和。\n\n**Note:** 元组的下标与标签号一一对应，即标签为 0 的统计结果将输出至元组下标为 0 的向量。\n\n#### 例子\n\n数据预处理：\n\n```\n// 打标签函数\ndef tag_func(v){\n\n  return iif(v <= 5, 0, iif(v <= 10 and v > 5, 1, 2))\n// output\n}\n// 原始数据表\ntime = take(2022.01.01T09:00:00.000 + 1..3, 6)\nsym=`st0`st0`st0`st1`st1`st1\norderNo = `10001`10002`10001`10002`10003`10002\nvolume = 2 4 6 3 2 9\nt = table(sym, time, orderNo, volume)\n\n// 计算累计和并根据阈值打标签\nt1 = select *, cumsum(volume) as sumVolume from t context by sym, orderNo\nt2 = lj(t, t1,`sym`time`orderNo)\nt3 = select sym, time, orderNo, volume, sumVolume, tag_func(sumVolume) as groupId from t2\n```\n\n对于历史数据，可以使用 SQL 语句计算不同组的累计成交量：\n\n```\nt4 = select sym, time, orderNo, prev(groupId) as prevGroupId, groupId, prev(sumVolume) as prevSumVolume, sumVolume from t3 context by sym,orderNo\nt5 = lj(t3, t4,`sym`time`orderNo)\nre = select sym, time, orderNo, dynamicGroupCumsum(sumVolume, prevSumVolume, groupId, prevGroupId, 3) as `groupId0`groupId1`groupId2 from t5 context by sym\nre\n```\n\n| sym | time                    | orderNo | groupId0 | groupId1 | groupId2 |\n| --- | ----------------------- | ------- | -------- | -------- | -------- |\n| st0 | 2022.01.01T09:00:00.001 | 10001   | 2        | 0        | 0        |\n| st0 | 2022.01.01T09:00:00.002 | 10002   | 6        | 0        | 0        |\n| st0 | 2022.01.01T09:00:00.003 | 10001   | 4        | 8        | 0        |\n| st1 | 2022.01.01T09:00:00.001 | 10002   | 3        | 0        | 0        |\n| st1 | 2022.01.01T09:00:00.002 | 10003   | 5        | 0        | 0        |\n| st1 | 2022.01.01T09:00:00.003 | 10002   | 2        | 0        | 12       |\n\n对于实时数据，可以使用流数据引擎计算不同组的累计成交量：\n\n```\nresult = table(1000:0, `sym`time`orderNo`groupId0`groupId1`groupId2, [SYMBOL, TIME, SYMBOL,INT,INT,INT])\nfactor0 = [ <time>, <prev(groupId) as prevGroupId>, <groupId>, <prev(sumVolume) as prevSumVolume>, <sumVolume>]\nfactor1 = [<time>, <orderNo>, <dynamicGroupCumsum(sumVolume, prevSumVolume, groupId, prevGroupId, 3)>]\ndm1 = table(1000:0, `sym`time`orderNo`volume`sumVolume`groupId, [SYMBOL, TIME, SYMBOL,INT, INT,INT])\ndm2 = table(1000:0, `sym`orderNo`time`prevGroupId`groupId`prevSumVolume`sumVolume, [SYMBOL, SYMBOL, TIME, INT, INT, INT, INT])\nres1 = createReactiveStateEngine(name=\"reactive_csum\", metrics =factor1, dummyTable=dm2, outputTable=result, keyColumn=`sym, keepOrder=true)\nres0 = createReactiveStateEngine(name=\"reactive_prev\", metrics =factor0, dummyTable=dm1, outputTable=res1, keyColumn=`sym`orderNo, keepOrder=true)\nres0.append!(t3)\n\nselect * from result\n```\n\n| sym | time                    | orderNo | groupId0 | groupId1 | groupId2 |\n| --- | ----------------------- | ------- | -------- | -------- | -------- |\n| st0 | 2022.01.01T09:00:00.001 | 10001   | 2        | 0        | 0        |\n| st0 | 2022.01.01T09:00:00.002 | 10002   | 6        | 0        | 0        |\n| st0 | 2022.01.01T09:00:00.003 | 10001   | 4        | 8        | 0        |\n| st1 | 2022.01.01T09:00:00.001 | 10002   | 3        | 0        | 0        |\n| st1 | 2022.01.01T09:00:00.002 | 10003   | 5        | 0        | 0        |\n| st1 | 2022.01.01T09:00:00.003 | 10002   | 2        | 0        | 12       |\n\n```\ndropStreamEngine(\"reactive_csum\")\ndropStreamEngine(\"reactive_prev\")\n```\n\n相关函数：[dynamicGroupCumcount](https://docs.dolphindb.cn/zh/funcs/d/dynamicGroupCumcount.html)\n"
    },
    "ffill": {
        "url": "https://docs.dolphindb.cn/zh/funcs/f/ffill.html",
        "signatures": [
            {
                "full": "ffill(obj, [limit])",
                "name": "ffill",
                "parameters": [
                    {
                        "full": "obj",
                        "name": "obj"
                    },
                    {
                        "full": "[limit]",
                        "name": "limit",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [ffill](https://docs.dolphindb.cn/zh/funcs/f/ffill.html)\n\n\n\n#### 语法\n\nffill(obj, \\[limit])\n\n#### 详情\n\n* 如果 *obj*是向量，则使用空值前最近的非空元素来填充空值。\n* 如果 *obj* 是数组向量：\n  * 对于每一行，如果该行为空，则用该行前最近的非空行填充。\n  * 对于某一列中的空值，使用该列中空值前最近的非空元素填充。\n* 如果 *obj*是矩阵或表，则对每一列按照上述规则进行填充。\n\n**Attention:** 该函数会生成新的对象，不会改变输入的对象；而函数 `ffill!` 会改变输入的对象。\n\n#### 参数\n\n**obj** 可以是向量、数组向量、矩阵或表。\n\n**limit** 是正整数，表示最大可填充的连续空值个数。*obj* 为数组向量时不支持该参数。\n\n#### 返回值\n\n返回填充空缺值后的对象，其类型与形式同 *obj*。\n\n#### 例子\n\n例1.\n\n```\nx=1 2 3 NULL NULL NULL 4 5 6\nx.ffill();\n```\n\n返回：\\[1,2,3,3,3,3,4,5,6]\n\n```\nx;\n```\n\n返回：\\[1,2,3,,,,4,5,6]。由此可见，x 中的空值没有被填充。\n\n例2. 指定参数 *limit*\n\n```\nx=1 2 3 NULL NULL NULL 4 5 6\nx.ffill(1);\n```\n\n返回：\\[1,2,3,3,,,4,5,6]\n\n```\nx.ffill(2);\nx;\n```\n\n返回：\\[1,2,3,3,3,,4,5,6]\n\n例3. 指定 *obj* 为一个表.\n\n```\ndate=[2012.06.12,2012.06.12,2012.06.13,2012.06.14,2012.06.15]\nsym=[\"IBM\",\"MSFT\",\"IBM\",\"MSFT\",\"MSFT\"]\nprice=[40.56,26.56,,,50.76]\nqty=[2200,4500,,5600,]\ntimestamp=[09:34:07,09:35:26,09:36:42,09:36:51,09:36:59]\nt=table(date,timestamp,sym,price,qty);\nt;\n```\n\n得到：\n\n| date       | timestamp | sym  | price | qty  |\n| ---------- | --------- | ---- | ----- | ---- |\n| 2012.06.12 | 09:34:07  | IBM  | 40.56 | 2200 |\n| 2012.06.12 | 09:35:26  | MSFT | 26.56 | 4500 |\n| 2012.06.13 | 09:36:42  | IBM  |       |      |\n| 2012.06.14 | 09:36:51  | MSFT |       | 5600 |\n| 2012.06.15 | 09:36:59  | MSFT | 50.76 |      |\n\n```\nt.ffill();\n```\n\n得到：\n\n| date       | timestamp | sym  | price | qty  |\n| ---------- | --------- | ---- | ----- | ---- |\n| 2012.06.12 | 09:34:07  | IBM  | 40.56 | 2200 |\n| 2012.06.12 | 09:35:26  | MSFT | 26.56 | 4500 |\n| 2012.06.13 | 09:36:42  | IBM  | 26.56 | 4500 |\n| 2012.06.14 | 09:36:51  | MSFT | 26.56 | 5600 |\n| 2012.06.15 | 09:36:59  | MSFT | 50.76 | 5600 |\n\n```\nselect date, timestamp, sym, price.ffill() as price, qty.ffill() as qty from t context by sym;\n```\n\n得到：\n\n| date       | timestamp | sym  | price | qty  |\n| ---------- | --------- | ---- | ----- | ---- |\n| 2012.06.12 | 09:34:07  | IBM  | 40.56 | 2200 |\n| 2012.06.13 | 09:36:42  | IBM  | 40.56 | 2200 |\n| 2012.06.12 | 09:35:26  | MSFT | 26.56 | 4500 |\n| 2012.06.14 | 09:36:51  | MSFT | 26.56 | 5600 |\n| 2012.06.15 | 09:36:59  | MSFT | 50.76 | 5600 |\n\n下例中，数组向量 x 的第四行为空，因此使用第三行 \\[6, 7, 8] 对其进行填充；第一列的第二个元素为空，故用该列中其之前的最近的非空元素 1 进行填充。\n\n```\nx = array(INT[], 0).append!([1 2 3, NULL 5, 6 7 8, NULL])\nx\n// output:[[1,2,3],[NULL,5],[6,7,8],[NULL]]\nffill(x)\n// output:[[1,2,3],[1,5],[6,7,8],[6,7,8]]\n```\n"
    },
    "ffill!": {
        "url": "https://docs.dolphindb.cn/zh/funcs/f/ffill_.html",
        "signatures": [
            {
                "full": "ffill!(obj,[limit])",
                "name": "ffill!",
                "parameters": [
                    {
                        "full": "obj",
                        "name": "obj"
                    },
                    {
                        "full": "[limit]",
                        "name": "limit",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [ffill!](https://docs.dolphindb.cn/zh/funcs/f/ffill_.html)\n\n\n\n#### 语法\n\nffill!(obj,\\[limit])\n\n#### 详情\n\n* 如果 *obj* 是一个向量，使用 NULL 值前的非空元素来填充 NULL 值。\n\n* 如果 *obj* 是一个矩阵或表，对于表中的每一列，使用 NULL 值前的非空元素来填充 NULL 值。\n\n**Attention:**\n\n该函数会改变输入的对象；而函数 `ffill` 会生成新的对象，不会改变输入的对象。\n\n#### 参数\n\n**obj** 可以是向量、矩阵或表。\n\n**limit** 是正整数，表示需要填充的 NULL 值的数量。\n\n#### 返回值\n\n返回填充空缺值后的对象，其类型与形式同 *obj*。\n\n#### 例子\n\n例1.\n\n```\nx=1 2 3 NULL NULL NULL 4 5 6\nx.ffill!(); \nx; \n// x 中的空值被填充了\n[1,2,3,3,3,3,4,5,6]\n```\n\n例2. 通过 *limit* 参数，指定需要填充 1 个NULL值：\n\n```\nx=1 2 3 NULL NULL NULL 4 5 6\nx.ffill!(1);\n// output\n[1,2,3,3,,,4,5,6]\n```\n\n例3. *obj* 指定为一个表\n\n```\ndate=[2012.06.12,,2012.06.13,2012.06.14,2012.06.15]\nsym=[\"IBM\",\"MSFT\",\"IBM\",\"MSFT\",\"MSFT\"]\nprice=[40.56,26.56,,,50.76]\nqty=[2200,4500,1200,5600,]\ntimestamp=[09:34:07,,09:36:42,09:36:51,09:36:59]\nt=table(date,timestamp,sym,price,qty);\n\nffill!(t);\nt;\n```\n\n输出返回：\n\n| date       | timestamp | sym  | price | qty  |\n| ---------- | --------- | ---- | ----- | ---- |\n| 2012.06.12 | 09:34:07  | IBM  | 40.56 | 2200 |\n| 2012.06.12 | 09:34:07  | MSFT | 26.56 | 4500 |\n| 2012.06.13 | 09:36:42  | IBM  | 26.56 | 1200 |\n| 2012.06.14 | 09:36:51  | MSFT | 26.56 | 5600 |\n| 2012.06.15 | 09:36:59  | MSFT | 50.76 | 5600 |\n"
    },
    "fflush": {
        "url": "https://docs.dolphindb.cn/zh/funcs/f/fflush.html",
        "signatures": [
            {
                "full": "fflush(obj)",
                "name": "fflush",
                "parameters": [
                    {
                        "full": "obj",
                        "name": "obj"
                    }
                ]
            }
        ],
        "markdown": "### [fflush](https://docs.dolphindb.cn/zh/funcs/f/fflush.html)\n\n\n\n#### 语法\n\nfflush(obj)\n\n#### 详情\n\n将缓冲区中的数据写入操作系统的文件系统。该函数必须要用户登录后才能执行。\n\n**Note:**\n\n1. 将数据写入文件，建议通过 [close](https://docs.dolphindb.cn/zh/funcs/c/close.html) 关闭该文件或通过 `fflush` 强制将缓冲区的数据写入文件，否则可能丢失数据。\n\n2. 该命令并没有将数据刷入磁盘，因此，发生意外宕机时可能会出现数据丢失。\n\n#### 参数\n\n**obj** 是一个文件句柄。通常使用函数 [file](https://docs.dolphindb.cn/zh/funcs/f/file.html) 打开一个文件获得一个文件句柄。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\nrows = 10\nt=table(1..rows as id, 1..rows+100 as value)\nf1=file(\"test.bin\", \"w\")\nf1.writeRecord(t)\n// 没有关闭文件或者将缓冲区数据刷入文件。此时读取的文件并不包含新写入的数据\nt1 = table(rows:0,`id`value,`INT`INT)\nf=file('test.bin')\nf.readRecord!(t1)\n// readRecord!(f, t1) => Reach the end of a file or a buffer.\n\n// 调用 fflush\nf1.fflush()\n\nt1 = table(rows:0,`id`value,`INT`INT)\nf=file('test.bin')\nf.readRecord!(t1)\n10\n```\n"
    },
    "file": {
        "url": "https://docs.dolphindb.cn/zh/funcs/f/file.html",
        "signatures": [
            {
                "full": "file(name, [mode=\"r\"], [isLittleEndian])",
                "name": "file",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "[mode=\"r\"]",
                        "name": "mode",
                        "optional": true,
                        "default": "\"r\""
                    },
                    {
                        "full": "[isLittleEndian]",
                        "name": "isLittleEndian",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [file](https://docs.dolphindb.cn/zh/funcs/f/file.html)\n\n\n\n#### 语法\n\nfile(name, \\[mode=\"r\"], \\[isLittleEndian])\n\n#### 详情\n\nfile 函数通过给定的模式打开一个文件。该函数必须要用户登录后才能执行。\n\n打开的模式可以是以下 6 种之一：\"r\", \"r+\", \"w\", \"w+\", \"a\" 和 \"a+\"。默认的模式是 \"r\" （只读）。[close](https://docs.dolphindb.cn/zh/funcs/c/close.html) 函数用于关闭一个打开的文件。\n\n\"r\": 只读模式。游标位于文件头。\n\n\"r+\": 读写模式。游标位于文件头。\n\n\"w\": 只写模式，把文件清空。游标位于文件头。\n\n\"w+\": 读写模式。如果文件不存在将创建文件，否则把文件清空。游标位于文件头。\n\n\"a\": 追加模式（只写）。如果文件不存在将创建文件。游标位于文件尾，从文件尾开始写。连续地写文件，每次写完后，游标都会位于文件尾。\n\n\"a+\": 追加模式（读写）。如果文件不存在将创建文件。游标位于文件尾，从文件尾开始读写。连续地写文件，每次写完后，游标都会位于文件尾。\n\n#### 参数\n\n**name** 字符串，表示文件名称。\n\n**mode** 字符串，表示打开的模式。\n\n**isLittleEndian** 布尔值，表示是否采用小端模式。默认情况下，采用的是操作系统的大小端模式。它是一个可选参数。\n\n#### 返回值\n\n一个句柄（HANDLE）。\n\n#### 例子\n\n```\nfout=file(\"test.txt\",\"w\");\nfout.writeLine(\"hello world!\");\n// output\n1\nfout.close();\n\nfin = file(\"test.txt\");\nprint fin.readLine();\n// output\nhello world!\nfin.close();\n```\n"
    },
    "files": {
        "url": "https://docs.dolphindb.cn/zh/funcs/f/files.html",
        "signatures": [
            {
                "full": "files(directory, [pattern])",
                "name": "files",
                "parameters": [
                    {
                        "full": "directory",
                        "name": "directory"
                    },
                    {
                        "full": "[pattern]",
                        "name": "pattern",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [files](https://docs.dolphindb.cn/zh/funcs/f/files.html)\n\n\n\n#### 语法\n\nfiles(directory, \\[pattern])\n\n#### 详情\n\n该函数必须要用户登录后才能执行。\n\n如果没有指定 *pattern*，返回一个包含目录中的文件和子目录信息的表。\n\n如果指定了 *pattern*，返回一个包含文件名中包含了pattern 的文件和子目录的表。\n\n#### 参数\n\n**directory** 是表示目录路径的字符串。\n\n**pattern** 是表示在该目录下搜索的文件名的模式的字符串。\n\n#### 返回值\n\n一个表，包含如下字段：\n\n* fileName：文件/目录名。\n* isDir：是否是目录。\n* fileSize：文件大小。\n* lastAccessed：最后访问时间。\n* lastModified：最后修改时间。\n\n#### 例子\n\n```\nfiles(\"/home/06_DolphinDB/01_App/DolphinDB_Win_V0.2\");\n```\n\n| filename                          | isDir | fileSize | lastAccessed            | lastModified            |\n| --------------------------------- | ----- | -------- | ----------------------- | ----------------------- |\n| LICENSE\\_AND\\_AGREEMENT.txt       | false | 22558    | 2026.03.24 03:55:19.119 | 2026.03.24 03:55:19.907 |\n| README\\_WIN.txt                   | false | 5104     | 2026.03.24 03:51:56.331 | 2026.03.24 03:51:59.091 |\n| server                            | true  | 0        | 2026.03.24 06:11:27.922 | 2026.03.24 03:55:19.183 |\n| THIRD\\_PARTY\\_SOFTWARE\\_LICENS... | false | 8435     | 2026.03.24 03:48:44.566 | 2025.06.13 02:36:47.453 |\n\n```\nfiles(\"/home/06_DolphinDB/01_App/DolphinDB_Win_V0.2\", \"readme%\");\n```\n\n| filename        | isDir | fileSize | lastAccessed            | lastModified            |\n| --------------- | ----- | -------- | ----------------------- | ----------------------- |\n| README\\_WIN.txt | false | 5104     | 2026.03.24 03:48:41.830 | 2025.12.26 08:29:33.239 |\n\n```\nselect * from files(\"/home/06_DolphinDB/01_App/DolphinDB_Win_V0.2\") where filename like \"README%\";\n```\n\n| filename        | isDir | fileSize | lastAccessed            | lastModified            |\n| --------------- | ----- | -------- | ----------------------- | ----------------------- |\n| README\\_WIN.txt | false | 5104     | 2026.03.24 03:48:41.830 | 2025.12.26 08:29:33.239 |\n"
    },
    "fill!": {
        "url": "https://docs.dolphindb.cn/zh/funcs/f/fill_.html",
        "signatures": [
            {
                "full": "fill!(obj, index, value)",
                "name": "fill!",
                "parameters": [
                    {
                        "full": "obj",
                        "name": "obj"
                    },
                    {
                        "full": "index",
                        "name": "index"
                    },
                    {
                        "full": "value",
                        "name": "value"
                    }
                ]
            }
        ],
        "markdown": "### [fill!](https://docs.dolphindb.cn/zh/funcs/f/fill_.html)\n\n\n\n#### 语法\n\nfill!(obj, index, value)\n\n#### 详情\n\n将 *obj* 中 *index* 对应位置的值设为 *value*，相当于赋值语句 obj\\[index]=value。\n\n#### 参数\n\n**obj** 可以是一个向量、元组、矩阵、字典或表。\n\n如果 **obj** 是向量、元组或矩阵，**index** 是整数，表示下标；如果 **obj** 是字典或表，**index** 是字符串，分别表示 key 或列名。\n\n**value** 是标量或向量，表示新的值。\n\n#### 返回值\n\n返回填充空缺值后的对象，其类型与形式同 *obj*。\n\n#### 例子\n\n例1. 向量\n\n```\na=[1,2,3,4];\nfill!(a,3,12);\na;\n// output\n[1,2,3,12]\n\nfill!(a,[0,1],[10,11]);\n// output\n[10,11,3,12]\n```\n\n例2. 元组\n\n```\na=([1,2,3],[\"a\",\"b\",\"c\"]);\nfill!(a,0,[4,2]);\na[0];\n// output\n[4,2]\n\n// 创建一个长度为20，并且每个元素为 FLOAT 类型的 NULL 值\narray(ANY, 20).fill!(0:20, float());\n\n// 相当于以下语句\nt = array(ANY, 20);\nt[0:20] = float()\n```\n\n例3. 矩阵\n\n```\nm=1..12$3:4;\nfill!(m,2,5); // 将第2列的值全部设为5\nm;\n```\n\n| #0 | #1 | #2 | #3 |\n| -- | -- | -- | -- |\n| 1  | 4  | 5  | 10 |\n| 2  | 5  | 5  | 11 |\n| 3  | 6  | 5  | 12 |\n\n```\nfill!(m,[1,2],5); // 将第1,2列的值全部设为5\nm;\n```\n\n| #0 | #1 | #2 | #3 |\n| -- | -- | -- | -- |\n| 1  | 5  | 5  | 10 |\n| 2  | 5  | 5  | 11 |\n| 3  | 5  | 5  | 12 |\n\n```\nfill!(m,(1,),9); // 将第1行的值设为9\nm;\n```\n\n| #0 | #1 | #2 | #3 |\n| -- | -- | -- | -- |\n| 1  | 5  | 5  | 10 |\n| 9  | 9  | 9  | 9  |\n| 3  | 5  | 5  | 12 |\n\n```\nm.fill!((1,2),10).fill!((2,2),12); // 将第1行，第2列的值设为10，第2行第2列的值设为12\nm;\n```\n\n| #0 | #1 | #2 | #3 |\n| -- | -- | -- | -- |\n| 1  | 5  | 5  | 10 |\n| 9  | 9  | 10 | 9  |\n| 3  | 5  | 12 | 12 |\n\n例4. 表\n\n```\nt=table(1 2 3 as id,10.2 45.2 12.3 as val);\nfill!(t,`id,4 5 6);\nt;\n```\n\n| id | val  |\n| -- | ---- |\n| 4  | 10.2 |\n| 5  | 45.2 |\n| 6  | 12.3 |\n\n```\nfill!(t,`qty,452 142 48);\nt;\n```\n\n| id | val  | qty |\n| -- | ---- | --- |\n| 4  | 10.2 | 452 |\n| 5  | 45.2 | 142 |\n| 6  | 12.3 | 48  |\n\n例5. 字典\n\n```\nd=dict(`a`b`c,1 2 3);\nfill!(d,`a,4);\nd;\n// output\nc->3\na->4\nb->2\n```\n"
    },
    "find": {
        "url": "https://docs.dolphindb.cn/zh/funcs/f/find.html",
        "signatures": [
            {
                "full": "find(X, Y)",
                "name": "find",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [find](https://docs.dolphindb.cn/zh/funcs/f/find.html)\n\n\n\n#### 语法\n\nfind(X, Y)\n\n#### 详情\n\n* 若 *X* 是向量，对 *Y* 中每一个元素，返回其第一次出现在 *X* 中的位置；如果没有在X中出现，返回 -1。若要查找所有出现的位置，可使用 [at](https://docs.dolphindb.cn/zh/funcs/a/at.html) 函数 。\n\n* 若 *X* 是字典，对 *Y* 中每一个元素，若其为 *X* 的键，返回 *X* 中对应的值；若不是 *X* 的键，返回 NULL。\n\n* 若 *X* 是单列内存表，对 *Y* 中每一个元素，返回其第一次出现在 *X* 的唯一列中的位置；如果没有在 *X* 的唯一列中出现，返回-1。注意：表中单列的类型不能是 Array Vector。\n\n* 若 *X* 是键值内存表或索引内存表，对 *Y* 中每一个元素，返回其第一次出现在 *X* 的主键中的位置； 如果没有在 *X* 的主键中出现，返回 -1。\n\n通过 `find` 函数，用一个大向量搜索另一个大向量时，系统将建立一个字典，用以优化性能。但如果只是用几个值搜索一个向量，系统可能不会为了优化性能建立字典。是否建立字典是动态决定的。如果需要在已经排序的向量中搜索少量数据，我们推荐使用 [binsrch](https://docs.dolphindb.cn/zh/funcs/b/binsrch.html) 函数。\n\n#### 参数\n\n**X** 可以是向量、字典、单列内存表、键值表或者索引内存表。\n\n**Y** 可以是标量、向量、数组向量、元组、字典、矩阵、表。\n\n#### 返回值\n\n* 当 *X* 为向量、单列内存表、键值表或者索引内存表时，返回值为整型标量或向量。\n* 当 *X* 为字典时，返回值类型与 X 中对应值的类型一致。\n\n#### 例子\n\n*X* 是向量：\n\n```\nfind(7 3 3 5, 3);\n// output\n1\n\nat(7 3 3 5 == 3);\n// output\n[1,2]\n\n(7 3 3 5 6).find(2 4 5);\n// output\n[-1,-1,3]\n```\n\n*X* 是字典：\n\n```\nz=dict(1 2 3,4.5 6.6 3.2);\nz;\n// output\n3->3.2\n1->4.5\n2->6.6\n\nfind(z,3);\n// output\n3.2\n\nfind(z,5);\n// output\n00F\n```\n\n*X* 是单列内存表：\n\n```\nt = table(1 3 5 7 9 as id)\nfind(t, 2 3)\n// output\n[-1,1]\n```\n\n*X* 是键值表或者索引内存表：\n\n```\nkt = keyedTable(`name`id,1000:0,`name`id`age`department,[STRING,INT,INT,STRING])\ninsert into kt values(`Tom`Sam`Cindy`Emma`Nick, 1 2 3 4 5, 30 35 32 25 30, `IT`Finance`HR`HR`IT)\nfind(kt,(`Emma`Sam, 4 1));\n// output\n[3,-1]\n\nt1 = indexedTable(`sym`side, 10000:0, `sym`side`price`qty, [SYMBOL,CHAR,DOUBLE,INT])\ninsert into t1 values(`IBM`MSFT`GOOG, ['B','S','B'], 10.01 10.02 10.03, 10 10 20)\nfind(t1, (`GOOG`MSFT, ['B','S']))\n// output\n[2,1]\n```\n"
    },
    "first": {
        "url": "https://docs.dolphindb.cn/zh/funcs/f/first.html",
        "signatures": [
            {
                "full": "first(X)",
                "name": "first",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [first](https://docs.dolphindb.cn/zh/funcs/f/first.html)\n\n\n\n#### 语法\n\nfirst(X)\n\n或\n\nfirst X\n\n#### 详情\n\n返回向量的第一个元素，或矩阵、表的第一行。\n\n**Note:** 若向量的第一个元素为 NULL，则返回 NULL。若要返回第一个非 NULL 的元素，请使用 [firstNot](https://docs.dolphindb.cn/zh/funcs/f/firstNot.html) 函数。\n\n#### 参数\n\n**X** 可以是标量、数据对、向量、矩阵或表。\n\n#### 返回值\n\n一个标量或向量，其数据类型同 *X*。\n\n#### 例子\n\n```\nfirst(`hello `world);\n```\n\n输出返回：hello\n\n```\nfirst(1..10);\n```\n\n输出返回：1\n\n```\nm = matrix(1 2 3, 4 5 6);\nm;\n```\n\n输出返回：\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 4  |\n| 2  | 5  |\n| 3  | 6  |\n\n```\nfirst(m);\n```\n\n输出返回：\\[1,4]\n\n相关函数：[last](https://docs.dolphindb.cn/zh/funcs/l/last.html)\n"
    },
    "firstHit": {
        "url": "https://docs.dolphindb.cn/zh/funcs/f/firstHit.html",
        "signatures": [
            {
                "full": "firstHit(func, X, target)",
                "name": "firstHit",
                "parameters": [
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "target",
                        "name": "target"
                    }
                ]
            }
        ],
        "markdown": "### [firstHit](https://docs.dolphindb.cn/zh/funcs/f/firstHit.html)\n\n\n\n#### 语法\n\nfirstHit(func, X, target)\n\n#### 详情\n\n返回 *X* 中第一个满足 *X* *func* *target* （例如 *X*>5) 条件的元素。\n\n若 *X* 中无元素满足条件，则返回空值。\n\n通过 `firstHit` 查找时，NULL 值会被忽略。如需查找第一个非 NULL 值， 可以调用函数 [firstNot](https://docs.dolphindb.cn/zh/funcs/f/firstNot.html)。\n\n#### 参数\n\n**func** 关系运算符 >, >=, <, <=, !=, <>, ==。\n\n**X** 向量或矩阵。\n\n**target** 和 *X* 类型相同的标量，表示比较的对象。\n\n#### 返回值\n\n返回值类型与 *X* 类型一致。数据形式为标量或向量。\n\n#### 例子\n\n```\nX = NULL 3.2 4.5 1.2 NULL 7.8 0.6 9.1\nfirstHit(<, X, 2.5)\n```\n\n输出返回：1.2\n\n若无元素满足查找条件，返回空值，如下面这个例子：\n\n```\nfirstHit(>, X, 10.0)\n```\n\n输出返回：NULL\n\n相关函数：[ifirstHit](https://docs.dolphindb.cn/zh/funcs/i/ifirstHit.html)\n"
    },
    "firstNot": {
        "url": "https://docs.dolphindb.cn/zh/funcs/f/firstNot.html",
        "signatures": [
            {
                "full": "firstNot(X, [k])",
                "name": "firstNot",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[k]",
                        "name": "k",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [firstNot](https://docs.dolphindb.cn/zh/funcs/f/firstNot.html)\n\n\n\n#### 语法\n\nfirstNot(X, \\[k])\n\n#### 详情\n\n若 *X* 是向量：\n\n* 如果没有指定 *k*，返回 *X* 中第一个不为 NULL 的元素。\n\n* 如果指定 *k*，返回 *X* 中第一个不为 *k* 或 NULL 的元素。\n\n若 *X* 是矩阵或表，在每列内进行上述计算，返回一个向量。\n\n`firstNot` 函数也支持查询分布式表和分区表。\n\n#### 参数\n\n**X** 可以是标量、数据对、向量、矩阵或表。\n\n**k** 是一个标量，它是可选参数。\n\n#### 返回值\n\n* 当 *X* 是向量时，返回标量，数据类型与 *X* 相同\n* 当 *X* 是矩阵或表时，返回向量，每个元素对应每列的计算结果，数据类型与原列元素类型相同。\n\n#### 例子\n\n*X* 是向量：\n\n```\nfirstNot(0 0 0 6 1, 0);\n// output\n6\n\nfirstNot(NULL 0 3 2 1, 0);\n// output\n3\n\nfirstNot(NULL 0 1 6);\n// output\n0\n\nt=table(1 1 1 1 1 2 2 2 2 2 as id, 0 0 0 2 1 NULL NULL 0 0 3 as x);\nt;\n```\n\n| id | x |\n| -- | - |\n| 1  | 0 |\n| 1  | 0 |\n| 1  | 0 |\n| 1  | 2 |\n| 1  | 1 |\n| 2  |   |\n| 2  |   |\n| 2  | 0 |\n| 2  | 0 |\n| 2  | 3 |\n\n```\nselect firstNot(x, 0) from t group by id;\n```\n\n| id | firstNot\\_x |\n| -- | ----------- |\n| 1  | 2           |\n| 2  | 3           |\n\n```\nm=matrix(0 NULL 1 2 3, NULL 2 NULL 0 3);\nm;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 0  | 2  |\n| 1  |    |\n| 2  | 0  |\n| 3  | 3  |\n\n```\nfirstNot(m, 0);\n// output\n[1,2]\n```\n"
    },
    "fixedLengthArrayVector": {
        "url": "https://docs.dolphindb.cn/zh/funcs/f/fixedLengthArrayVector.html",
        "signatures": [
            {
                "full": "fixedLengthArrayVector(args…)",
                "name": "fixedLengthArrayVector",
                "parameters": [
                    {
                        "full": "args…",
                        "name": "args…"
                    }
                ]
            }
        ],
        "markdown": "### [fixedLengthArrayVector](https://docs.dolphindb.cn/zh/funcs/f/fixedLengthArrayVector.html)\n\n\n\n#### 语法\n\nfixedLengthArrayVector(args…)\n\n#### 详情\n\n将向量、矩阵或表拼接为一个数组向量。其拼接方式如下图所示（对应例1），输出的数组向量每一行（每个数组元素）的长度相等，等于所有输入数据列数的总和：\n\n**Note:** 向量的长度（元组中每个向量的长度）、矩阵、表的行数必须相同。\n\n![](https://docs.dolphindb.cn/zh/images/fixedLengthArrayVector.png)\n\n#### 参数\n\n**args** 可以是一个或多个向量/固定长度数组向量/元组/矩阵或表。*args* 的每个元素必须具有相同的数据类型，且必须是数组向量支持的类型。\n\n#### 返回值\n\n一个数组向量。\n\n#### 例子\n\n例1. 图例代码\n\n```\nvec = 1 5 3\ntp = [3 4 5, 4 5 6]\nm =  matrix(5 0 7, 7 6 9, 1 9 0)\ntb = table(6 9 4 as v1, 1 4 3 as v2)\nf = fixedLengthArrayVector(vec, tp, m, tb)\nf;\n\n[[1,3,4,5,7,1,6,1],[5,4,5,0,6,9,9,4],[3,5,6,7,9,0,4,3]]\n\ntypestr(f);\n// output\nFAST INT[] VECTOR\n```\n\n例2. 将多列合并成一列\n\n下例简单示意了将 2 档 bid 报价存储为数组向量的例子。\n\n```\nlogin(\"admin\",\"123456\")\nsyms=\"A\"+string(1..30)\ndatetimes=2019.01.01T00:00:00..2019.01.31T23:59:59\nn=200\nif(existsDatabase(\"dfs://stock\")) {\n      dropDatabase(\"dfs://stock\")\n}\ndb=database(\"dfs://stock\", RANGE, cutPoints(syms,3), engine=\"TSDB\");\nt=table(take(datetimes,n) as trade_time, take(syms,n) as sym,take(500+rand(10.0,n), n) as bid1, take(500+rand(20.0,n),n) as bid2)\nt1=select trade_time, sym, fixedLengthArrayVector(bid1,bid2) as bid from t\n\nquotes=db.createPartitionedTable(t1,`quotes,`sym, sortColumns=`sym`trade_time).append!(t1)\nselect * from quotes\n```\n\n| trade\\_time         | sym | bid                      |\n| ------------------- | --- | ------------------------ |\n| 2019.01.01T00:00:00 | A1  | \\[503.111142,507.55833]  |\n| 2019.01.01T00:00:30 | A1  | \\[502.991382,501.734092] |\n| 2019.01.01T00:01:00 | A1  | \\[500.790709,509.200963] |\n| 2019.01.01T00:01:30 | A1  | \\[501.127932,507.972508] |\n| 2019.01.01T00:02:00 | A1  | \\[500.678614,514.947117] |\n\n通过索引可以取出单档 bid 的数据，单独进行计算。对 bid 列应用函数计算，相当于将所有档的 bid 数据一起计算。\n\n```\nselect avg(bid[0]) as avg_bid1, avg(bid[1]) as avg_bid2, avg(bid) as avg_bid from quotes\n```\n\n| avg\\_bid1 | avg\\_bid2 | avg\\_bid |\n| --------- | --------- | -------- |\n| 505.0263  | 509.2912  | 507.16   |\n\n现实场景下，可能需要将 50 档甚至更多的报价存储为数组向量，编写脚本十分不便。由于报价字段名通常以表示报价类型的字符串加编号的形式存储，可以通过以下方式编写脚本：\n\n```\n// 随机生成 50 档报价\nn = 200\nt=table(take(datetimes,n) as trade_time, take(syms,n) as sym)\nfor(i  in 1:51){\n\n      t[\"bid\"+string(i)] = take(500+rand(10.0,n), n)\n}\n\n// 将 50 档报价存储为数组向量\nt[\"bid\"]=fixedLengthArrayVector(t[\"bid\"+string(1..50)])\nt1=select trade_time, sym, bid from t\n```\n\n例3. 将多个数组向量合并存储为一个数组向量。参考前例，此处随机生成交易所 A、B 的 5 档行情，然后将交易所 A、B 的 5 档报价分别存储为数组向量，最后将交易所 A、B 的报价数组向量合并存储为一个数组向量。\n\n```\n//随机生成交易所A、B的5档行情\nsyms = \"A\" + string(1..5)\ndatetimes = 2019.01.01T00:00:00..2019.01.31T23:59:59\nn = 10\nt1 = table(take(datetimes, n) as trade_time, take(syms, n) as sym)\nfor(i  in 1:6){\n      t1[\"bid\" + string(i)] = take(50 + rand(10.0, n), n)\n}\nt2 = table(take(datetimes, n) as trade_time, take(syms, n) as sym)\nfor(i  in 1:6){\n      t2[\"bid\" + string(i)] = take(50 + rand(10.0, n), n)\n}\n\n// 将交易所A、B的5档报价分别存储为数组向量\nt1[\"bid\"] = fixedLengthArrayVector(t1[\"bid\" + string(1..5)])\nt2[\"bid\"] = fixedLengthArrayVector(t2[\"bid\" + string(1..5)])\n\n// 将交易所A、B的报价合并存储为一个数组向量\nt1[\"bid\"] = fixedLengthArrayVector(t1[\"bid\"], t2[\"bid\"])\nt3 = select trade_time, sym, bid from t1\n```\n\n| trade\\_time         | sym | bid                                                            |\n| ------------------- | --- | -------------------------------------------------------------- |\n| 2019.01.01T00:00:01 | A2  | \\[58.97,50.65,54.38,50.11,56.26,52.35,52.79,55.43,52.16,53.35] |\n| 2019.01.01T00:00:02 | A3  | \\[50.25,53.45,52.68,58.19,56.51,57.54,55.22,51.74,58.63,57.43] |\n| 2019.01.01T00:00:03 | A4  | \\[56.42,50.28,57.04,52.45,51.83,57.75,55.04,57.34,57.82,53.28] |\n| 2019.01.01T00:00:04 | A5  | \\[59.90,51.73,55.54,57.74,53.48,59.62,57.26,53.99,52.67,57.82] |\n| 2019.01.01T00:00:05 | A1  | \\[53.16,59.27,52.97,50.41,58.30,57.83,54.93,56.91,52.51,57.95] |\n| 2019.01.01T00:00:06 | A2  | \\[53.14,50.87,52.62,54.47,59.97,56.99,55.32,54.66,56.77,58.39] |\n| 2019.01.01T00:00:07 | A3  | \\[58.33,59.80,52.34,57.52,57.39,54.67,51.19,52.11,55.27,53.07] |\n| 2019.01.01T00:00:08 | A4  | \\[55.21,54.88,54.38,52.36,56.56,53.81,57.84,53.24,54.87,54.63] |\n| 2019.01.01T00:00:09 | A5  | \\[52.98,55.72,55.83,50.60,51.01,57.02,54.07,54.63,55.44,59.28] |\n| 2019.01.01T00:00:00 | A1  | \\[56.68,54.55,53.11,53.38,59.60,57.35,59.92,50.62,56.06,54.69] |\n\n**相关函数**：[arrayVector](https://docs.dolphindb.cn/zh/funcs/a/arrayVector.html)\n"
    },
    "flatten": {
        "url": "https://docs.dolphindb.cn/zh/funcs/f/flatten.html",
        "signatures": [
            {
                "full": "flatten(X)",
                "name": "flatten",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [flatten](https://docs.dolphindb.cn/zh/funcs/f/flatten.html)\n\n\n\n#### 语法\n\nflatten(X)\n\n#### 详情\n\n将一个矩阵、一个元组或一系列向量转换成一维向量。\n\n注意：\n\n* 如果元组中的元素不包含元组，则将元组转化为一维向量。\n\n* 如果是嵌套元组，则把值为元组的元素先转化为一维向量，其它元素不变，返回的结果仍然是一个元组。\n\n#### 参数\n\n**X** 可以是向量、元组或矩阵。\n\n#### 返回值\n\n一个向量。\n\n#### 例子\n\n将一个矩阵转换成向量。\n\n```\nm=1..10$5:2;\nflatten(m);\n// output\n[1,2,3,4,5,6,7,8,9,10]\n```\n\n将一系列向量转换成一个向量。\n\n```\na=1..10;\nb = a cut 2;\nb;\n// output\n([1,2],[3,4],[5,6],[7,8],[9,10])\nflatten(b);\n// output\n[1,2,3,4,5,6,7,8,9,10]\n\nx=flatten([1, [2,3]]);\nx;\n// output\n[1,2,3]\n```\n\n关于将一个向量分成多个小的向量，参见 [cut](https://docs.dolphindb.cn/zh/funcs/c/cut.html) 函数。\n\n将一个嵌套元组转换成一个向量。\n\n```\nlist = (1, (2, (3, 4, 5)), (6, 7), 8, [9])\nx1 = flatten(list)\nx1\n//此时先将元组元素(3, 4, 5)、(6, 7)转换为一维向量[3,4,5]、[6,7]，返回结果仍然为元组\n// output:(1,(2,[3,4,5]),[6,7],8,[9])\nx2= flatten(x1)\nx2\n//再次执行，将元组元素(2,[3,4,5])转换为一维向量[2,3,4,5]，返回结果仍然为元组\n// output:(1,[2,3,4,5],[6,7],8,[9])\nx3= flatten(x2)\nx3\n//最后，将元组转换为一维向量\n// output:[1,2,3,4,5,6,7,8,9]\n```\n\n也可使用 `reduce` 函数循环执行转换，返回最终结果。\n\n```\nreduce(flatten, init=list)\n// output:[1,2,3,4,5,6,7,8,9]\n```\n\n若想观察逐步转换的结果，可使用 `accumulate`。\n\n```\naccumulate(flatten, init=list)\n// output:[(1,(2,(3,4,5)),(6,7),8,[9]),(1,(2,[3,4,5]),[6,7],8,[9]),(1,[2,3,4,5],[6,7],8,[9]),[1,2,3,4,5,6,7,8,9]]\n```\n\n将一个包含矩阵的元组转换成一个向量。\n\n```\nm = 1..10$5:2;\nn = ( m ,11, (12, 13), [14])\nreduce(flatten, init=n)\n// output:[1,2,3,4,5,6,7,8,9,11,12,13,14]\n```\n\n**Related information**\n\n[flip](https://docs.dolphindb.cn/zh/funcs/f/flip.html)\n"
    },
    "flip": {
        "url": "https://docs.dolphindb.cn/zh/funcs/f/flip.html",
        "signatures": [
            {
                "full": "transpose(X)",
                "name": "transpose",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            },
            {
                "full": "flip(X)",
                "name": "flip",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [flip](https://docs.dolphindb.cn/zh/funcs/f/flip.html)\n\n是 [transpose](https://docs.dolphindb.cn/zh/funcs/t/transpose.html) 的别名。\n\n与 Python 中 numpy.flip 的区别：numpy.flip 用于沿指定轴反转元素顺序，DolphinDB 的 flip 是 transpose 的别名，用于转置矩阵。\n\n\n以下是 `transpose` 函数的文档：\n### [transpose](https://docs.dolphindb.cn/zh/funcs/t/transpose.html)\n\n\n\n#### 语法\n\ntranspose(X)\n\n别名：flip(X)\n\n#### 详情\n\n本函数用于转置输入数据 *X*：\n\n* 如果 *X* 是一个元组，`transpose` 函数返回的是一个与 *X* 中每个向量长度相同的元组，返回结果中的第 n 个元素是由 *X* 中每个向量的第 n 个值组成的向量。\n\n* 如果 *X* 是一个矩阵，`transpose` 函数返回 *X* 的转置矩阵。\n\n* 如果 *X* 是一个表，`transpose` 函数把表 *X* 转换为一个有序字典（从 2.00.9 版本开始支持有序字典），表中的列名为 key，每列的值为 value。\n\n* 如果 *X* 是一个字典，且 key 是 STRING 类型，`transpose` 函数把字典 *X* 转换为一个表\n\n  * 当value 为标量或等长向量时，表的列名为字典的 key 值，每列的值为对应 value。\n  * 当 value 为字典时，表中第一列的列名为 ”key“，其值为 *X* 的 key 值；后续列的列名为 *X*中第一个子字典的键，其值为各子字典中对应的值。若某个子字典中不包含某键，则表中对应值为空值。\n    **Note:** 不支持将包含超过 32,767 个键的字典转换为表。\n\n* 如果 *X* 是一个数组向量或列式元组，transpose 函数将 *X* 的行和列转置。\n\n#### 参数\n\n**X** 是一个元组、矩阵、表或字典、数组向量或列式元组。\n\n* 如果 X 是元组，则元组中的元素须为长度相等的向量。\n* 如果 *X* 是数组向量或列式元组，则每行包含的元素个数必须相等。\n\n#### 例子\n\n例1. *X* 是一个元组。\n\n```\nx=(`A`B`C,1 2 3);\nx.transpose();\n// output：((\"A\",1),(\"B\",2),(\"C\",3))\n```\n\n例2. *X* 是一个矩阵。\n\n```\nx=1..6 $ 3:2;\nx;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 4  |\n| 2  | 5  |\n| 3  | 6  |\n\n```\ntranspose x;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1  | 2  | 3  |\n| 4  | 5  | 6  |\n\n例3. *X* 是一个表。\n\n```\ntimestamp = [09:34:07,09:36:42,09:36:51,09:36:59,09:32:47,09:35:26,09:34:16,09:34:26,09:38:12]\nsym = `C`MS`MS`MS`IBM`IBM`C`C`C\nprice= 49.6 29.46 29.52 30.02 174.97 175.23 50.76 50.32 51.29\nqty = 2200 1900 2100 3200 6800 5400 1300 2500 8800\nt = table(timestamp, sym, qty, price);\nt;\n```\n\n| timestamp | sym | qty  | price  |\n| --------- | --- | ---- | ------ |\n| 09:34:07  | C   | 2200 | 49.6   |\n| 09:36:42  | MS  | 1900 | 29.46  |\n| 09:36:51  | MS  | 2100 | 29.52  |\n| 09:36:59  | MS  | 3200 | 30.02  |\n| 09:32:47  | IBM | 6800 | 174.97 |\n| 09:35:26  | IBM | 5400 | 175.23 |\n| 09:34:16  | C   | 1300 | 50.76  |\n| 09:34:26  | C   | 2500 | 50.32  |\n| 09:38:12  | C   | 8800 | 51.29  |\n\n```\ntranspose(t);\n/*\ntimestamp->[09:34:07,09:36:42,09:36:51,09:36:59,09:32:47,09:35:26,09:34:16,09:34:26,09:38:12]\nsym->[C,MS,MS,MS,IBM,IBM,C,C,C]\nqty->[2200,1900,2100,3200,6800,5400,1300,2500,8800]\nprice->[49.6,29.46,29.52,30.02,174.97,175.23,50.76,50.32,51.29]\n*/\n```\n\n例4. *X* 是一个字典。\n\n```\nz=dict(`id`val,[`a`b`c,1 2 3]);\nz;\n/*\nval->[1,2,3]\nid->[a,b,c]\n*/\ntranspose(z);\n```\n\n| val | id |\n| --- | -- |\n| 1   | a  |\n| 2   | b  |\n| 3   | c  |\n\n```\n//当字典的 value 既包含标量又包含向量时，transpose 会重复标量的值以匹配向量的长度\nz1=dict(`id`val,[`a,1 2 3]);\nz1;\ntranspose(z1)\n```\n\n<table id=\"table_fx3_3x5_x1c\"><tbody><tr><td>\n\n**val**\n\n</td><td>\n\n**id**\n\n</td></tr><tr><td>\n\n1\n\n</td><td>\n\na\n\n</td></tr><tr><td>\n\n2\n\n</td><td>\n\na\n\n</td></tr><tr><td>\n\n3\n\n</td><td>\n\na\n\n</td></tr></tbody>\n</table>例5. *X* 是一个嵌套字典。\n\n```\nd = {'tag1':{'val1':2,'val2':6},'tag2':{'val2':1, 'val3':3}}\nd\n/*\ntag1->\n    val1->2\n    val2->6\n\ntag2->\n    val2->1\n    val3->3\n*/\ntranspose(d)\n```\n\n<table id=\"table_yr2_jxb_d2c\"><thead><tr><th align=\"left\">\n\nkey\n\n</th><th align=\"left\">\n\nval1\n\n</th><th align=\"left\">\n\nval2\n\n</th></tr></thead><tbody><tr><td align=\"left\">\n\ntag1\n\n</td><td align=\"left\">\n\n2\n\n</td><td align=\"left\">\n\n6\n\n</td></tr><tr><td align=\"left\">\n\ntag2\n\n</td><td align=\"left\">\n\n</td><td align=\"left\">\n\n1\n\n</td></tr></tbody>\n</table>从结果可以看出，转置后的表的列包括 \"key\" 和第一个子字典的键（val1，val2），“key” 列的值对应字典 `d` 的键，val1 和 val2 列的值对应子字典中的相应值。由于 tag2 对应的子字典不包含键 val1，故表中对应的值为空值，且键 val3 对应的值会被丢弃。\n"
    },
    "float": {
        "url": "https://docs.dolphindb.cn/zh/funcs/f/float.html",
        "signatures": [
            {
                "full": "float([X])",
                "name": "float",
                "parameters": [
                    {
                        "full": "[X]",
                        "name": "X",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [float](https://docs.dolphindb.cn/zh/funcs/f/float.html)\n\n\n\n#### 语法\n\nfloat(\\[X])\n\n#### 详情\n\n将输入数据的类型转换为 FLOAT。\n\n#### 参数\n\n**X** 可选参数。任意数据类型，并且可以是任意数据形式。\n\n#### 返回值\n\nFLOAT 类型的数据，数据形式同 *X*。\n\n#### 例子\n\n创建一个 FLOAT 类型的变量，默认值为 NULL。\n\n```\nx=float()\nx // 输出 null\ntypestr x // 输出 'FLOAT'\n```\n\n转换用于表示数字的字符串。\n\n```\nx=float(\"123\")\nx // 输出 123\ntypestr x // 输出 'FLOAT'\n```\n\n转换布尔值。\n\n```\nx=float([true, false])\nx // 输出 [1, 0]\ntypestr x // 输出 'FAST FLOAT VECTOR'\n```\n\n转换 DOUBLE 类型的数据。\n\n```\nx=123456789.1234567 // 16 位数字\ntypestr x // 输出 'DOUBLE'\n\ny=float(x)\ny // 输出 123,456,792 （FLOAT 最多只能包含 9 位数字）\ntypestr y // 输出 'FLOAT'\n```\n\n创建值为正无穷和负无穷的变量。\n\n```\n// 创建值为正无穷的变量\nposInf=float(\"inf\")\nposInf // 输出 ∞\ntypestr posInf // 输出 'FLOAT'\nposInf > 1000000000 // 输出 true\n\n// 创建值为负无穷的变量\nnegInf=float(\"-inf\")\nnegInf // 输出 -∞\ntypestr negInf // 输出 'FLOAT'\nnegInf < NULL // 输出 true\n```\n"
    },
    "floor": {
        "url": "https://docs.dolphindb.cn/zh/funcs/f/floor.html",
        "signatures": [
            {
                "full": "floor(X)",
                "name": "floor",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [floor](https://docs.dolphindb.cn/zh/funcs/f/floor.html)\n\n\n\n#### 语法\n\nfloor(X)\n\n#### 详情\n\n`floor` 和 [ceil](https://docs.dolphindb.cn/zh/funcs/c/ceil.html) 函数分别把一个实数映射到小于等于它的最大整数，和大于等于它的最小整数。函数 [round](https://docs.dolphindb.cn/zh/funcs/r/round.html) 根据四舍五入规则把一个实数映射到最接近的整数。\n\n**Note:**\n\n* 与 Python 中 `numpy.floor` 的区别：二者都返回小于等于输入的最大整数；`numpy.floor` 是 ufunc，支持广播、*out*、*where* 等参数，DolphinDB 的 `floor` 接受标量、向量或矩阵并返回整型结果。\n* DolphinDB `floor` 与 TA-Lib `FLOOR` 的核心功能相同，区别在于 DolphinDB `floor` 支持标量、数据对、向量、矩阵和表作为输入，而 TA-Lib `FLOOR` 仅接受一维数组（numpy array）输入。若输入数据相同，二者返回结果一致。\n\n#### 参数\n\n**X** 可以是标量、向量或矩阵。\n\n#### 返回值\n\n整型标量、向量或矩阵。\n\n#### 例子\n\n```\nfloor(2.1);\n// output\n2\nfloor(2.9);\n// output\n2\nfloor(-2.1);\n// output\n-3\n\nceil(2.1);\n// output\n3\nceil(2.9);\n// output\n3\nceil(-2.1);\n// output\n-2\n\nround(2.1);\n// output\n2\nround(2.9);\n// output\n3\nround(-2.1);\n// output\n-2\n\nm = 1.1 2.2 3.3 4.4 5.5 6.6 7.7 8.8 9.9 10$2:5;\nm;\n```\n\n| #0  | #1  | #2  | #3  | #4  |\n| --- | --- | --- | --- | --- |\n| 1.1 | 3.3 | 5.5 | 7.7 | 9.9 |\n| 2.2 | 4.4 | 6.6 | 8.8 | 10  |\n\n```\nfloor(m);\n```\n\n| #0 | #1 | #2 | #3 | #4 |\n| -- | -- | -- | -- | -- |\n| 1  | 3  | 5  | 7  | 9  |\n| 2  | 4  | 6  | 8  | 10 |\n"
    },
    "flushComputeNodeMemCache": {
        "url": "https://docs.dolphindb.cn/zh/funcs/f/flushcomputenodememcache.html",
        "signatures": [
            {
                "full": "flushComputeNodeMemCache()",
                "name": "flushComputeNodeMemCache",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [flushComputeNodeMemCache](https://docs.dolphindb.cn/zh/funcs/f/flushcomputenodememcache.html)\n\n\n\n#### 语法\n\nflushComputeNodeMemCache()\n\n#### 详情\n\n应用于计算组中的计算节点上，将该节点的内存缓存的内容写入磁盘缓存。\n\n适用场景：在计算节点升级并需要优雅重启时，首先使用该函数将内存缓存的内容写入磁盘，这样在计算节点重启后，可以避免从远程数据节点集群重新获取数据，从而提升性能。\n\n#### 参数\n\n无\n\n#### 返回值\n\n无\n"
    },
    "flushOLAPCache": {
        "url": "https://docs.dolphindb.cn/zh/funcs/f/flushOLAPCache.html",
        "signatures": [
            {
                "full": "flushOLAPCache()",
                "name": "flushOLAPCache",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [flushOLAPCache](https://docs.dolphindb.cn/zh/funcs/f/flushOLAPCache.html)\n\n\n\n#### 语法\n\nflushOLAPCache()\n\n#### 详情\n\n将 OLAP 引擎缓冲区里已经完成的事务强制写入数据库。请注意，使用该函数前，需配置 *OLAPCacheEngineSize* 和 *dataSync* = 1。\n\n#### 参数\n\n无\n\n#### 返回值\n\n无\n"
    },
    "flushPKEYCache": {
        "url": "https://docs.dolphindb.cn/zh/funcs/f/flushpkeycache.html",
        "signatures": [
            {
                "full": "flushPKEYCache()",
                "name": "flushPKEYCache",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [flushPKEYCache](https://docs.dolphindb.cn/zh/funcs/f/flushpkeycache.html)\n\n\n\n#### 语法\n\nflushPKEYCache()\n\n#### 详情\n\n将 PKEY 引擎 CacheEngine 里的数据强制写入磁盘，包括各分区上已经完成的事务的数据和长时间未使用的 Symbol Base。\n\n#### 参数\n\n无\n\n#### 返回值\n\n无\n\n#### 例子\n\n```\nflushPKEYCache()\n```\n"
    },
    "flushTSDBCache": {
        "url": "https://docs.dolphindb.cn/zh/funcs/f/flushTSDBCache.html",
        "signatures": [
            {
                "full": "flushTSDBCache()",
                "name": "flushTSDBCache",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [flushTSDBCache](https://docs.dolphindb.cn/zh/funcs/f/flushTSDBCache.html)\n\n\n\n#### 语法\n\nflushTSDBCache()\n\n#### 详情\n\n将 TSDB 引擎缓冲区里已经完成的事务强制写入数据库。请注意，使用该函数前，需配置 *TSDBCacheEngineSize*。\n\n#### 参数\n\n无\n\n#### 返回值\n\n无\n"
    },
    "fmin": {
        "url": "https://docs.dolphindb.cn/zh/funcs/f/fmin.html",
        "signatures": [
            {
                "full": "fmin(func, X0, [xtol=0.0001], [ftol=0.0001], [maxIter], [maxFun])",
                "name": "fmin",
                "parameters": [
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "X0",
                        "name": "X0"
                    },
                    {
                        "full": "[xtol=0.0001]",
                        "name": "xtol",
                        "optional": true,
                        "default": "0.0001"
                    },
                    {
                        "full": "[ftol=0.0001]",
                        "name": "ftol",
                        "optional": true,
                        "default": "0.0001"
                    },
                    {
                        "full": "[maxIter]",
                        "name": "maxIter",
                        "optional": true
                    },
                    {
                        "full": "[maxFun]",
                        "name": "maxFun",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [fmin](https://docs.dolphindb.cn/zh/funcs/f/fmin.html)\n\n#### 语法\n\nfmin(func, X0, \\[xtol=0.0001], \\[ftol=0.0001], \\[maxIter], \\[maxFun])\n\n#### 详情\n\n使用 Nelder-Mead 单纯形算法找到目标函数的最小值。\n\n注意：该算法只使用函数值，不使用一阶导数或二阶导数。\n\n**Note:**\n\n* DolphinDB `fmin` 与 [scipy.optimize.fmin](https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.fmin.html) 功能相同。二者的主要差异在返回结果形式：DolphinDB `fmin` 返回包含 xopt、fopt、iterations、fcalls 和 warnFlag 的字典；`scipy.optimize.fmin` 默认只返回 xopt，设置 *full\\_output*=True 时返回完整优化信息。\n* [numpy.fmin](https://numpy.org/doc/stable/reference/generated/numpy.fmin.html) 与前二者完全不同，它不是优化函数，而是逐元素返回两个数组中的较小值。\n\n#### 参数\n\n**func** 函数名，表示需要最小化的目标函数。注意：函数返回值须是数值标量类型。\n\n**X0** 数值类型的标量或向量，表示使目标函数最小化的参数的初始猜测。\n\n**xtol** 可选参数，正数值标量，表示在迭代过程中 `xopt` 之间可接受的收敛的绝对误差。默认值为 0.0001。\n\n**ftol** 可选参数，正数值标量，表示在迭代过程中 `func(xopt)` 的绝对误差可接受的收敛标准。默认值为 0.0001。\n\n**maxIter** 可选参数，非负整数标量，表示执行的最大迭代次数。\n\n**maxFun** 可选参数，非负整数标量，表示最大目标函数调用次数。\n\n#### **返回值**\n\n返回一个字典，包含以下成员：\n\n* xopt：浮点数向量，使目标函数最小化的参数值。\n\n* fopt：浮点数标量，目标函数最小值。fopt=func(xopt)。\n\n* iterations：整数标量，优化过程中执行的总迭代数。\n\n* fcalls：整数标量，优化过程中目标函数的调用次数。\n\n* warnFlag：整数标量，有三个可能值：\n\n  * 0：表示成功执行算法全过程。\n\n  * 1：表示已达最大目标函数调用次数，算法停止执行。\n\n  * 2：表示已达最大迭代次数，算法停止执行。\n\n#### 例子\n\n下例中自定义一个 f(x) 函数，使用 Nelder-Mead 单纯形算法找到其最小值。\n\n```\ndef f(x) {return x*x}\nfmin(f, 1)\n/* Ouput:\nxopt->[-8.881784197001252E-16]\nfopt->7.888609052210119E-31\niterations->17\nfcalls->34\nwarnFlag->0\n*/\n```\n\n"
    },
    "fminBFGS": {
        "url": "https://docs.dolphindb.cn/zh/funcs/f/fminbfgs.html",
        "signatures": [
            {
                "full": "fminBFGS(func, X0, [fprime], [gtol=1e-5], [norm], [epsilon], [maxIter], [xrtol=0], [c1=1e-4], [c2=0.9])",
                "name": "fminBFGS",
                "parameters": [
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "X0",
                        "name": "X0"
                    },
                    {
                        "full": "[fprime]",
                        "name": "fprime",
                        "optional": true
                    },
                    {
                        "full": "[gtol=1e-5]",
                        "name": "gtol",
                        "optional": true,
                        "default": "1e-5"
                    },
                    {
                        "full": "[norm]",
                        "name": "norm",
                        "optional": true
                    },
                    {
                        "full": "[epsilon]",
                        "name": "epsilon",
                        "optional": true
                    },
                    {
                        "full": "[maxIter]",
                        "name": "maxIter",
                        "optional": true
                    },
                    {
                        "full": "[xrtol=0]",
                        "name": "xrtol",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[c1=1e-4]",
                        "name": "c1",
                        "optional": true,
                        "default": "1e-4"
                    },
                    {
                        "full": "[c2=0.9]",
                        "name": "c2",
                        "optional": true,
                        "default": "0.9"
                    }
                ]
            }
        ],
        "markdown": "### [fminBFGS](https://docs.dolphindb.cn/zh/funcs/f/fminbfgs.html)\n\n\n\n#### 语法\n\nfminBFGS(func, X0, \\[fprime], \\[gtol=1e-5], \\[norm], \\[epsilon], \\[maxIter], \\[xrtol=0], \\[c1=1e-4], \\[c2=0.9])\n\n#### 详情\n\n使用 BFGS 算法找到目标函数的最小值。\n\nDolphinDB `fminBFGS` 与 `scipy.optimize.fmin_bfgs` 使用相同的 BFGS 优化算法，核心参数和计算结果一致。主要区别在于：DolphinDB 不支持 *args*（需用部分应用替代）、不支持 *full\\_output*/*disp*\\*/retall\\*/*callback*/*hess\\_inv0* 等参数，返回值为字典而非元组。\n\n#### 参数\n\n**func** 函数名，表示需要最小化的目标函数。注意：函数返回值须是数值标量类型。\n\n**X0** 数值类型的标量或向量，表示使目标函数最小化的参数的初始猜测。\n\n**fprime** 可选参数，函数名，表示计算 *func* 梯度的函数。如果为空，则使用数值微分方法来获取函数梯度。\n\n**gtol** 可选参数，正数值标量，判断是否停止迭代的梯度范数衡量值。如果梯度的范数小于 *gtol*，则停止迭代。默认值为 1e-5。\n\n**norm** 可选参数，正数值标量，表示范数的阶数，默认使用最大值范数。\n\n**epsilon** 可选参数，正数值标量，表示当使用数值近似方法来求解函数梯度时使用的步长。默认值为 *1.4901161193847656e-08*。\n\n**maxIter** 可选参数，非负整数标量，表示执行的最大迭代次数，默认值为 *X0* 的长度乘以200。\n\n**xrtol** 可选参数，非负数值标量，用于判断是否结束迭代的步长衡量值。如果步长小于`xk * xrtol`（`xk`为当前参数向量），则停止迭代。默认值为 0。\n\n**c1** 可选参数，数值标量，值域为(0,1)，*c1* 应小于 *c2*，表示 Armijo 条件规则的参数。默认值为 1e-4。\n\n**c2** 可选参数，数值标量，值域为(0,1)，*c2* 应大于 *c1*，表示曲率条件规则参数。默认值为 0.9。\n\n#### 返回值\n\n返回一个字典，字典有以下成员：\n\n* xopt：浮点数向量，使目标函数最小化的参数值。\n\n* fopt：浮点数标量，目标函数最小值，fopt=func(xopt)。\n\n* gopt：浮点数向量，目标函数最小值处的梯度，func'(xopt)，应接近 0。\n\n* Hinv：浮点数矩阵，目标函数最小值处Hessian矩阵的逆矩阵。\n\n* iterations：整数标量，优化过程中执行的总迭代数。\n\n* fcalls：整数标量，优化过程中的目标函数调用次数。\n\n* gcalls：整数标量，优化过程中的梯度函数调用次数。\n\n* warnFlag：整数标量，有四个可能值：\n\n  * 0：表示成功执行算法全过程。\n\n  * 1：表示已达最大迭代次数，算法停止执行。\n\n  * 2：表示线搜索失败或者目标函数值出现极值。\n\n  * 3：表示计算结果中出现 NULL 值。\n\n#### 例子\n\n本例自定义条件，传入参数 *func*, *X0*, *fprime*，使用 BFGS 算法找到目标函数 `quadratic_cost` 的最小值。\n\n```\ndef quadratic_cost(x, Q) {\n\treturn dot(dot(x, Q), x)\n}\n\ndef quadratic_cost_grad(x, Q) {\n\treturn 2 * dot(Q, x)\n}\n\nx0 = [-3, -4]\ncost_weight = diag([1., 10.])\n\nfminBFGS(quadratic_cost{,cost_weight}, x0, quadratic_cost_grad{,cost_weight})\n\n/* Ouput:\nfcalls->8\nwarnFlag->0\nxopt->[0.000002859166,-4.54371E-7]\nHinv->\n#0              #1             \n0.508225788096  -0.001307222772\n-0.001307222772 0.050207740748 \n\ngopt->[0.000005718332,-0.000009087439]\nfopt->1.0E-11\ngcalls->8\niterations->7\n*/\n```\n\n相关函数：[fminBFGSB](https://docs.dolphindb.cn/zh/funcs/f/fminlbfgsb.html)\n"
    },
    "fminLBFGSB": {
        "url": "https://docs.dolphindb.cn/zh/funcs/f/fminlbfgsb.html",
        "signatures": [
            {
                "full": "fminLBFGSB(func, X0, [fprime], [bounds], [m=10], [factr=1e7], [pgtol=1e-5], [epsilon=1e-8], [maxIter=15000], [maxFun=15000], [maxLS=20])",
                "name": "fminLBFGSB",
                "parameters": [
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "X0",
                        "name": "X0"
                    },
                    {
                        "full": "[fprime]",
                        "name": "fprime",
                        "optional": true
                    },
                    {
                        "full": "[bounds]",
                        "name": "bounds",
                        "optional": true
                    },
                    {
                        "full": "[m=10]",
                        "name": "m",
                        "optional": true,
                        "default": "10"
                    },
                    {
                        "full": "[factr=1e7]",
                        "name": "factr",
                        "optional": true,
                        "default": "1e7"
                    },
                    {
                        "full": "[pgtol=1e-5]",
                        "name": "pgtol",
                        "optional": true,
                        "default": "1e-5"
                    },
                    {
                        "full": "[epsilon=1e-8]",
                        "name": "epsilon",
                        "optional": true,
                        "default": "1e-8"
                    },
                    {
                        "full": "[maxIter=15000]",
                        "name": "maxIter",
                        "optional": true,
                        "default": "15000"
                    },
                    {
                        "full": "[maxFun=15000]",
                        "name": "maxFun",
                        "optional": true,
                        "default": "15000"
                    },
                    {
                        "full": "[maxLS=20]",
                        "name": "maxLS",
                        "optional": true,
                        "default": "20"
                    }
                ]
            }
        ],
        "markdown": "### [fminLBFGSB](https://docs.dolphindb.cn/zh/funcs/f/fminlbfgsb.html)\n\n\n\n#### 语法\n\nfminLBFGSB(func, X0, \\[fprime], \\[bounds], \\[m=10], \\[factr=1e7], \\[pgtol=1e-5], \\[epsilon=1e-8], \\[maxIter=15000], \\[maxFun=15000], \\[maxLS=20])\n\n#### 详情\n\n使用 L-BFGS-B 算法找到目标函数的最小值。\n\n与 Python 中 `scipy.optimize.fmin_l_bfgs_b` 的区别：二者均使用 L-BFGS-B 算法进行优化。Python 函数通过 *args* 传入目标函数和梯度函数的额外参数，并提供 *approx\\_grad*、*callback*、*disp* 等 Python 接口参数；DolphinDB 的 `fminLBFGSB` 不提供这些参数，额外参数可通过部分应用传入。Python 函数返回 (x, f, d) 元组；DolphinDB 返回字典，包含 xopt、fopt、gopt、 iterations、fcalls 和 warnFlag。\n\n#### 参数\n\n**func** 函数名，表示需要最小化的目标函数。注意：该函数的返回值须是数值标量类型。\n\n**X0** 数值类型的标量或向量，表示使目标函数最小化的参数的初始猜测。\n\n**fprime** 可选参数，函数名，表示计算 *func* 梯度的函数。如果为空，则使用数值微分方法来获取函数梯度。\n\n**bounds** 可选参数，数值类型矩阵，形状为(N,2)，其中 N 为需要优化的参数数量，即 N=size(X0)。每一行的两个值（min, max），定义了 X0 中对应参数的边界。可以用 `float(\"inf\")` 来表示不设边界。\n\n**m** 可选参数，正整数标量，表示有限内存矩阵的最大可变度量修正数。默认值为 10。\n\n**factr** 可选参数，数值标量，正数，用于衡量迭代是否结束的指标值。当满足条件![](https://docs.dolphindb.cn/zh/funcs/images/fminLBFGSB1.png)时，算法将停止迭代，其中 eps 是机器精度。*factr* 的典型值有：1e12 代表低精度；1e7 代表中等精度；10.0 代表极高的精度。默认值为 1e7。\n\n**pgtol** 可选参数，数值标量，正数，用于衡量迭代是否结束的指标值。当满足条件![](https://docs.dolphindb.cn/zh/funcs/images/fminLBFGSB2.png)时，算法将停止迭代，其中![](https://docs.dolphindb.cn/zh/funcs/images/fminLBFGSB3.png)是投影梯度的第 i 个分量。默认值为 1e-5。\n\n**epsilon** 可选参数，数值标量，正数，表示当使用数值近似方法来求解函数梯度时使用的步长。默认值为 1e-8。\n\n**maxIter** 可选参数，非负整数标量，表示执行的最大迭代次数，默认值为 15000。\n\n**maxFun** 可选参数，非负整数标量，表示最大目标函数调用次数，默认值为 15000。\n\n**maxLS** 可选参数，非负整数标量，表示每轮迭代的最大线搜索步数，默认值为 20。\n\n#### 返回值\n\n返回一个字典，字典有以下成员：\n\n* xopt：浮点数向量，使目标函数最小化的参数值。\n\n* fopt：浮点数标量，目标函数最小值。fopt=func(xopt)。\n\n* gopt：浮点数向量，目标函数最小值点处的函数梯度。gopt=func'(xopt)。\n\n* iterations：整数标量，优化过程中执行的总迭代数。\n\n* fcalls：整数标量，优化过程中的目标函数调用次数。\n\n* warnFlag：整数标量，有三个可能值：\n\n  * 0：表示成功执行算法全过程。\n\n  * 1：表示已达最大目标函数调用次数或已达最大迭代次数，算法停止执行。\n\n  * 2：表示由于其他原因算法停止执行。\n\n#### 例子\n\n本例自定义约束条件，传入参数 *func*, *X0*，使用 L-BFGS-B 算法找到目标函数 `fun` 的最小值。\n\n```\nX = double(0..9)\nM = 2\nB = 3\nY = double(M * X + B)\n\ndef fun(params, x, y) {\n\tm = params[0]\n\tb = params[1]\n\ty_model = m*x + b\n\terror = sum(square(y - y_model))\n\treturn error\n}\n\ninitial_values = [0.0, 1.0]\nfminLBFGSB(fun{,X,Y}, initial_values)\n\n/* Ouput:\n\nfcalls->27\nwarnFlag->0\nxopt->[1.999999985435,3.000000060585]\ngopt->[8.05E-10,8.84E-10]\nfopt->0E-12\niterations->6\n\n*/\n```\n\n相关函数：[fminBFGS](https://docs.dolphindb.cn/zh/funcs/f/fminbfgs.html)\n"
    },
    "fminNCG": {
        "url": "https://docs.dolphindb.cn/zh/funcs/f/fminncg.html",
        "signatures": [
            {
                "full": "fminNCG(func, X0, fprime, fhess, [xtol=1e-5], [maxIter], [c1=1e-4], [c2=0.9])",
                "name": "fminNCG",
                "parameters": [
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "X0",
                        "name": "X0"
                    },
                    {
                        "full": "fprime",
                        "name": "fprime"
                    },
                    {
                        "full": "fhess",
                        "name": "fhess"
                    },
                    {
                        "full": "[xtol=1e-5]",
                        "name": "xtol",
                        "optional": true,
                        "default": "1e-5"
                    },
                    {
                        "full": "[maxIter]",
                        "name": "maxIter",
                        "optional": true
                    },
                    {
                        "full": "[c1=1e-4]",
                        "name": "c1",
                        "optional": true,
                        "default": "1e-4"
                    },
                    {
                        "full": "[c2=0.9]",
                        "name": "c2",
                        "optional": true,
                        "default": "0.9"
                    }
                ]
            }
        ],
        "markdown": "### [fminNCG](https://docs.dolphindb.cn/zh/funcs/f/fminncg.html)\n\n\n\n#### 语法\n\nfminNCG(func, X0, fprime, fhess, \\[xtol=1e-5], \\[maxIter], \\[c1=1e-4], \\[c2=0.9])\n\n#### 详情\n\n使用牛顿共轭梯度法（Newton conjugate gradient；也称为截断牛顿法，Truncated Newton method）对目标函数进行无约束最小化。本方法适用于解决大型非线性优化问题。\n\n与 Python 中 `scipy.optimize.fmin_ncg` 的区别：二者均使用 Newton-CG 方法进行无约束最小化。Python 函数支持通过 *fhess\\_p* 提供 Hessian 与任意向量的乘积，也支持 *args*、*epsilon*、*full\\_output*、 *disp*、*retall*、*callback* 等参数；DolphinDB 的 `fminNCG` 要求通过 *fhess* 指定 Hessian 矩阵函数，额外参数可通过部分应用传入，不提供上述 Python 接口参数。Python 函数默认仅返回最优参数 xopt，设置 *full\\_output* 后返回更多信息；DolphinDB 始终返回字典，包含 xopt、fopt、 iterations、fcalls、 gcalls、hcalls 和 warnFlag。\n\n#### 参数\n\n**func** 函数名，表示需要最小化的目标函数。注意：函数返回值须是数值标量类型。\n\n**X0** 数值类型的标量或向量，表示使目标函数最小化的参数的初始猜测。\n\n**fprime** 函数名，表示计算 *func* 梯度的函数。\n\n**fhess** 函数名，表示计算 *func* 的 Hessian 矩阵的函数。\n\n**xtol** 可选参数，正数值标量，用于判断是否结束迭代的步长衡量值。如果两次迭代间参数变化量的范数小于 `xtol*size(X0)`，则认为算法收敛，停止迭代。默认值为 1e-5。\n\n**maxIter** 可选参数，非负整数标量，表示执行的最大迭代次数。\n\n**c1** 可选参数，数值标量，值域为(0,1)，*c1* 应小于 *c2*，表示 Armijo 条件规则的参数。默认值为 1e-4。\n\n**c2** 可选参数，数值标量，值域为(0,1)，*c2* 应大于 *c1*，表示曲率条件规则参数。默认值为 0.9。\n\n#### 返回值\n\n返回一个字典，字典有以下成员：\n\n* xopt：浮点数向量，使目标函数最小化的参数值。\n\n* fopt：浮点数标量，目标函数最小值。fopt=func(xopt)。\n\n* iterations：整数标量，优化过程中执行的总迭代数。\n\n* fcalls：整数标量，优化过程中的目标函数调用次数。\n\n* gcalls：整数标量，优化过程中的梯度函数调用次数。\n\n* hcalls：整数标量，优化过程中的计算 Hessian 函数的调用次数。\n\n* warnFlag：整数标量，有四个可能值：\n\n  * 0：表示成功执行算法全过程。\n\n  * 1：表示已达最大迭代次数，算法停止执行。\n\n  * 2：表示由于精度损失问题，线搜索失败。\n\n  * 3：表示结果产生 NULL 值。\n\n#### 例子\n\n本例自定义条件，传入参数 *f*, *X0*, *fprime*, *fhess*，使用牛顿共轭梯度法找到目标函数 `rosen` 的最小值。\n\n```\ndef rosen(x) { \n\tN = size(x);\n\treturn sum(100.0*power(x[1:N]-power(x[0:(N-1)], 2.0), 2.0)+power(1-x[0:(N-1)], 2.0));\n}\n\ndef rosen_der(x) {\n\tN = size(x);\n\txm = x[1:(N-1)]\n\txm_m1 = x[0:(N-2)]\n\txm_p1 = x[2:N]\n\tder = array(double, N)\n\tder[1:(N-1)] = (200 * (xm - xm_m1*xm_m1) - 400 * (xm_p1 - xm*xm) * xm - 2 * (1 - xm))\n\tder[0] = -400 * x[0] * (x[1] - x[0]*x[0]) - 2 * (1 - x[0])\n\tder[N-1] = 200 * (x[N-1] - x[N-2]*x[N-2])\n\treturn der\n}\n\ndef diag1(x, k) {\n\tN = size(x)\n\tm = matrix(type(x), N+1,N+1)\n\tif (k == 1) {\n\t\tfor(i in 0:N){\n\t\t\tm[i, i+1] = x[i]\n\t\t}\n\t} else {\n\t\tfor(i in 0:N){\n\t\t\tm[i+1, i] = x[i]\n\t\t}\n\t}\n\n\treturn m\n}\n\ndef rosen_hess(x) {\n\tN = size(x);\n\tx1= x[0:(N-1)] * 400\n\tH = diag1(-x1, 1) - diag1(x1, -1)\n\tdiagonal = array(type(x), N)\n\tdiagonal[0] = 1200 * x[0]*x[0] - 400 * x[1] + 2\n\tdiagonal[N-1] = 200\n\tdiagonal[1:(N-1)] = 202 + 1200 * x[1:(N-1)]*x[1:(N-1)] - 400 * x[2:N]\n\tH = H + diag(diagonal)\n\treturn H\n}\n\nX0 = [4, -2.5]\nfminNCG(rosen, X0, rosen_der, rosen_hess)\n\n/* Ouput:（返回顺序可能略有不同）\nxopt->[0.999999966120496,0.999999932105584]\nfopt->1.149654357653714E-15\niterations->34\nfcalls->45\ngcalls->45\nhcalls->34\nwarnFlag->0\n*/\n```\n"
    },
    "fminSLSQP": {
        "url": "https://docs.dolphindb.cn/zh/funcs/f/fminslsqp.html",
        "signatures": [
            {
                "full": "fminSLSQP(func, X0, [fprime], [constraints], [bounds], [ftol=1e-6], [epsilon], [maxIter=100])",
                "name": "fminSLSQP",
                "parameters": [
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "X0",
                        "name": "X0"
                    },
                    {
                        "full": "[fprime]",
                        "name": "fprime",
                        "optional": true
                    },
                    {
                        "full": "[constraints]",
                        "name": "constraints",
                        "optional": true
                    },
                    {
                        "full": "[bounds]",
                        "name": "bounds",
                        "optional": true
                    },
                    {
                        "full": "[ftol=1e-6]",
                        "name": "ftol",
                        "optional": true,
                        "default": "1e-6"
                    },
                    {
                        "full": "[epsilon]",
                        "name": "epsilon",
                        "optional": true
                    },
                    {
                        "full": "[maxIter=100]",
                        "name": "maxIter",
                        "optional": true,
                        "default": "100"
                    }
                ]
            }
        ],
        "markdown": "### [fminSLSQP](https://docs.dolphindb.cn/zh/funcs/f/fminslsqp.html)\n\n\n\n#### 语法\n\nfminSLSQP(func, X0, \\[fprime], \\[constraints], \\[bounds], \\[ftol=1e-6], \\[epsilon], \\[maxIter=100])\n\n#### 详情\n\n使用顺序最小二乘编程方法（Sequential Least Squares Programming, SLSQP）找到目标函数的最小值。\n\n与 Python 中 `scipy.optimize.fmin_slsqp` 的区别：二者均使用 SLSQP 方法进行优化。Python 函数用 *eqcons*、*f\\_eqcons*、 *ieqcons*、*f\\_ieqcons*、*fprime\\_eqcons* 和 *fprime\\_ieqcons* 分别指定等式/不等式约束及其梯度，并提供 *args*、*iprint*、*disp*、 *full\\_output*、*callback* 等 Python 接口参数；DolphinDB 的 `fminSLSQP` 使用 *constraints* 参数传入字典向量，每个字典通过 *type*、*fun* 和 *jac* 描述约束，额外参数可通过部分应用传入。Python 函数默认仅返回最优参数，设置 *full\\_output* 后返回目标函数值、迭代次数和退出状态等信息；DolphinDB 返回字典，包含 xopt、fopt、 iterations 和 mode。\n\n#### 参数\n\n**func** 函数名，表示需要最小化的目标函数。注意：函数返回值须是数值标量类型。\n\n**X0** 数值类型的标量或向量，表示使目标函数最小化的参数的初始猜测。\n\n**fprime** 可选参数，函数名，表示计算 *func* 梯度的函数。如果为空，则使用数值微分方法来获取函数梯度。\n\n**constraints** 可选参数，字典向量，表示待优化参数需满足的约束条件，每个字典应包含下列成员：\n\n* type：字符串标量，表示约束类型。有两个可选值：'eq'表示等式约束，'ineq'表示不等式约束。\n\n* fun：函数名，表示约束函数。注意：函数返回值须是一个数值标量或向量。\n\n* jac：函数名，表示约束函数 fun 的梯度函数。注意：函数返回值须是一个数值向量或矩阵。\n\n  注意：\n\n  * 假设 fun 返回值的大小为 m，待优化参数的 size 为 n，则 jac 的返回值的形状必须是(n, m)。\n  * *constraints* 中的等式约束（Equality Constraint）的数量不能超过待优化参数的大小。假设待优化参数的大小为 n，*constraints* 中共有 k 个等式约束函数，*constraints* 中第 i 个等式约束的约束函数 fun 的返回值大小为 *leni*，则应满足： ![](https://docs.dolphindb.cn/zh/funcs/images/fminSLSQP2.png)\n\n**bounds** 可选参数，数值矩阵，形状为(N,2)，其中 N 为需要优化的参数数量，即 N=size(X0)。每一行的两个值（min, max），定义了对应参数的边界。\n\n**ftol** 可选参数，数值标量，正数，表示算法停止时对目标函数值的精度要求，默认值为 1e-6。\n\n**epsilon** 可选参数，数值标量，正数，表示当使用数值近似方法来求解函数梯度时使用的步长。默认值为 1.4901161193847656e-08。\n\n**maxIter** 可选参数，非负整数标量，表示最大迭代次数，默认值为 100。\n\n#### 返回值\n\n返回一个字典，字典有以下成员：\n\n* xopt：浮点数向量，使目标函数最小化的参数值。\n\n* fopt：浮点数标量，目标函数最小值。fopt=func(xopt)。\n\n* iterations：整数标量，优化过程中执行的总迭代数。\n\n* mode：整数标量，表示算法退出时的状态。mode=0 时表示成功进行优化，取其他值表示算法异常退出，详细说明可参考文档 [jacobwilliams - slsqp](https://jacobwilliams.github.io/slsqp/proc/slsqp.html)。\n\n#### 例子\n\n本例自定义条件，传入参数 *f*, *X0*, *fargs*, *fprime*, *constraints*, *bounds*，使用 SLSQP 算法找到目标函数 `rosen` 的最小值。\n\n```\ndef rosen(x) { \n\tN = size(x);\n\treturn sum(100.0*power(x[1:N]-power(x[0:(N-1)], 2.0), 2.0)+power(1-x[0:(N-1)], 2.0));\n}\n\ndef rosen_der(x) {\n\tN = size(x);\n\txm = x[1:(N-1)]\n\txm_m1 = x[0:(N-2)]\n\txm_p1 = x[2:N]\n\tder = array(double, N)\n\tder[1:(N-1)] = (200 * (xm - xm_m1*xm_m1) - 400 * (xm_p1 - xm*xm) * xm - 2 * (1 - xm))\n\tder[0] = -400 * x[0] * (x[1] - x[0]*x[0]) - 2 * (1 - x[0])\n\tder[N-1] = 200 * (x[N-1] - x[N-2]*x[N-2])\n\treturn der\n}\n\ndef eq_fun(x) {\n\treturn 2*x[0] + x[1] - 1\n}\n\ndef eq_jac(x) {\n\treturn [2.0, 1.0]\n}\n\ndef ieq_fun(x) {\n\treturn [1 - x[0] - 2*x[1], 1 - x[0]*x[0] - x[1], 1 - x[0]*x[0] + x[1]]\n}\n\ndef ieq_jac(x) {\n\tret = matrix(DOUBLE, 2, 3)\n\tret[0,:] = [-1.0, -2*x[0], -2*x[0]]\n\tret[1,:] = [-2.0, -1.0, 1.0]\n\treturn ret\n}\n\neqCons=dict(STRING, ANY)\neqCons[`type]=`eq\neqCons[`fun]=eq_fun\neqCons[`jac]=eq_jac\n\nineqCons=dict(STRING, ANY)\nineqCons[`type]=`ineq\nineqCons[`fun]=ieq_fun\nineqCons[`jac]=ieq_jac\n\ncons = [eqCons, ineqCons]\n\nX0 = [0.5, 0]\nbounds = matrix([0 -0.5, 1.0 2.0])\nres = fminSLSQP(rosen, X0, rosen_der, cons, bounds, 1e-9)\nres;\n/* Ouput:\nmode->0\nxopt->[0.414944749170,0.170110501659]\nfopt->0.342717574994\niterations->4\n*/\n```\n"
    },
    "forceTriggerOrderBookSnapshot": {
        "url": "https://docs.dolphindb.cn/zh/funcs/f/forceTriggerOrderBookSnapshot.html",
        "signatures": [
            {
                "full": "forceTriggerOrderBookSnapshot(engine, [time])",
                "name": "forceTriggerOrderBookSnapshot",
                "parameters": [
                    {
                        "full": "engine",
                        "name": "engine"
                    },
                    {
                        "full": "[time]",
                        "name": "time",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [forceTriggerOrderBookSnapshot](https://docs.dolphindb.cn/zh/funcs/f/forceTriggerOrderBookSnapshot.html)\n\n首发版本：3.00.3.1\n\n\n\n#### 语法\n\nforceTriggerOrderBookSnapshot(engine, \\[time])\n\n#### 详情\n\n该函数用于强制触发订单簿快照输出，适用于不满足常规触发条件（如时间窗口或数据）但仍需生成快照的场景。调用后，快照会立即生成并输出。\n\n注意，仅在同时满足以下条件时可调用该函数：\n\n* `createOrderBookSnapshotEngine` 设置 *triggerType* = \"mutual\"，且 *useSystemTime* = false。\n* 订单簿快照引擎已事先共享。\n\n#### 参数\n\n**engine**订单簿引擎名称或引擎对象。\n\n**time** 可选参数，TIME 类型标量，设置输出快照的时间戳，即输出表中该条记录的 timestamp 值。若不指定该参数，则时间戳将为当前引擎中最后一条数据的时间戳。\n\n#### 返回值\n\n无\n\n#### 例子\n\n```\ndef createInputTable(){\n\tname = `SecurityID`Date`Time`SourceType`Type`Price`Qty`BSFlag`BuyNo`SellNo`ApplSeqNum`ChannelNo`ReceiveTime\n\ttype = `STRING`DATE`TIME`INT`INT`LONG`LONG`INT`LONG`LONG`LONG`INT`NANOTIMESTAMP\n\tit = table(1:0, name, type)\n\titMap = dict( `codeColumn`timeColumn`typeColumn`priceColumn`qtyColumn`buyOrderColumn`sellOrderColumn`sideColumn`msgTypeColumn`seqColumn`receiveTime, `SecurityID`Time`Type`Price`Qty`BuyNo`SellNo`BSFlag`SourceType`ApplSeqNum`ReceiveTime )\n\treturn it, itMap\n}\n\ndata = table(take(\"600010.SH\", 3) join take(\"600020.SH\", 3) join take(\"600010.SH\", 2) join take(\"600020.SH\", 3) join take(\"600010.SH\", 2) join take(\"600020.SH\", 1) as SecurityID, take(today(), 14) as date, [14:56:51.000, 14:56:52.000, 14:56:52.000, 14:56:53.000, 14:56:54.000, 14:56:55.000, 14:56:56.000, 14:56:57.000, 14:56:58.000, 14:56:59.000, 14:56:59.000, 14:57:00.000, 14:57:00.000, 14:57:01.000] as time, [0,0,1, 0,0,1,0,0,0,0,1,1,0,0] as SourceType, [2,2,0,2,2,0,2,2,2,2,0,0,2,2] as Type, [229000, 219000, 229000, 229000, 219000, 229000, 229000, 219000, 229000, 219000, 229000,  229000, 219000, 219000]as price, [2000, 1000, 1000, 2000, 1000, 1000, 2000, 1000, 2000, 1000, 1000, 1000, 2000, 2000] as qty, [1,2,2,1,2,2,1,2,1,2,2,2,1,1] as BSFlag, [1,2,1,6,7,6,3,4,8,9,6,1,5,10] as BuyNo, [1,2,2,6,7,7,3,4,8,9,9,4,5,10] as SellNo, 1..14 as ApplSeqNum, take(101, 14) as Channel, take(2023.02.20T04:01:42.499000000, 14) as receiveTime)\n\n\ntry{dropStreamEngine(\"engine1\")} catch(exp){}\n\norderbookDepth = 10\noutlist = lower(genOutputColumnsForOBSnapshotEngine(true, true, (10, true), true, true, true,5, true, true, true)[0])\noutputTable = streamTable(genOutputColumnsForOBSnapshotEngine(true, true, (10, true), true, true, true,5, true, true, true)[1])\ninputTable = createInputTable()[0]\ninputColMap = createInputTable()[1]\ndic = dict([\"600010.SH\", \"600020.SH\"], [1023, 1265])\nmaxdic = dict([\"600010.SH\", \"600020.SH\"], [3521, 3278])\nmindic = dict([\"600010.SH\", \"600020.SH\"], [2531, 2210])\nengine = createOrderBookSnapshotEngine(name=\"engine1\", exchange=\"XSHE\", orderbookDepth=orderbookDepth, intervalInMilli = 300, date=today(), startTime=09:15:00.000, prevClose=dic, maxPrice = maxdic, minPrice = mindic, priceNullFill = 0.0, precision = 3, orderBySeq = true, skipCrossedMarket = false, dummyTable=inputTable, outputTable=outputTable, inputColMap=inputColMap, outputColMap = outlist, orderBookAsArray=true, triggerType = \"mutual\", endTime = 15:30:00.000, outputCodeMap = [\"600010.SH\", \"600020.SH\"], orderBookDetailDepth = 5)\nengine.append!(data)\nselect * from outputTable\n```\n\n查看订单簿快照结果，600010.SH 和 600020.SH 对应的最后一条快照的时间戳为 2025.05.26 14:57:00.000。其中，600020.SH 的最后一条数据未能满足触发条件，导致未输出对应的快照。此时，可通过 `forceTriggerOrderBookSnapshot` 触发 600020.SH 的最后一条数据输出。\n\n```\nshare engine as engine1\nforceTriggerOrderBookSnapshot(engine1)\nselect * from outputTable\n```\n\n执行后，可见输出了时间戳为 2025.05.26 15:00:00.000 的 600010.SH 和 600020.SH 的订单簿快照。\n"
    },
    "form": {
        "url": "https://docs.dolphindb.cn/zh/funcs/f/form.html",
        "signatures": [
            {
                "full": "form(X)",
                "name": "form",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [form](https://docs.dolphindb.cn/zh/funcs/f/form.html)\n\n\n\n#### 语法\n\nform(X)\n\n#### 详情\n\n生成变量或常数的数据形式标识符（data form ID）。数据形式标识符和对应的数据形式为：0: 标量; 1: 向量; 2: 数据对; 3: 矩阵; 4: 集合; 5: 字典; 6: 表; 10: tensor。\n\n#### 参数\n\n**X** 是一个任意的变量或常数。\n\n#### 返回值\n\n一个整型标量，表示数据形式标识符。\n\n#### 例子\n\n```\nform(false);\n// output\n0\n\nform(`TEST);\n// output\n0\n\nform(`t1`t2`t3);\n// output\n1\n\nform(1 2 3);\n// output\n1\n\nx= 1 2 3\nif(form(x) == VECTOR){y=1}\ny;\n// output\n1\n\nform(1..6$2:3);\n// output\n3\n```\n"
    },
    "format": {
        "url": "https://docs.dolphindb.cn/zh/funcs/f/format.html",
        "signatures": [
            {
                "full": "format(X, format)",
                "name": "format",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "format",
                        "name": "format"
                    }
                ]
            }
        ],
        "markdown": "### [format](https://docs.dolphindb.cn/zh/funcs/f/format.html)\n\n\n\n#### 语法\n\nformat(X, format)\n\n#### 详情\n\n把指定格式应用到给定对象。\n\n根据输入对象的数据类型，`format` 函数调用 [decimalFormat](https://docs.dolphindb.cn/zh/funcs/d/decimalFormat.html) 或 [temporalFormat](https://docs.dolphindb.cn/zh/funcs/t/temporalFormat.html)。\n\n有关从数字向指定格式字符串的转换，参考（表中的备注列，请参考 [decimalFormat](https://docs.dolphindb.cn/zh/funcs/d/decimalFormat.html)）：\n\n| 标志 | 含义         | 备注  |\n| -- | ---------- | --- |\n| 0  | 强制数字位数     | 备注1 |\n| #  | 可选数字位数     | 备注2 |\n| .  | 小数点        |     |\n| %  | 百分号        | 备注3 |\n| E  | 科学计数法的符号   | 备注4 |\n| ,  | 分隔符        | 备注5 |\n| ;  | 表示正数和负数的符号 | 备注6 |\n\n有关 DolphinDB 时序对象的格式，参考：\n\n| 格式        | 含义       | 范围                                          |\n| --------- | -------- | ------------------------------------------- |\n| yyyy      | 年份（4个数字） | 1000-9999                                   |\n| yy        | 年份（2个数字  | 00-99. (00-39: 2000-2039; 40-99: 1940-1999) |\n| MM        | 月份       | 1-12                                        |\n| MMM       | 月份       | JAN, FEB, ... DEC （不区分大小写）                  |\n| dd        | 日期       | 1-31                                        |\n| HH        | 时（24小时制） | 0-23                                        |\n| hh        | 时（12小时制） | 0-11                                        |\n| mm        | 分钟       | 0-59                                        |\n| ss        | 秒        | 0-59                                        |\n| aa        | 上午/下午    | AM, PM. （不区分大小写）                            |\n| SSS       | 毫秒       | 0-999                                       |\n| nnnnnn    | 微秒       | 0-999999                                    |\n| nnnnnnnnn | 纳秒       | 0-999999999                                 |\n\n**Note:**\n\nDolphinDB `format` 与 Python 内置的 [format](https://docs.python.org/3/library/functions.html#format) 都用于格式化输出，但二者的格式字符串语法不同，不能直接互换。\n\n#### 参数\n\n**X** 可以是标量或向量。\n\n**format** 是表示 *X* 格式的字符串。\n\n#### 返回值\n\n字符串标量或向量。\n\n#### 例子\n\n```\nt = table(1..100 as id, (1..100 + 2018.01.01) as date, rand(100.0, 100) as price, rand(10000, 100) as qty);\nt;\n```\n\n| id  | date       | price     | qty  |\n| --- | ---------- | --------- | ---- |\n| 1   | 2018.01.02 | 70.832104 | 1719 |\n| 2   | 2018.01.03 | 12.22557  | 6229 |\n| 3   | 2018.01.04 | 8.695886  | 1656 |\n| 4   | 2018.01.05 | 24.324535 | 2860 |\n| 5   | 2018.01.06 | 0.443173  | 6874 |\n| 6   | 2018.01.07 | 90.302176 | 3277 |\n| 7   | 2018.01.08 | 78.556843 | 3424 |\n| 8   | 2018.01.09 | 45.836447 | 8636 |\n| 9   | 2018.01.10 | 57.416425 | 707  |\n| 10  | 2018.01.11 | 98.879764 | 2267 |\n| ... |            |           |      |\n\n```\nselect id, date.format(\"MM/dd/yyyy\") as date, price.format(\"00.00\") as price, qty.format(\"#,###\") as qty from t;\n```\n\n| id  | date       | price | qty   |\n| --- | ---------- | ----- | ----- |\n| 1   | 01/02/2018 | 70.83 | 1,719 |\n| 2   | 01/03/2018 | 12.23 | 6,229 |\n| 3   | 01/04/2018 | 08.70 | 1,656 |\n| 4   | 01/05/2018 | 24.32 | 2,860 |\n| 5   | 01/06/2018 | 00.44 | 6,874 |\n| 6   | 01/07/2018 | 90.30 | 3,277 |\n| 7   | 01/08/2018 | 78.56 | 3,424 |\n| 8   | 01/09/2018 | 45.84 | 8,636 |\n| 9   | 01/10/2018 | 57.42 | 707   |\n| 10  | 01/11/2018 | 98.88 | 2,267 |\n| ... |            |       |       |\n"
    },
    "fromJson": {
        "url": "https://docs.dolphindb.cn/zh/funcs/f/fromJson.html",
        "signatures": [
            {
                "full": "fromJson(X)",
                "name": "fromJson",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [fromJson](https://docs.dolphindb.cn/zh/funcs/f/fromJson.html)\n\n\n\n#### 语法\n\nfromJson(X)\n\n#### 详情\n\n将符合 DolphinDB 规范的 JSON 格式的字符串转换为 DolphinDB 对象。\n\n符合 DolphinDB 规范的 JSON 字符串应至少包含3个键值对：\"form\"（数据结构）、\"type\"（数据类型）、\"value\"（值）。键值对 \"value\" 的值为实际数据。\n\n当数据结构为表时，键值对 \"name\" 可用来指定列名；若为其他数据结构，键值对 ''name\" 无意义。\n\n#### 参数\n\n**X** 是符合 DolphinDB 规范的 JSON 字符串数据。\n\n#### 返回值\n\n返回值的数据形式和类型由 JSON 字符串中的 `\"form\"`和 `\"type\"`字段共同决定。\n\n#### 例子\n\n```\nx=1 2 3\ny=toJson(x)\ny;\n// output\n{\"name\":\"x\",\"form\":\"vector\",\"type\":\"int\",\"size\":\"3\",\"value\":[1,2,3]}\n\nfromJson(y);\n// output\n[1,2,3]\n```\n\n相关函数：[toJson](https://docs.dolphindb.cn/zh/funcs/t/toJson.html)\n"
    },
    "fromStdJson": {
        "url": "https://docs.dolphindb.cn/zh/funcs/f/fromStdJson.html",
        "signatures": [
            {
                "full": "fromStdJson(X)",
                "name": "fromStdJson",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [fromStdJson](https://docs.dolphindb.cn/zh/funcs/f/fromStdJson.html)\n\n\n\n#### 语法\n\nfromStdJson(X)\n\n#### 详情\n\n将标准 JSON 文本转化为符合 DolphinDB 规范的数据。\n\n转换规则说明：\n\n| JSON 数据类型 | 对应 DolphinDB 数据类型/形式                                        |\n| --------- | ----------------------------------------------------------- |\n| 对象        | 转换为字典，key 类型始终为 STRING；如果其 value 由多种类型组成，那么 value 的类型为 ANY。 |\n| 数组        | 向量                                                          |\n| 字符串       | 优先解析为 TEMPORAL 类型；如果解析失败，则转换为 STRING。                       |\n| 数字        | DOUBLE                                                      |\n| 布尔值       | BOOL                                                        |\n| null      | NULL                                                        |\n\n**Note:**\n\n该函数会自动解析表示转义的特殊字符，如 `\\n`、`\\r` 等。\n\n#### 参数\n\n**X** 符合标准 JSON 格式的字符串，或由这些字符串组成的向量。\n\n#### 返回值\n\n返回值的数据形式和类型由输入 JSON 的数据类型决定，具体转换规则参见详情中的规则转换表。\n\n#### 例子\n\n```\nX = \"\\\"\\\\u4e2d\\\\u6587\\\"\";\nfromStdJson(X);\n//output: 中文\n\nX = \"\\\"\\\\u4e2d\\\\n\\\\u6587\\\"\";\nfromStdJson(X);\n//output: 中\n//        文\n\nX = \"[1, 2, 3]\";\nfromStdJson(X);\n//output:[1,2,3]\n\nX = \"[1, null, false, \\\"2012.06.13 13:30:10\\\", [\\\"\\\\u5d4c\\\\u5957\\\\u6570\\\\u7ec4\\\"]]\";\nfromStdJson(X);\n//output:(1,,false,2012.06.13T13:30:10,[\"嵌套数组\"])\n\nX = \"{\\\"1\\\": \\\"2017.07.10 14:10:12\\\",\\\"0\\\": \\\"2012.06.13 13:30:10\\\"}\";\nfromStdJson(X);\n//output:1->2017.07.10T14:10:12\n//       0->2012.06.13T13:30:10\n```\n\n相关函数：[toStdJson](https://docs.dolphindb.cn/zh/funcs/t/toStdJson.html)\n"
    },
    "fromUTF8": {
        "url": "https://docs.dolphindb.cn/zh/funcs/f/fromUTF8.html",
        "signatures": [
            {
                "full": "fromUTF8(str, encode)",
                "name": "fromUTF8",
                "parameters": [
                    {
                        "full": "str",
                        "name": "str"
                    },
                    {
                        "full": "encode",
                        "name": "encode"
                    }
                ]
            }
        ],
        "markdown": "### [fromUTF8](https://docs.dolphindb.cn/zh/funcs/f/fromUTF8.html)\n\n\n\n#### 语法\n\nfromUTF8(str, encode)\n\n#### 详情\n\n把 UTF8 编码的字符串转换为其他编码。DolphinDB 对编码名称的大小写敏感，所有编码名称必须用小写表示。\n\n因为 Windows 版本目前仅支持 gbk 和 utf-8 两种编码的相互转换，因此在 Windows 中，`fromUTF8` 的第二个参数只能是 \"gbk\"。Linux 版本支持任意两种编码之间的转换。\n\n#### 参数\n\n**str** 是一个字符串标量或向量。\n\n**encode** 是一个字符串，表示 *str* 的目标编码名称。\n\n#### 返回值\n\n字符串类型标量或向量。\n\n#### 例子\n\n```\nfromUTF8(\"DolphinDB\",\"gbk\");\n```\n\n输出返回：DolphinDB\n\n```\nfromUTF8([\"hello\",\"world\"],\"euc-cn\");\n```\n\n输出返回：\\[\"hello\",\"world\"]\n\n相关函数：[convertEncode](https://docs.dolphindb.cn/zh/funcs/c/convertEncode.html), [toUTF8](https://docs.dolphindb.cn/zh/funcs/t/toUTF8.html)\n"
    },
    "fTest": {
        "url": "https://docs.dolphindb.cn/zh/funcs/f/fTest.html",
        "signatures": [
            {
                "full": "fTest(X, Y, [ratio=1.0], [confLevel=0.95])",
                "name": "fTest",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "[ratio=1.0]",
                        "name": "ratio",
                        "optional": true,
                        "default": "1.0"
                    },
                    {
                        "full": "[confLevel=0.95]",
                        "name": "confLevel",
                        "optional": true,
                        "default": "0.95"
                    }
                ]
            }
        ],
        "markdown": "### [fTest](https://docs.dolphindb.cn/zh/funcs/f/fTest.html)\n\n\n\n#### 语法\n\nfTest(X, Y, \\[ratio=1.0], \\[confLevel=0.95])\n\n#### 详情\n\n对 *X* 和 *Y* 进行 F 检验。\n\n#### 参数\n\n**X** 是一个数值向量，表示用于F检验的样本。\n\n**Y** 是一个数值向量，表示用于独立双样本F检验的另一个样本。它是可选参数。\n\n**ratio** 是一个大于0的浮点数，表示X和Y方差的比例的假设值。默认值是1.0。\n\n**confLevel** 是0到1之间的浮点数，表示置信区间的置信水平。\n\n#### 返回值\n\n一个字典，包含以下 key：\n\n* numeratorDf：分子的自由度\n* stat：一张表，包含三种不同备择假设下的 p 值和置信区间\n* denominatorDf：分母的自由度\n* confLevel：置信水平\n* fValue：F 统计量\n* method：字符串 \"F test to compare two variances\"\n\n#### 例子\n\n```\nx = norm(10.0, 1.0, 20);\ny = norm(1.0, 2.0, 10);\nfTest(x, y, 0.5);\n// output\nnumeratorDf->19\nstat->\nalternativeHypothesis                  pValue    lowerBound upperBound\n-------------------------------------- --------- ---------- ----------\nratio of variances is not equal to 0.5 0.002326  0.025844   0.274161\nratio of variances is less than 0.5    0.001163  0          0.230624\nratio of variances is greater than 0.5 0.998837  0.032295   Infinity\n\ndenominatorDf->9\nconfLevel->0.95\nfValue->0.190386\nmethod->F test to compare two variances\n```\n"
    },
    "funcByName": {
        "url": "https://docs.dolphindb.cn/zh/funcs/f/funcByName.html",
        "signatures": [
            {
                "full": "funcByName(name)",
                "name": "funcByName",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    }
                ]
            }
        ],
        "markdown": "### [funcByName](https://docs.dolphindb.cn/zh/funcs/f/funcByName.html)\n\n\n\n#### 语法\n\nfuncByName(name)\n\n#### 详情\n\n动态执行函数或运算符，主要用于元编程。\n\n#### 参数\n\n**name** 是一个字符串，表示运算符或函数。函数可为内置函数或自定义函数。\n\n#### 返回值\n\nFUNCTIONDEF 类型标量，表示函数定义。\n\n#### 例子\n\n```\ndef f(x, a, b){\n   return funcByName(x)(a, b)\n}\n\nf(\"+\", 1 2 3, 4 5 6);\n// output\n[5,7,9]\n\nf(\"sub\", 1 8 3, 4 8 6);\n// output\n[-3,0,-3]\n\nf(\"corr\", 1 8 3, 4 8 6);\n// output\n0.970725\n\ndef cal(a,b){\n   return pow(a\\b,2)\n}\n\nf(\"cal\", 4 8 10, 2 2 2);\n// output\n[4,16,25]\n\nfuncByName(\"call\")(sum,1..10);\n// output\n55\n```\n"
    },
    "fxEuropeanOptionPricer": {
        "url": "https://docs.dolphindb.cn/zh/funcs/f/fxEuropeanOptionPricer.html",
        "signatures": [
            {
                "full": "fxEuropeanOptionPricer(instrument, pricingDate, spot, domesticCurve, foreignCurve, volSurf, [setting])",
                "name": "fxEuropeanOptionPricer",
                "parameters": [
                    {
                        "full": "instrument",
                        "name": "instrument"
                    },
                    {
                        "full": "pricingDate",
                        "name": "pricingDate"
                    },
                    {
                        "full": "spot",
                        "name": "spot"
                    },
                    {
                        "full": "domesticCurve",
                        "name": "domesticCurve"
                    },
                    {
                        "full": "foreignCurve",
                        "name": "foreignCurve"
                    },
                    {
                        "full": "volSurf",
                        "name": "volSurf"
                    },
                    {
                        "full": "[setting]",
                        "name": "setting",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [fxEuropeanOptionPricer](https://docs.dolphindb.cn/zh/funcs/f/fxEuropeanOptionPricer.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\nfxEuropeanOptionPricer(instrument, pricingDate, spot, domesticCurve, foreignCurve, volSurf, \\[setting])\n\n#### 详情\n\n使用 BlackScholes Model 和 Analytic Method，对外汇欧式期权进行定价，返回期权的净现值（NPV）。\n\n#### 参数\n\n注意：所有输入向量必须等长，输入标量将自动扩展以匹配其它向量的长度。\n\n**instrument** INSTRUMENT 类型标量或向量，表示待定价的外汇欧式期权。外汇欧式期权所需的关键字段详见[产品字段要求](https://docs.dolphindb.cn/zh/funcs/f/fxEuropeanOptionPricer.html#topic_sp5_5xj_ngc)。\n\n**pricingDate** DATE 类型标量或向量，表示定价日期。\n\n**spot**数值类型标量或向量，表示标的汇率的即期价格。\n\n**domesticCurve** MKTDATA 类型标量或向量（IrYieldCurve），表示本币的折现曲线。曲线所需包含的关键字段见[曲线字段要求](https://docs.dolphindb.cn/zh/funcs/f/fxEuropeanOptionPricer.html#topic_ldg_vxj_ngc)。\n\n**foreignCurve** MKTDATA 类型标量或向量（IrYieldCurve），表示外币的折现曲线。曲线所需包含的关键字段见[曲线字段要求](https://docs.dolphindb.cn/zh/funcs/f/fxEuropeanOptionPricer.html#topic_ldg_vxj_ngc)。\n\n**volSurf** MKTDATA 类型标量或向量（FxVolatilitySurface），表示外汇期权波动率曲面。曲线所需包含的关键字段见[曲线字段要求](https://docs.dolphindb.cn/zh/funcs/f/fxEuropeanOptionPricer.html#topic_ldg_vxj_ngc)。\n\n**setting** 可选参数，一个字典，用于设置定价输出。包含以下 key：\n\n* **calcDelta**：value 为布尔值，指定是否计算 delta。\n* **calcGamma**：value 为布尔值，指定是否计算 gamma。\n* **calcVega**：value 为布尔值，指定是否计算 vega。\n* **calcTheta**：value 为布尔值，指定是否计算 theta。\n* **calcRhoDomestic**：value 为布尔值，指定是否计算 domestic rho。\n* **calcRhoForeign**：value 为布尔值，指定是否计算 foreign rho。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\npricingDate = 2025.08.18\nccyPair = \"USDCNY\"\n\noption = {\n    \"productType\": \"Option\",\n    \"optionType\": \"EuropeanOption\",\n    \"assetType\": \"FxEuropeanOption\",\n    \"notionalCurrency\": \"USD\",\n    \"notionalAmount\": 1E6,\n    \"strike\": 7.2,\n    \"maturity\": 2025.10.28,\n    \"payoffType\": \"Call\",\n    \"dayCountConvention\": \"Actual365\",\n    \"underlying\": ccyPair\n}\n\nquoteTerms = ['1d', '1w', '2w', '3w', '1M', '2M', '3M', '6M', '9M', '1y', '18M', '2y', '3y']\nquoteNames = [\"ATM\", \"D25_RR\", \"D25_BF\", \"D10_RR\", \"D10_BF\"]\nquotes = [0.030000, -0.007500, 0.003500, -0.010000, 0.005500, \n          0.020833, -0.004500, 0.002000, -0.006000, 0.003800, \n          0.022000, -0.003500, 0.002000, -0.004500, 0.004100, \n          0.022350, -0.003500, 0.002000, -0.004500, 0.004150, \n          0.024178, -0.003000, 0.002200, -0.004750, 0.005500, \n          0.027484, -0.002650, 0.002220, -0.004000, 0.005650, \n          0.030479, -0.002500, 0.002400, -0.003500, 0.005750, \n          0.035752, -0.000500, 0.002750,  0.000000, 0.006950, \n          0.038108,  0.001000, 0.002800,  0.003000, 0.007550, \n          0.039492,  0.002250, 0.002950,  0.005000, 0.007550, \n          0.040500,  0.004000, 0.003100,  0.007000, 0.007850, \n          0.041750,  0.005250, 0.003350,  0.008000, 0.008400, \n          0.044750,  0.006250, 0.003400,  0.009000, 0.008550]\nquotes = reshape(quotes, size(quoteNames):size(quoteTerms)).transpose()\n\ncurveDates = [2025.08.21,\n              2025.08.27,\n              2025.09.03,\n              2025.09.10,\n              2025.09.22,\n              2025.10.20,\n              2025.11.20,\n              2026.02.24,\n              2026.05.20,\n              2026.08.20,\n              2027.02.22,\n              2027.08.20,\n              2028.08.21]\n              \ndomesticCurveInfo = {\n    \"mktDataType\": \"Curve\",\n    \"curveType\": \"IrYieldCurve\",\n    \"referenceDate\": pricingDate,\n    \"currency\": \"CNY\",\n    \"dayCountConvention\": \"Actual365\",\n    \"compounding\": \"Continuous\",  \n    \"interpMethod\": \"Linear\",\n    \"extrapMethod\": \"Flat\",\n    \"frequency\": \"Annual\",\n    \"dates\": curveDates,\n    \"values\":[1.5113, \n              1.5402, \n              1.5660, \n              1.5574, \n              1.5556, \n              1.5655, \n              1.5703, \n              1.5934, \n              1.6040, \n              1.6020, \n              1.5928, \n              1.5842, \n              1.6068]/100\n}\nforeignCurveInfo = {\n    \"mktDataType\": \"Curve\",\n    \"curveType\": \"IrYieldCurve\",\n    \"referenceDate\": pricingDate,\n    \"currency\": \"USD\",\n    \"dayCountConvention\": \"Actual365\",\n    \"compounding\": \"Continuous\",  \n    \"interpMethod\": \"Linear\",\n    \"extrapMethod\": \"Flat\",\n    \"frequency\": \"Annual\",\n    \"dates\": curveDates,\n    \"values\":[4.3345, \n              4.3801, \n              4.3119, \n              4.3065, \n              4.2922, \n              4.2196, \n              4.1599, \n              4.0443, \n              4.0244, \n              3.9698, \n              3.7740, \n              3.6289, \n              3.5003]/100\n}\n\nspot = 7.1627\ninstrument = parseInstrument(option)\ndomesticCurve = parseMktData(domesticCurveInfo)\nforeignCurve = parseMktData(foreignCurveInfo)\nsurf = fxVolatilitySurfaceBuilder(pricingDate, ccyPair, quoteNames, quoteTerms, quotes, spot, domesticCurve, foreignCurve)\n\nfxEuropeanOptionPricer(instrument, pricingDate, spot, domesticCurve, foreignCurve, surf)   // output: 1693.9919\nfxEuropeanOptionPricer([instrument, instrument], pricingDate, spot, domesticCurve, foreignCurve, surf)\nfxEuropeanOptionPricer(instrument, [pricingDate, pricingDate], spot, domesticCurve, foreignCurve, surf)\nfxEuropeanOptionPricer(instrument, pricingDate, [spot, spot], domesticCurve, foreignCurve, surf)\nfxEuropeanOptionPricer(instrument, pricingDate, spot, [domesticCurve, domesticCurve], foreignCurve, surf)\nfxEuropeanOptionPricer(instrument, pricingDate, spot, domesticCurve, [foreignCurve, foreignCurve], surf)\nfxEuropeanOptionPricer(instrument, pricingDate, spot, domesticCurve, foreignCurve, [surf, surf])\n```\n\n**相关函数：**[parseInstrument](https://docs.dolphindb.cn/zh/funcs/p/parseInstrument.html), [parseMktData](https://docs.dolphindb.cn/zh/funcs/p/parseMktData.html)\n\n#### 产品字段说明\n\n| 字段名         | 类型     | 描述                | 是否必填 |\n| ----------- | ------ | ----------------- | ---- |\n| productType | STRING | 固定填 \"UserDefined\" | 是    |\n\n#### 曲线字段要求\n\n**IrYieldCurve**\n\n<table id=\"table_g2t_2l1_4gc\"><thead><tr><th>\n\n字段名\n\n</th><th>\n\n类型\n\n</th><th>\n\n描述\n\n</th><th>\n\n是否必填\n\n</th></tr></thead><tbody><tr><td>\n\nmktDataType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"Curve\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nreferenceDate\n\n</td><td>\n\nDATE\n\n</td><td>\n\n参考日期\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ncurveType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"IrYieldCurve\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ndayCountConvention\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n曲线的日期计数惯例，可选值为：\n\n* \"Actual360\"：实际天数除以360\n\n* \"Actual365\"：实际天数除以365（不区分闰年）\n\n* \"ActualActualISMA\"：实际天数/实际天数（ISMA规则）\n\n* \"ActualActualISDA\"：实际天数/实际天数（ISDA规则）\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ninterpMethod\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n内插方法，可选值为：\n\n* \"Linear\"：线性插值\n\n* \"CubicSpline\"：三次样条插值\n\n* \"CubicHermiteSpline\"：三次埃尔米特样条插值\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nextrapMethod\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n外插方法，可选值为：\n\n* \"Flat\"：平插\n\n* \"Linear\"：线性插值\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ndates\n\n</td><td>\n\nDATE 向量\n\n</td><td>\n\n数据点的日期\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nvalues\n\n</td><td>\n\nDOUBLE 向量\n\n</td><td>\n\n数据点的值，与 *dates* 中的元素一一对应\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ncurveName\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n曲线名称\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ncurrency\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n货币，可选值为\"CNY\", \"USD\", \"EUR\", \"GBP\", \"JPY\", \"HKD\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ncompounding\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n复利类型，可选值为：\n\n* \"Simple\"：单利\n\n* \"Compounded\"：离散复利\n\n* \"Continuous\"：连续复利\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nsettlement\n\n</td><td>\n\nDATE\n\n</td><td>\n\n结算日，如果指定了结算日，则后续期限间隔的计算都将从 *settlement* 开始，而不是 *referenceDate*\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\nfrequency\n\n</td><td>\n\nINTEGRAL或 STRING\n\n</td><td>\n\n计息频率，可选值为：\n\n* -1 或 \"NoFrequency\"：无效计息频率\n\n* 0 或 \"Once\"：到期一次还本付息\n\n* 1 或 \"Annual\"：每年付息一次\n\n* 2 或 \"Semiannual\"：每半年付息一次\n\n* 3 或 \"EveryFourthMonth\"：每四个月付息一次\n\n* 4 或 \"Quarterly\"：每季度付息一次\n\n* 6 或 \"BiMonthly\"：每两月付息一次\n\n* 12 或 \"Monthly\"：每月付息一次\n\n* 13 或 \"EveryFourthWeek\"：每四周付息一次\n\n* 26 或 \"BiWeekly\"：每两周付息一次\n\n* 52 或 \"Weekly\"：每周付息一次\n\n* 365 或 \"Daily\"：每日付息一次\n\n* 999 或 \"Other\"：其他计息频率\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ncurveModel\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n曲线构建模型，目前仅支持 \"Bootstrap\"。\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ncurveParams\n\n</td><td>\n\nDICT\n\n</td><td>\n\n模型的参数。\n\n</td><td>\n\n否\n\n</td></tr></tbody>\n</table>**FxVolatilitySurface**\n\n<table id=\"table_cmy_bcl_ngc\"><thead><tr><th>\n\n字段名\n\n</th><th>\n\n类型\n\n</th><th>\n\n描述\n\n</th><th>\n\n是否必填\n\n</th></tr></thead><tbody><tr><td>\n\nmktDataType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"Surface\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nreferenceDate\n\n</td><td>\n\nDATE\n\n</td><td>\n\n参考日期\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nsurfaceType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"FxVolatilitySurface\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nsmileMethod\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n波动率微笑方法，可选值为：\n\n* \"Linear\"：线性微笑\n\n* \"CubicSpline\"：三次样条微笑\n\n* \"SVI\"：SVI 模型微笑\n\n* \"SABR\"：SABR 模型微笑\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nvolSmiles\n\n</td><td>\n\nDICT(STRING, ANY) 向量\n\n</td><td>\n\n波动率微笑向量，向量中每个元素为一条波动率微笑。\n\n包含以下成员：\n\n* **strikes**: DOUBLE 类型向量，表示不同的行权价\n\n* **vols**: DOUBLE 类型向量，表示行权价对应的波动率，与 *strikes*等长\n\n* **curveParams**：字典DICT(STRING, DOUBLE)类型，表示波动率微笑方法的模型参数，只在 *smileMethod* 取值 \"SVI\" 或 \"SABR\" 时生效：\n\n  * smileMethod = 'SVI': 应包含键 'a', 'b', 'rho', 'm', 'sigma'\n\n  * smileMethod = 'SABR': 应包含键 'alpha', 'beta', 'rho', 'nu'\n\n* **fwd**：可选，DOUBLE 类型标量，当 *smileMethod*取值 \"SVI\" 或 \"SABR\" 时必填，表示远期值\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ntermDates\n\n</td><td>\n\nDATE 向量\n\n</td><td>\n\n*volSmiles*中每条波动率微笑对应的期限日期\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nsurfaceName\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n曲面名称\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ncurrencyPair\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n外汇的货币对，可选值为\"EURUSD\", \"USDCNY\", \"EURCNY\", \"GBPCNY\", \"JPYCNY\", \"HKDCNY\"。\n\n货币对的表示也可由 `.` 或 `/` 分隔，例如 \"EURUSD\" 也可写为 \"EUR.USD\" 或 \"EUR/USD\"。\n\n</td><td>\n\n是\n\n</td></tr></tbody>\n</table>\n"
    },
    "fxForwardPricer": {
        "url": "https://docs.dolphindb.cn/zh/funcs/f/fxForwardPricer.html",
        "signatures": [
            {
                "full": "fxForwardPricer(instrument, pricingDate, spot, domesticCurve, foreignCurve)",
                "name": "fxForwardPricer",
                "parameters": [
                    {
                        "full": "instrument",
                        "name": "instrument"
                    },
                    {
                        "full": "pricingDate",
                        "name": "pricingDate"
                    },
                    {
                        "full": "spot",
                        "name": "spot"
                    },
                    {
                        "full": "domesticCurve",
                        "name": "domesticCurve"
                    },
                    {
                        "full": "foreignCurve",
                        "name": "foreignCurve"
                    }
                ]
            }
        ],
        "markdown": "### [fxForwardPricer](https://docs.dolphindb.cn/zh/funcs/f/fxForwardPricer.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\nfxForwardPricer(instrument, pricingDate, spot, domesticCurve, foreignCurve)\n\n#### 详情\n\n基于给定的即期汇率、本币与外币的贴现曲线，以及定价日期，计算外汇远期合约的净现值（NPV）。\n\n#### 参数\n\n注意：所有输入向量必须等长，输入标量将自动扩展以匹配其它向量的长度。\n\n**instrument** 一个 INSTRUMENT 类型标量或向量（FxForward）。表示需要定价的外汇远期。外汇远期所需的关键字段见 [FxForward 字段要求](https://docs.dolphindb.cn/zh/funcs/f/fxForwardPricer.html#topic_ylx_cf2_ngc)。\n\n**pricingDate** DATE 类型标量或向量，表示定价日期。\n\n**spot** DOUBLE 类型标量或向量，表示即期汇率。\n\n**domesticCurve** MKTDATA 类型标量或向量（IrYieldCurve），表示本币贴现曲线。曲线所需包含的关键字段见[曲线字段要求](https://docs.dolphindb.cn/zh/funcs/f/fxForwardPricer.html#topic_q1d_df2_ngc)。\n\n**foreignCurve** MKTDATA 类型标量或向量（IrYieldCurve），表示外币贴现曲线。曲线所需包含的关键字段见[曲线字段要求](https://docs.dolphindb.cn/zh/funcs/f/fxForwardPricer.html#topic_q1d_df2_ngc)。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\npricingDate = 2025.08.18\n\nfxForward = {\n    \"productType\": \"Forward\",\n    \"forwardType\": \"FxForward\",\n    \"expiry\": 2025.12.16,\n    \"delivery\": 2025.12.18,\n    \"currencyPair\": \"USDCNY\",\n    \"direction\": \"Buy\",\n    \"notionalCurrency\": \"USD\",\n    \"notionalAmount\": 1E6,\n    \"strike\": 7.1\n}\n\ncurveDates = [2025.08.21,\n              2025.08.27,\n              2025.09.03,\n              2025.09.10,\n              2025.09.22,\n              2025.10.20,\n              2025.11.20,\n              2026.02.24,\n              2026.05.20,\n              2026.08.20,\n              2027.02.22,\n              2027.08.20,\n              2028.08.21]\ndomesticCurveInfo = {\n    \"mktDataType\": \"Curve\",\n    \"curveType\": \"IrYieldCurve\",\n    \"referenceDate\": pricingDate,\n    \"currency\": \"CNY\",\n    \"dayCountConvention\": \"Actual365\",\n    \"compounding\": \"Continuous\",  \n    \"interpMethod\": \"Linear\",\n    \"extrapMethod\": \"Flat\",\n    \"frequency\": \"Annual\",\n    \"dates\": curveDates,\n    \"values\":[1.5113, \n              1.5402, \n              1.5660, \n              1.5574, \n              1.5556, \n              1.5655, \n              1.5703, \n              1.5934, \n              1.6040, \n              1.6020, \n              1.5928, \n              1.5842, \n              1.6068]/100\n}\nforeignCurveInfo = {\n    \"mktDataType\": \"Curve\",\n    \"curveType\": \"IrYieldCurve\",\n    \"referenceDate\": pricingDate,\n    \"currency\": \"USD\",\n    \"dayCountConvention\": \"Actual365\",\n    \"compounding\": \"Continuous\",  \n    \"interpMethod\": \"Linear\",\n    \"extrapMethod\": \"Flat\",\n    \"frequency\": \"Annual\",\n    \"dates\": curveDates,\n    \"values\":[4.3345, \n              4.3801, \n              4.3119, \n              4.3065, \n              4.2922, \n              4.2196, \n              4.1599, \n              4.0443, \n              4.0244, \n              3.9698, \n              3.7740, \n              3.6289, \n              3.5003]/100\n}\n\ninstrument = parseInstrument(fxForward)\n\ndomesticCurve = parseMktData(domesticCurveInfo)\nforeignCurve = parseMktData(foreignCurveInfo)\nspot = 7.1627\n\nfxForwardPricer(instrument, pricingDate, spot, domesticCurve, foreignCurve)   // output: 1919.8118\nfxForwardPricer([instrument, instrument], pricingDate, spot, domesticCurve, foreignCurve)\nfxForwardPricer(instrument, [pricingDate, pricingDate], spot, domesticCurve, foreignCurve)\nfxForwardPricer(instrument, pricingDate, [spot, spot], domesticCurve, foreignCurve)\nfxForwardPricer(instrument, pricingDate, spot, [domesticCurve, domesticCurve], foreignCurve)\nfxForwardPricer(instrument, pricingDate, spot, domesticCurve, [foreignCurve, foreignCurve])\n```\n\n**相关函数：**[parseInstrument](https://docs.dolphindb.cn/zh/funcs/p/parseInstrument.html), [parseMktData](https://docs.dolphindb.cn/zh/funcs/p/parseMktData.html)\n\n#### 远期字段要求\n\n<table id=\"table_jxb_jbl_ngc\"><thead><tr><th>\n\n字段名\n\n</th><th>\n\n类型\n\n</th><th>\n\n描述\n\n</th><th>\n\n是否必填\n\n</th></tr></thead><tbody><tr><td>\n\nproductType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n产品名称，固定值为 \"Forward\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nforwardType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n远期类型，固定值为 \"FxForward\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nnotional\n\n</td><td>\n\nANY 向量\n\n</td><td>\n\n名义本金，格式如 \\[\"USD\", 1.0]\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ninstrumentId\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n金融工具 ID\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\nexpiry\n\n</td><td>\n\nDATE\n\n</td><td>\n\n到期日\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ndelivery\n\n</td><td>\n\nDATE\n\n</td><td>\n\n交割日\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ncurrencyPair\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n货币对，格式如：\"EURUSD\"，\"EUR.USD\" 或 \"EUR/USD\"。支持如下货币对：\n\n* EURUSD：欧元兑美元\n\n* USDCNY：美元兑人民币\n\n* EURCNY：欧元兑人民币\n\n* GBPCNY：英镑兑人民币\n\n* JPYCNY：日元兑人民币\n\n* HKDCNY：港币兑人民币\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ndirection\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n交易方向。可选：\"Buy\"、\"Sell\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nstrike\n\n</td><td>\n\nDOUBLE\n\n</td><td>\n\n执行价格\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ndomesticCurve\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n定价时参考的本币贴现曲线名称\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\nforeignCurve\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n定价时参考的外币贴现曲线名称\n\n</td><td>\n\n否\n\n</td></tr></tbody>\n</table>## 曲线字段要求\n\n<table id=\"table_vx5_sj1_4gc\"><thead><tr><th>\n\n字段名\n\n</th><th>\n\n类型\n\n</th><th>\n\n描述\n\n</th><th>\n\n是否必填\n\n</th></tr></thead><tbody><tr><td>\n\nmktDataType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"Curve\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nreferenceDate\n\n</td><td>\n\nDATE\n\n</td><td>\n\n参考日期\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ncurveType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"IrYieldCurve\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ndayCountConvention\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n曲线的日期计数惯例，可选值为：\n\n* \"Actual360\"：实际天数除以360\n\n* \"Actual365\"：实际天数除以365（不区分闰年）\n\n* \"ActualActualISMA\"：实际天数/实际天数（ISMA规则）\n\n* \"ActualActualISDA\"：实际天数/实际天数（ISDA规则）\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ninterpMethod\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n内插方法，可选值为：\n\n* \"Linear\"：线性插值\n\n* \"CubicSpline\"：三次样条插值\n\n* \"CubicHermiteSpline\"：三次埃尔米特样条插值\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nextrapMethod\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n外插方法，可选值为：\n\n* \"Flat\"：平插\n\n* \"Linear\"：线性插值\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ndates\n\n</td><td>\n\nDATE 向量\n\n</td><td>\n\n数据点的日期\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nvalues\n\n</td><td>\n\nDOUBLE 向量\n\n</td><td>\n\n数据点的值，与 *dates* 中的元素一一对应\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ncurveName\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n曲线名称\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ncurrency\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n货币，可选值为\"CNY\", \"USD\", \"EUR\", \"GBP\", \"JPY\", \"HKD\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ncompounding\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n复利类型，可选值为：\n\n* \"Simple\"：单利\n\n* \"Compounded\"：离散复利\n\n* \"Continuous\"：连续复利\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nsettlement\n\n</td><td>\n\nDATE\n\n</td><td>\n\n结算日，如果指定了结算日，则后续期限间隔的计算都将从 *settlement* 开始，而不是 *referenceDate*\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\nfrequency\n\n</td><td>\n\nINTEGRAL或 STRING\n\n</td><td>\n\n计息频率，可选值为：\n\n* -1 或 \"NoFrequency\"：无效计息频率\n\n* 0 或 \"Once\"：到期一次还本付息\n\n* 1 或 \"Annual\"：每年付息一次\n\n* 2 或 \"Semiannual\"：每半年付息一次\n\n* 3 或 \"EveryFourthMonth\"：每四个月付息一次\n\n* 4 或 \"Quarterly\"：每季度付息一次\n\n* 6 或 \"BiMonthly\"：每两月付息一次\n\n* 12 或 \"Monthly\"：每月付息一次\n\n* 13 或 \"EveryFourthWeek\"：每四周付息一次\n\n* 26 或 \"BiWeekly\"：每两周付息一次\n\n* 52 或 \"Weekly\"：每周付息一次\n\n* 365 或 \"Daily\"：每日付息一次\n\n* 999 或 \"Other\"：其他计息频率\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ncurveModel\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n曲线构建模型，目前仅支持 \"Bootstrap\"。\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ncurveParams\n\n</td><td>\n\nDICT\n\n</td><td>\n\n模型的参数。\n\n</td><td>\n\n否\n\n</td></tr></tbody>\n</table>\n"
    },
    "fxSwapPricer": {
        "url": "https://docs.dolphindb.cn/zh/funcs/f/fxSwapPricer.html",
        "signatures": [
            {
                "full": "fxSwapPricer(instrument, pricingDate, spot, domesticCurve, foreignCurve)",
                "name": "fxSwapPricer",
                "parameters": [
                    {
                        "full": "instrument",
                        "name": "instrument"
                    },
                    {
                        "full": "pricingDate",
                        "name": "pricingDate"
                    },
                    {
                        "full": "spot",
                        "name": "spot"
                    },
                    {
                        "full": "domesticCurve",
                        "name": "domesticCurve"
                    },
                    {
                        "full": "foreignCurve",
                        "name": "foreignCurve"
                    }
                ]
            }
        ],
        "markdown": "### [fxSwapPricer](https://docs.dolphindb.cn/zh/funcs/f/fxSwapPricer.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\nfxSwapPricer(instrument, pricingDate, spot, domesticCurve, foreignCurve)\n\n#### 详情\n\n计算外汇掉期的净现值。\n\n#### 参数\n\n注意：所有输入向量必须等长，输入标量将自动扩展以匹配其它向量的长度。\n\n**instrument**INSTRUMENT 类型标量或向量，一个 FxSwap 对象，表示需要定价的外汇掉期。\n\n**pricingDate** DATE 类型标量或向量，表示定价日期。\n\n**spot** 数值类型标量或向量，表示汇率即期价格。\n\n**domesticCurve** MKTDATA 类型标量或向量，一个 IrYieldCurve 对象，表示本币折现曲线。\n\n**foreignCurve** MKTDATA 类型标量或向量，一个 IrYieldCurve 对象，表示外币折现曲线。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\npricingDate = 2025.08.18\n\nfxSwap = {\n    \"productType\": \"Swap\",\n    \"swapType\": \"FxSwap\",\n    \"currencyPair\": \"USDCNY\",\n    \"direction\": \"Buy\",\n    \"notionalCurrency\": \"USD\",\n    \"notionalAmount\": 1E6,\n    \"nearStrike\": 7.15,\n    \"nearExpiry\": pricingDate + 60,\n    \"nearDelivery\": pricingDate + 62,\n    \"farStrike\": 7.18,\n    \"farExpiry\": pricingDate + 180,\n    \"farDelivery\": pricingDate + 182\n}\n\ncurveDates = [2025.08.21,\n              2025.08.27,\n              2025.09.03,\n              2025.09.10,\n              2025.09.22,\n              2025.10.20,\n              2025.11.20,\n              2026.02.24,\n              2026.05.20,\n              2026.08.20,\n              2027.02.22,\n              2027.08.20,\n              2028.08.21]\ndomesticCurveInfo = {\n    \"mktDataType\": \"Curve\",\n    \"curveType\": \"IrYieldCurve\",\n    \"referenceDate\": pricingDate,\n    \"currency\": \"CNY\",\n    \"dayCountConvention\": \"Actual365\",\n    \"compounding\": \"Continuous\",  \n    \"interpMethod\": \"Linear\",\n    \"extrapMethod\": \"Flat\",\n    \"frequency\": \"Annual\",\n    \"dates\": curveDates,\n    \"values\":[1.5113, \n              1.5402, \n              1.5660, \n              1.5574, \n              1.5556, \n              1.5655, \n              1.5703, \n              1.5934, \n              1.6040, \n              1.6020, \n              1.5928, \n              1.5842, \n              1.6068]/100\n}\nforeignCurveInfo = {\n    \"mktDataType\": \"Curve\",\n    \"curveType\": \"IrYieldCurve\",\n    \"referenceDate\": pricingDate,\n    \"currency\": \"USD\",\n    \"dayCountConvention\": \"Actual365\",\n    \"compounding\": \"Continuous\",  \n    \"interpMethod\": \"Linear\",\n    \"extrapMethod\": \"Flat\",\n    \"frequency\": \"Annual\",\n    \"dates\": curveDates,\n    \"values\":[4.3345, \n              4.3801, \n              4.3119, \n              4.3065, \n              4.2922, \n              4.2196, \n              4.1599, \n              4.0443, \n              4.0244, \n              3.9698, \n              3.7740, \n              3.6289, \n              3.5003]/100\n}\n\ninstrument = parseInstrument(fxSwap)\ndomesticCurve = parseMktData(domesticCurveInfo)\nforeignCurve = parseMktData(foreignCurveInfo)\nspot = 7.1627\n\nfxSwapPricer(instrument, pricingDate, spot, domesticCurve, foreignCurve)   // output:84379.328782705269986\nfxSwapPricer(instrument, pricingDate, [spot, spot], domesticCurve, foreignCurve)\nfxSwapPricer(instrument, [pricingDate, pricingDate], spot, domesticCurve, foreignCurve)\nfxSwapPricer([instrument, instrument], pricingDate, spot, domesticCurve, foreignCurve)\nfxSwapPricer(instrument, pricingDate, spot, [domesticCurve, domesticCurve], foreignCurve)\nfxSwapPricer(instrument, pricingDate, spot, domesticCurve, [foreignCurve, foreignCurve])\n```\n\n**相关函数：**[parseInstrument](https://docs.dolphindb.cn/zh/funcs/p/parseInstrument.html)，[parseMktData](https://docs.dolphindb.cn/zh/funcs/p/parseMktData.html)\n"
    },
    "fxVolatilitySurfaceBuilder": {
        "url": "https://docs.dolphindb.cn/zh/funcs/f/fxVolatilitySurfaceBuilder.html",
        "signatures": [
            {
                "full": "fxVolatilitySurfaceBuilder(referenceDate, currencyPair, quoteNames, quoteTerms, quotes, spot, domesticCurve, foreignCurve, [model='SVI'], [surfaceName])",
                "name": "fxVolatilitySurfaceBuilder",
                "parameters": [
                    {
                        "full": "referenceDate",
                        "name": "referenceDate"
                    },
                    {
                        "full": "currencyPair",
                        "name": "currencyPair"
                    },
                    {
                        "full": "quoteNames",
                        "name": "quoteNames"
                    },
                    {
                        "full": "quoteTerms",
                        "name": "quoteTerms"
                    },
                    {
                        "full": "quotes",
                        "name": "quotes"
                    },
                    {
                        "full": "spot",
                        "name": "spot"
                    },
                    {
                        "full": "domesticCurve",
                        "name": "domesticCurve"
                    },
                    {
                        "full": "foreignCurve",
                        "name": "foreignCurve"
                    },
                    {
                        "full": "[model='SVI']",
                        "name": "model",
                        "optional": true,
                        "default": "'SVI'"
                    },
                    {
                        "full": "[surfaceName]",
                        "name": "surfaceName",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [fxVolatilitySurfaceBuilder](https://docs.dolphindb.cn/zh/funcs/f/fxVolatilitySurfaceBuilder.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\nfxVolatilitySurfaceBuilder(referenceDate, currencyPair, quoteNames, quoteTerms, quotes, spot, domesticCurve, foreignCurve, \\[model='SVI'], \\[surfaceName])\n\n#### 详情\n\n构建外汇波动率曲面。\n\n#### 参数\n\n**referenceDate** DATE 类型标量，表示曲面的参考日期。\n\n**currencyPair**STRING 类型标量，表示货币对，形式为 \"EURUSD\"，\"EUR.USD\" 或 \"EUR/USD\"。支持的货币对包括：\n\n* EURUSD：欧元兑美元\n\n* USDCNY：美元兑人民币\n\n* EURCNY：欧元兑人民币\n\n* GBPCNY：英镑兑人民币\n\n* JPYCNY：日元兑人民币\n\n* HKDCNY：港币兑人民币\n\n**quoteNames** STRING 类型向量，须为 \\[\"ATM\", \"D25\\_RR\", \"D25\\_BF\", \"D10\\_RR\", \"D10\\_BF\"] 的一组排列，表示报价名称，其中：\n\n* \"ATM\"：平值波动率\n\n* \"D25\\_RR\"：Delta = 0.25 的风险逆转\n\n* \"D25\\_BF\"：Delta = 0.25 的蝶式\n\n* \"D10\\_RR\"：Delta = 0.1 的风险逆转\n\n* \"D10\\_BF\"：Delta = 0.1 的蝶式\n\n**quoteTerms** DURATION 或 STRING 类型向量，表示市场报价的对应期限。当为 STRING 类型标量时，除可以是能转换成 DURATION 的字符串外，还可以为以下可选值：\n\n* \"ON\"：Overnight，近端起息日为 T，远端起息日为 T+1\n\n* \"TN\"：Tomorrow-next，近端起息日为 T+1，远端起息日为 T+2\n\n* \"SN\"：Spot-next，近端起息日为 T+2，远端起息日为 T+3\n\n**quotes** DOUBLE 类型矩阵，形状为 `(size(quoteTerms), size(quoteNames))`。第 i 行第 j 列表示 quoteNames\\[j] 在 quoteTerms\\[i] 上的市场报价。\n\n**spot** DOUBLE 类型标量，表示即期汇率。\n\n**domesticCurve** MKTDATA 类型标量，一个 IrYieldCurve 对象，表示本币的折现曲线。本币折现曲线所需包含的关键字段见[曲线字段要求](https://docs.dolphindb.cn/zh/funcs/f/fxVolatilitySurfaceBuilder.html#topic_o13_dm2_ngc)。\n\n**foreignCurve** MKTDATA 类型标量，一个 IrYieldCurve 对象，表示外币的折现曲线。外币折现曲线所需包含的关键字段见[曲线字段要求](https://docs.dolphindb.cn/zh/funcs/f/fxVolatilitySurfaceBuilder.html#topic_o13_dm2_ngc)。\n\n**model** 可选参数，STRING 类型标量，指定构建波动率曲面所用模型。支持以下选项：\n\n* “SVI”：默认值，Stochastic Volatility Inspired 模型\n\n* “SABR”：Stochastic Alpha Beta Rho 模型\n\n* “Linear”：线性模型\n\n* “CubicSpline”：三次样条模型\n\n**surfaceName** 可选参数，STRING 类型标量，指定曲面的名称。默认值为 \"FXVOLSURF/{currencyPair}\"。\n\n#### 返回值\n\nMKTDATA 类型标量，一个 FxVolatilitySurface 对象。\n\n#### 例子\n\n```\nrefDate = 2025.08.18\nccyPair = \"USDCNY\"\nquoteTerms = ['1d', '1w', '2w', '3w', '1M', '2M', '3M', '6M', '9M', '1y', '18M', '2y', '3y']\nquoteNames = [\"ATM\", \"D25_RR\", \"D25_BF\", \"D10_RR\", \"D10_BF\"]\nquotes = [0.030000, -0.007500, 0.003500, -0.010000, 0.005500, \n          0.020833, -0.004500, 0.002000, -0.006000, 0.003800, \n          0.022000, -0.003500, 0.002000, -0.004500, 0.004100, \n          0.022350, -0.003500, 0.002000, -0.004500, 0.004150, \n          0.024178, -0.003000, 0.002200, -0.004750, 0.005500, \n          0.027484, -0.002650, 0.002220, -0.004000, 0.005650, \n          0.030479, -0.002500, 0.002400, -0.003500, 0.005750, \n          0.035752, -0.000500, 0.002750,  0.000000, 0.006950, \n          0.038108,  0.001000, 0.002800,  0.003000, 0.007550, \n          0.039492,  0.002250, 0.002950,  0.005000, 0.007550, \n          0.040500,  0.004000, 0.003100,  0.007000, 0.007850, \n          0.041750,  0.005250, 0.003350,  0.008000, 0.008400, \n          0.044750,  0.006250, 0.003400,  0.009000, 0.008550]\nquotes = reshape(quotes, size(quoteNames):size(quoteTerms)).transpose()\nspot = 7.1627\ncurveDates = [2025.08.21,\n              2025.08.27,\n              2025.09.03,\n              2025.09.10,\n              2025.09.22,\n              2025.10.20,\n              2025.11.20,\n              2026.02.24,\n              2026.05.20,\n              2026.08.20,\n              2027.02.22,\n              2027.08.20,\n              2028.08.21]\ndomesticCurveInfo = {\n    \"mktDataType\": \"Curve\",\n    \"curveType\": \"IrYieldCurve\",\n    \"referenceDate\": refDate,\n    \"currency\": \"CNY\",\n    \"dayCountConvention\": \"Actual365\",\n    \"compounding\": \"Continuous\",  \n    \"interpMethod\": \"Linear\",\n    \"extrapMethod\": \"Flat\",\n    \"frequency\": \"Annual\",\n    \"dates\": curveDates,\n    \"values\":[1.5113, \n              1.5402, \n              1.5660, \n              1.5574, \n              1.5556, \n              1.5655, \n              1.5703, \n              1.5934, \n              1.6040, \n              1.6020, \n              1.5928, \n              1.5842, \n              1.6068]/100\n}\nforeignCurveInfo = {\n    \"mktDataType\": \"Curve\",\n    \"curveType\": \"IrYieldCurve\",\n    \"referenceDate\": refDate,\n    \"currency\": \"USD\",\n    \"dayCountConvention\": \"Actual365\",\n    \"compounding\": \"Continuous\",  \n    \"interpMethod\": \"Linear\",\n    \"extrapMethod\": \"Flat\",\n    \"frequency\": \"Annual\",\n    \"dates\": curveDates,\n    \"values\":[4.3345, \n              4.3801, \n              4.3119, \n              4.3065, \n              4.2922, \n              4.2196, \n              4.1599, \n              4.0443, \n              4.0244, \n              3.9698, \n              3.7740, \n              3.6289, \n              3.5003]/100\n}\ndomesticCurve = parseMktData(domesticCurveInfo)\nforeignCurve = parseMktData(foreignCurveInfo)\nsurf = fxVolatilitySurfaceBuilder(refDate, ccyPair, quoteNames, quoteTerms, quotes, spot, domesticCurve, foreignCurve)\nsurfDict = extractMktData(surf)\nprint(surfDict)\n\n```\n\n**相关函数：**[extractMktData](https://docs.dolphindb.cn/zh/funcs/e/extractMktData.html), [parseMktData](https://docs.dolphindb.cn/zh/funcs/p/parseMktData.html)\n\n#### 曲线字段要求\n\n<table id=\"table_vqh_nn1_4gc\"><thead><tr><th>\n\n字段名\n\n</th><th>\n\n类型\n\n</th><th>\n\n描述\n\n</th><th>\n\n是否必填\n\n</th></tr></thead><tbody><tr><td>\n\nmktDataType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"Curve\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nreferenceDate\n\n</td><td>\n\nDATE\n\n</td><td>\n\n参考日期\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ncurveType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"IrYieldCurve\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ndayCountConvention\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n曲线的日期计数惯例，可选值为：\n\n* \"Actual360\"：实际天数除以360\n\n* \"Actual365\"：实际天数除以365（不区分闰年）\n\n* \"ActualActualISMA\"：实际天数/实际天数（ISMA规则）\n\n* \"ActualActualISDA\"：实际天数/实际天数（ISDA规则）\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ninterpMethod\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n内插方法，可选值为：\n\n* \"Linear\"：线性插值\n\n* \"CubicSpline\"：三次样条插值\n\n* \"CubicHermiteSpline\"：三次埃尔米特样条插值\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nextrapMethod\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n外插方法，可选值为：\n\n* \"Flat\"：平插\n\n* \"Linear\"：线性插值\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ndates\n\n</td><td>\n\nDATE 向量\n\n</td><td>\n\n数据点的日期\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nvalues\n\n</td><td>\n\nDOUBLE 向量\n\n</td><td>\n\n数据点的值，与 *dates* 中的元素一一对应\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ncurveName\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n曲线名称\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ncurrency\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n货币，可选值为\"CNY\", \"USD\", \"EUR\", \"GBP\", \"JPY\", \"HKD\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ncompounding\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n复利类型，可选值为：\n\n* \"Simple\"：单利\n\n* \"Compounded\"：离散复利\n\n* \"Continuous\"：连续复利\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nsettlement\n\n</td><td>\n\nDATE\n\n</td><td>\n\n结算日，如果指定了结算日，则后续期限间隔的计算都将从 *settlement* 开始，而不是 *referenceDate*\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\nfrequency\n\n</td><td>\n\nINTEGRAL或 STRING\n\n</td><td>\n\n计息频率，可选值为：\n\n* -1 或 \"NoFrequency\"：无效计息频率\n\n* 0 或 \"Once\"：到期一次还本付息\n\n* 1 或 \"Annual\"：每年付息一次\n\n* 2 或 \"Semiannual\"：每半年付息一次\n\n* 3 或 \"EveryFourthMonth\"：每四个月付息一次\n\n* 4 或 \"Quarterly\"：每季度付息一次\n\n* 6 或 \"BiMonthly\"：每两月付息一次\n\n* 12 或 \"Monthly\"：每月付息一次\n\n* 13 或 \"EveryFourthWeek\"：每四周付息一次\n\n* 26 或 \"BiWeekly\"：每两周付息一次\n\n* 52 或 \"Weekly\"：每周付息一次\n\n* 365 或 \"Daily\"：每日付息一次\n\n* 999 或 \"Other\"：其他计息频率\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ncurveModel\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n曲线构建模型，目前仅支持 \"Bootstrap\"。\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ncurveParams\n\n</td><td>\n\nDICT\n\n</td><td>\n\n模型的参数。\n\n</td><td>\n\n否\n\n</td></tr></tbody>\n</table>\n"
    },
    "fy5253": {
        "url": "https://docs.dolphindb.cn/zh/funcs/f/fy5253.html",
        "signatures": [
            {
                "full": "fy5253(X, [weekday=0], [startingMonth=1], [nearest=true], [offset], [n=1])",
                "name": "fy5253",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[weekday=0]",
                        "name": "weekday",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[startingMonth=1]",
                        "name": "startingMonth",
                        "optional": true,
                        "default": "1"
                    },
                    {
                        "full": "[nearest=true]",
                        "name": "nearest",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[offset]",
                        "name": "offset",
                        "optional": true
                    },
                    {
                        "full": "[n=1]",
                        "name": "n",
                        "optional": true,
                        "default": "1"
                    }
                ]
            }
        ],
        "markdown": "### [fy5253](https://docs.dolphindb.cn/zh/funcs/f/fy5253.html)\n\n\n\n#### 语法\n\nfy5253(X, \\[weekday=0], \\[startingMonth=1], \\[nearest=true], \\[offset], \\[n=1])\n\n#### 详情\n\n采用52-53周财年（4-4-5历），该函数返回X所在财政年度的起始日期。\n\n* 如果 *nearest*=true，表示将最接近 *startingMonth* 最后一天的 *weekday* 的日期作为财政年度的起始日期。\n\n* 如果 *nearest*=false，表示将 *startingMonth* 中最后一个 *weekday* 的日期作为财政年度的起始日期。\n\n如果指定了 *offset*，表示从 *offset* 开始，结果每隔 *n* 年更新一次。注意，只有当 *n*>1 时，*offset* 才会生效。\n\nDolphinDB 和 pandas 在概念层面上都提供了类似日期偏移的功能，计算规则对比参见 [与 Date Offset 相关的函数](https://docs.dolphindb.cn/zh/progr/data_mani/temp_obj_mani.md#section_cwb_1p5_h1c)。\n\n#### 参数\n\n**X** 可以是 DATE, DATETIME, TIMESTAMP 或 NANOTIMESTAMP 类型的标量或向量。\n\n**weekday** 是0到6之间的整数，表示星期编号。0表示星期一，1表示星期二，... ，6表示星期日。默认值为0。\n\n**startingMonth** 是1到12之间的整数，表示一年的起始月份。默认值是1。\n\n**nearest** 是一个布尔值。默认值为 true。\n\n**offset** 是与 *X* 类型相同的标量，并且它必须小于等于X中的最小值。它是一个可选参数。如果没有指定，*offset* 默认为 *X* 中的最小值。\n\n**n** 是一个正整数。它是一个可选参数，默认值为1。\n\n#### 返回值\n\nDATE 类型标量或向量。\n\n#### 例子\n\n```\nfy5253(2016.11.01,0,1,true);\n// output\n2016.02.01\n// 最接近2016.01.31的周一是2016.02.01\n\nfy5253(2016.11.01,0,1,false);\n// output\n2016.01.25\n// 2016年1月中最后一个周一是2016.01.25\n\ndate=2011.10.25 2012.10.25 2013.10.25 2014.10.25 2015.10.25 2016.10.25 2017.10.25 2018.10.25 2019.10.25 2020.10.25\ntime = [09:34:07,09:36:42,09:36:51,09:36:59,09:32:47,09:35:26,09:34:16,09:34:26,09:38:12,09:38:13]\nsym = take(`MSFT,10)\nprice= 49.6 29.46 29.52 30.02 174.97 175.23 50.76 50.32 51.29 52.38\nqty = 2200 1900 2100 3200 6800 5400 1300 2500 8800 4500\nt1 = table(date, time, sym, qty, price);\n\nselect avg(price),sum(qty) from t1 group by fy5253(date,0,1,true,2011.10.01,2);\n```\n\n| fy5253\\_date | avg\\_price | sum\\_qty |\n| ------------ | ---------- | -------- |\n| 2011.01.31   | 39.53      | 4100     |\n| 2013.01.28   | 29.77      | 5300     |\n| 2015.02.02   | 175.1      | 12200    |\n| 2017.01.30   | 50.54      | 3800     |\n| 2019.01.28   | 51.835     | 13300    |\n\n相关函数：[fy5253Quarter](https://docs.dolphindb.cn/zh/funcs/f/fy5253Quarter.html)\n"
    },
    "fy5253Quarter": {
        "url": "https://docs.dolphindb.cn/zh/funcs/f/fy5253Quarter.html",
        "signatures": [
            {
                "full": "fy5253Quarter(X, [weekday=0], [startingMonth=1], [qtrWithExtraWeek=1], [nearest=true], [offset], [n=1])",
                "name": "fy5253Quarter",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[weekday=0]",
                        "name": "weekday",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[startingMonth=1]",
                        "name": "startingMonth",
                        "optional": true,
                        "default": "1"
                    },
                    {
                        "full": "[qtrWithExtraWeek=1]",
                        "name": "qtrWithExtraWeek",
                        "optional": true,
                        "default": "1"
                    },
                    {
                        "full": "[nearest=true]",
                        "name": "nearest",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[offset]",
                        "name": "offset",
                        "optional": true
                    },
                    {
                        "full": "[n=1]",
                        "name": "n",
                        "optional": true,
                        "default": "1"
                    }
                ]
            }
        ],
        "markdown": "### [fy5253Quarter](https://docs.dolphindb.cn/zh/funcs/f/fy5253Quarter.html)\n\n\n\n#### 语法\n\nfy5253Quarter(X, \\[weekday=0], \\[startingMonth=1], \\[qtrWithExtraWeek=1], \\[nearest=true], \\[offset], \\[n=1])\n\n#### 详情\n\n采用52-53周财年（4-4-5历），该函数返回X所在财政季度的起始日期。\n\n* 如果 *nearest*=true，表示将最接近 *startingMonth* 最后一天的 *weekday* 的日期作为财政年度的起始日期。\n\n* 如果 *nearest*=false，表示将 *startingMonth* 中最后一个 *weekday* 的日期作为财政年度的起始日期。\n\n如果指定了 *offset*，表示从 *offset* 开始，结果每隔 *n* 个季度更新一次。注意，只有当 *n*>1 时，*offset* 才会生效。\n\nDolphinDB 和 pandas 在概念层面上都提供了类似日期偏移的功能，计算规则对比参见 [与 Date Offset 相关的函数](https://docs.dolphindb.cn/zh/progr/data_mani/temp_obj_mani.md#section_cwb_1p5_h1c)。\n\n#### 参数\n\n**X** 可以是 DATE, DATETIME, TIMESTAMP 或 NANOTIMESTAMP 类型的标量或向量。\n\n**weekday** 是0到6之间的整数，表示星期编号。0表示星期一，1表示星期二，... ，6表示星期日。默认值为0。\n\n**startingMonth** 是1到12之间的整数，表示一年的起始月份。默认值是1。\n\n**qtrWithExtraWeek** 是1到4之间的整数。如果有闰季（一般一个季度有13周，闰季有14周），它表示闰季所在的季度。\n\n**nearest** 是一个布尔值。默认值为 true。\n\n**offset** 是与 *X* 类型相同的标量，并且它必须小于等于 *X* 中的最小值。它是一个可选参数。如果没有指定，*offset* 默认为 *X* 中的最小值。\n\n**n** 是一个正整数。它是一个可选参数，默认值为1。\n\n#### 返回值\n\nDATE 类型标量或向量。\n\n#### 例子\n\n```\nfy5253Quarter(2019.12.01,0,1,1,true);\n// output\n2019.11.04\n\nfy5253Quarter(2019.12.01,0,1,4,true);\n// output\n2019.10.28\n// 2019年的财年起始日期是2019.01.28，2020年的财年起始日期是2020.02.03，两者相差53周，说明有一个闰季。qtrWithExtraWeek=1表示第一个季度为闰季，它包含14周，因此2019.12.01所在季度的起始日期为2019.11.01；qtrWithExtraWeek=4表示第4个季度为闰季，它包含14周，因此2019.12.01所在季度的起始日期是2019.10.28。\n\ndate=2016.01.12 2016.02.25 2016.05.12 2016.06.28 2016.07.10 2016.08.18 2016.09.02 2016.10.16 2016.11.26 2016.12.30\ntime = [09:34:07,09:36:42,09:36:51,09:36:59,09:32:47,09:35:26,09:34:16,09:34:26,09:38:12,09:38:13]\nsym = take(`MSFT,10)\nprice= 49.6 29.46 29.52 30.02 174.97 175.23 50.76 50.32 51.29 52.38\nqty = 2200 1900 2100 3200 6800 5400 1300 2500 8800 4500\nt1 = table(date, time, sym, qty, price);\n\nselect avg(price),sum(qty) from t1 group by fy5253Quarter(date,0,1,1,true,2016.01.01,2);\n```\n\n| fy5253Quarter\\_date | avg\\_price | sum\\_qty |\n| ------------------- | ---------- | -------- |\n| 2015.11.02          | 39.53      | 4100     |\n| 2016.05.02          | 85.136667  | 21300    |\n| 2016.10.31          | 51.835     | 13300    |\n\n相关函数：[fy5253](https://docs.dolphindb.cn/zh/funcs/f/fy5253.html)\n"
    },
    "eig": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/eig.html",
        "signatures": [
            {
                "full": "eig(A)",
                "name": "eig",
                "parameters": [
                    {
                        "full": "A",
                        "name": "A"
                    }
                ]
            }
        ],
        "markdown": "### [eig](https://docs.dolphindb.cn/zh/funcs/e/eig.html)\n\n\n\n#### 语法\n\neig(A)\n\n#### 详情\n\n计算矩阵的特征值与特征向量。\n\n**Note:**\n\n* DolphinDB `eig` 与 [numpy.linalg.eigh](https://numpy.org/doc/stable/reference/generated/numpy.linalg.eigh.html) 功能相同。\n* [numpy.linalg.eig](https://numpy.org/doc/stable/reference/generated/numpy.linalg.eig.html) 和 [scipy.linalg.eig](https://docs.scipy.org/doc/scipy/reference/generated/scipy.linalg.eig.html) 是通用的特征分解函数，其适用范围更广，并非专门针对实对称矩阵或 Hermitian 矩阵设计。\n\n#### 参数\n\n**A** 是一个实对称矩阵或 Hermitian（共轭对称）矩阵。\n\n#### 返回值\n\n返回一个字典，为矩阵 *A* 的特征值（values）与特征向量（vectors）。\n\n#### 例子\n\n```\nA = 1 1 2 7 9 3 5 7 0 $ 3:3;\neig(A);\n// output\nvectors->\n#0        #1       #2\n--------- -------- ---------\n0.839752  0.169451 -0.515852\n-0.301349 0.935753 -0.18318\n0.45167   0.309277 0.836864\n\nvalues->[1.716868,10.17262,-1.889488]\n```\n\n对应第一个特征值 1.716868 的特征向量为：\n\n```\neig(A).vectors[0];\n// output\n[0.839752,-0.301349,0.45167]\n```\n\n使用 `numpy.linalg.eigh` 函数计算同一个矩阵的特征值与特征向量。返回的特征值顺序可能与 DolphinDB `eig` 不同，特征向量符号也可能相反，但在数学意义上等价。\n\n```\nimport numpy as np\n\nA = np.array([[1., 7., 5.],\n              [1., 9., 7.],\n              [2., 3., 0.]])\n\nw, v = np.linalg.eigh(A)\n\nprint(\"values:\")\nprint(w)\n\nprint(\"vectors:\")\nprint(v)\n\n\"\"\" 输出：\nvalues:\n[-1.88948817  1.71686814 10.17262003]\nvectors:\n[[-0.51585193  0.83975187 -0.16945081]\n [-0.18318039 -0.30134864 -0.93575314]\n [ 0.83686422  0.45167    -0.30927736]]\n\"\"\"\n```\n"
    },
    "elasticNet": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/elasticNet.html",
        "signatures": [
            {
                "full": "elasticNet(ds, yColName, xColNames, [alpha=1.0], [l1Ratio=0.5], [intercept=true], [normalize=false], [maxIter=1000], [tolerance=0.0001], [positive=false], [swColName], [checkInput=true])",
                "name": "elasticNet",
                "parameters": [
                    {
                        "full": "ds",
                        "name": "ds"
                    },
                    {
                        "full": "yColName",
                        "name": "yColName"
                    },
                    {
                        "full": "xColNames",
                        "name": "xColNames"
                    },
                    {
                        "full": "[alpha=1.0]",
                        "name": "alpha",
                        "optional": true,
                        "default": "1.0"
                    },
                    {
                        "full": "[l1Ratio=0.5]",
                        "name": "l1Ratio",
                        "optional": true,
                        "default": "0.5"
                    },
                    {
                        "full": "[intercept=true]",
                        "name": "intercept",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[normalize=false]",
                        "name": "normalize",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[maxIter=1000]",
                        "name": "maxIter",
                        "optional": true,
                        "default": "1000"
                    },
                    {
                        "full": "[tolerance=0.0001]",
                        "name": "tolerance",
                        "optional": true,
                        "default": "0.0001"
                    },
                    {
                        "full": "[positive=false]",
                        "name": "positive",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[swColName]",
                        "name": "swColName",
                        "optional": true
                    },
                    {
                        "full": "[checkInput=true]",
                        "name": "checkInput",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [elasticNet](https://docs.dolphindb.cn/zh/funcs/e/elasticNet.html)\n\n\n\n#### 语法\n\nelasticNet(ds, yColName, xColNames, \\[alpha=1.0], \\[l1Ratio=0.5], \\[intercept=true], \\[normalize=false], \\[maxIter=1000], \\[tolerance=0.0001], \\[positive=false], \\[swColName], \\[checkInput=true])\n\n#### 详情\n\n进行弹性网络回归（ElasticNet 回归）计算。即最小化以下目标函数：\n\n![](https://docs.dolphindb.cn/zh/images/elasticnet.png)\n\n#### 参数\n\n**ds** 是内存表或通常用 [sqlDS](https://docs.dolphindb.cn/zh/funcs/s/sqlDS.html) 函数生成的数据源。\n\n**yColName** 是字符串，表示数据源中因变量的列名。\n\n**xColNames** 是字符串标量或向量，表示数据源中自变量的列名。\n\n**alpha** 是浮点数，表示乘以 L1 范数惩罚项的系数。默认值是1.0。\n\n**l1Ratio** 是0与1之间的浮点数，表示 L1 范数惩罚项所占比例。若 *l1Ratio*=0，只有 L2 范数惩罚项。若 *l1Ratio*=1，只有 L1 范数惩罚项。默认值为0.5。\n\n**intercept** 是布尔值，表示是否回归模型包含截距。默认值为true。\n\n**normalize** 是布尔值。默认值为 false。若设为 true，则所有自变量均会进行如下标准化：减去平均值，然后除以 L2 范数。若 intercept 为 false，该参数会被忽略。\n\n**maxIter** 是正整数，表示最大迭代次数。默认值是1000。\n\n**tolerance** 是浮点数，表示迭代中止的边界差值。默认值是0.0001。\n\n**positive** 是布尔值，表示是否强制系数为正数。默认值是 false。\n\n**swColName** 字符串，表示列名，必须为 ds 中存在的列名。如果未指定该参数，则所有样本的权重都默认为1；如果指定该参数，则将指定的列作为样本的权重。\n\n**checkInput** 布尔值，表示是否检查输入参数（*yColName*, *xColNames* 和 *swColName*）的合法性。\n\n* 若 *checkInput*=true（默认值），则会检查这些参数中是否存在无效值（NULL），若存在，则会报错；\n\n* 若 *checkInput*=false，则不检查无效值。\n\n**Important:** 强烈建议开启 *checkInput*，以检查输入参数的有效性。如果不开启 *checkInput*，则必须确保输入参数中不存在无效值，并且中间计算过程中不会产生无效值，否则可能得到一个无用的模型。\n\n#### 返回值\n\n返回一个字典，表示ElasticNet 回归模型的分析结果，包含以下 key：\n\n* modelName：模型名称。ElasticNet 方法对应的模型名为 \"elasticNet\"。\n* coefficients：模型的回归系数。\n* intercept：截距。\n* dual\\_gap：表示优化结束时的对偶间隙。\n* tolerance：迭代中止的边界差值。\n* iterations：迭代次数\n* xColNames：数据源中自变量的列名。\n* predict：用于预测的函数。\n\n#### 例子\n\n```\ny = [225.720746,-76.195841,63.089878,139.44561,-65.548346,2.037451,22.403987,-0.678415,37.884102,37.308288]\nx0 = [2.240893,-0.854096,0.400157,1.454274,-0.977278,-0.205158,0.121675,-0.151357,0.333674,0.410599]\nx1 = [0.978738,0.313068,1.764052,0.144044,1.867558,1.494079,0.761038,0.950088,0.443863,-0.103219]\nt = table(y, x0, x1)\nelasticNet(t, `y, `x0`x1);\n```\n\n如果 t 是一个 DFS 表，则应使用数据源作为输入：\n\n```\nelasticNet(sqlDS(<select * from t>), `y, `x0`x1);\n```\n"
    },
    "elasticNetBasic": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/elasticNetBasic.html",
        "signatures": [
            {
                "full": "elasticNetBasic(Y, X, [mode=0], [alpha=1.0], [l1Ratio=0.5], [intercept=true], [normalize=false], [maxIter=1000], [tolerance=0.0001], [positive=false], [swColName], [checkInput=true])",
                "name": "elasticNetBasic",
                "parameters": [
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[mode=0]",
                        "name": "mode",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[alpha=1.0]",
                        "name": "alpha",
                        "optional": true,
                        "default": "1.0"
                    },
                    {
                        "full": "[l1Ratio=0.5]",
                        "name": "l1Ratio",
                        "optional": true,
                        "default": "0.5"
                    },
                    {
                        "full": "[intercept=true]",
                        "name": "intercept",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[normalize=false]",
                        "name": "normalize",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[maxIter=1000]",
                        "name": "maxIter",
                        "optional": true,
                        "default": "1000"
                    },
                    {
                        "full": "[tolerance=0.0001]",
                        "name": "tolerance",
                        "optional": true,
                        "default": "0.0001"
                    },
                    {
                        "full": "[positive=false]",
                        "name": "positive",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[swColName]",
                        "name": "swColName",
                        "optional": true
                    },
                    {
                        "full": "[checkInput=true]",
                        "name": "checkInput",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [elasticNetBasic](https://docs.dolphindb.cn/zh/funcs/e/elasticNetBasic.html)\n\n\n\n#### 语法\n\nelasticNetBasic(Y, X, \\[mode=0], \\[alpha=1.0], \\[l1Ratio=0.5], \\[intercept=true], \\[normalize=false], \\[maxIter=1000], \\[tolerance=0.0001], \\[positive=false], \\[swColName], \\[checkInput=true])\n\n#### 详情\n\n进行弹性网络回归（ElasticNet 回归）计算。即最小化以下目标函数：\n\n![](https://docs.dolphindb.cn/zh/images/elasticnet.png)\n\n#### 参数\n\n`Y` 数值类型的向量，表示因变量。\n\n`X` 数值类型的向量/元组/矩阵/表，表示自变量。\n\n* 当 *X* 是向量/元组时，其长度必须等于 Y 的长度。\n\n* 当 *X* 是矩阵/表时，其行数必须等于 Y 的长度。\n\n`mode` 一个整数，可取以下 3 个值\n\n* 0（默认值）: 输出一个系数估计向量\n\n* 1: 输出一个具有系数估计，标准差，t 统计量和 p 值的表\n\n* 2: 输出一个具有 ANOVA(方差分析)、RegressionStat(回归统计)、Cofficient(系数) 和 Residual(残差) 的字典，具体含义见下表：\n\n键 ANOVA 对应值：\n\n| Source of Variance | 自由度(Degree of freedom) | 平方和(Sum of Square) | 均方差(Mean of square) | F统计量       | Significance |\n| ------------------ | ---------------------- | ------------------ | ------------------- | ---------- | ------------ |\n| Regression(回归)     | 变量个数(p)                | 回归平方和(SSR)         | 回归均方差(MSR=SSR/R)    | MSR对MSE的比值 | 显著性，即统计出的P值  |\n| Residual(残差)       | 残差自由度(n-p-1)           | 残差平方和(SSE)         | 残差均方差(MSE=MSE/E)    |            |              |\n| Total              | 样本自由度， 不包括常数项(n-1)     | 总离差平方和(SST)        |                     |            |              |\n\n键 RegressionStat 对应值：\n\n| item         | 统计值                                                             |\n| ------------ | --------------------------------------------------------------- |\n| R2           | R决定系数，描述回归曲线对真实数据点拟合程度的统计量。范围在 \\[0,1]之间，越接近1 ，说明对y的解释能力越强，拟合越好。 |\n| AdjustedR2   | 经自由度修正后的决定系数，通过样本数量与模型数量对 R-squared 进行修正。                       |\n| StdError     | 回归残差标准误差，残差经自由度修正后的标准差。                                         |\n| Observations | 观察样本个数。                                                         |\n\n键 Coefficient 对应值：\n\n| 元素       | 说明               |\n| -------- | ---------------- |\n| factor   | 自变量名称            |\n| beta     | 回归系数估计值          |\n| stdError | 回归系数标准误差。        |\n| tstat    | T统计值，衡量系数的统计显著性。 |\n\n键 Residual 对应每一个预测值和实际值之间的残差。\n\n`alpha` 一个浮点数，表示乘以L1范数惩罚项的系数。默认值是1.0。\n\n`l1Ratio` 0与1之间的浮点数，表示L1范数惩罚项所占比例。若 l1Ratio=0，只有L2范数惩罚项。若 l1Ratio=1，只有L1范数惩罚项。默认值为0.5。\n\n`intercept` 布尔值，表示是否包含回归中的截距。默认值为 true，此时系统自动给 *X* 添加一列 “1” 以生成截距。\n\n`normalize` 布尔值，默认值为 false。若设为 true，则所有自变量均会进行如下标准化：减去平均值，然后除以L2范数。若 intercept 为 false，该参数会被忽略。\n\n`maxIter` 一个正整数，表示最大迭代次数。默认值是1000。\n\n`tolerance` 一个浮点数，表示迭代中止的边界差值。默认值是0.0001。\n\n`positive` 布尔值，表示是否强制系数为正数。默认值是 false。\n\n`swColName` 字符串，表示列名，必须为 X 中存在的列名。如果未指定该参数，则所有样本的权重都默认为1；如果指定该参数，则将指定的列作为自变量的权重。\n\n`checkInput` 布尔值，表示是否检查输入参数（yColName, xColNames 和 swColName）的合法性。\n\n* 若 checkInput=true（默认值），则会检查这些参数中是否存在无效值（NULL），若存在，则会报错；\n\n* 若 checkInput=false，则不检查无效值。\n\n**Important:** 强烈建议开启 checkInput，以检查输入参数的有效性。如果不开启 checkInput，则必须确保输入参数中不存在无效值，并且中间计算过程中不会产生无效值，否则可能得到一个无用的模型。\n\n#### 返回值\n\n取决于 *[mode](https://docs.dolphindb.cn/zh/funcs/e/elasticNetBasic.html#mode)* 参数。\n\n#### 例子\n\n```\ny = [225.720746,-76.195841,63.089878,139.44561,-65.548346,2.037451,22.403987,-0.678415,37.884102,37.308288]\nx0 = [2.240893,-0.854096,0.400157,1.454274,-0.977278,-0.205158,0.121675,-0.151357,0.333674,0.410599]\nx1 = [0.978738,0.313068,1.764052,0.144044,1.867558,1.494079,0.761038,0.950088,0.443863,-0.103219]\n\n// mode 为 0 （默认）时，返回向量\nelasticNetBasic(y, [x0,x1])\n// Output: [22.577707498321878,57.579636500541489,0]\n\n// mode 为 1 时，返回一个表\nelasticNetBasic(y, [x0,x1], mode=1)\n// Output:\nfactor    beta               stdError           tstat             pvalue           \n--------- ------------------ ------------------ ----------------- -----------------\nintercept 22.577707498321878 22.386965663128339 1.008520218329887 0.346787434490777\nx0        57.579636500541489 13.942071237979131 4.129919831688331 0.00440442978694 \nx1        0                  19.967090598379201 0                 1\n\n// mode 为 2 时，返回一个字典\nelasticNetBasic(y, [x0,x1], mode=2)\n// Output:\nCoefficient->\nfactor    beta               stdError           tstat             pvalue           \n--------- ------------------ ------------------ ----------------- -----------------\nintercept 22.577707498321878 22.386965663128339 1.008520218329887 0.346787434490777\nx0        57.579636500541489 13.942071237979131 4.129919831688331 0.00440442978694 \nx1        0                  19.967090598379201 0                 1                \n\nRegressionStat->\nitem         statistics        \n------------ ------------------\nR2           0.389552377491606 \nAdjustedR2   0.215138771060637 \nStdError     39.286356679948966\nObservations 10                \n\nANOVA->\nBreakdown  DF SS                    MS                    F                 Significance     \n---------- -- --------------------- --------------------- ----------------- -----------------\nRegression 2  28418.938722454950038 14209.469361227475019 9.206495588035528 0.010968516432523\nResidual   7  10803.924748289195122 1543.417821184170634                                     \nTotal      9  72952.805231094462214                                                          \n\nResidual->[74.113234125070192,-49.595011281755397,17.47127589853094,33.131334209489637,-31.854741498345688,-8.727333433143787,-7.179722769525263,-14.54104145650942,-3.906433128003563,-8.911560665807712]\n```\n"
    },
    "elasticNetCV": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/elasticNetCV.html",
        "signatures": [
            {
                "full": "elasticNetCV(ds, yColName, xColNames, [alpha=[0.01,0.1,1.0]], [l1Ratio=0.5], [intercept=true], [normalize=false], [maxIter=1000], [tolerance=0.0001], [positive=false])",
                "name": "elasticNetCV",
                "parameters": [
                    {
                        "full": "ds",
                        "name": "ds"
                    },
                    {
                        "full": "yColName",
                        "name": "yColName"
                    },
                    {
                        "full": "xColNames",
                        "name": "xColNames"
                    },
                    {
                        "full": "[alpha=[0.01",
                        "name": "[alpha=[0.01"
                    },
                    {
                        "full": "0.1",
                        "name": "0.1"
                    },
                    {
                        "full": "1.0]]",
                        "name": "1.0]]"
                    },
                    {
                        "full": "[l1Ratio=0.5]",
                        "name": "l1Ratio",
                        "optional": true,
                        "default": "0.5"
                    },
                    {
                        "full": "[intercept=true]",
                        "name": "intercept",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[normalize=false]",
                        "name": "normalize",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[maxIter=1000]",
                        "name": "maxIter",
                        "optional": true,
                        "default": "1000"
                    },
                    {
                        "full": "[tolerance=0.0001]",
                        "name": "tolerance",
                        "optional": true,
                        "default": "0.0001"
                    },
                    {
                        "full": "[positive=false]",
                        "name": "positive",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [elasticNetCV](https://docs.dolphindb.cn/zh/funcs/e/elasticNetCV.html)\n\n#### 语法\n\nelasticNetCV(ds, yColName, xColNames, \\[alpha=\\[0.01,0.1,1.0]], \\[l1Ratio=0.5], \\[intercept=true], \\[normalize=false], \\[maxIter=1000], \\[tolerance=0.0001], \\[positive=false])\n\n#### 详情\n\n使用五折交叉验证方法进行弹性网络回归（ElasticNet），输出最优参数对应的模型。\n\n#### 参数\n\n**alpha** 是浮点型标量或向量，表示乘以L1范数惩罚项的系数。默认值是 \\[0.01, 0.1, 1.0]。\n\n**Note:** 除 *alphas* 参数外，其它参数都和 [elasticNet](https://docs.dolphindb.cn/zh/funcs/e/elasticNet.html) 的参数相同，参数描述可参考 [elasticNet](https://docs.dolphindb.cn/zh/funcs/e/elasticNet.html)。这里仅说明 *alphas* 参数。\n\n#### 返回值\n\n返回一个字典，包含以下 key：\n\n* modelName：模型名称。elasticNetCV 方法对应的模型名为 \"elasticNetCV\"。\n* coefficients：模型的回归系数。\n* intercept：截距。\n* dual\\_gap：表示优化结束时的对偶间隙。\n* tolerance：迭代中止的边界差值。\n* iterations：迭代次数\n* xColNames：数据源中自变量的列名。\n* predict：用于预测的函数。\n* alpha：交叉验证选择的惩罚量。\n\n#### 例子\n\n```\ny = [225.720746,-76.195841,63.089878,139.44561,-65.548346,2.037451,22.403987,-0.678415,37.884102,37.308288]\nx0 = [2.240893,-0.854096,0.400157,1.454274,-0.977278,-0.205158,0.121675,-0.151357,0.333674,0.410599]\nx1 = [0.978738,0.313068,1.764052,0.144044,1.867558,1.494079,0.761038,0.950088,0.443863,-0.103219]\nt = table(y, x0, x1);\n\nelasticNetCV(t, `y, `x0`x1);\n```\n\n返回如下：\n\n```\ndual_gap->0.0037\nmodelName->elasticNetCV\nintercept->0.5416\nalpha->0.0100\ncoefficients->[93.8331,13.9105]\npredict->coordinateDescentPredict\nxColNames->[x0,x1]\ntolerance->0.0001\niterations->5\n```\n\n"
    },
    "ema": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/ema.html",
        "signatures": [
            {
                "full": "ema(X, window, warmup=false)",
                "name": "ema",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "warmup=false",
                        "name": "warmup=false"
                    }
                ]
            }
        ],
        "markdown": "### [ema](https://docs.dolphindb.cn/zh/funcs/e/ema.html)\n\n\n\n#### 语法\n\nema(X, window, warmup=false)\n\nTA-lib 系列函数参数说明和窗口计算规则请参考：[TA-lib 系列](https://docs.dolphindb.cn/zh/funcs/themes/TAlib.html)\n\n#### 详情\n\n在给定长度（以元素个数衡量）的滑动窗口内，计算 *X* 的指数移动平均（Exponential Moving Average）。\n\n其计算公式如下，其中 EMAk 为第 k 个指数移动平均值，n 为移动窗口长度，Xk 为向量 X 中第 k 个元素。\n\n* *warmup*=false：\n\n  * 前 n-1 个值：直接返回空值（不计算）\n  * 第 n 个值（第一个 EMA）：\n  * 从第 n+1 个开始：\n\n    ![EMA\\_k](https://docs.dolphindb.cn/zh/images/ema_k.png)\n\n* *warmup*=true:\n\n  ![EMA\\_ktrue](https://docs.dolphindb.cn/zh/images/ema_ktrue.png)\n\n  其中，向量 X 的定义为：X=\\[Xk-n, …, Xk-1]\n\n#### 参数\n\n**warmup** 布尔值，默认为 false，即计算结果的前 *window*-1 个元素为空值。若为 true，则结果的前 *window*-1 元素将由详情给出的公式计算得出。\n\n#### 返回值\n\n返回 DOUBLE 类型，数据形式同 *X*。\n\n#### 例子\n\n```\nx=12.1 12.2 12.6 12.8 11.9 11.6 11.2\nema(x,3);\n// output: [,,12.3,12.55,12.225,11.9125,11.55625]\n\nema(x,3, warmup=true)\n// output: [12.1,12.2,12.4667,12.6333,12.2667,11.9333,11.5667]\n\nx=matrix(12.1 12.2 12.6 12.8 11.9 11.6 11.2, 14 15 18 19 21 12 10)\nema(x,3);\n```\n\n| #0       | #1        |\n| -------- | --------- |\n|          |           |\n|          |           |\n| 12.30    | 15.666667 |\n| 12.55    | 17.333333 |\n| 12.225   | 19.166667 |\n| 11.9125  | 15.583333 |\n| 11.55625 | 12.791667 |\n\n相关函数：[gema](https://docs.dolphindb.cn/zh/funcs/g/gema.html), [wilder](https://docs.dolphindb.cn/zh/funcs/w/wilder.html), [dema](https://docs.dolphindb.cn/zh/funcs/d/dema.html), [tema](https://docs.dolphindb.cn/zh/funcs/t/tema.html)\n"
    },
    "emitEvent": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/emitEvent.html",
        "signatures": [
            {
                "full": "emitEvent(event, [eventTimeField], [outputName])",
                "name": "emitEvent",
                "parameters": [
                    {
                        "full": "event",
                        "name": "event"
                    },
                    {
                        "full": "[eventTimeField]",
                        "name": "eventTimeField",
                        "optional": true
                    },
                    {
                        "full": "[outputName]",
                        "name": "outputName",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [emitEvent](https://docs.dolphindb.cn/zh/funcs/e/emitEvent.html)\n\n\n\n#### 语法\n\nemitEvent(event, \\[eventTimeField], \\[outputName])\n\n#### 详情\n\n`emitEvent` 是 CEP monitor 内部的事件控制接口，用于将事件插入到 CEP 引擎的事件输出队列的队尾。当 CEP 引擎指定了多个事件流序列化器时，`emitEvent` 必须通过参数 *outputName* 指定目标序列化器（`StreamEventSerializer`）的名称，CEP 引擎据此进行匹配，并将事件输出到对应的一个或多个流表中。\n\n#### 参数\n\n**event** 事件实例。\n\n**eventTimeField** 字符串标量，表示事件中的时间字段名。若要指定此参数，*event* 必须包含时间字段。当 *useSystemTime*=true 时，输出事件中的时间为系统时间；否则，输出最新事件时间。\n\n**outputName** 可选，字符串标量，指定事件流序列化器的名称。\n\n* 若 CEP 引擎中仅指定了一个输出表，则无需指定该参数。\n* 若 CEP 引擎指定了多个输出表，必须指定 *outputName*，引擎将根据名称将事件输出至对应的序列化器。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n下例展示如何通过 *outputName* 参数，指定不同事件流序列化器，由 CEP 引擎进行匹配，并将事件输出到对应的流数据表中。\n\n```\nclass MarketData{\n    market :: STRING\n    code :: STRING\n    price :: DOUBLE\n    qty :: INT\n    def MarketData(m,c,p,q){\n        market = m\n        code = c\n        price = p\n        qty = q\n    }\n}\n\nclass Orders{\n    trader :: STRING\n    market :: STRING\n    code :: STRING\n    price :: DOUBLE\n    qty :: INT\n    def Orders(t, m,c,p,q){\n        trader = t\n        market = m\n        code = c\n        price = p\n        qty = q\n    }\n}\n\nclass Trades{\n    trader :: STRING\n    market :: STRING\n    code :: STRING\n    price :: DOUBLE\n    qty :: INT\n    def Trades(t, m,c,p,q){\n        trader = t\n        market = m\n        code = c\n        price = p\n        qty = q\n    }\n}\n\nshare streamTable(array(STRING, 0) as eventType, array(BLOB, 0) as blobs) as MarketDataChannel\nserializer1 = streamEventSerializer(name=`MarketDataChannel, eventSchema=[MarketData], outputTable=MarketDataChannel)\n\nshare streamTable(array(STRING, 0) as eventType, array(BLOB, 0) as blobs) as OrdersChannel\nserializer2 = streamEventSerializer(name=`OrdersChannel, eventSchema=[Orders], outputTable=OrdersChannel)\n\nshare streamTable(array(STRING, 0) as eventType, array(BLOB, 0) as blobs) as TradesChannel\nserializer3 = streamEventSerializer(name=`TradesChannel, eventSchema=[Trades], outputTable=TradesChannel)\n\nclass SimpleShareSearch:CEPMonitor {\n\t//构造函数\n\tdef SimpleShareSearch(){\n\t}\n    // 通过 emitEvent 指定事件流需要发送的序列化器的名称\n\tdef processMarketData(event){\n        emitEvent(event,,\"MarketDataChannel\")\n    }\n    def processOrders(event){\n        emitEvent(event,,\"OrdersChannel\")\n    }\n    def processTrades(event){\n        emitEvent(event,,\"TradesChannel\")\n    }\n\t// 创建 CEP 子引擎之后，系统会自动构造 SimpleShareSearch 类对象为 Monitor 实例并调用 onload 函数\n\tdef onload() {\n\t\t//监听StockTick事件\n\t\taddEventListener(handler=processMarketData, eventType=\"MarketData\", times=\"all\")\n\t\taddEventListener(handler=processOrders, eventType=\"Orders\", times=\"all\")\n\t\taddEventListener(handler=processTrades, eventType=\"Trades\", times=\"all\")\n\t}\n}\n\ndummy = table(array(STRING, 0) as eventType, array(BLOB, 0) as blobs)\n\n// 创建 CEP 引擎，指定3个事件流序列化器\nengine = createCEPEngine(name='cep1', monitors=<SimpleShareSearch()>, dummyTable=dummy, eventSchema=[MarketData,Orders,Trades], outputTable=[serializer1,serializer2,serializer3])\n\nm= MarketData(\"m\", \"c\", 10.0, 100)\n\nappendEvent(engine, m)\n\no = Orders(\"a\",\"m\", \"c\", 10.0, 100)\nt = Trades(\"a\",\"m\", \"c\", 10.0, 100)\n\nappendEvent(engine, o)\nappendEvent(engine, t)\n```\n\n**相关函数**：[addEventListener](https://docs.dolphindb.cn/zh/funcs/a/addEventListener.html), [createCEPEngine](https://docs.dolphindb.cn/zh/funcs/c/createCEPEngine.html), [appendEvent](https://docs.dolphindb.cn/zh/funcs/a/appendEvent.html), [routeEvent](https://docs.dolphindb.cn/zh/funcs/r/routeEvent.html), [sendEvent](https://docs.dolphindb.cn/zh/funcs/s/sendEvent.html)\n"
    },
    "enableActivePartition": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/enableActivePartition.html",
        "signatures": [
            {
                "full": "enableActivePartition(db, activeDate, siteAlias)",
                "name": "enableActivePartition",
                "parameters": [
                    {
                        "full": "db",
                        "name": "db"
                    },
                    {
                        "full": "activeDate",
                        "name": "activeDate"
                    },
                    {
                        "full": "siteAlias",
                        "name": "siteAlias"
                    }
                ]
            }
        ],
        "markdown": "### [enableActivePartition](https://docs.dolphindb.cn/zh/funcs/e/enableActivePartition.html)\n\n\n\n#### 语法\n\nenableActivePartition(db, activeDate, siteAlias)\n\n#### 详情\n\n创建活动数据库和历史数据库之间的连接。\n\n#### 参数\n\n**db** 是历史数据库的句柄。\n\n**activeDate** 是活动数据库的日期。\n\n**setAlias** 是活动数据库所在节点的别名。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\nhistdb = database(\"C:\\DolphinDBDemo\\example\\data\\dbspace\\historical-A\\Trades2ndDomain\")\nactiveNodeAlias = getNodeAlias()\nactiveDate = today()\nenableActivePartition(histdb, activeDate, activeNodeAlias);\n```\n"
    },
    "enableDynamicScriptOptimization": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/enabledynamicscriptoptimization.html",
        "signatures": [
            {
                "full": "enableDynamicScriptOptimization()",
                "name": "enableDynamicScriptOptimization",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [enableDynamicScriptOptimization](https://docs.dolphindb.cn/zh/funcs/e/enabledynamicscriptoptimization.html)\n\n\n\n#### 语法\n\nenableDynamicScriptOptimization()\n\n#### 详情\n\n开启脚本引擎优化。\n\n此命令须在控制节点由管理员执行。\n\n此命令的影响将在系统重启后失效。若要永久生效，请在配置文件（集群模式为 controller.cfg，单节点模式为 dolphindb.cfg）中修改配置参数 *enableDynamicScriptOptimization* 。\n\n#### 参数\n\n无。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\nenableDynamicScriptOptimization()\n```\n\n**相关函数：** [disableDynamicScriptOptimization](https://docs.dolphindb.cn/zh/funcs/d/disabledynamicscriptoptimization.html)\n"
    },
    "enableQueryMonitor": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/enableQueryMonitor.html",
        "signatures": [
            {
                "full": "enableQueryMonitor()",
                "name": "enableQueryMonitor",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [enableQueryMonitor](https://docs.dolphindb.cn/zh/funcs/e/enableQueryMonitor.html)\n\n\n\n#### 语法\n\nenableQueryMonitor()\n\n#### 详情\n\n启用监控查询任务状态的功能。系统默认会开启该功能。\n\n#### 参数\n\n无\n\n#### 返回值\n\n无。\n\n相关函数： [disableQueryMonitor](https://docs.dolphindb.cn/zh/funcs/d/disableQueryMonitor.html)\n"
    },
    "enableResourceTracking": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/enableresourcetracking.html",
        "signatures": [
            {
                "full": "enableResourceTracking()",
                "name": "enableResourceTracking",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [enableResourceTracking](https://docs.dolphindb.cn/zh/funcs/e/enableresourcetracking.html)\n\n\n\n#### 语法\n\nenableResourceTracking()\n\n#### 详情\n\n在线开启资源跟踪。仅当 *resourceSamplingInterval* 设置为正整数时才能调用该函数。该函数仅限管理员在数据节点上调用。\n\n成功启动资源跟踪后，各个数据节点会根据 *resourceSamplingInterval* 设置的时间间隔获取以下资源：CPU、内存和数据使用量、查询分布式表的信息。\n\n* CPU、内存和数据使用量写入一个 CSV 日志文件，路径是 `<HomeDir>/resource/hardware.log`。日志记录了以下信息：\n\n  * timestamp：NANOTIMESTAMP 类型的时间戳。\n\n  * userId：登录用户名。\n\n  * cpu：当前用户占用的工作线程数量。\n\n  * memory：内存使用量，当前用户使用的所有变量的内存占用大小。单位是字节。\n\n  * send：单次采集间隔内发送的数据量。单位是字节。\n\n  * recv：单次采集间隔内接收的数据量。单位是字节。需要注意的是，统计的接收数据量可能会有一定误差，最大误差范围在 2KB 以内。\n\n* 查询分布式表的信息写入另一个 CSV 日志文件，路径是`<HomeDir>/resource/access.log`。目前仅支持 SQL SELECT 语句，并且在跟踪过程中不会记录非标准 SQL-92 嵌套表连接中的表信息，例如在 ej(ej(t1, t2, \\`id), t3, \\`id) 查询中，t1 和 t2 的信息将不会被记录。日志记录了以下内容：\n\n  * timestamp：NANOTIMESTAMP 类型的时间戳。如果 type 是 sql，则这里记录开始执行 SQL 的时间戳；如果 type 是 rowCount 或 memUsage，则这里记录的是读出数据的时间戳。\n\n  * rootQueryId：SQL 查询任务的 ID，是分布式 SQL 查询任务的唯一标识符。一个分布式查询会按分区拆分为多个 SQL 子查询。该 ID 为分布式查询及其拆分出的子查询的根 ID。\n\n  * userId：用户名。\n\n  * database：数据库名。\n\n  * table：表名。\n\n  * type：记录的信息类型，包括3类：sql, rowCount, memUsage。\n\n  * value：\n\n    * 当类型为 sql 时，为 SQL 查询任务的执行次数。该值总是为1。\n\n    * 当类型为 rowCount 时，为读出的行数。\n\n    * 当类型为 memUsage 时，为读出的表的数据量。单位是字节。\n\n    注意：这里只记录每次访问表的行数和数据量。例如维度表读入内存后，会记录每次访问该表的行数和数据量，而非第一次读入内存的数据量。\n\n  * script：当类型为 sql 时，记录 SQL 脚本，其他类型则为空字符串。\n\n为防止文件大小持续增长，DolphinDB 对这两个文件都采用日志滚动策略，一旦文件大小达到阈值就会生成滚动日志文件。文件名以时间戳作为前缀。例如20231101162302\\_access.log，表示 2023.11.01T16:23:02 拆分出来的滚动日志。\n\n系统会根据 *resourceSamplingLogRetentionTime* 的配置值自动清理资源跟踪日志。此自动清理机制不受资源跟踪功能的开启或关闭影响。\n\n#### 参数\n\n无。\n\n#### 返回值\n\n无。\n\n相关函数：[disableResourceTracking](https://docs.dolphindb.cn/zh/funcs/d/disableresourcetracking.html)\n"
    },
    "enableTableCachePurge": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/enabletablecachepurge.html",
        "signatures": [
            {
                "full": "enableTableCachePurge(table, [cacheSize],[cachePurgeTimeColumn],[cachePurgeInterval],[cacheRetentionTime])",
                "name": "enableTableCachePurge",
                "parameters": [
                    {
                        "full": "table",
                        "name": "table"
                    },
                    {
                        "full": "[cacheSize]",
                        "name": "cacheSize",
                        "optional": true
                    },
                    {
                        "full": "[cachePurgeTimeColumn]",
                        "name": "cachePurgeTimeColumn",
                        "optional": true
                    },
                    {
                        "full": "[cachePurgeInterval]",
                        "name": "cachePurgeInterval",
                        "optional": true
                    },
                    {
                        "full": "[cacheRetentionTime]",
                        "name": "cacheRetentionTime",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [enableTableCachePurge](https://docs.dolphindb.cn/zh/funcs/e/enabletablecachepurge.html)\n\n\n\n#### 语法\n\nenableTableCachePurge(table, \\[cacheSize],\\[cachePurgeTimeColumn],\\[cachePurgeInterval],\\[cacheRetentionTime])\n\n#### 详情\n\n为非持久化流表开启自动清理缓存。\n\n通过以下两种方式之一来清理内存中的数据：\n\n* 配置 *cacheSize* 参数时，如果插入的数据使内存中流数据表的行数达到阈值，系统将清理内存中较旧的已发布记录。阈值确定方法如下：\n\n  * 每次 append 的数据都不超过 *cacheSize* 时，阈值为 *cacheSize* 的 2.5 倍。\n\n  * 当 append 的数据超过 *cacheSize* 时，阈值为追加行数和 cacheSize 之和的 1.2 倍。\n\n* 同时配置*cachePurgeTimeColumn*, *cachePurgeInterval* 和 *cacheRetentionTime*，系统将根据时间列清理数据。每次插入新数据时，系统会计算新数据与内存中第一条数据的时间戳差值，当差值大于等于 *cachePurgeInterval*时，系统仅保留时间戳与新数据时间戳差值小于等于 *cacheRetentionTime*的数据，清理其它数据。\n\n#### 参数\n\n**table** 是一个空的流数据表。\n\n**cacheSize** 是一个正整数，可选参数，表示流数据表在内存中最多保留的记录数。\n\n**cachePurgeTimeColumn** 字符串标量，需要指定为非持久化流表中的时间列名称。\n\n**cachePurgeInterval** DURATION 类型标量，表示触发清理内存中数据的时间间隔。\n\n**cacheRetentionTime** DURATION 类型标量，表示内存中数据的最长保留期限。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n例1. 配置 cacheSize 参数，根据内存中的数据量进行清理。\n\n```\nt = streamTable(1000:0, `time`sym`volume, [DATETIME, SYMBOL, INT])\nenableTableCachePurge(table=t, cacheSize=1000)\ntime = datetime(2024.01.01T09:00:00) +1..1000*2\nsym=take(`a`b`c, 1000)\nvolume = rand(10,1000)\n\ninsert into t values([time, sym, volume])\ngetStreamTableCacheOffset(t)\n//0\n\ntime = datetime(2024.01.01T09:35:00) +1..1000*2\nsym=take(`a`b`c, 1000)\nvolume = rand(10,1000)\ninsert into t values([time, sym, volume])\ngetStreamTableCacheOffset(t)\n//500\n```\n\n例2. 配置*cachePurgeTimeColumn*, *cachePurgeInterval* 和 \\*cacheRetentionTime，\\*根据时间列清理数据。\n\n```\nt = streamTable(1000:0, `time`sym`volume, [DATETIME, SYMBOL, INT])\n\nenableTableCachePurge(table=t, cachePurgeTimeColumn=`time,\n cachePurgeInterval=30m, cacheRetentionTime=20m)\n\ntime = datetime(2024.01.01T09:00:00) +1..1000*2\nsym=take(`a`b`c, 1000)\nvolume = rand(10,1000)\n\ninsert into t values([time, sym, volume])\ngetStreamTableCacheOffset(t)\n//0\n\ntime = datetime(2024.01.01T09:35:00) +1..1000*2\nsym=take(`a`b`c, 1000)\nvolume = rand(10,1000)\ninsert into t values([time, sym, volume])\ngetStreamTableCacheOffset(t)\n//999\n```\n"
    },
    "enableTablePersistence": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/enableTablePersistence.html",
        "signatures": [
            {
                "full": "enableTablePersistence(table, [asynWrite=true], [compress=true], [cacheSize], [retentionMinutes=1440], [flushMode=0],[cachePurgeTimeColumn],[cachePurgeInterval],[cacheRetentionTime],[preCache])",
                "name": "enableTablePersistence",
                "parameters": [
                    {
                        "full": "table",
                        "name": "table"
                    },
                    {
                        "full": "[asynWrite=true]",
                        "name": "asynWrite",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[compress=true]",
                        "name": "compress",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[cacheSize]",
                        "name": "cacheSize",
                        "optional": true
                    },
                    {
                        "full": "[retentionMinutes=1440]",
                        "name": "retentionMinutes",
                        "optional": true,
                        "default": "1440"
                    },
                    {
                        "full": "[flushMode=0]",
                        "name": "flushMode",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[cachePurgeTimeColumn]",
                        "name": "cachePurgeTimeColumn",
                        "optional": true
                    },
                    {
                        "full": "[cachePurgeInterval]",
                        "name": "cachePurgeInterval",
                        "optional": true
                    },
                    {
                        "full": "[cacheRetentionTime]",
                        "name": "cacheRetentionTime",
                        "optional": true
                    },
                    {
                        "full": "[preCache]",
                        "name": "preCache",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [enableTablePersistence](https://docs.dolphindb.cn/zh/funcs/e/enableTablePersistence.html)\n\n\n\n#### 语法\n\nenableTablePersistence(table, \\[asynWrite=true], \\[compress=true], \\[cacheSize], \\[retentionMinutes=1440], \\[flushMode=0],\\[cachePurgeTimeColumn],\\[cachePurgeInterval],\\[cacheRetentionTime],\\[preCache])\n\n#### 详情\n\n该命令将共享的流计算表保存到磁盘上。\n\n为保证该命令能够正常执行，需要在配置文件中（单节点：`dolphindb.cfg`，集群：`cluster.cfg`）指定配置参数 *persistenceDir*，配置参考 [功能配置](https://docs.dolphindb.cn/zh/db_distr_comp/cfg/function_configuration.html)。流数据表在磁盘上的存储目录是 `<PERSISTENCE_DIR>/<TABLE_NAME>`。目录包含两种类型的文件：数据文件（名称类型 *data0.log, data1.log...*）和索引文件 *index.log* 。把这些数据保存到磁盘后，如果重启系统，该命令会把磁盘中的数据加载到内存中。\n\n参数 *asynWrite* 会告知系统是否以异步模式保存表。在异步模式中，追加的数据会被放进队列，之后用于保存的工作线程把数据写入磁盘。在同步模式中，表的追加数据操作直到追加数据被保存到磁盘中才完成。该参数的默认值是 true，即为异步模式。通常情况下，异步模式实现更高的吞吐量，但是如果服务器崩溃，可能会丢失最后追加的行。在异步模式中，保存表的工作是由单个工作线程完成，并且一个工作线程可能处理多个表。如果只保存一个表，增加工作线程的数量并不会提升性能。\n\n默认情况下，流数据表将所有数据保存在内存中。如果流数据表太大，系统可能会出现内存不足的情况。为了避免内存不足的问题，可以通过以下两种方式之一来清理内存中的数据：\n\n* 配置 *cacheSize* 参数时，如果插入的数据使内存中流数据表的行数达到 *cacheSize* 设置的阈值，系统将清理内存中较旧的已发布记录。阈值确定规则如下：\n\n  * 每次 append 的数据都不超过 *cacheSize* 时，内存中的记录数不会大于 *cacheSize* 的 2.5 倍。\n  * 否则，当 append 的数据超过 *cacheSize* 时，内存中的记录数不会超过追加行数和 *cacheSize* 之和的 1.2 倍。\n* 同时配置*cachePurgeTimeColumn*, *cachePurgeInterval* 和 *cacheRetentionTime*，系统将根据时间列清理数据。每次插入新数据时，系统会计算新数据与内存中第一条数据的时间戳差值，当差值大于等于 *cachePurgeInterval*时，系统仅保留时间戳与新数据时间戳差值小于等于 *cacheRetentionTime*的数据，清理其它数据。\n\n**Note:**\n\n* 如果设置 *flushMode*=0，则 server 发生 crash 时可能会丢失一部分数据。\n\n#### 参数\n\n**table** 是一个空的流数据表。\n\n**asynWrite** 是一个布尔值，表示是否异步持久化数据到磁盘。默认值为 true，流数据写入内存即为写入成功，持久化到磁盘的操作将会由另一个线程执行。\n\n**Note:**\n\n持久化数据到磁盘包含两个步骤：\n\n* 写内存数据到操作系统缓存\n\n* 写缓存数据到磁盘（是否开启同步刷盘由参数 *flushMode* 决定）\n\n**compress** 是一个布尔值。可选参数，表示是否以压缩模式模式保存至磁盘。默认值为 true。\n\n**cacheSize** 整数，可选参数，表示流数据表在内存中最多保留多少行。如果它为0或者没有指定，所有记录行都会保存在内存中。如果 *cacheSize* 设置为小于 1000 的正整数，它会被自动调整为 1000。\n\n**retentionMinutes** 是一个整数，表示保留大小超过 1GB 的 log 文件的时间（从文件的最后修改时间开始计算），单位是分钟。默认值是 1440，即一天。\n\n**flushMode** 是一个整数，表示是否开启同步刷盘，取值只能为 0 或 1。默认值是 0，表示异步刷盘，内存中的流数据写入操作系统缓存即为写入成功，并进行下一批数据的写入。 若为 1，则表示同步刷盘，当前批次的流数据必须落盘完成，才会进行下一批数据的写入。\n\n**cachePurgeTimeColumn** 字符串标量，需要指定为持久化流表中的时间列名称。\n\n**cachePurgeInterval** DURATION 类型标量，表示触发清理内存中数据的时间间隔。\n\n**cacheRetentionTime** DURATION 类型标量，表示内存中数据的最长保留期限。\n\n**preCache** 可选参数，是一个整数，表示从磁盘加载到内存的记录条数。如果没有指定该参数，默认会把所有记录加载到内存中。\n\n**Note:** 自 3.00.2 版本起，该函数要求参数 *cacheRetentionTime* 必须小于 *cachePurgeInterval*。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n例1.\n\n```\ncolName=[\"time\",\"x\"]\ncolType=[\"timestamp\",\"int\"]\nt = streamTable(100:0, colName, colType);\nshare t as st\n\nenableTablePersistence(table=st, cacheSize=1200000)\n\nfor(s in 0:200){\n  n=10000\n  time=2019.01.01T00:00:00.000+s*n+1..n\n  x=rand(10.0, n)\n  insert into st values(time, x)\n}\n\ngetPersistenceMeta(st);\n\n/* output: \npersistenceDir->/data/ssd/DolphinDBDemo/persistence3/st\nretentionMinutes->1440\nhashValue->0\nasynWrite->true\ndiskOffset->0\nsizeInMemory->800000\ncompress->1\nmemoryOffset->1200000\ntotalSize->2000000\nsizeOnDisk->2000000\n*/\n```\n\n**Note:**\n\n以上代码先使用 `share` 命令共享流数据表，再通过 `enableTablePersistence` 命令持久化流数据表。我们推荐使用 [enableTableShareAndPersistence](https://docs.dolphindb.cn/zh/funcs/e/enableTableShareAndPersistence.html) 函数将共享和持久化组织成原子性操作。\n\n例2. 本例将说明 *cachePurgeTimeColumn*, *cachePurgeInterval* 和 *cacheRetentionTime* 的使用方法。\n\n```\ncolName=[\"time\",\"x\"]\ncolType=[\"timestamp\",\"int\"]\nt1 = streamTable(100:0, colName, colType);\nshare t1 as st1\n\nenableTablePersistence(table=st1,cachePurgeTimeColumn = `time, cachePurgeInterval = duration(\"7H\"),cacheRetentionTime = duration(\"2H\"))\n\ntime=2019.01.01T00:00:00.000\nfor(s in 0:6000){\n  time = temporalAdd(time,1,\"m\");\n  x=rand(10.0, 1)\n  insert into st1 values(time, x)\n}\n\ngetPersistenceMeta(st1);\n\n//通过查看流数据表的元数据，看到该表中的总记录数是 6000 行，系统根据时间列的自动清理内存后，在内存中仅保留了 300 行数据。\n\n/* output:\nlastLogSeqNum->-1\nsizeInMemory->300\ntotalSize->6000\nasynWrite->true\ncompress->true\nraftGroup->-1\nmemoryOffset->5700\nretentionMinutes->1440\nsizeOnDisk->6000\npersistenceDir->/data/ssd/DolphinDBDemo/persistence3/st1\nhashValue->0\ndiskOffset->0\n*/\n```\n\n**Related information**\n\n[disableTablePersistence](https://docs.dolphindb.cn/zh/funcs/d/disableTablePersistence.html)\n\n[clearTablePersistence](https://docs.dolphindb.cn/zh/funcs/c/clearTablePersistence.html)\n\n[getPersistenceMeta](https://docs.dolphindb.cn/zh/funcs/g/getPersistenceMeta.html)\n"
    },
    "enableTableShareAndCachePurge": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/enabletableshareandcachepurge.html",
        "signatures": [
            {
                "full": "enableTableShareAndCachePurge(table, tableName, [cacheSize],[cachePurgeTimeColumn],[cachePurgeInterval],[cacheRetentionTime])",
                "name": "enableTableShareAndCachePurge",
                "parameters": [
                    {
                        "full": "table",
                        "name": "table"
                    },
                    {
                        "full": "tableName",
                        "name": "tableName"
                    },
                    {
                        "full": "[cacheSize]",
                        "name": "cacheSize",
                        "optional": true
                    },
                    {
                        "full": "[cachePurgeTimeColumn]",
                        "name": "cachePurgeTimeColumn",
                        "optional": true
                    },
                    {
                        "full": "[cachePurgeInterval]",
                        "name": "cachePurgeInterval",
                        "optional": true
                    },
                    {
                        "full": "[cacheRetentionTime]",
                        "name": "cacheRetentionTime",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [enableTableShareAndCachePurge](https://docs.dolphindb.cn/zh/funcs/e/enabletableshareandcachepurge.html)\n\n\n\n#### 语法\n\nenableTableShareAndCachePurge(table, tableName, \\[cacheSize],\\[cachePurgeTimeColumn],\\[cachePurgeInterval],\\[cacheRetentionTime])\n\n#### 详情\n\n将非持久化的流数据表共享，并设置定时清理。\n\n通过以下两种方式之一来清理内存中的数据：\n\n* 配置 *cacheSize* 参数时，如果插入的数据使内存中流数据表的行数达到阈值，系统将清理内存中较旧的已发布记录。阈值确定方法如下：\n\n  * 每次 append 的数据都不超过 *cacheSize* 时，阈值为 *cacheSize* 的 2.5 倍。\n\n  * 当 append 的数据超过 *cacheSize* 时，阈值为追加行数和 cacheSize 之和的 1.2 倍。\n\n* 同时配置*cachePurgeTimeColumn*, *cachePurgeInterval* 和 *cacheRetentionTime*，系统将根据时间列清理数据。每次插入新数据时，系统会计算新数据与内存中第一条数据的时间戳差值，当差值大于等于 *cachePurgeInterval*时，系统仅保留时间戳与新数据时间戳差值小于等于 *cacheRetentionTime*的数据，清理其它数据。\n\n#### 参数\n\n**table** 是一个空的流数据表。\n\n**tableName** 是一个字符串，表示 table 共享后的名称。\n\n**cacheSize** 是一个正整数，可选参数，表示流数据表在内存中最多保留的记录数。\n\n**cachePurgeTimeColumn** 字符串标量，可选参数。需要指定为持久化流表中的时间列名称。\n\n**cachePurgeInterval** DURATION 类型标量，表示触发清理内存中数据的时间间隔。\n\n**cacheRetentionTime** DURATION 类型标量，表示内存中数据的最长保留期限。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n例1. 配置 cacheSize 参数，根据内存中的数据量进行清理。\n\n```\nt = streamTable(1000:0, `time`sym`volume, [DATETIME, SYMBOL, INT])\nenableTableShareAndCachePurge(table=t, tableName=`st, cacheSize=1000)\ntime = datetime(2024.01.01T09:00:00) +1..1000*2\nsym=take(`a`b`c, 1000)\nvolume = rand(10,1000)\n\ninsert into t values([time, sym, volume])\ngetStreamTableCacheOffset(t)\n//0\n\ntime = datetime(2024.01.01T09:35:00) +1..1000*2\nsym=take(`a`b`c, 1000)\nvolume = rand(10,1000)\ninsert into t values([time, sym, volume])\ngetStreamTableCacheOffset(t)\n//500\n```\n\n例2. 配置*cachePurgeTimeColumn*, *cachePurgeInterval* 和 \\*cacheRetentionTime，\\*根据时间列清理数据。\n\n```\nt = streamTable(1000:0, `time`sym`volume, [DATETIME, SYMBOL, INT])\nenableTableShareAndCachePurge(table=t, tableName=`st, cachePurgeTimeColumn=`time,\n cachePurgeInterval=30m, cacheRetentionTime=20m)\n\ntime = datetime(2024.01.01T09:00:00) +1..1000*2\nsym=take(`a`b`c, 1000)\nvolume = rand(10,1000)\n\ninsert into t values([time, sym, volume])\ngetStreamTableCacheOffset(t)\n//0\n\ntime = datetime(2024.01.01T09:35:00) +1..1000*2\nsym=take(`a`b`c, 1000)\nvolume = rand(10,1000)\ninsert into t values([time, sym, volume])\ngetStreamTableCacheOffset(t)\n//999\n```\n"
    },
    "enableTableShareAndPersistence": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/enableTableShareAndPersistence.html",
        "signatures": [
            {
                "full": "enableTableShareAndPersistence(table, tableName, [asynWrite=true], [compress=true], [cacheSize], [retentionMinutes=1440], [flushMode=0], [preCache],[cachePurgeTimeColumn],[cachePurgeInterval],[cacheRetentionTime])",
                "name": "enableTableShareAndPersistence",
                "parameters": [
                    {
                        "full": "table",
                        "name": "table"
                    },
                    {
                        "full": "tableName",
                        "name": "tableName"
                    },
                    {
                        "full": "[asynWrite=true]",
                        "name": "asynWrite",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[compress=true]",
                        "name": "compress",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[cacheSize]",
                        "name": "cacheSize",
                        "optional": true
                    },
                    {
                        "full": "[retentionMinutes=1440]",
                        "name": "retentionMinutes",
                        "optional": true,
                        "default": "1440"
                    },
                    {
                        "full": "[flushMode=0]",
                        "name": "flushMode",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[preCache]",
                        "name": "preCache",
                        "optional": true
                    },
                    {
                        "full": "[cachePurgeTimeColumn]",
                        "name": "cachePurgeTimeColumn",
                        "optional": true
                    },
                    {
                        "full": "[cachePurgeInterval]",
                        "name": "cachePurgeInterval",
                        "optional": true
                    },
                    {
                        "full": "[cacheRetentionTime]",
                        "name": "cacheRetentionTime",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [enableTableShareAndPersistence](https://docs.dolphindb.cn/zh/funcs/e/enableTableShareAndPersistence.html)\n\n\n\n#### 语法\n\nenableTableShareAndPersistence(table, tableName, \\[asynWrite=true], \\[compress=true], \\[cacheSize], \\[retentionMinutes=1440], \\[flushMode=0], \\[preCache],\\[cachePurgeTimeColumn],\\[cachePurgeInterval],\\[cacheRetentionTime])\n\n#### 详情\n\n该命令将流数据表共享，并把它持久化到磁盘上。\n\n为了保证该命令能够正常执行，需要在配置文件中（单节点：`dolphindb.cfg`，集群：`cluster.cfg`）指定配置参数 *persistenceDir*，配置参考：[功能配置](https://docs.dolphindb.cn/zh/db_distr_comp/cfg/function_configuration.html)。流数据表在磁盘上的存储目录是 `<PERSISTENCE_DIR>/<TABLE_NAME>`。目录包含两种类型的文件：数据文件（名称类型 *data0.log, data1.log...*）和索引文件 *index.log*。把这些数据保存到磁盘后，如果重启系统，再次执行该命令会把磁盘中的数据加载到内存中，加载的记录条数由参数 *preCache* 指定，但是实际加载的记录条数有可能会超过 *preCache*。\n\n参数 *asynWrite* 会告知系统是否以异步模式保存表。在异步模式中，追加的数据会被放进队列，之后用于保存的工作线程把数据写入磁盘。在同步模式中，表的追加数据操作直到追加数据被保存到磁盘中才完成。该参数的默认值是 true，即为异步模式。通常情况下，异步模式实现更高的吞吐量，但是如果服务器崩溃，可能会丢失最后追加的行。在异步模式中，保存表的工作是由单个工作线程完成，并且一个工作线程可能处理多个表。如果只保存一个表，增加工作线程的数量并不会提升性能。\n\n默认情况下，流数据表将所有数据保存在内存中。如果流数据表太大，系统可能会出现内存不足的情况。为了避免内存不足的问题，可以通过以下两种方式之一来清理内存中的数据：\n\n* 配置 *cacheSize* 参数时，如果插入的数据使内存中流数据表的行数达到阈值，系统将清理内存中较旧的已发布记录。阈值确定规则如下：\n\n  * 每次 append 的数据都不超过 *cacheSize* 时，内存中的记录数不会大于 *cacheSize* 的 2.5 倍。\n  * 否则，当 append 的数据超过 *cacheSize* 时，内存中的记录数不会超过追加行数和 *cacheSize* 之和的 1.2 倍。\n* 同时配置*cachePurgeTimeColumn*, *cachePurgeInterval* 和 *cacheRetentionTime*，系统将根据时间列清理数据。每次插入新数据时，系统会计算新数据与内存中第一条数据的时间戳差值，当差值大于等于 *cachePurgeInterval*时，系统仅保留时间戳与新数据时间戳差值小于等于 *cacheRetentionTime*的数据，清理其它数据。\n\n**Note:**\n\n* 如果设置 asynWrite=true，此时流数据写入速度最快，若 server 发生 crash 可能导致部分数据丢失。\n\n* 如果设置 asynWrite=false，flushmode=0，此时流数据写入速度中等，server 发生 crash 不会丢失数据，但操作系统崩溃可能导致部分数据丢失。\n\n* 如果设置 asynWrite=false，flushmode=1，此时流数据写入速度最慢，server 发生 crash 或操作系统崩溃都不会导致数据丢失。\n\n* 不可以将同一个流数据表通过修改共享变量名称的方式共享 2 次及以上。\n\n#### 参数\n\n**table** 是一个空的流数据表。\n\n**tableName** 是一个字符串，表示 table 共享后的名称。\n\n**asynWrite** 可选参数，是一个布尔值，表示是否异步持久化数据到磁盘。默认值为 true，流数据写入内存即为写入成功，持久化到磁盘的操作将会由另一个线程执行。\n\n**Note:**\n\n持久化数据到磁盘包含两个步骤：\n\n* 写内存数据到操作系统缓存\n\n* 写缓存数据到磁盘（是否开启同步刷盘由参数 *flushMode* 决定）\n\n**compress** 可选参数，是一个布尔值，表示是否以压缩模式模式保存至磁盘。默认值为 true。\n\n**cacheSize** 可选参数，整数，表示流数据表在内存中最多保留多少行。如果未指定该参数，则所有记录行都会保存在内存中。如果 *cacheSize* 小于 1000，它会被自动调整为 1000。\n\n**retentionMinutes** 可选参数，是一个整数，表示文件大小超过 1GB的 log 文件的保留时间(从文件的最后修改时间开始计算)，单位是分钟。默认值是 1440，即一天。如果 log 文件未达 1GB，则会一直保留至大小达到 1GB。\n\n**flushMode** 可选参数，是一个整数，表示是否开启同步刷盘，取值只能为 0 或 1。默认值是 0，表示异步刷盘，内存中的流数据写入操作系统缓存即为写入成功，并进行下一批数据的写入。 若为 1，则表示同步刷盘，当前批次的流数据必须落盘完成，才会进行下一批数据的写入。\n\n**preCache** 可选参数，是一个整数，表示从磁盘加载到内存的记录条数。如果没有指定该参数，重启后实际加载到内存的数据量受 *cacheSize* 限制。\n\n**cachePurgeTimeColumn** 可选参数，字符串标量，需要指定为持久化流表中的时间列名称。\n\n**cachePurgeInterval** 可选参数，DURATION 类型标量，表示触发清理内存中数据的时间间隔。\n\n**cacheRetentionTime** 可选参数，DURATION 类型标量，表示内存中数据的最长保留期限。\n\n**Note:** 自 3.00.2 版本起，该函数要求参数 *cacheRetentionTime* 必须小于 *cachePurgeInterval*。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n例1.\n\n```\ncolName=[\"time\",\"x\"]\ncolType=[\"timestamp\",\"int\"]\nt = streamTable(100:0, colName, colType);\nenableTableShareAndPersistence(table=t, tableName=`st, cacheSize=1200000)\ngo;\n```\n\n```\nfor(s in 0:200){\n  n=10000\n  time=2019.01.01T00:00:00.000+s*n+1..n\n  x=rand(10.0, n)\n  insert into st values(time, x)\n}\n```\n\n```\ngetPersistenceMeta(st);\n\n/* output:\nsizeInMemory->800000\nasynWrite->true\ntotalSize->2000000\ncompress->true\nmemoryOffset->1200000\nretentionMinutes->1440\nsizeOnDisk->2000000\npersistenceDir->/home/llin/hzy/server1/pst/st\nhashValue->0\ndiskOffset->0\n*/\n```\n\n例2. 本例将说明 *cachePurgeTimeColumn*, *cachePurgeInterval* 和 *cacheRetentionTime* 的使用方法。\n\n```\ncolName=[\"time\",\"x\"]\ncolType=[\"timestamp\",\"int\"]\nt1 = streamTable(100:0, colName, colType);\n\nenableTableShareAndPersistence(table=t1,tableName=`st1, cachePurgeTimeColumn=`time, cachePurgeInterval=duration(\"7H\"),cacheRetentionTime=duration(\"2H\"))\n\ngo;\n\ntime=2019.01.01T00:00:00.000\nfor(s in 0:6000){\n  time = temporalAdd(time,1,\"m\");\n  x=rand(10.0, 1)\n  insert into st1 values(time, x)\n}\n\ngetPersistenceMeta(st1);\n\n/* output:\nlastLogSeqNum->-1\nsizeInMemory->300\ntotalSize->12000\nasynWrite->true\ncompress->true\nraftGroup->-1\nmemoryOffset->11700\nretentionMinutes->1440\nsizeOnDisk->11879\npersistenceDir->/home/ffliu/jjxu/DolphinDB_Linux64_V3.0/server/persistence/st1\nhashValue->0\ndiskOffset->0\n*/\n```\n\n**Related information**\n\n[disableTablePersistence](https://docs.dolphindb.cn/zh/funcs/d/disableTablePersistence.html)\n\n[clearTablePersistence](https://docs.dolphindb.cn/zh/funcs/c/clearTablePersistence.html)\n\n[getPersistenceMeta](https://docs.dolphindb.cn/zh/funcs/g/getPersistenceMeta.html)\n"
    },
    "enableTDEKey": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/enabletdekey.html",
        "signatures": [
            {
                "full": "enableTDEKey(masterKeyPath)",
                "name": "enableTDEKey",
                "parameters": [
                    {
                        "full": "masterKeyPath",
                        "name": "masterKeyPath"
                    }
                ]
            }
        ],
        "markdown": "### [enableTDEKey](https://docs.dolphindb.cn/zh/funcs/e/enabletdekey.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nenableTDEKey(masterKeyPath)\n\n#### 详情\n\n启用数据静态加密并初始化 TDE 密钥。该函数必须由管理员在控制节点执行。仅 Linux 系统支持该功能。\n\n完成主密钥设置后，用户可以调用函数 [getCurrentTDEKeyVersion](https://docs.dolphindb.cn/zh/funcs/g/getcurrenttdekeyversion.html) 查询当前主密钥版本，验证加密配置是否生效。\n\n#### 参数\n\n**masterKeyPath** 字符串标量，指定 TDE 密钥文件的路径。\n\n#### 返回值\n\n如果设置成功，函数返回 true。如函数报错，请检查密钥路径是否正确，以及文件是否符合密钥格式要求。\n\n#### 例子\n\n```\nenableTDEKey(path/to/key)\n```\n"
    },
    "enableTransferCompressionToComputeNode": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/enabletransfercompressiontocomputenode.html",
        "signatures": [
            {
                "full": "enableTransferCompressionToComputeNode(enable)",
                "name": "enableTransferCompressionToComputeNode",
                "parameters": [
                    {
                        "full": "enable",
                        "name": "enable"
                    }
                ]
            }
        ],
        "markdown": "### [enableTransferCompressionToComputeNode](https://docs.dolphindb.cn/zh/funcs/e/enabletransfercompressiontocomputenode.html)\n\n首发版本：3.00.5\n\n\n\n#### 语法\n\nenableTransferCompressionToComputeNode(enable)\n\n#### 详情\n\n用于控制数据节点在向计算节点传输数据前是否进行压缩。\n\n#### 参数\n\n**enable** 布尔值，指定是否压缩将被传输的数据。true 表示压缩，false 表示不压缩。\n\n#### 返回值\n\n无\n\n#### 例子\n\n```\nenableTransferCompressionToComputeNode(true)\n```\n\n**相关函数：**[isTransferCompressionToComputeNodeEnabled](https://docs.dolphindb.cn/zh/funcs/i/istransfercompressiontocomputenodeenabled.html)\n"
    },
    "enableTSDBAsyncSorting": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/enableTSDBAsyncSorting.html",
        "signatures": [
            {
                "full": "enableTSDBAsyncSorting()",
                "name": "enableTSDBAsyncSorting",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [enableTSDBAsyncSorting](https://docs.dolphindb.cn/zh/funcs/e/enableTSDBAsyncSorting.html)\n\n\n\n#### 语法\n\nenableTSDBAsyncSorting()\n\n#### 详情\n\nTSDB 写入 Cache Engine 中的数据会根据 *sortColumns* 排序。写入任务和排序任务可以同步或异步进行，该命令用于开启异步进行数据排序的功能。异步线程数量由配置参数 *TSDBAsyncSortingWorkerNum* 指定。 只能由管理员在数据节点上执行。请注意，执行该命令前请确认 *TSDBAsyncSortingWorkerNum* 配置值大于0。\n\n因异步数据排序能提高数据写入性能，若 TSDB 引擎所在服务器 CPU 核数较多，建议在进行数据写入前，执行该命令开启异步数据排序功能。\n\n#### 参数\n\n无\n\n#### 返回值\n\n无。\n\n相关函数：[disableTSDBAsyncSorting](https://docs.dolphindb.cn/zh/funcs/d/disableTSDBAsyncSorting.html)\n"
    },
    "encodeShortGenomeSeq": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/encodeShortGenomeSeq.html",
        "signatures": [
            {
                "full": "encodeShortGenomeSeq(X)",
                "name": "encodeShortGenomeSeq",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [encodeShortGenomeSeq](https://docs.dolphindb.cn/zh/funcs/e/encodeShortGenomeSeq.html)\n\n\n\n#### 语法\n\nencodeShortGenomeSeq(X)\n\n别名：encodeSGS\n\n#### 详情\n\n对 DNA 序列（由 A, T, C, G 自由组合）进行编码。通过编码，可以减小 DNA 序列的存储空间，提高计算效率。\n\n注意：\n\n* 若 *X* 指定为空字符（\"\"），则函数返回0。\n\n* 若 *X* 中包含了除 A, T, C, G（大小写敏感）以外的字符，则返回空值。\n\n* 若 *X* 指定的字符串所包含的字符个数超过了28，则返回空值。\n\n#### 参数\n\n**X** STRING 类型标量或向量、CHAR 类型向量。\n\n#### 返回值\n\n长整型（LONG）或长整型向量（FAST LONG VECTOR）。\n\n#### 例子\n\n```\na=encodeShortGenomeSeq(\"TCGATCG\")\na;\n// output\n465691\ntypestr(a)\n// output\nLONG\n    \nb=encodeShortGenomeSeq(\"TCGATCG\" \"TCGATCGCCC\") \n// output\n[465691,168216298]\ntypestr(b)\n// output\nFAST LONG VECTOR\n    \n// \"TCGATCG\"重复5次后，因长度超过了28，所以返回了空值。\nencodeShortGenomeSeq(repeat(\"TCGATCG\" \"TCGAT\", 5))\n// output\n[,1801916404867712433]\n    \ny=toCharArray(\"TCGATCGCCC\")\nencodeShortGenomeSeq(y)\n// output\n168216298\n    \nencodeShortGenomeSeq(\"TC G\") \n// output\n00l\nencodeShortGenomeSeq(\"TCtG\") \n// output\n00l\n// 基因序列中出现 N，编码返回空。\nencodeShortGenomeSeq(\"NNNNNNNNTCGGGGCAT\")\n// output\n00l\nencodeShortGenomeSeq(\"TCGGGGCATNGCCCG\")\n// output\n00l\nencodeShortGenomeSeq(\"GCCCGATNNNNN\")\n// output\n00l\n```\n\n相关函数：[decodeShortGenomeSeq](https://docs.dolphindb.cn/zh/funcs/d/decodeShortGenomeSeq.html), [genShortGenomeSeq](https://docs.dolphindb.cn/zh/funcs/g/genShortGenomeSeq.html)\n"
    },
    "encryptModule": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/encryptmodule.html",
        "signatures": [
            {
                "full": "encryptModule(name, [moduleDir], [overwrite=false])",
                "name": "encryptModule",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "[moduleDir]",
                        "name": "moduleDir",
                        "optional": true
                    },
                    {
                        "full": "[overwrite=false]",
                        "name": "overwrite",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [encryptModule](https://docs.dolphindb.cn/zh/funcs/e/encryptmodule.html)\n\n首发版本：3.00.5，3.00.4.3\n\n\n\n#### 语法\n\nencryptModule(name, \\[moduleDir], \\[overwrite=false])\n\n#### 详情\n\n对模块（dos 文件）进行加密，用于生成可分发的加密模块（dom 文件）。该函数必须要用户登录后才能执行。\n\n**Note:**\n\n* `saveModule` 也可用于生成 dom 文件，但无法进行加密。\n* `encryptModule` 包含函数序列化协议，所以会有兼容性考虑。\n  * 在 3.00.0 版本 server 中加密的模块无法在任何 2.00.0 版本 server 上运行。\n  * 在 2.00.0 版本 server 中加密的模块可以在同级别的 3.00.0 版本 server 中运行。比如 2.00.17 和 3.00.4 是同级别的，所以 2.00.17 中生成的加密模块可以在 3.00.4 中运行。但不保证在 3.00.4 之前的 3.00.0 版本 server 中能够运行。\n\n#### 参数\n\n**name** 是一个字符串，用于指定模块文件的名称。\n\n**moduleDir** 是一个字符串，用于指定模块文件所在的目录，默认为节点的 \\[home]/modules 目录。可通过 [getHomeDir](https://docs.dolphindb.cn/zh/funcs/g/getHomeDir.html) 查询 home 目录。\n\n**overwrite** 是一个布尔值，用于指定是否覆盖已存在的同名 dom 文件。默认值为 false，即不覆盖。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n假设节点 home 目录下的 modules 目录包含了 ta.dos 模块文件，将其序列化为加密的二进制文件。\n\n```\nencryptModule(\"ta\")\n```\n\n函数执行成功后 modules 目录中会出现 ta.dom 文件。\n\n![](https://docs.dolphindb.cn/zh/images/encrypt_module.png)\n\n**相关函数**\n\n[saveModule](https://docs.dolphindb.cn/zh/funcs/s/saveModule.html)\n\n[loadModule](https://docs.dolphindb.cn/zh/funcs/l/loadModule.html)\n"
    },
    "endsWith": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/endsWith.html",
        "signatures": [
            {
                "full": "endsWith(X, str)",
                "name": "endsWith",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "str",
                        "name": "str"
                    }
                ]
            }
        ],
        "markdown": "### [endsWith](https://docs.dolphindb.cn/zh/funcs/e/endsWith.html)\n\n\n\n#### 语法\n\nendsWith(X, str)\n\n#### 详情\n\n检查 *X* 是否以 *str* 结尾。如果是，返回 true； 否则返回 false。\n\n#### 参数\n\n**X** 是搜索的目标字符串。它可以是标量或向量。\n\n**str** 是被搜索的目标字符串。它可以是标量或向量。\n\n#### 返回值\n\n布尔类型标量或向量。\n\n#### 例子\n\n```\nendsWith('ABCDEF!', \"F!\");\n// output\ntrue\n\nendsWith('ABCDEF!', \"E!\");\n// output\nfalse\n```\n"
    },
    "enlist": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/enlist.html",
        "signatures": [
            {
                "full": "enlist(X)",
                "name": "enlist",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [enlist](https://docs.dolphindb.cn/zh/funcs/e/enlist.html)\n\n\n\n#### 语法\n\nenlist(X)\n\n#### 详情\n\n*X* 是标量时，返回一个向量。\n\n*X* 是字典时，\n\n* 若键为字符串，返回一个单行的表。\n\n* 若键为非字符串，返回一个元组。\n\n*X* 是向量、元组等其他数据形式时，返回一个元组。\n\n#### 参数\n\n**X** 任意数据形式。\n\n#### 例子\n\n```\nenlist(1)\n// output\n[1]\n\nenlist(`aaa)\n// output\n[\"aaa\"]\n\nenlist([2022.01.01,2022.01.02,2022.01.03])\n// output\n([2022.01.01,2022.01.02,2022.01.03])\n\nenlist([\"a\",2,3])\n// output\n((\"a\",2,3))\n\na = array(INT[], 0, 10).append!([1 2 3, 4 5,6 7 8, 9 NULL])\nenlist(a)\n// output\n([[1,2,3],[4,5],[6,7,8],[9,00i]])\n\nd1=dict(`a`b`c, (1, 2 3, 4))\nenlist(d1)\n```\n\n| c | b       | a |\n| - | ------- | - |\n| 4 | \\[2, 3] | 1 |\n\n```\nvalue =(-2 2 3, 0 1, 2.2 -3 1)\nd2 = dict(1 2 3, value, true)\nprint enlist(d2)\n\n/* output;\n(1->[-2,2,3]\n2->[0,1]\n3->[2.2,-3,1]\n)\n*/\n```\n"
    },
    "eq": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/eq.html",
        "signatures": [
            {
                "full": "eq(X, Y)",
                "name": "eq",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [eq](https://docs.dolphindb.cn/zh/funcs/e/eq.html)\n\n\n\n#### 语法\n\neq(X, Y) 或 X==Y\n\n#### 详情\n\n如果 *X* 和 *Y* 都不是集合，返回逐个元素比较 *X*==*Y* 的结果。\n\n如果 *X* 和 *Y* 都是集合，则检查 *X* 和 *Y* 是否是同一个集合。\n\n#### 参数\n\n**X** 和 **Y** 可以是标量、数据对、向量、矩阵或集合。如果 *X* 或 *Y* 其中一个是数据对、向量或矩阵，另一个必须是标量，或具有相同长度或维度的数据对、向量或矩阵。\n\n#### 返回值\n\n返回布尔类型，数据形式取决于 *X*/*Y*。\n\n#### 例子\n\n```\n1 2 3 == 2;\n// output\n[0,1,0]\n\n1 2 3==0 2 4;\n// output\n[0,1,0]\n\n1:2==1:6;\n// output\n1 : 0\n\nm1=1..6$2:3;\nm1;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1  | 3  | 5  |\n| 2  | 4  | 6  |\n\n```\nm1 == 4;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 0  | 0  | 0  |\n| 0  | 1  | 0  |\n\n```\nm2=6..1$2:3;\nm2;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 6  | 4  | 2  |\n| 5  | 3  | 1  |\n\n```\nm1==m2;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 0  | 0  | 0  |\n| 0  | 0  | 0  |\n\n集合操作：如果 *X*==*Y*，则 *X* 和 *Y* 是同一个集合。\n\n```\nx=set(4 6)\ny=set(4 6 8);\n\nx==y;\n// output\n0\nx==x;\n// output\n1\n```\n"
    },
    "eqAmericanOptionPricer": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/eqamericanoptionpricer.html",
        "signatures": [
            {
                "full": "eqAmericanOptionPricer(instrument, pricingDate, spot, discountCurve, dividendCurve, volSurf, [setting], [model='BlackScholes'], [method='Analytic'])",
                "name": "eqAmericanOptionPricer",
                "parameters": [
                    {
                        "full": "instrument",
                        "name": "instrument"
                    },
                    {
                        "full": "pricingDate",
                        "name": "pricingDate"
                    },
                    {
                        "full": "spot",
                        "name": "spot"
                    },
                    {
                        "full": "discountCurve",
                        "name": "discountCurve"
                    },
                    {
                        "full": "dividendCurve",
                        "name": "dividendCurve"
                    },
                    {
                        "full": "volSurf",
                        "name": "volSurf"
                    },
                    {
                        "full": "[setting]",
                        "name": "setting",
                        "optional": true
                    },
                    {
                        "full": "[model='BlackScholes']",
                        "name": "model",
                        "optional": true,
                        "default": "'BlackScholes'"
                    },
                    {
                        "full": "[method='Analytic']",
                        "name": "method",
                        "optional": true,
                        "default": "'Analytic'"
                    }
                ]
            }
        ],
        "markdown": "### [eqAmericanOptionPricer](https://docs.dolphindb.cn/zh/funcs/e/eqamericanoptionpricer.html)\n\n首发版本：3.00.5\n\n\n\n#### 语法\n\neqAmericanOptionPricer(instrument, pricingDate, spot, discountCurve, dividendCurve, volSurf, \\[setting], \\[model='BlackScholes'], \\[method='Analytic'])\n\n#### 详情\n\n对权益类美式期权进行定价。\n\n#### 参数\n\n**instrument** EqAmerican 类型的 Instrument 标量或向量，表示需要定价的权益类美式期权。权益类美式期权所需的关键字段详见产品字段要求。\n\n**pricingDate** DATE 类型标量或向量，表示定价日期。\n\n**spot** 数值类型标量或向量，表示现货价格。\n\n**discountCurve** IrYieldCurve 类型的 MktData 标量或向量，表示折现曲线。\n\n**dividendCurve** DividendCurve 类型的 MktData 标量或向量，表示股息曲线。\n\n**volSurf** MKTDATA 类型（VolatilitySurface）的标量或向量，表示波动率曲面。\n\n**setting** 可选参数，一个字典，用于设置定价输出。包含以下 key：\n\n* calcDelta：value 是布尔值，指定是否计算 delta\n\n* calcGamma：value 是布尔值，指定是否计算 gamma\n\n* calcVega：value 是布尔值，指定是否计算 vega\n\n* calcTheta：value 是布尔值，指定是否计算 theta\n\n* calcRhoIr：value 是布尔值，指定是否计算 rhoir\n\n* calcRhoDividend：value 是布尔值，指定是否计算 rhodividend\n\n**model** 可选参数，STRING 类型标量，表示使用的模型。可选值为：\n\n* “BlackScholes”（默认值）：Black–Scholes model\n\n* “BAW”：Barone-Adesi-Whaley 公式\n\n* “AmericanBinomialTree”：美式二叉树定价模型\n\n**method** 可选参数，STRING 类型标量，表示使用的方法。可选值为：\n\n* “Analytic”（默认值）：解析法，支持 *model* 为 BlackScholes 或 BAW。\n\n* “Tree”：树方法，支持 *model* 为 AmericanBinomialTree。\n\n#### 返回值\n\n* 当未指定 *setting* 时：返回 DOUBLE 类型标量，表示期权的净现值（NPV）。\n\n* 当指定 *setting* 时：返回一个字典，包含 NPV 及按 *setting* 指定的 Greeks 结果。\n\n#### 例子\n\n```\n//腾讯股票期权定价\nreferenceDate = 2026.02.13\n// 1. Discount Curve (HKD Proxy - Simplified)\n// 注意：实际生产中应使用HIBOR或OIS曲线\ndiscountCurveDict = {\n    \"mktDataType\": \"Curve\",\n    \"curveType\": \"IrYieldCurve\",\n    \"curveName\": \"HKD_RF\",\n    \"referenceDate\": referenceDate,\n    \"currency\": \"HKD\",\n    \"dayCountConvention\": \"Actual365\",\n    \"compounding\": \"Continuous\",\n    \"interpMethod\": \"Linear\",\n    \"extrapMethod\": \"Flat\",\n    \"dates\": [\n        referenceDate + 1, referenceDate + 30, referenceDate + 90,\n        referenceDate + 180, referenceDate + 365\n    ],\n    \"values\":[0.04, 0.04, 0.04, 0.04, 0.04]\n}\ndiscountCurve = parseMktData(discountCurveDict)\n// 2. Data Preparation\nspot = 532.0\ntermDates = [2026.02.20, 2026.02.26, 2026.03.30, 2026.04.29, 2026.05.28, 2026.06.29, 2026.09.29, 2026.12.30]\n// Matrices are ensured to be dense (no zeros) by Python preprocessing\ncallPrices = matrix(\n    [102.240, 92.250, 82.270, 72.300, 62.360, 52.480, 42.710, 33.180, 24.170, 15.940, 9.000, 4.600, 2.130, 0.960, 0.370, 0.130, 0.050, 0.020, 0.010, 0.010],\n    [102.480, 92.530, 82.620, 72.750, 62.980, 53.350, 43.970, 35.430, 26.800, 19.250, 12.390, 8.200, 5.010, 3.030, 1.710, 0.940, 0.490, 0.250, 0.130, 0.070],\n    [105.350, 94.410, 84.930, 75.670, 66.690, 59.800, 50.880, 41.900, 34.080, 29.030, 23.600, 18.700, 14.700, 11.470, 8.880, 7.000, 5.320, 4.000, 2.990, 2.220],\n    [107.770, 96.450, 87.340, 78.510, 70.000, 61.880, 55.250, 46.990, 41.510, 34.530, 29.120, 24.370, 20.000, 16.900, 13.980, 11.410, 9.320, 7.760, 6.500, 5.320],\n    [109.270, 97.890, 89.050, 80.500, 72.290, 64.460, 57.080, 50.140, 45.000, 38.800, 33.130, 28.330, 24.220, 20.630, 17.580, 14.840, 12.540, 10.560, 8.850, 7.440],\n    [110.210, 98.620, 90.010, 81.730, 73.930, 66.430, 59.420, 52.930, 47.380, 42.070, 36.780, 32.290, 28.310, 24.260, 21.250, 18.380, 15.900, 13.610, 11.710, 10.000],\n    [115.610, 107.450, 96.760, 89.450, 82.610, 75.990, 69.870, 63.990, 58.540, 54.680, 49.600, 45.520, 40.960, 36.480, 33.520, 30.130, 27.110, 24.080, 21.680, 19.310],\n    [124.400, 116.880, 109.390, 99.560, 92.910, 89.300, 82.750, 77.110, 69.700, 66.470, 61.260, 56.670, 52.370, 48.220, 44.480, 40.740, 37.360, 34.350, 31.340, 28.570]\n)\nputPrices = matrix(\n    [0.010, 0.010, 0.030, 0.050, 0.110, 0.210, 0.460, 0.880, 1.750, 3.450, 6.570, 12.100, 19.820, 28.260, 38.190, 48.020, 58.000, 68.000, 78.000, 88.000],\n    [0.050, 0.090, 0.160, 0.290, 0.510, 0.900, 1.480, 2.390, 3.930, 6.260, 10.000, 15.350, 21.820, 30.000, 39.150, 48.500, 58.190, 68.000, 80.340, 88.000],\n    [0.560, 0.900, 1.410, 2.140, 3.160, 4.540, 6.360, 8.640, 11.390, 14.720, 18.710, 24.150, 30.180, 37.360, 44.600, 53.900, 61.660, 70.100, 80.340, 88.940],\n    [1.310, 1.960, 2.840, 4.000, 5.470, 7.000, 9.210, 11.950, 15.110, 18.850, 23.340, 28.440, 34.710, 41.520, 48.300, 57.590, 64.690, 73.180, 81.860, 90.830],\n    [2.860, 3.870, 5.230, 6.730, 8.460, 10.740, 13.480, 16.630, 20.240, 24.470, 29.080, 34.410, 40.600, 47.430, 54.580, 62.650, 70.440, 78.580, 86.920, 95.580],\n    [3.790, 5.140, 6.750, 8.680, 10.870, 13.690, 16.300, 19.650, 23.400, 27.920, 32.950, 38.280, 44.180, 50.760, 57.030, 65.510, 73.230, 78.580, 86.920, 97.520],\n    [8.130, 10.140, 12.540, 15.140, 17.750, 20.910, 24.310, 28.300, 32.340, 37.020, 42.040, 47.690, 53.480, 60.030, 66.160, 73.900, 80.970, 88.120, 95.810, 101.990],\n    [14.020, 15.890, 18.190, 21.170, 24.270, 27.800, 31.600, 35.490, 40.040, 44.910, 49.510, 54.850, 60.560, 67.000, 72.830, 78.360, 84.930, 94.000, 102.120, 109.690]\n)\nstrikes = matrix(\n    [430.00, 440.00, 450.00, 460.00, 470.00, 480.00, 490.00, 500.00, 510.00, 520.00, 530.00, 540.00, 550.00, 560.00, 570.00, 580.00, 590.00, 600.00, 610.00, 620.00],\n    [430.00, 440.00, 450.00, 460.00, 470.00, 480.00, 490.00, 500.00, 510.00, 520.00, 530.00, 540.00, 550.00, 560.00, 570.00, 580.00, 590.00, 600.00, 610.00, 620.00],\n    [430.00, 440.00, 450.00, 460.00, 470.00, 480.00, 490.00, 500.00, 510.00, 520.00, 530.00, 540.00, 550.00, 560.00, 570.00, 580.00, 590.00, 600.00, 610.00, 620.00],\n    [430.00, 440.00, 450.00, 460.00, 470.00, 480.00, 490.00, 500.00, 510.00, 520.00, 530.00, 540.00, 550.00, 560.00, 570.00, 580.00, 590.00, 600.00, 610.00, 620.00],\n    [430.00, 440.00, 450.00, 460.00, 470.00, 480.00, 490.00, 500.00, 510.00, 520.00, 530.00, 540.00, 550.00, 560.00, 570.00, 580.00, 590.00, 600.00, 610.00, 620.00],\n    [430.00, 440.00, 450.00, 460.00, 470.00, 480.00, 490.00, 500.00, 510.00, 520.00, 530.00, 540.00, 550.00, 560.00, 570.00, 580.00, 590.00, 600.00, 610.00, 620.00],\n    [430.00, 440.00, 450.00, 460.00, 470.00, 480.00, 490.00, 500.00, 510.00, 520.00, 530.00, 540.00, 550.00, 560.00, 570.00, 580.00, 590.00, 600.00, 610.00, 620.00],\n    [430.00, 440.00, 450.00, 460.00, 470.00, 480.00, 490.00, 500.00, 510.00, 520.00, 530.00, 540.00, 550.00, 560.00, 570.00, 580.00, 590.00, 600.00, 610.00, 620.00]\n)\noptionPrices = matrix(\n    [0.010, 0.010, 0.030, 0.050, 0.110, 0.210, 0.460, 0.880, 1.750, 3.450, 6.570, 4.600, 2.130, 0.960, 0.370, 0.130, 0.050, 0.020, 0.010, 0.010],\n    [0.050, 0.090, 0.160, 0.290, 0.510, 0.900, 1.480, 2.390, 3.930, 6.260, 10.000, 8.200, 5.010, 3.030, 1.710, 0.940, 0.490, 0.250, 0.130, 0.070],\n    [0.560, 0.900, 1.410, 2.140, 3.160, 4.540, 6.360, 8.640, 11.390, 14.720, 18.710, 18.700, 14.700, 11.470, 8.880, 7.000, 5.320, 4.000, 2.990, 2.220],\n    [1.310, 1.960, 2.840, 4.000, 5.470, 7.000, 9.210, 11.950, 15.110, 18.850, 23.340, 24.370, 20.000, 16.900, 13.980, 11.410, 9.320, 7.760, 6.500, 5.320],\n    [2.860, 3.870, 5.230, 6.730, 8.460, 10.740, 13.480, 16.630, 20.240, 24.470, 29.080, 28.330, 24.220, 20.630, 17.580, 14.840, 12.540, 10.560, 8.850, 7.440],\n    [3.790, 5.140, 6.750, 8.680, 10.870, 13.690, 16.300, 19.650, 23.400, 27.920, 32.950, 32.290, 28.310, 24.260, 21.250, 18.380, 15.900, 13.610, 11.710, 10.000],\n    [8.130, 10.140, 12.540, 15.140, 17.750, 20.910, 24.310, 28.300, 32.340, 37.020, 42.040, 45.520, 40.960, 36.480, 33.520, 30.130, 27.110, 24.080, 21.680, 19.310],\n    [14.020, 15.890, 18.190, 21.170, 24.270, 27.800, 31.600, 35.490, 40.040, 44.910, 49.510, 56.670, 52.370, 48.220, 44.480, 40.740, 37.360, 34.350, 31.340, 28.570]\n)\npayoffTypes = matrix(\n    [\"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\"],\n    [\"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\"],\n    [\"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\"],\n    [\"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\"],\n    [\"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\"],\n    [\"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\"],\n    [\"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\"],\n    [\"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\"]\n)\n// 3. Build Dividend Curve (CallPutParity)\n// 使用 Call-Put Parity 从期权价格中隐含出分红（股息）曲线\ndividendCurve = eqDividendCurveBuilder(\n    referenceDate, termDates, \"CallPutParity\", ,\n    callPrices, putPrices, strikes, spot, discountCurve, \"Actual365\"\n)\n// 4. Build Volatility Surface (SVI Model)\n// 构建波动率曲面\nsurface = eqVolatilitySurfaceBuilder(\n        referenceDate,\n        termDates,\n        strikes,\n        optionPrices,\n        payoffTypes,\n        spot,\n        discountCurve,\n        dividendCurve,\n        \"SVI\"\n)\n// 5. Pricing Test: eqAmericanOptionPricer\noptionDict = {\n    \"productType\": \"Option\",\n    \"optionType\": \"AmericanOption\",\n    \"assetType\": \"EqAmericanOption\",\n    \"notionalCurrency\": \"HKD\",    // price currency\n    \"notionalAmount\": 1,          // 份数      \n    \"strike\": 530.0,\n    \"maturity\": 2026.02.24,\n    \"payoffType\": \"Call\",\n    \"dayCountConvention\": \"Actual365\",\n    \"underlying\": \"00700.HK\"\n}\ninstrument = parseInstrument(optionDict)\nres = eqAmericanOptionPricer(\n        instrument,\n        referenceDate,\n        spot,\n        discountCurve,\n        dividendCurve,\n        surface,\n        setting={\"calcDelta\": true, \"calcGamma\": true, \"calcVega\": true, \"calcTheta\": true, \"calcRho\": true, \"calcRhoIr\": true, \"calcRhoDividend\": true}\n)\nprint(res)\n```\n\n#### 产品字段说明\n\n<table id=\"table_rn2_gyd_l3c\"><thead><tr><th>\n\n**字段名**\n\n</th><th>\n\n**类型**\n\n</th><th>\n\n**描述**\n\n</th><th>\n\n**是否必填**\n\n</th></tr></thead><tbody><tr><td>\n\nproductType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"Option\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\noptionType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"AmericanOption\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nassetType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"EqAmericanOption\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nnotionalAmount\n\n</td><td>\n\nDOUBLE\n\n</td><td>\n\n名义本金额\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nnotionalCurrency\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n名义本金货币，默认为 CNY\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ninstrumentId\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n合约代码，如代码 `TCH250328C0040000`的解读如下：\n\n* `TCH`: 标的为腾讯控股\n\n* `250328`: 到期日为2025年3月28日。\n\n* `C`: 期权类型为认购（Call）\n\n* `0040000`: 行权价为400.00港元。\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ndirection\n\n</td><td>\n\nSRTRING\n\n</td><td>\n\n买卖方向 Buy Sell，默认为 Buy\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\nmaturity\n\n</td><td>\n\nDATE\n\n</td><td>\n\n到期日\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nstrike\n\n</td><td>\n\nDOUBLE\n\n</td><td>\n\n执行利率\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\npayoffType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n枚举，可选Call和Put\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nunderlying\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n标的期货合约代码，如 `TCH`\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ndayCountConvention\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n日期计数惯例, 可选 \"ActualActualISDA\", \"ActualActualISMA\", \"Actual365\", \"Actual360\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ndiscountCurve\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n定价时参考的贴现曲线名称，人民币存款默认为 \"CNY\\_FR\\_007\"\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ndividendCurve\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n定价时参考的股息曲线名称\n\n</td><td>\n\n否\n\n</td></tr></tbody>\n</table>**相关函数：**[parseInstrument](../p/parseInstrument.md)、[parseMktData](../p/parseMktData.md)、[eqDividendCurveBuilder](eqDividendCurveBuilder.md)、[eqVolatilitySurfaceBuilder](eqvolatilitysurfacebuilder.md)\n"
    },
    "eqDividendCurveBuilder": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/eqDividendCurveBuilder.html",
        "signatures": [
            {
                "full": "eqDividendCurveBuilder(referenceDate, termDates, method, [futPrices], [callPrices], [putPrices], [strikes], spot, discountCurve, dayCountConvention='Actual365', [curveName])",
                "name": "eqDividendCurveBuilder",
                "parameters": [
                    {
                        "full": "referenceDate",
                        "name": "referenceDate"
                    },
                    {
                        "full": "termDates",
                        "name": "termDates"
                    },
                    {
                        "full": "method",
                        "name": "method"
                    },
                    {
                        "full": "[futPrices]",
                        "name": "futPrices",
                        "optional": true
                    },
                    {
                        "full": "[callPrices]",
                        "name": "callPrices",
                        "optional": true
                    },
                    {
                        "full": "[putPrices]",
                        "name": "putPrices",
                        "optional": true
                    },
                    {
                        "full": "[strikes]",
                        "name": "strikes",
                        "optional": true
                    },
                    {
                        "full": "spot",
                        "name": "spot"
                    },
                    {
                        "full": "discountCurve",
                        "name": "discountCurve"
                    },
                    {
                        "full": "dayCountConvention='Actual365'",
                        "name": "dayCountConvention='Actual365'"
                    },
                    {
                        "full": "[curveName]",
                        "name": "curveName",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [eqDividendCurveBuilder](https://docs.dolphindb.cn/zh/funcs/e/eqDividendCurveBuilder.html)\n\n首发版本：3.00.5\n\n\n\n#### 语法\n\neqDividendCurveBuilder(referenceDate, termDates, method, \\[futPrices], \\[callPrices], \\[putPrices], \\[strikes], spot, discountCurve, dayCountConvention='Actual365', \\[curveName])\n\n#### 详情\n\n构建权益类分红（股息）曲线。\n\n#### 参数\n\n**referenceDate** DATE 类型标量，表示曲线的生成日期。\n\n**termDates** DATE 类型向量，表示曲线的期限日期，要求严格单调递增，且大于 *referenceDate*。\n\n**method** STRING 类型标量，可选 “CallPutParity” 和 “FuturesPrice”：\n\n* method = “CallPutParity”，表示通过看涨看跌平价关系推导隐含股息率；需要使用 *callPrices*、*putPrices*、*strikes*\n\n* method = “FuturesPrice”，表示通过期货价格公式推导隐含股息率；需要使用 *futPrices*\n\n**futPrices** 可选参数，DOUBLE 类型向量，正数，表示标的期货合约价格。\n\n**callPrices** 可选参数，DOUBLE 类型矩阵，正数，表示看涨期权的价格矩阵。\n\n**putPrices** 可选参数，DOUBLE 类型矩阵，正数，表示看跌期权的价格矩阵。\n\n**strikes** 可选参数，DOUBLE 类型矩阵，表示执行价，要求严格单调递增。\n\n**注**：\n\n* *callPrices*、*putPrices*、*strikes* 三者形状一致且列数与 *termDates* 等长。\n\n* *futPrices* 也与 *termDates* 等长。\n\n**spot** DOUBLE 类型标量，正数，表示标的的即期价格。\n\n**discountCurve** MKTDATA 类型标量，一个 IrYieldCurve 对象，表示折现曲线。\n\n**dayCountConvention** STRING 类型标量，表示计息日数惯例。可选值为：\n\n* \"Actual365\"（默认）：实际/365\n\n* \"Actual360\"：实际/360\n\n* \"ActualActualISMA\"：实际/实际（ISMA 规则）\n\n* \"ActualActualISDA\"：实际/实际（ISDA 规则）\n\n**curveName** 可选参数，STRING 类型标量，表示曲线名称。\n\n#### 返回值\n\nMKTDATA 类型对象。\n\n#### 例子\n\n##### CallPutParity\n\n通过 CallPutParity 方法构建一条上证 50ETF（标的代码： 510050.SH）的股息曲线。\n\n```\nreferenceDate = 2026.02.13\nspot = 3.114  // Close Price Of 510050.SH\n\n// 1. Term Structure (Option Expiry Dates)\ntermDates = [2026.02.25, 2026.03.25, 2026.06.24, 2026.09.23]\n\n// 2. Raw Data Matrices (Settlement Price)\ncallPrices = matrix(\n    [0.2640, 0.2140, 0.1640, 0.1140, 0.0327, 0.0042, 0.0016, 0.0008, 0.0003, 0.0002],\n    [0.2723, 0.2289, 0.1810, 0.1424, 0.0721, 0.0323, 0.0138, 0.0075, 0.0050, 0.0039],\n    [0.3150, 0.2770, 0.2391, 0.2073, 0.1519, 0.1061, 0.0731, 0.0519, 0.0379, 0.0280],\n    [0.3521, 0.3170, 0.2850, 0.2555, 0.2030, 0.1577, 0.1243, 0.0986, 0.0790, 0.0642]\n)\nputPrices = matrix(\n    [0.0004, 0.0008, 0.0021, 0.0044, 0.0215, 0.0928, 0.1889, 0.2884, 0.3895, 0.4903],\n    [0.0090, 0.0124, 0.0170, 0.0260, 0.0590, 0.1225, 0.1993, 0.2928, 0.3918, 0.4903],\n    [0.0352, 0.0463, 0.0571, 0.0746, 0.1188, 0.1733, 0.2401, 0.3204, 0.4049, 0.4938],\n    [0.0601, 0.0739, 0.0903, 0.1091, 0.1548, 0.2113, 0.2795, 0.3471, 0.4307, 0.5120]\n)\nstrikes = matrix(\n    [2.8500, 2.9000, 2.9500, 3.0000, 3.1000, 3.2000, 3.3000, 3.4000, 3.5000, 3.6000],\n    [2.8500, 2.9000, 2.9500, 3.0000, 3.1000, 3.2000, 3.3000, 3.4000, 3.5000, 3.6000],\n    [2.8500, 2.9000, 2.9500, 3.0000, 3.1000, 3.2000, 3.3000, 3.4000, 3.5000, 3.6000],\n    [2.8500, 2.9000, 2.9500, 3.0000, 3.1000, 3.2000, 3.3000, 3.4000, 3.5000, 3.6000]\n)\n\n// 3. Discount Curve \n// Data From https://www.chinamoney.com.cn/chinese/bkcurvuir/\nterms = [1d, 1w, 2w, 3w, 1M, 2M, 3M, 6M, 9M, 1y, 18M, 2y, 3y]\ndates = array(DATE, size(terms))\nfor(i in 0..(size(terms)-1)){\n    dates[i] = transFreq(temporalAdd(referenceDate, terms[i]), \"CFET\", \"right\", \"right\")\n}\ndiscountCurveDict = {\n    \"mktDataType\": \"Curve\",\n    \"curveType\": \"IrYieldCurve\",\n    \"curveName\": \"CNY_FR_007\",\n    \"referenceDate\": referenceDate,\n    \"currency\": \"CNY\",\n    \"dayCountConvention\": \"Actual365\",\n    \"compounding\": \"Continuous\",\n    \"interpMethod\": \"Linear\",\n    \"extrapMethod\": \"Flat\",\n    \"dates\": dates,\n    \"values\":[1.5577, 1.5247, 1.5181, 1.5181, 1.5195, 1.5216, 1.5167, 1.4964, 1.4758, 1.4732, 1.4859, 1.4985,1.5306] \\ 100\n}\ndiscountCurve = parseMktData(discountCurveDict)\n\n// 4. Implied Dividend Curve\n// Using Call-Put Parity on the full matrices\ndividendCurve = eqDividendCurveBuilder(\n    referenceDate, termDates, \"CallPutParity\", ,\n    callPrices, putPrices, strikes, spot, discountCurve, \"Actual365\"\n)\n\nprint(dividendCurve)\n```\n\n##### FuturesPrice\n\n通过 FuturesPrice 方法构建一条沪深300股指（标的代码： 000300.SH）的股息曲线。\n\n```\nreferenceDate = 2026.02.13\nspot = 4660.41  // Close Price Of 000300.SH\n\n// 1. Futures Price\ntermDates = [2026.02.24, 2026.03.20, 2026.06.22, 2026.09.18] // IF2602/03/06/09 Expiry Date\nfutPrices = [4650.6, 4639.6, 4601.2, 4540.4]  // Settlement Price\n\n// 2. Discount Curve\n// Data From https://www.chinamoney.com.cn/chinese/bkcurvuir/\nterms = [1d, 1w, 2w, 3w, 1M, 2M, 3M, 6M, 9M, 1y, 18M, 2y, 3y]\ndates = array(DATE, size(terms))\nfor(i in 0..(size(terms)-1)){\n    dates[i] = transFreq(temporalAdd(referenceDate, terms[i]), \"CFET\", \"right\", \"right\")\n}\ndiscountCurveDict = {\n    \"mktDataType\": \"Curve\",\n    \"curveType\": \"IrYieldCurve\",\n    \"curveName\": \"CNY_FR_007\",\n    \"referenceDate\": referenceDate,\n    \"currency\": \"CNY\",\n    \"dayCountConvention\": \"Actual365\",\n    \"compounding\": \"Continuous\",\n    \"interpMethod\": \"Linear\",\n    \"extrapMethod\": \"Flat\",\n    \"dates\": dates,\n    \"values\":[1.5577, 1.5247, 1.5181, 1.5181, 1.5195, 1.5216, 1.5167, 1.4964, 1.4758, 1.4732, 1.4859, 1.4985, 1.5306] \\ 100\n}\ndiscountCurve = parseMktData(discountCurveDict)\n\n//3. Build Dividend Curve\ndividendCurve = eqDividendCurveBuilder(referenceDate, termDates, \"FuturesPrice\", futPrices,\n    , , , spot, discountCurve, \"Actual365\", \"HS300\")\nprint(dividendCurve)\n```\n\n**相关函数**：[parseMktData](https://docs.dolphindb.cn/zh/funcs/p/parseMktData.html)\n"
    },
    "eqEuropeanOptionPricer": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/eqeuropeanoptionpricer.html",
        "signatures": [
            {
                "full": "eqEuropeanOptionPricer(instrument, pricingDate, spot, discountCurve, dividendCurve, volSurf, [setting])",
                "name": "eqEuropeanOptionPricer",
                "parameters": [
                    {
                        "full": "instrument",
                        "name": "instrument"
                    },
                    {
                        "full": "pricingDate",
                        "name": "pricingDate"
                    },
                    {
                        "full": "spot",
                        "name": "spot"
                    },
                    {
                        "full": "discountCurve",
                        "name": "discountCurve"
                    },
                    {
                        "full": "dividendCurve",
                        "name": "dividendCurve"
                    },
                    {
                        "full": "volSurf",
                        "name": "volSurf"
                    },
                    {
                        "full": "[setting]",
                        "name": "setting",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [eqEuropeanOptionPricer](https://docs.dolphindb.cn/zh/funcs/e/eqeuropeanoptionpricer.html)\n\n首发版本：3.00.5\n\n\n\n#### 语法\n\neqEuropeanOptionPricer(instrument, pricingDate, spot, discountCurve, dividendCurve, volSurf, \\[setting])\n\n#### 详情\n\n对权益类欧式期权进行定价。\n\n#### 参数\n\n**instrument** INSTRUMENT 类型标量或向量，表示需要定价的权益类欧式期权。字段要求参考 [Instrument 字段说明](https://docs.dolphindb.cn/zh/funcs/e/eqeuropeanoptionpricer.md#)。\n\n**pricingDate** DATE 类型标量或向量，表示定价日期。\n\n**spot** 数值类型标量或向量，表示现货价格。\n\n**discountCurve** MKTDATA 标量或向量，表示[折现曲线（IrYieldCurve）](https://docs.dolphindb.cn/zh/funcs/p/parseMktData.html)。\n\n**dividendCurve** MKTDATA 标量或向量，表示股息曲线（DividendCurve）。该曲线通过 `eqDividendCurveBuilder` 构建。\n\n**volSurf** VolatilitySurface 对象，表示权益类期权波动率曲面。该曲面由 `eqVolatilitySurfaceBuilder` 构建。\n\n**setting** 可选参数，字典（Dictionary\\<STRING, BOOL>），用于指定是否计算希腊字母（Greeks）所代表的期权价格敏感性指标。可选值：\n\n| 键               | 值             | 描述                                    |\n| --------------- | ------------- | ------------------------------------- |\n| calcDelta       | 布尔值，默认为 false | 是否计算 Delta，即期权价格相对于标的资产价格的敏感性。        |\n| calcGamma       | 布尔值，默认为 false | 是否计算 Gamma，即期权 Delta 相对于标的资产价格的敏感性。   |\n| calcVega        | 布尔值，默认为 false | 是否计算 Vega，即期权价格相对于标的资产波动率的敏感性。        |\n| calcTheta       | 布尔值，默认为 false | 是否计算 Theta，即期权价格相对于时间变化的敏感性。          |\n| calcRhoIr       | 布尔值，默认为 false | 是否计算 RhoIr，即期权价格相对于无风险利率的敏感性。         |\n| calcRhoDividend | 布尔值，默认为 false | 是否计算 RhoDividend，即期权价格相对于股息收益率变化的敏感性。 |\n\n#### 返回值\n\n* 若不指定 *setting* 参数，返回 DOUBLE 类型标量，表示期权的净现值（NPV），即期权的理论价格。\n* 指定 *setting* 参数时，返回一个字典（Dictionary\\<STRING, DOUBLE>），包含期权的净现值（NPV）以及希腊字母（Greeks）所代表的期权价格敏感性指标。有关敏感性指标的说明请参考 *setting* 参数说明。\n\n#### 例子\n\n```\n// ================================================================\n// 数据来源:\n//   现货价格  : akshare fund_etf_hist_sina('sh510050')     → 3.1140\n//   期权链/IV : akshare option_risk_indicator_sse('20260213')\n//               → Black-Scholes 重建期权结算价\n//   利率曲线  : 中国货币网 外币隐含利率曲线（CNY, USD.CNY/Shibor/掉期点）\n//               https://www.chinamoney.com.cn/chinese/bkcurvuiruuh/\n//               API: POST /ags/ms/cm-u-bk-fx/IuirCurvHis  2026-02-13\n//\n// 定价标的  : 看涨 Call  strike=3.2000  expiry=2026-03-25\n// ================================================================\n\npricingDate   = 2026.02.13\nreferenceDate = pricingDate\n\n// ------------------------------------------------------------------\n// 1. 现货价格\n// ------------------------------------------------------------------\nspot = 3.1140\n\n// ------------------------------------------------------------------\n// 2. 定义定价合约  (近月 ATM/轻虚值看涨期权)\n// ------------------------------------------------------------------\noptionDict = {\n    \"productType\"       : \"Option\",\n    \"optionType\"        : \"EuropeanOption\",\n    \"assetType\"         : \"EqEuropeanOption\",\n    \"notionalCurrency\"  : \"CNY\",\n    \"notionalAmount\"    : 10000,\n    \"strike\"            : 3.2000,\n    \"maturity\"          : 2026.03.25,\n    \"payoffType\"        : \"Call\",\n    \"dayCountConvention\": \"Actual365\",\n    \"underlying\"        : \"510050\"\n}\noption = parseInstrument(optionDict)\n\n// ------------------------------------------------------------------\n// 3. 期权链原始数据  (用于构建股息曲线与波动率曲面)\n//    到期日序列: 2026.02.25 | 2026.03.25 | 2026.06.24 | 2026.09.23\n//    行权价区间: [2.85, 3.60]\n// ------------------------------------------------------------------\ntermDates = [2026.02.25, 2026.03.25, 2026.06.24, 2026.09.23]\n\ncallPrices = matrix(\n    [0.2655, 0.2155, 0.1656, 0.1156, 0.0318, 0.0039, 0.0015, 0.0008, 0.0003, 0.0001],\n    [0.2690, 0.2248, 0.1770, 0.1385, 0.0697, 0.0303, 0.0128, 0.0069, 0.0046, 0.0036],\n    [0.3030, 0.2655, 0.2278, 0.1970, 0.1431, 0.0991, 0.0677, 0.0479, 0.0346, 0.0254],\n    [0.3330, 0.2987, 0.2681, 0.2388, 0.1883, 0.1448, 0.1139, 0.0899, 0.0715, 0.0574]\n)\n\nputPrices = matrix(\n    [0.0004, 0.0009, 0.0021, 0.0045, 0.0218, 0.0939, 0.1901, 0.2896, 0.3908, 0.4916],\n    [0.0125, 0.0165, 0.0229, 0.0316, 0.0616, 0.1250, 0.2029, 0.2967, 0.3962, 0.4948],\n    [0.0396, 0.0507, 0.0634, 0.0798, 0.1253, 0.1814, 0.2499, 0.3321, 0.4175, 0.5077],\n    [0.0651, 0.0798, 0.0973, 0.1180, 0.1662, 0.2250, 0.2952, 0.3651, 0.4508, 0.5342]\n)\n\nstrikes = matrix(\n    [2.8500, 2.9000, 2.9500, 3.0000, 3.1000, 3.2000, 3.3000, 3.4000, 3.5000, 3.6000],\n    [2.8500, 2.9000, 2.9500, 3.0000, 3.1000, 3.2000, 3.3000, 3.4000, 3.5000, 3.6000],\n    [2.8500, 2.9000, 2.9500, 3.0000, 3.1000, 3.2000, 3.3000, 3.4000, 3.5000, 3.6000],\n    [2.8500, 2.9000, 2.9500, 3.0000, 3.1000, 3.2000, 3.3000, 3.4000, 3.5000, 3.6000]\n)\n\n// ------------------------------------------------------------------\n// 4. 折现曲线  ── 中国货币网 外币隐含利率曲线 CNY 利率（2026-02-13）\n//    数据源: https://www.chinamoney.com.cn/chinese/bkcurvuiruuh/\n//    USD.CNY / Shibor / 即期询价报价均值 / 掉期点  →  rmbRateStr 字段\n// ------------------------------------------------------------------\ndiscountCurveDict = {\n    \"mktDataType\"       : \"Curve\",\n    \"curveType\"         : \"IrYieldCurve\",\n    \"curveName\"         : \"CNY_FR_007\",\n    \"referenceDate\"     : referenceDate,\n    \"currency\"          : \"CNY\",\n    \"dayCountConvention\": \"Actual365\",\n    \"compounding\"       : \"Continuous\",\n    \"interpMethod\"      : \"Linear\",\n    \"extrapMethod\"      : \"Flat\",\n    \"dates\"             : [referenceDate + 1, referenceDate + 7, referenceDate + 14, referenceDate + 21, referenceDate + 30, referenceDate + 61, referenceDate + 91, referenceDate + 182, referenceDate + 273, referenceDate + 365, referenceDate + 547, referenceDate + 730, referenceDate + 1095],\n    \"values\"            : [0.016134, 0.016107, 0.016102, 0.016102, 0.016102, 0.016103, 0.016029, 0.015832, 0.015889, 0.015898, 0.015561, 0.015583, 0.015892]\n}\ndiscountCurve = parseMktData(discountCurveDict)\n\n// ------------------------------------------------------------------\n// 5. 股息曲线  ── Call-Put 平价隐含法 (CallPutParity)\n// ------------------------------------------------------------------\ndividendCurve = eqDividendCurveBuilder(\n    referenceDate, termDates, \"CallPutParity\", ,\n    callPrices, putPrices, strikes, spot, discountCurve,\n    \"Actual365\", \"510050\"\n)\n\n// ------------------------------------------------------------------\n// 6. 波动率曲面  ── SABR 模型，使用虚值期权\n//    行权价 < Spot → OTM Put；行权价 >= Spot → OTM Call\n// ------------------------------------------------------------------\noptionExpiries = termDates\n\noptionPrices = matrix(\n    [0.0004, 0.0009, 0.0021, 0.0045, 0.0218, 0.0039, 0.0015, 0.0008, 0.0003, 0.0001],\n    [0.0125, 0.0165, 0.0229, 0.0316, 0.0616, 0.0303, 0.0128, 0.0069, 0.0046, 0.0036],\n    [0.0396, 0.0507, 0.0634, 0.0798, 0.1253, 0.0991, 0.0677, 0.0479, 0.0346, 0.0254],\n    [0.0651, 0.0798, 0.0973, 0.1180, 0.1662, 0.1448, 0.1139, 0.0899, 0.0715, 0.0574]\n)\n\npayoffTypes = matrix(\n    [\"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\"],\n    [\"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\"],\n    [\"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\"],\n    [\"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\"]\n)\n\nvolSurface = eqVolatilitySurfaceBuilder(\n    referenceDate,\n    optionExpiries,\n    strikes,\n    optionPrices,\n    payoffTypes,\n    spot,\n    discountCurve,\n    dividendCurve,\n    \"SABR\",\n    \"50ETF_SABR_20260213\"\n)\n\n// ------------------------------------------------------------------\n// 7. 定价 ── 单合约 NPV\n// ------------------------------------------------------------------\nnpv = eqEuropeanOptionPricer(option, pricingDate, spot, discountCurve, dividendCurve, volSurface)\nprint(\"NPV = \" + string(npv))\n\n// ------------------------------------------------------------------\n// 8. 定价 ── 含希腊字母 (Greeks)\n// ------------------------------------------------------------------\nsetting = {\n    \"calcDelta\"      : true,\n    \"calcGamma\"      : true,\n    \"calcVega\"       : true,\n    \"calcTheta\"      : true,\n    \"calcRhoIr\"      : true,\n    \"calcRhoDividend\": true\n}\nresult = eqEuropeanOptionPricer(option, pricingDate, spot, discountCurve, dividendCurve, volSurface, setting)\nprint(result)\n\n// ------------------------------------------------------------------\n// 9. 批量定价 ── 对 2026-03-25 到期的全部公共行权价 Call 合约\n// ------------------------------------------------------------------\nallStrikes = [2.8500, 2.9000, 2.9500, 3.0000, 3.1000, 3.2000, 3.3000, 3.4000, 3.5000, 3.6000]\nresults = array(DOUBLE, 0)\nfor (k in allStrikes) {\n    iDict = {\n        \"productType\"       : \"Option\",\n        \"optionType\"        : \"EuropeanOption\",\n        \"assetType\"         : \"EqEuropeanOption\",\n        \"notionalCurrency\"  : \"CNY\",\n        \"notionalAmount\"    : 10000,\n        \"strike\"            : k,\n        \"maturity\"          : 2026.03.25,\n        \"payoffType\"        : \"Call\",\n        \"dayCountConvention\": \"Actual365\",\n        \"underlying\"        : \"510050\"\n    }\n    iOpt = parseInstrument(iDict)\n    results.append!(eqEuropeanOptionPricer(iOpt, pricingDate, spot, discountCurve, dividendCurve, volSurface))\n}\nt = table(allStrikes as strike, results as npv)\nprint(t)\n```\n\n#### Instrument 字段说明\n\n<table id=\"table_cw5_zvx_f3c\"><thead><tr><th>\n\n字段名\n\n</th><th>\n\n类型\n\n</th><th>\n\n描述\n\n</th><th>\n\n是否必填\n\n</th></tr></thead><tbody><tr><td>\n\nproductType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"Option\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\noptionType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"EuropeanOption\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nassetType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 “EqEuropeanOption\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nnotionalAmount\n\n</td><td>\n\nDOUBLE\n\n</td><td>\n\n名义本金额\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nnotionalCurrency\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n名义本金货币，默认为 CNY\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ninstrumentId\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n合约代码，如中证500ETF期权\n\n510500C2512M04800\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ndirection\n\n</td><td>\n\nSRTRING\n\n</td><td>\n\n买卖方向 Buy Sell，默认为 Buy\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\nmaturity\n\n</td><td>\n\nDATE\n\n</td><td>\n\n到期日\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nstrike\n\n</td><td>\n\nDOUBLE\n\n</td><td>\n\n执行利率\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\npayoffType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n枚举，可选Call和Put\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nunderlying\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n标的期货合约代码，如 510050\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ndayCountConvention\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n日期计数惯例, 可选 \"ActualActualISDA\", \"ActualActualISMA\", \"Actual365\", \"Actual360\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ndiscountCurve\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n定价时参考的贴现曲线名称，人民币存款默认为 \"CNY\\_FR\\_007\"\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ndividendCurve\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n定价时参考的股息曲线名称\n\n</td><td>\n\n否\n\n</td></tr></tbody>\n</table>**相关函数：**[parseInstrument](../p/parseInstrument.md)、[parseMktData](../p/parseMktData.md)、[eqDividendCurveBuilder](eqDividendCurveBuilder.md)、[eqVolatilitySurfaceBuilder](eqvolatilitysurfacebuilder.md)\n"
    },
    "eqFloat": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/eqFloat.html",
        "signatures": [
            {
                "full": "eqFloat(X, Y, [precision=9])",
                "name": "eqFloat",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "[precision=9]",
                        "name": "precision",
                        "optional": true,
                        "default": "9"
                    }
                ]
            }
        ],
        "markdown": "### [eqFloat](https://docs.dolphindb.cn/zh/funcs/e/eqFloat.html)\n\n\n\n#### 语法\n\neqFloat(X, Y, \\[precision=9])\n\n#### 详情\n\n以给定（小数点后位数）精度，逐个元素比较 *X*==*Y*。\n\n#### 参数\n\n**X** 和 **Y** 可以是数值类型标量、向量或矩阵。如果 *X* 与 *Y* 其中一个是向量或矩阵，另一个必须是标量或具有相同长度或维度的向量或矩阵。\n\n**precision** 是一个非负整数，表示对 FLOAT 或 DOUBLE 类型，比较精度为小数点后几位。\n\n#### 返回值\n\n返回布尔类型，数据形式取决于 *X*/*Y*。\n\n#### 例子\n\n```\neqFloat(0.1234567891, 0.123456789);\n// output\ntrue\n\neqFloat(0.123456788, 0.123456789);\n// output\nfalse\n\neqFloat(0.123456788 0.123456789 0.1234567891, 0.123456789);\n// output\n[false,true,true]\n```\n"
    },
    "eqObj": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/eqObj.html",
        "signatures": [
            {
                "full": "eqObj(obj1, obj2, [precision])",
                "name": "eqObj",
                "parameters": [
                    {
                        "full": "obj1",
                        "name": "obj1"
                    },
                    {
                        "full": "obj2",
                        "name": "obj2"
                    },
                    {
                        "full": "[precision]",
                        "name": "precision",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [eqObj](https://docs.dolphindb.cn/zh/funcs/e/eqObj.html)\n\n\n\n#### 语法\n\neqObj(obj1, obj2, \\[precision])\n\n#### 详情\n\n检验两个对象的类型和值是否相同。只有当类型和值都相同时，此函数才会返回 true。 如果值相同但类型不同，则此函数仍返回 false，这与函数 [eq](https://docs.dolphindb.cn/zh/funcs/e/eq.html) 不同。\n\n**Note:** 使用 `eqObj` 比较浮点数时，根据 abs(obj1-obj2)<=pow(10,-precision) 的结果来判断 obj1 和 obj2 的值是否相等。\n\n#### 参数\n\n**obj1** 和 **obj2** 可以是标量、数据对、向量或矩阵。\n\n**precision** 是一个非负整数，表示对 FLOAT 或 DOUBLE 类型，比较精度为小数点后几位。\n\n#### 返回值\n\n布尔类型标量。\n\n#### 例子\n\n```\neqObj(2, 2.0);\n// output: false\n\neq(2, 2.0);\n// output: true\n\neqObj(1.1, 1.2, 0);\n// output: true\n\neqObj(1.1, 1.2, 1);\n// output: true\n\neqObj(1 2 3, 1 2 3);\n// output: true\n\neq(1 2 3, 1 2 3);\n// output: [true,true,true]\n```\n\n`eqObj` 不能直接用于比较两个表是否相同。但是，可以使用高阶函数 [each](https://docs.dolphindb.cn/zh/funcs/ho_funcs/each.html) 来逐列对比两个表的值。\n\n```\nt1=table(1 2 3 as x, 4 5 6 as y);\nt2=table(1 2 3 as x, 4 5 6 as y);\n\nt1.values();\n// output: ([1,2,3],[4,5,6])\n\neach(eqObj, t1.values(), t2.values());\n// output: [true,true]\n```\n"
    },
    "eqPercent": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/eqpercent.html",
        "signatures": [
            {
                "full": "eqPercent(X, Y,[toleranceLevel=0.0001])",
                "name": "eqPercent",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "[toleranceLevel=0.0001]",
                        "name": "toleranceLevel",
                        "optional": true,
                        "default": "0.0001"
                    }
                ]
            }
        ],
        "markdown": "### [eqPercent](https://docs.dolphindb.cn/zh/funcs/e/eqpercent.html)\n\n\n\n#### 语法\n\neqPercent(X, Y,\\[toleranceLevel=0.0001])\n\n#### 详情\n\n根据自定义约束条件，判断两个输入参数的每个对应位置上的元素是否都相等。\n\n#### 参数\n\n**X** 和 **Y** 要比较的两个数值，仅支持长度相同的标量、向量、数据对或矩阵。数据类型仅支持 BOOL, CHAR, SHORT, INT, LONG, FLOAT, DOUBLE, DECIMAL。注意：*X* 和 *Y* 中的元素在比较时可以是不同的数据类型。\n\n**toleranceLevel** 可选参数，数值标量，值域为(0,100)，表示可容许误差的百分位数，默认值为 0.0001。即两元素差值的绝对值不多于 *Y* 绝对值的 `toleranceLevel%`。如 *Y* 输入 1000，*toleranceLevel* 取默认值 0.0001，则可容忍误差为 1000\\*0.0001%=0.001，即\\[999.999, 1000.001]之间的 *X* 会被认为相等。\n\n#### 返回值\n\n输出一个 BOOL 标量，true 代表 *X* 与 *Y* 每个对应位置的元素都在约束下相等；false 反之。\n\n注意：\n\n* 如果传入的参数 *X* 或 *Y* 的类型不受支持，则返回 `eqObj(X, Y)` 的结果值。\n\n* NULL 值和其他值不相等。\n\n* 不同类型之间的 NULL 值被认为相等。\n\n#### 例子\n\n以下给出几个简单示例。\n\n```\neqPercent((1.9999 2.9999), (2 3))\n//Output:true\n\neqPercent((1.9 2.9), (2 3), 2)\n//Output:false\n\neqPercent((1.99f 2.99), (2 3h), 2)\n//Output:true\n//X和Y中的元素在比较时可以是不同的数据类型\n\neqPercent((1.9999 NULL), (2 3))\n//Output:false\n\na=double(NULL)\neqPercent(a,NULL)\n//Output:true\n//DOUBLE类型和VOID类型的NULL相等\n\neqPercent(2012.06M, 2)\n//Output:false\n//传入不支持其类型的X，返回eqObj(X, Y)的结果值。\n```\n\n相关函数：[eqObj](https://docs.dolphindb.cn/zh/funcs/e/eqObj.html)\n"
    },
    "eqProxyVolatilitySurfaceBuilder": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/eqproxyvolatilitysurfacebuilder.html",
        "signatures": [
            {
                "full": "eqProxyVolatilitySurfaceBuilder(referenceDate, proxyExpiries, proxyStrikes, proxyCallPrices, proxyPutPrices, proxySpot, spot, discountCurve, dividendCurve, [model=”SVI”], [surfaceName])",
                "name": "eqProxyVolatilitySurfaceBuilder",
                "parameters": [
                    {
                        "full": "referenceDate",
                        "name": "referenceDate"
                    },
                    {
                        "full": "proxyExpiries",
                        "name": "proxyExpiries"
                    },
                    {
                        "full": "proxyStrikes",
                        "name": "proxyStrikes"
                    },
                    {
                        "full": "proxyCallPrices",
                        "name": "proxyCallPrices"
                    },
                    {
                        "full": "proxyPutPrices",
                        "name": "proxyPutPrices"
                    },
                    {
                        "full": "proxySpot",
                        "name": "proxySpot"
                    },
                    {
                        "full": "spot",
                        "name": "spot"
                    },
                    {
                        "full": "discountCurve",
                        "name": "discountCurve"
                    },
                    {
                        "full": "dividendCurve",
                        "name": "dividendCurve"
                    },
                    {
                        "full": "[model=”SVI”]",
                        "name": "model",
                        "optional": true,
                        "default": "”SVI”"
                    },
                    {
                        "full": "[surfaceName]",
                        "name": "surfaceName",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [eqProxyVolatilitySurfaceBuilder](https://docs.dolphindb.cn/zh/funcs/e/eqproxyvolatilitysurfacebuilder.html)\n\n首发版本：3.00.5\n\n\n\n#### 语法\n\neqProxyVolatilitySurfaceBuilder(referenceDate, proxyExpiries, proxyStrikes, proxyCallPrices, proxyPutPrices, proxySpot, spot, discountCurve, dividendCurve, \\[model=”SVI”], \\[surfaceName])\n\n#### 详情\n\n构造权益类代理波动率曲面。\n\n#### 参数\n\n**referenceDate** DATE 类型标量，表示参考日期。\n\n**proxyExpiries** DATE 类型向量，表示代理期权合约的到期日。\n\n**proxyStrikes** DOUBLE 类型矩阵，表示代理期权合约的执行价，列数与 *proxyExpiries* 一致。\n\n**proxyCallPrices** DOUBLE 类型矩阵，表示代理期权合约的看涨报价，列数与 *proxyExpiries* 一致，行数与 *proxyStrikes*一致。\n\n**proxyPutPrices** DOUBLE 类型矩阵，表示代理期权合约的看跌报价，列数与 *proxyExpiries* 一致，行数与 *proxyStrikes* 一致。\n\n**proxySpot** DOUBLE 类型标量，表示代理期权的现货报价。\n\n**spot** DOUBLE 类型标量，表示期权的现货报价。\n\n**discountCurve** MKTDATA 标量或向量，表示[折现曲线（IrYieldCurve）](https://docs.dolphindb.cn/zh/funcs/p/parseMktData.md#)。\n\n**dividendCurve** MKTDATA 标量或向量，表示股息曲线（DividendCurve）。该曲线通过 `eqDividendCurveBuilder` 构建。\n\n**model** 可选参数，STRING 类型标量，表示构建波动率微笑的模型。默认值为 “SVI”， 可选值为“SABR”， “Linear”，“CubicSpline”， “SVI”。\n\n**surfaceName** 可选参数，STRING 类型标量，表示曲面名称。\n\n#### 返回值\n\n一个 VolatilitySurface 对象。\n\n#### 例子\n\n```\nreferenceDate = 2025.11.12\n\n// parse For discount curve: CNY_FR_007\n\ndiscountCurveDict = {\n    \"mktDataType\": \"Curve\",\n    \"curveType\": \"IrYieldCurve\",\n    \"curveName\": \"CNY_FR_007\",\n    \"referenceDate\": referenceDate,\n    \"currency\": \"CNY\",\n    \"dayCountConvention\": \"Actual365\",\n    \"compounding\": \"Continuous\",\n    \"interpMethod\": \"Linear\",\n    \"extrapMethod\": \"Flat\",\n    \"dates\": [\n        2025.11.13, 2025.11.19, 2025.11.26, 2025.12.03, 2025.12.12,\n        2026.01.12, 2026.02.12, 2026.05.12, 2026.08.12, 2026.11.12,\n        2027.05.12, 2027.11.12, 2028.11.12\n    ],\n    \"values\":[\n        0.015219, 0.015311, 0.015668, 0.015948, 0.016003,\n        0.015557, 0.015474, 0.015278, 0.01517, 0.01515,\n        0.015306, 0.015462, 0.015716\n    ]\n}\ndiscountCurve = parseMktData(discountCurveDict)\n\n// build eq dividend curve\n\nspot = 7.285\n\nterm_dates = [2026.01.28, 2026.03.25, 2026.06.23, 2026.12.23]\n\ncall_prices = matrix(\n    [1.2850, 1.0350, 0.7850, 0.5350, 0.3078, 0.1618, 0.0730, 0.0318, 0.0141, 0.0073],\n    [1.2850, 1.0350, 0.7850, 0.5350, 0.3421, 0.2235, 0.1388, 0.0898, 0.0544, 0.0362],\n    [1.2850, 1.0350, 0.7850, 0.5350, 0.3901, 0.2851, 0.2087, 0.1495, 0.1083, 0.0788],\n    [1.2850, 1.0350, 0.7850, 0.5350, 0.2850, 0.0945, 0.0168, 0.0031, 0.0016, 0.0012]\n)\n\nput_prices = matrix(\n    [0.0040, 0.0086, 0.0189, 0.0408, 0.0938, 0.1934, 0.3500, 0.5638, 0.7947, 1.0380],\n    [0.0279, 0.0493, 0.0847, 0.1428, 0.2354, 0.3668, 0.5289, 0.7182, 0.9429, 1.1685],\n    [0.1000, 0.1525, 0.2224, 0.3175, 0.4276, 0.5790, 0.7471, 0.9336, 1.1392, 1.3555],\n    [0.0012, 0.0013, 0.0021, 0.0048, 0.0139, 0.0710, 0.2414, 0.4752, 0.7342, 0.9793]\n)\n\nstrikes = matrix(\n    [6.00, 6.25, 6.50, 6.75, 7.00, 7.25, 7.50, 7.75, 8.00, 8.25],\n    [6.00, 6.25, 6.50, 6.75, 7.00, 7.25, 7.50, 7.75, 8.00, 8.25],\n    [6.00, 6.25, 6.50, 6.75, 7.00, 7.25, 7.50, 7.75, 8.00, 8.25],\n    [6.00, 6.25, 6.50, 6.75, 7.00, 7.25, 7.50, 7.75, 8.00, 8.25]\n)\n\ndividendCurve = eqDividendCurveBuilder(referenceDate, term_dates, \"CallPutParity\", ,\n    call_prices, put_prices, strikes, spot, discountCurve, \"Actual365\");\n\n// build eq proxy volatility surface\n\nexpiries = [2026.01.28, 2026.03.25, 2026.06.23, 2026.12.23]\n\ncall_prices = matrix(\n    [1.2850, 1.0350, 0.7850, 0.5350, 0.3078, 0.1618, 0.0730, 0.0318, 0.0141, 0.0073],\n    [1.2850, 1.0350, 0.7850, 0.5350, 0.3421, 0.2235, 0.1388, 0.0898, 0.0544, 0.0362],\n    [1.2850, 1.0350, 0.7850, 0.5350, 0.3901, 0.2851, 0.2087, 0.1495, 0.1083, 0.0788],\n    [1.2850, 1.0350, 0.7850, 0.5350, 0.2850, 0.0945, 0.0168, 0.0031, 0.0016, 0.0012]\n)\n\nput_prices = matrix(\n    [0.0040, 0.0086, 0.0189, 0.0408, 0.0938, 0.1934, 0.3500, 0.5638, 0.7947, 1.0380],\n    [0.0279, 0.0493, 0.0847, 0.1428, 0.2354, 0.3668, 0.5289, 0.7182, 0.9429, 1.1685],\n    [0.1000, 0.1525, 0.2224, 0.3175, 0.4276, 0.5790, 0.7471, 0.9336, 1.1392, 1.3555],\n    [0.0012, 0.0013, 0.0021, 0.0048, 0.0139, 0.0710, 0.2414, 0.4752, 0.7342, 0.9793]\n)\n\nstrikes = matrix(\n    [6.00, 6.25, 6.50, 6.75, 7.00, 7.25, 7.50, 7.75, 8.00, 8.25],\n    [6.00, 6.25, 6.50, 6.75, 7.00, 7.25, 7.50, 7.75, 8.00, 8.25],\n    [6.00, 6.25, 6.50, 6.75, 7.00, 7.25, 7.50, 7.75, 8.00, 8.25],\n    [6.00, 6.25, 6.50, 6.75, 7.00, 7.25, 7.50, 7.75, 8.00, 8.25]\n)\n\nproxy_spot = 7.285\nspot = 7169.79\n\nsurface = eqProxyVolatilitySurfaceBuilder(referenceDate, expiries, strikes,\n    call_prices, put_prices, proxy_spot, spot, discountCurve, dividendCurve , \"SVI\")\nprint(surface)\n```\n\n**相关函数：**[parseMktData](https://docs.dolphindb.cn/zh/funcs/p/parseMktData.html)、[eqDividendCurveBuilder](https://docs.dolphindb.cn/zh/funcs/e/eqDividendCurveBuilder.html)\n"
    },
    "eqVolatilitySurfaceBuilder": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/eqvolatilitysurfacebuilder.html",
        "signatures": [
            {
                "full": "eqVolatilitySurfaceBuilder(referenceDate, optionExpiries, strikes, optionPrices, payoffTypes, spot, discountCurve, dividendCurve, [model='SVI'], [surfaceName])",
                "name": "eqVolatilitySurfaceBuilder",
                "parameters": [
                    {
                        "full": "referenceDate",
                        "name": "referenceDate"
                    },
                    {
                        "full": "optionExpiries",
                        "name": "optionExpiries"
                    },
                    {
                        "full": "strikes",
                        "name": "strikes"
                    },
                    {
                        "full": "optionPrices",
                        "name": "optionPrices"
                    },
                    {
                        "full": "payoffTypes",
                        "name": "payoffTypes"
                    },
                    {
                        "full": "spot",
                        "name": "spot"
                    },
                    {
                        "full": "discountCurve",
                        "name": "discountCurve"
                    },
                    {
                        "full": "dividendCurve",
                        "name": "dividendCurve"
                    },
                    {
                        "full": "[model='SVI']",
                        "name": "model",
                        "optional": true,
                        "default": "'SVI'"
                    },
                    {
                        "full": "[surfaceName]",
                        "name": "surfaceName",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [eqVolatilitySurfaceBuilder](https://docs.dolphindb.cn/zh/funcs/e/eqvolatilitysurfacebuilder.html)\n\n首发版本：3.00.5\n\n\n\n#### 语法\n\neqVolatilitySurfaceBuilder(referenceDate, optionExpiries, strikes, optionPrices, payoffTypes, spot, discountCurve, dividendCurve, \\[model='SVI'], \\[surfaceName])\n\n#### 详情\n\n构建权益类期权波动率曲面。\n\n#### 参数\n\n**referenceDate** DATE 类型标量，表示曲面的参考日期。\n\n**optionExpiries** DATE 类型向量，表示期权合约的到期日。\n\n**strikes** DOUBLE 类型矩阵，列数与 optionExpries 一致，表示期权合约的执行价。\n\n**optionPrices** DOUBLE 类型矩阵，列数与 optionExpries 一致，表示期权合约的价格。\n\n**payoffTypes** STRING 类型矩阵，列数与 optionExpries 一致，表示期权类型。可选 “Call” 和 “Put”。\n\n注意： *strikes* ， *optionPrices* ， *payoffTypes* 形状要求一致。\n\n**spot** DOUBLE 类型标量，表示即期价格。\n\n**discountCurve** IrYieldCurve 对象，表示折现曲线。\n\n**dividendCurve** DividendCurve 对象，表示标的分红曲线。\n\n**model** 可选参数，STRING 类型标量，表示构建波动率微笑的模型。默认值为 “SVI”，可选值为 “SABR”，“Linear”，“CubicSpline”。\n\n**surfaceName** 可选参数，STRING 类型标量，表示曲面名称。\n\n#### 返回值\n\n一个 VolatilitySurface 对象。\n\n#### 例子\n\n下面展示标的为科创 50ETF(588080.SH) 期权的波动率曲面构建过程。\n\n```\nreferenceDate = 2026.02.11\nspot = 1.5007\n\n// 1. Term Structure\ntermDates = [2026.02.25, 2026.03.25, 2026.06.24, 2026.09.23]\n\n// 2. Raw Data Matrices (Aligned)\ncallPrices = matrix(\n    [0.2402, 0.1908, 0.1415, 0.0927, 0.0496, 0.0199, 0.0075, 0.0032, 0.0014, 0.0010, 0.0007, 0.0002],\n    [0.2398, 0.1956, 0.1516, 0.1095, 0.0780, 0.0530, 0.0347, 0.0232, 0.0152, 0.0101, 0.0069, 0.0043],\n    [0.2537, 0.2137, 0.1803, 0.1494, 0.1252, 0.1051, 0.0871, 0.0717, 0.0597, 0.0500, 0.0421, 0.0361],\n    [0.2730, 0.2442, 0.2086, 0.1816, 0.1676, 0.1439, 0.1301, 0.1099, 0.0961, 0.0848, 0.0748, 0.0663]\n)\nputPrices = matrix(\n    [0.0003, 0.0003, 0.0004, 0.0018, 0.0085, 0.0297, 0.0671, 0.1130, 0.1601, 0.2084, 0.2609, 0.3124],\n    [0.0033, 0.0062, 0.0114, 0.0215, 0.0383, 0.0621, 0.0947, 0.1331, 0.1767, 0.2114, 0.2565, 0.3032],\n    [0.0234, 0.0349, 0.0505, 0.0713, 0.0936, 0.1237, 0.1562, 0.1919, 0.2218, 0.2610, 0.3010, 0.3437],\n    [0.0445, 0.0640, 0.0808, 0.1062, 0.1312, 0.1615, 0.1882, 0.2187, 0.2567, 0.2937, 0.3323, 0.3777]\n)\nstrikes = matrix(\n    [1.2500, 1.3000, 1.3500, 1.4000, 1.4500, 1.5000, 1.5500, 1.6000, 1.6500, 1.7000, 1.7500, 1.8000],\n    [1.2500, 1.3000, 1.3500, 1.4000, 1.4500, 1.5000, 1.5500, 1.6000, 1.6500, 1.7000, 1.7500, 1.8000],\n    [1.2500, 1.3000, 1.3500, 1.4000, 1.4500, 1.5000, 1.5500, 1.6000, 1.6500, 1.7000, 1.7500, 1.8000],\n    [1.2500, 1.3000, 1.3500, 1.4000, 1.4500, 1.5000, 1.5500, 1.6000, 1.6500, 1.7000, 1.7500, 1.8000]\n)\n\n// 3. Discount Curve \ndiscountCurveDict = {\n    \"mktDataType\": \"Curve\",\n    \"curveType\": \"IrYieldCurve\",\n    \"curveName\": \"CNY_RF\",\n    \"referenceDate\": referenceDate,\n    \"currency\": \"CNY\",\n    \"dayCountConvention\": \"Actual365\",\n    \"compounding\": \"Continuous\",\n    \"interpMethod\": \"Linear\",\n    \"extrapMethod\": \"Flat\",\n    \"dates\": [referenceDate + 1, referenceDate + 3650],\n    \"values\":[0.02, 0.02]\n}\ndiscountCurve = parseMktData(discountCurveDict)\n\n// 4. Implied Dividend Curve\n// Using Call-Put Parity on the full matrices\ndividendCurve = eqDividendCurveBuilder(\n    referenceDate, termDates, \"CallPutParity\", ,\n    callPrices, putPrices, strikes, spot, discountCurve, \"Actual365\"\n)\n\n// 5. Volatility Surface Construction Data\n// Selecting OTM options: Puts for Low Strikes, Calls for High Strikes\noptionExpiries = termDates\noptionPrices = matrix(\n    [0.0003, 0.0003, 0.0004, 0.0018, 0.0085, 0.0297, 0.0075, 0.0032, 0.0014, 0.0010, 0.0007, 0.0002],\n    [0.0033, 0.0062, 0.0114, 0.0215, 0.0383, 0.0621, 0.0347, 0.0232, 0.0152, 0.0101, 0.0069, 0.0043],\n    [0.0234, 0.0349, 0.0505, 0.0713, 0.0936, 0.1237, 0.0871, 0.0717, 0.0597, 0.0500, 0.0421, 0.0361],\n    [0.0445, 0.0640, 0.0808, 0.1062, 0.1312, 0.1615, 0.1301, 0.1099, 0.0961, 0.0848, 0.0748, 0.0663]\n)\npayoffTypes = matrix(\n    [\"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\"],\n    [\"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\"],\n    [\"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\"],\n    [\"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\"]\n)\n\n// 6. Build Surface.\nsurf = eqVolatilitySurfaceBuilder(\n        referenceDate,\n        optionExpiries,\n        strikes,        // Matrix\n        optionPrices,   // Matrix (OTM)\n        payoffTypes,    // Matrix (\"Call\"/\"Put\")\n        spot,\n        discountCurve,\n        dividendCurve,\n        \"SABR\",         // Model\n        \"588080.SH\"     // Name\n)\nprint(surf)\n\n// 波动率曲面可视化\n\n\ndts = (0..20)*0.05\nks = (0..40)*((max(strikes[0])-min(strikes[0]))\\40)+min(strikes[0])\nm = optionVolPredict(surf, dts, ks).rename!(dts, ks)\n\n\nplot(\n    m,\n    title=[\"Vol Surface\", \"K\", \"T\", \"vol\"],\n    chartType=SURFACE)\n    \n```\n\n**相关函数：** [parseMktData](https://docs.dolphindb.cn/zh/funcs/p/parseMktData.html)、[eqDividendCurveBuilder](https://docs.dolphindb.cn/zh/funcs/e/eqDividendCurveBuilder.html)\n"
    },
    "erase!": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/erase_.html",
        "signatures": [
            {
                "full": "erase!(obj, key|filter)",
                "name": "erase!",
                "parameters": [
                    {
                        "full": "obj",
                        "name": "obj"
                    },
                    {
                        "full": "key|filter",
                        "name": "key|filter"
                    }
                ]
            }
        ],
        "markdown": "### [erase!](https://docs.dolphindb.cn/zh/funcs/e/erase_.html)\n\n\n\n#### 语法\n\nerase!(obj, key|filter)\n\n#### 详情\n\n删除集合中的某些元素或字典中的键值或表中的某些行。\n\n#### 参数\n\n**obj** 可以是集合、字典或表。\n\n对于集合，**key|filter** 表示要删除的元素；对于字典，*key|filter* 表示要删除的键值；对于表，*key|filter* 表示过滤条件的元代码。\n\n#### 返回值\n\n返回修改后的集合、字典或表，数据类型同 *obj*。\n\n#### 例子\n\n对于集合：\n\n```\ny=set(8 9 4 6);\ny;\n// output\nset(6,4,9,8)\ny.erase!(6);\n// output\nset(4,9,8)\nerase!(y, 9 8);\n// output\nset(4)\n```\n\n对于字典：\n\n```\nx=1..6;\ny=11..16;\nz=dict(x,y);\nz;\n// output\n6->16\n5->15\n4->14\n3->13\n2->12\n1->11\n\nerase!(z, 1..4);\n// output\n6->16\n5->15\n```\n\n对于表：\n\n```\nx=1..10;\ny=11..20;\nt=table(x,y);\n// output\nerase!(t, <x<=3>);\n```\n\n| x  | y  |\n| -- | -- |\n| 4  | 14 |\n| 5  | 15 |\n| 6  | 16 |\n| 7  | 17 |\n| 8  | 18 |\n| 9  | 19 |\n| 10 | 20 |\n\n```\nerase!(t, <x<=9 and y>=15>);\n```\n\n| x  | y  |\n| -- | -- |\n| 4  | 14 |\n| 10 | 20 |\n"
    },
    "esd": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/esd.html",
        "signatures": [
            {
                "full": "esd(data, [hybrid], [maxAnomalies], [alpha])",
                "name": "esd",
                "parameters": [
                    {
                        "full": "data",
                        "name": "data"
                    },
                    {
                        "full": "[hybrid]",
                        "name": "hybrid",
                        "optional": true
                    },
                    {
                        "full": "[maxAnomalies]",
                        "name": "maxAnomalies",
                        "optional": true
                    },
                    {
                        "full": "[alpha]",
                        "name": "alpha",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [esd](https://docs.dolphindb.cn/zh/funcs/e/esd.html)\n\n\n\n#### 语法\n\nesd(data, \\[hybrid], \\[maxAnomalies], \\[alpha])\n\n#### 详情\n\n使用 ESD (Extreme Studentized Deviate) 算法对时间序列进行异常检测。\n\n#### 参数\n\n**data** 是一个数值向量。\n\n**hybrid** 是一个布尔值，表示是否用中位数和绝对中位差代替 Grubb's test 中 zscore 计算的平均值和标准差。如果 *hybrid* 为 true，算法更具鲁棒性。默认值为 false。\n\n**maxAnomalies** 是一个正整数或(0, 0.5)之间的浮点数。默认值为0.1。\n\n* 如果 *maxAnomalies* 是正整数，*maxAnomalies* 必须小于 *data* 长度的一半，函数最多检测 *maxAnomalies* 个异常点。\n\n* 如果 *maxAnomalies* 是(0, 0.5)之间的浮点数，函数最多检测 int(size(data) \\* maxAnomalies) 个异常点。\n\n**alpha** 是一个正数，表示检验的显著度。*alpha* 越大，数据越有可能被判断为异常点。\n\n#### 返回值\n\n返回一个包含异常值的表，该表有两列，index 列记录原始数据中异常值的下标，anoms 列记录异常值。\n\n#### 例子\n\n```\nn = 1000\nts = rand(10.0, n)\nts[500 600 700 999] += 20\nesd(ts);\n```\n\n| index | anoms     |\n| ----- | --------- |\n| 600   | 29.815742 |\n| 700   | 25.517493 |\n| 500   | 25.17515  |\n| 999   | 24.748516 |\n\n相关函数：[stl](https://docs.dolphindb.cn/zh/funcs/s/stl.html), [seasonalEsd](https://docs.dolphindb.cn/zh/funcs/s/seasonalEsd.html)\n"
    },
    "euclidean": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/euclidean.html",
        "signatures": [
            {
                "full": "euclidean(X, Y)",
                "name": "euclidean",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [euclidean](https://docs.dolphindb.cn/zh/funcs/e/euclidean.html)\n\n\n\n#### 语法\n\neuclidean(X, Y)\n\n#### 详情\n\n若 *X* 和 *Y* 是标量或向量，计算 *X* 和 *Y* 之间的欧氏距离。\n\n若 *X* 和 *Y* 是矩阵，计算每列元素之间的欧式距离，返回一个向量。 注意，若 *X* 或 *Y* 同时为索引矩阵或索引序列，会自动对齐标签，返回标签相同的行的计算结果，忽略标签不同的行。\n\n与所有其它聚合函数一致，计算时忽略 NULL 值。\n\n#### 参数\n\n**X** 和 **Y** 是长度相同的数值型标量/向量/矩阵。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\na=[100, 0, 0]\nb=[0, 51, NULL]\neuclidean(a,b)\n// output\n112.254176\n\ns1=indexedSeries(1 2 4, 10.4 11.2 9)\ns2=indexedSeries(1 2 5, 23.5 31.2 26)\neuclidean(s1,s2)\n// output\n23.9084\n\nm=matrix(23 56 47, 112 94 59)\neuclidean(a,m)\n// output\n[106.1791,111.6288]\n\nm1=matrix(11 15 89, 52 41 63)\neuclidean(m,m1)\n// output\n[59.9083,80.1561]\n\nm.rename!(2020.01.01..2020.01.03, `A`B)\nm.setIndexedMatrix!()\nm1.rename!(2020.01.01 2020.01.03 2020.01.04, `A`B)\nm1.setIndexedMatrix!()\neuclidean(m,m1)\n// output\n[34.176,62.6418]\n```\n\n相关函数：[rowEuclidean](https://docs.dolphindb.cn/zh/funcs/r/rowEuclidean.html)\n"
    },
    "eval": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/eval.html",
        "signatures": [
            {
                "full": "eval(expr)",
                "name": "eval",
                "parameters": [
                    {
                        "full": "expr",
                        "name": "expr"
                    }
                ]
            }
        ],
        "markdown": "### [eval](https://docs.dolphindb.cn/zh/funcs/e/eval.html)\n\n\n\n#### 语法\n\neval(expr)\n\n#### 详情\n\n解析给定的元代码。\n\n**Note:**\n\n* DolphinDB `eval` 用于执行 DolphinDB 元代码。\n* Python 内置的 [eval](https://docs.python.org/3/library/functions.html#eval) 用于执行 Python 表达式字符串。\n* [pandas.eval](https://pandas.pydata.org/docs/reference/api/pandas.eval.html) 用于对 pandas 对象执行表达式字符串。\n\n#### 参数\n\n**expr** 是元代码。\n\n#### 例子\n\n```\neval(<1+2>);\n// output\n3\n\neval(<1+2+3=10>);\n// output\n0\n\neval(expr(6,<,8));\n// output\n1\n\neval(expr(sum, 1 2 3));\n// output\n6\n\na=6; b=9;\neval(expr(<a>,+,<b>));\n// output\n15\n```\n\n相关函数：[expr](https://docs.dolphindb.cn/zh/funcs/e/expr.html), [parseExpr](https://docs.dolphindb.cn/zh/funcs/p/parseExpr.html)\n"
    },
    "evalTimer": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/evalTimer.html",
        "signatures": [
            {
                "full": "evalTimer(funcs, [count=1])",
                "name": "evalTimer",
                "parameters": [
                    {
                        "full": "funcs",
                        "name": "funcs"
                    },
                    {
                        "full": "[count=1]",
                        "name": "count",
                        "optional": true,
                        "default": "1"
                    }
                ]
            }
        ],
        "markdown": "### [evalTimer](https://docs.dolphindb.cn/zh/funcs/e/evalTimer.html)\n\n\n\n#### 语法\n\nevalTimer(funcs, \\[count=1])\n\n#### 详情\n\n返回执行指定函数耗费的时间，单位是毫秒。如果 *funcs* 包含多个函数，`evalTimer` 返回的是顺序执行这些函数耗费的时间。\n\n[timer](https://docs.dolphindb.cn/zh/progr/statements/timer.html) 语句和 `evalTimer` 函数的功能类似，两者的区别是：\n\n* `timer` 语句的输入是代码块； `evalTimer` 函数的输入是函数。如果要用 `evalTimer` 函数计算执行一段代码的时间，需要把代码写成自定义函数。\n\n* `timer` 语句的返回结果是一条消息，不能赋值给一个变量； `evalTimer` 函数的返回结果是一个标量，可以赋值给变量。\n\n#### 参数\n\n**funcs** 是一个或多个没有参数的函数。如果有多个函数，使用元组表示。\n\n**count** 是一个整数，表示执行的次数。它是可选参数，默认值为1。\n\n#### 返回值\n\nDOUBLE 类型标量。\n\n#### 例子\n\n```\nx=rand(10.0, 1000000)\nevalTimer(dot{x,2},10);\n// output\n39.609375\n\nevalTimer(sort{x},10);\n// output\n837.542702\n\nevalTimer([dot{x,2},sort{x}],10)\n// output\n870.065348\n```\n\n从上面的例子可以看出，`evalTimer` 返回的是顺序执行这些函数耗费的时间，而不是并行执行。\n"
    },
    "ewmCorr": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/ewmCorr.html",
        "signatures": [
            {
                "full": "ewmCorr(X, [com], [span], [halfLife], [alpha], [minPeriods=0], [adjust=true], [ignoreNA=false], [other], [bias=false])",
                "name": "ewmCorr",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[com]",
                        "name": "com",
                        "optional": true
                    },
                    {
                        "full": "[span]",
                        "name": "span",
                        "optional": true
                    },
                    {
                        "full": "[halfLife]",
                        "name": "halfLife",
                        "optional": true
                    },
                    {
                        "full": "[alpha]",
                        "name": "alpha",
                        "optional": true
                    },
                    {
                        "full": "[minPeriods=0]",
                        "name": "minPeriods",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[adjust=true]",
                        "name": "adjust",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[ignoreNA=false]",
                        "name": "ignoreNA",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[other]",
                        "name": "other",
                        "optional": true
                    },
                    {
                        "full": "[bias=false]",
                        "name": "bias",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [ewmCorr](https://docs.dolphindb.cn/zh/funcs/e/ewmCorr.html)\n\n\n\n#### 语法\n\newmCorr(X, \\[com], \\[span], \\[halfLife], \\[alpha], \\[minPeriods=0], \\[adjust=true], \\[ignoreNA=false], \\[other], \\[bias=false])\n\n#### 详情\n\n返回 *X* 和 *other* 的指数加权移动相关系数。该函数必须指定 *com*, *span*, *halfLife*, *alpha* 四个参数中的一个。\n\n#### 参数\n\n**X** 是一个数值型向量、矩阵或表。若 *X* 是表，只对其内数值型和布尔型的列进行计算。\n\n**com** 是一个大于等于0的数值型标量，表示质心。\n\n**span** 是一个大于等于1的数值型标量，表示跨度。\n\n**halfLife** 是一个大于0的数值型标量，表示半衰期。\n\n**alpha** 是一个(0,1]之间的浮点数，表示平滑系数。\n\n**minPeriods** 是一个整数，表示窗口中的最小观察数。默认值为0。\n\n**adjust** 是一个布尔值，表示是否除以开始阶段的衰减调整因子。默认值为 true。\n\n**ignoreNA** 是一个布尔值，表示计算权重时是否忽略NULL值。默认值为 false。\n\n**other** 当 *X* 是向量时，*other* 只能是一个与 *X* 长度相同的数值型向量；当 *X* 是矩阵时，*other* 是一个长度与 *X* 行数相同的数值型向量，或维度与 *X* 相同的矩阵；当 *X* 是表时，*other* 是一个长度与 *X* 行数相同的数值型向量，或维度与 *X* 相同的表。\n\n**bias** 是一个布尔值，表示是否校正系统偏差。默认值为 false。\n\n#### 返回值\n\nDOUBLE 类型，数据形式同 *X*。\n\n#### 例子\n\n```\na=[0,1,2,int(),4]\nb=[2,4,3,6,5]\newmCorr(X=a,other=b,com=0.5);\n// output\n[,1.0000,-0.0533,-0.0533,0.9146]\n\newmCorr(X=a,other=b,com=0.5,ignoreNA=true);\n// output\n[,1.0000,-0.0533,-0.0533,0.8934]\n\nn = 20\ncolNames = `time`sym`qty`price\ncolTypes = [TIME,SYMBOL,INT,DOUBLE]\nt1 = table(n:0, colNames, colTypes)\ninsert into t1 values(09:30:00.001,`AAPL,100,56.5)\ninsert into t1 values(09:30:00.001,`AAPL,200,30.5)\ninsert into t1 values(09:30:00.001,`DELL,150,35.5)\ninsert into t1 values(09:30:00.001,`DELL,170,60.5)\ninsert into t1 values(09:30:00.001,`DELL,130,40.5)\nb=[2,4,3,6,5]\newmCorr(X=t1,other=b,com=0.5);\n```\n\n| time         | sym  | qty    | price   |\n| ------------ | ---- | ------ | ------- |\n| 09:30:00.001 | AAPL |        |         |\n| 09:30:00.001 | AAPL | 1.0000 | -1.0000 |\n| 09:30:00.001 | DELL | 1.0000 | -0.8481 |\n| 09:30:00.001 | DELL | 0.5536 | 0.8747  |\n| 09:30:00.001 | DELL | 0.3064 | 0.7050  |\n\n相关函数：[ewmCov](https://docs.dolphindb.cn/zh/funcs/e/ewmCov.html), [ewmMean](https://docs.dolphindb.cn/zh/funcs/e/ewmMean.html), [ewmStd](https://docs.dolphindb.cn/zh/funcs/e/ewmStd.html), [ewmVar](https://docs.dolphindb.cn/zh/funcs/e/ewmVar.html)\n"
    },
    "ewmCov": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/ewmCov.html",
        "signatures": [
            {
                "full": "ewmCov(X, [com], [span], [halfLife], [alpha], [minPeriods=0], [adjust=true], [ignoreNA=false], [other], [bias=false])",
                "name": "ewmCov",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[com]",
                        "name": "com",
                        "optional": true
                    },
                    {
                        "full": "[span]",
                        "name": "span",
                        "optional": true
                    },
                    {
                        "full": "[halfLife]",
                        "name": "halfLife",
                        "optional": true
                    },
                    {
                        "full": "[alpha]",
                        "name": "alpha",
                        "optional": true
                    },
                    {
                        "full": "[minPeriods=0]",
                        "name": "minPeriods",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[adjust=true]",
                        "name": "adjust",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[ignoreNA=false]",
                        "name": "ignoreNA",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[other]",
                        "name": "other",
                        "optional": true
                    },
                    {
                        "full": "[bias=false]",
                        "name": "bias",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [ewmCov](https://docs.dolphindb.cn/zh/funcs/e/ewmCov.html)\n\n\n\n#### 语法\n\newmCov(X, \\[com], \\[span], \\[halfLife], \\[alpha], \\[minPeriods=0], \\[adjust=true], \\[ignoreNA=false], \\[other], \\[bias=false])\n\n#### 详情\n\n返回 *X* 和 *other* 的指数加权移动协方差。该函数必须指定 *com*, *span*, *halfLife*, *alpha* 四个参数中的一个。\n\n#### 参数\n\n**X** 是一个数值型向量、矩阵或表。若 *X* 是表，只对其内数值型和布尔型的列进行计算。\n\n**com** 是一个大于等于0的数值型标量，表示质心。\n\n**span** 是一个大于等于1的数值型标量，表示跨度。\n\n**halfLife** 是一个大于0的数值型标量，表示半衰期。\n\n**alpha** 是一个(0,1]之间的浮点数，表示平滑系数。\n\n**minPeriods** 是一个整数，表示窗口中的最小观察数。默认值为0。\n\n**adjust** 是一个布尔值，表示是否除以开始阶段的衰减调整因子。默认值为 true。\n\n**ignoreNA** 是一个布尔值，表示计算权重时是否忽略 NULL 值。默认值为 false。\n\n**other** 当 *X* 是向量时，*other* 只能是一个与 *X* 长度相同的数值型向量；当 *X* 是矩阵时，*other* 是一个长度与 *X* 行数相同的数值型向量，或维度与 *X* 相同的矩阵；当 *X* 是表时，*other* 是一个长度与 *X* 行数相同的数值型向量，或维度与 *X* 相同的表。\n\n**bias** 是一个布尔值，表示是否校正系统偏差。默认值为 false。\n\n#### 返回值\n\nDOUBLE 类型，数据形式同 *X*。\n\n#### 例子\n\n```\na=[0,1,2,int(),4]\nb=[2,4,3,6,5]\newmCov(X=a,other=b,com=0.5);\n// output\n[,1,-0.038462,-0.038462,2.112637]\n\newmCov(X=a,other=b,com=0.5,ignoreNA=true);\n// output\n[,1,-0.038462,-0.038462,1.969231]\n\nn = 20\ncolNames = `time`sym`qty`price\ncolTypes = [TIME,SYMBOL,INT,DOUBLE]\nt1 = table(n:0, colNames, colTypes)\ninsert into t1 values(09:30:00.001,`AAPL,100,56.5)\ninsert into t1 values(09:30:00.001,`AAPL,200,30.5)\ninsert into t1 values(09:30:00.001,`DELL,150,35.5)\ninsert into t1 values(09:30:00.001,`DELL,170,60.5)\ninsert into t1 values(09:30:00.001,`DELL,130,40.5)\nb=[2,4,3,6,5]\newmCov(X=t1,other=b,com=0.5);\n```\n\n| time         | sym  | qty     | price   |\n| ------------ | ---- | ------- | ------- |\n| 09:30:00.001 | AAPL |         |         |\n| 09:30:00.001 | AAPL | 100     | -26     |\n| 09:30:00.001 | DELL | 30.7692 | -6.1538 |\n| 09:30:00.001 | DELL | 25.2308 | 29.5346 |\n| 09:30:00.001 | DELL | 9.405   | 10.0012 |\n\n相关函数：[ewmCorr](https://docs.dolphindb.cn/zh/funcs/e/ewmCorr.html), [ewmMean](https://docs.dolphindb.cn/zh/funcs/e/ewmMean.html), [ewmStd](https://docs.dolphindb.cn/zh/funcs/e/ewmStd.html), [ewmVar](https://docs.dolphindb.cn/zh/funcs/e/ewmVar.html)\n"
    },
    "ewmMean": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/ewmMean.html",
        "signatures": [
            {
                "full": "ewmMean(X, [com], [span], [halfLife], [alpha], [minPeriods=0], [adjust=true], [ignoreNA=false], [times])",
                "name": "ewmMean",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[com]",
                        "name": "com",
                        "optional": true
                    },
                    {
                        "full": "[span]",
                        "name": "span",
                        "optional": true
                    },
                    {
                        "full": "[halfLife]",
                        "name": "halfLife",
                        "optional": true
                    },
                    {
                        "full": "[alpha]",
                        "name": "alpha",
                        "optional": true
                    },
                    {
                        "full": "[minPeriods=0]",
                        "name": "minPeriods",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[adjust=true]",
                        "name": "adjust",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[ignoreNA=false]",
                        "name": "ignoreNA",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[times]",
                        "name": "times",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [ewmMean](https://docs.dolphindb.cn/zh/funcs/e/ewmMean.html)\n\n#### 语法\n\newmMean(X, \\[com], \\[span], \\[halfLife], \\[alpha], \\[minPeriods=0], \\[adjust=true], \\[ignoreNA=false], \\[times])\n\n#### 详情\n\n返回 *X* 的指数加权移动平均值。该函数必须指定 *com*, *span*, *halfLife*, *alpha* 四个参数中的一个。\n\n#### 参数\n\n**X** 是一个数值型向量、矩阵或表。若 *X* 是表，只对其内数值型和布尔型的列进行计算。\n\n**com** 可选参数，是一个大于等于 0 的数值型标量，表示质心。根据质心指定平滑系数时，公式如下：\n\n![](https://docs.dolphindb.cn/zh/images/ewmmean_com.png)\n\n**span** 可选参数，是一个大于等于 1 的数值型标量，表示跨度。根据跨度指定平滑系数时，公式如下：\n\n![](https://docs.dolphindb.cn/zh/images/ewmmean_span.png)\n\n**halfLife** 可选参数，是一个大于 0 的数值型标量，表示半衰期。若为 DURATION 类型，需同时指定 *times* 参数，且两者单位需一致。根据半衰期指定平滑系数时，公式如下：\n\n![](https://docs.dolphindb.cn/zh/images/ewmmean_halflife.png)\n\n**alpha** 可选参数，是一个 (0,1] 之间的浮点数，表示平滑系数。\n\n**minPeriods** 可选参数，是一个整数，表示窗口中的最小观察数。默认值为 0。\n\n**adjust** 可选参数，是一个布尔值，表示是否除以开始阶段的衰减调整因子。默认值为 true。\n\n* 若 *adjust*为 true，其公式为：\n\n  ![](https://docs.dolphindb.cn/zh/images/ewmmean_adjust_true.png)\n\n* 若 *adjust* 为 false，其公式为：\n\n  ![](https://docs.dolphindb.cn/zh/images/ewmmean_adjust_false.png)\n\n**ignoreNA** 可选参数，是一个布尔值，表示计算权重时是否忽略 NULL 值。默认值为 false，即不忽略 NULL 值。以 \\[x0, NULL, x2] 为例：\n\n* 若 *ignoreNA* 为 true，\n  * *adjust* 为 false，x0、x2 的最终权重为 1-α、α；\n  * *adjust* 为 true，则 x0、x2 的最终权重为 1-α、1；\n* 若*ignoreNA* 为 false，\n  * *adjust* 为 false，则 x0、x2的最终权重为（1-α）2、α；\n  * *adjust* 为 true,则 x0、x2 的最终权重为（1-α）2、1。\n\n**times** 可选参数，时间类型向量，需与 *X* 等长且严格递增。仅当 *halfLife* 为 DURATION 类型时必需，单位需与 *halfLife* 一致。\n\n注意：若 *halfLife* 以 B（工作日）或交易日历为单位，则 *times* 必须为 DATE 类型向量。\n\n#### 返回值\n\nDOUBLE 类型，数据形式同 *X*。\n\n#### 例子\n\n使用以下的 a 作为 X 的值，\n\n```\na=[0,1,2,int(),4];\newmMean(X=a,com=0.5);\n// output: [0,0.75,1.615385,1.615385,3.670213]    \n  \newmMean(X=a,com=0.5,ignoreNA=true);\n// output: [0,0.75,1.615385,1.615385,3.225]\n  \newmMean(a, halfLife = 4d, times=[2019.12.31, 2020.01.03, 2020.01.10, 2020.01.15, 2020.01.17])\n// output: [0,0.627115,1.558466,1.558466,3.256043]\n\n// halfLife 指定为交易日历\newmMean(a, halfLife = 4XNYS, times=[2019.12.31, 2020.01.03, 2020.01.10, 2020.01.15, 2020.01.17])\n// output: [0,0.585786,1.409080,1.409080,2.913483]\n  \n// halfLife 指定为工作日\newmMean(a, halfLife = 4B, times=[2019.12.31, 2020.01.03, 2020.01.10, 2020.01.15, 2020.01.17])\n// output: [0,0.627115,1.448981,1.448981,2.947520]  \n```\n\n使用以下的 t1 作为 X 的值，\n\n```\nn = 20\ncolNames = `time`sym`qty`price\ncolTypes = [TIME,SYMBOL,INT,DOUBLE]\nt1 = table(n:0, colNames, colTypes)\ninsert into t1 values(09:30:00.001,`AAPL,100,56.5)\ninsert into t1 values(09:30:00.001,`AAPL,200,30.5)\ninsert into t1 values(09:30:00.001,`DELL,150,35.5)\ninsert into t1 values(09:30:00.001,`DELL,170,60.5)\ninsert into t1 values(09:30:00.001,`DELL,130,40.5)\nb=[2,4,3,6,5]\newmMean(X=t1,com=0.5);\n```\n\n返回如下：\n\n| time         | sym  | qty      | price   |\n| ------------ | ---- | -------- | ------- |\n| 09:30:00.001 | AAPL | 100      | 56.5    |\n| 09:30:00.001 | AAPL | 175      | 37      |\n| 09:30:00.001 | DELL | 157.6923 | 35.9615 |\n| 09:30:00.001 | DELL | 166      | 52.525  |\n| 09:30:00.001 | DELL | 141.9008 | 44.4752 |\n\n\n\n**Related information**\n\n[ewmCorr](https://docs.dolphindb.cn/zh/funcs/e/ewmCorr.html)\n\n[ewmCov](https://docs.dolphindb.cn/zh/funcs/e/ewmCov.html)\n\n[ewmStd](https://docs.dolphindb.cn/zh/funcs/e/ewmStd.html)\n\n[ewmVar](https://docs.dolphindb.cn/zh/funcs/e/ewmVar.html)\n"
    },
    "ewmStd": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/ewmStd.html",
        "signatures": [
            {
                "full": "ewmStd(X, [com], [span], [halfLife], [alpha], [minPeriods=0], [adjust=true], [ignoreNA=false], [bias=false])",
                "name": "ewmStd",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[com]",
                        "name": "com",
                        "optional": true
                    },
                    {
                        "full": "[span]",
                        "name": "span",
                        "optional": true
                    },
                    {
                        "full": "[halfLife]",
                        "name": "halfLife",
                        "optional": true
                    },
                    {
                        "full": "[alpha]",
                        "name": "alpha",
                        "optional": true
                    },
                    {
                        "full": "[minPeriods=0]",
                        "name": "minPeriods",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[adjust=true]",
                        "name": "adjust",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[ignoreNA=false]",
                        "name": "ignoreNA",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[bias=false]",
                        "name": "bias",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [ewmStd](https://docs.dolphindb.cn/zh/funcs/e/ewmStd.html)\n\n\n\n#### 语法\n\newmStd(X, \\[com], \\[span], \\[halfLife], \\[alpha], \\[minPeriods=0], \\[adjust=true], \\[ignoreNA=false], \\[bias=false])\n\n#### 详情\n\n返回 *X* 的指数加权移动标准差。该函数必须指定 *com*, *span*, *halfLife*, *alpha* 四个参数中的一个。\n\n#### 参数\n\n**X** 是一个数值型向量、矩阵或表。若 *X* 是表，只对其内数值型和布尔型的列进行计算。\n\n**com** 是一个大于等于0的数值型标量，表示质心。\n\n**span** 是一个大于等于1的数值型标量，表示跨度。\n\n**halfLife** 是一个大于0的数值型标量，表示半衰期。\n\n**alpha** 是一个(0,1]之间的浮点数，表示平滑系数。\n\n**minPeriods** 是一个整数，表示窗口中的最小观察数。默认值为0。\n\n**adjust** 是一个布尔值，表示是否除以开始阶段的衰减调整因子。默认值为 true。\n\n**ignoreNA** 是一个布尔值，表示计算权重时是否忽略 NULL 值。默认值为 false。\n\n**bias** 是一个布尔值，表示是否校正系统偏差。默认值为 false。\n\n#### 返回值\n\nDOUBLE 类型，数据形式同 *X*。\n\n#### 例子\n\n```\na=[0,1,2,int(),4]\newmStd(X=a,com=0.5);\n// output\n[,0.707107,0.919866,0.919866,1.720513]\n\newmStd(X=a,com=0.5,ignoreNA=true);\n// output\n[,0.707107,0.919866,0.919866,1.679057]\n\nn = 20\ncolNames = `time`sym`qty`price\ncolTypes = [TIME,SYMBOL,INT,DOUBLE]\nt1 = table(n:0, colNames, colTypes)\ninsert into t1 values(09:30:00.001,`AAPL,100,56.5)\ninsert into t1 values(09:30:00.001,`AAPL,200,30.5)\ninsert into t1 values(09:30:00.001,`DELL,150,35.5)\ninsert into t1 values(09:30:00.001,`DELL,170,60.5)\ninsert into t1 values(09:30:00.001,`DELL,130,40.5)\nb=[2,4,3,6,5]\newmStd(X=t1,com=0.5);\n```\n\n| time         | sym  | qty     | price   |\n| ------------ | ---- | ------- | ------- |\n| 09:30:00.001 | AAPL |         |         |\n| 09:30:00.001 | AAPL | 70.7107 | 18.3848 |\n| 09:30:00.001 | DELL | 39.2232 | 9.2487  |\n| 09:30:00.001 | DELL | 23.271  | 17.2418 |\n| 09:30:00.001 | DELL | 27.466  | 12.6944 |\n\n相关函数：[ewmCorr](https://docs.dolphindb.cn/zh/funcs/e/ewmCorr.html), [ewmCov](https://docs.dolphindb.cn/zh/funcs/e/ewmCov.html), [ewmMean](https://docs.dolphindb.cn/zh/funcs/e/ewmMean.html), [ewmVar](https://docs.dolphindb.cn/zh/funcs/e/ewmVar.html)\n"
    },
    "ewmVar": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/ewmVar.html",
        "signatures": [
            {
                "full": "ewmVar(X, [com], [span], [halfLife], [alpha], [minPeriods=0], [adjust=true], [ignoreNA=false], [bias=false])",
                "name": "ewmVar",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[com]",
                        "name": "com",
                        "optional": true
                    },
                    {
                        "full": "[span]",
                        "name": "span",
                        "optional": true
                    },
                    {
                        "full": "[halfLife]",
                        "name": "halfLife",
                        "optional": true
                    },
                    {
                        "full": "[alpha]",
                        "name": "alpha",
                        "optional": true
                    },
                    {
                        "full": "[minPeriods=0]",
                        "name": "minPeriods",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[adjust=true]",
                        "name": "adjust",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[ignoreNA=false]",
                        "name": "ignoreNA",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[bias=false]",
                        "name": "bias",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [ewmVar](https://docs.dolphindb.cn/zh/funcs/e/ewmVar.html)\n\n\n\n#### 语法\n\newmVar(X, \\[com], \\[span], \\[halfLife], \\[alpha], \\[minPeriods=0], \\[adjust=true], \\[ignoreNA=false], \\[bias=false])\n\n#### 详情\n\n返回 *X* 的指数加权移动方差。该函数必须指定 *com*, *span*, *halfLife*, *alpha* 四个参数中的一个。\n\n#### 参数\n\n**X** 是一个数值型向量、矩阵或表。若 *X* 是表，只对其内数值型和布尔型的列进行计算。\n\n**com** 是一个大于等于0的数值型标量，表示质心。\n\n**span** 是一个大于等于1的数值型标量，表示跨度。\n\n**halfLife** 是一个大于0的数值型标量，表示半衰期。\n\n**alpha** 是一个(0,1]之间的浮点数，表示平滑系数。\n\n**minPeriods** 是一个整数，表示窗口中的最小观察数。默认值为0。\n\n**adjust** 是一个布尔值，表示是否除以开始阶段的衰减调整因子。默认值为 true。\n\n**ignoreNA** 是一个布尔值，表示计算权重时是否忽略 NULL 值。默认值为 false。\n\n**bias** 是一个布尔值，表示是否校正系统偏差。默认值为 false。\n\n#### 返回值\n\nDOUBLE 类型，数据形式同 *X*。\n\n#### 例子\n\n```\na=[0,1,2,int(),4]\newmVar(X=a,com=0.5);\n// output\n[,0.5,0.846154,0.846154,2.960165]\n\newmVar(X=a,com=0.5,ignoreNA=true);\n// output\n[,0.5,0.846154,0.846154,2.819231]\n\nn = 20\ncolNames = `time`sym`qty`price\ncolTypes = [TIME,SYMBOL,INT,DOUBLE]\nt1 = table(n:0, colNames, colTypes)\ninsert into t1 values(09:30:00.001,`AAPL,100,56.5)\ninsert into t1 values(09:30:00.001,`AAPL,200,30.5)\ninsert into t1 values(09:30:00.001,`DELL,150,35.5)\ninsert into t1 values(09:30:00.001,`DELL,170,60.5)\ninsert into t1 values(09:30:00.001,`DELL,130,40.5)\nb=[2,4,3,6,5]\newmVar(X=t1,com=0.5);\n```\n\n| time         | sym  | qty       | price    |\n| :----------- | :--- | :-------- | :------- |\n| 09:30:00.001 | AAPL |           |          |\n| 09:30:00.001 | AAPL | 4999.9999 | 337.9999 |\n| 09:30:00.001 | DELL | 1538.4615 | 85.5384  |\n| 09:30:00.001 | DELL | 541.5384  | 297.2807 |\n| 09:30:00.001 | DELL | 754.3801  | 161.1487 |\n\n相关函数：[ewmCorr](https://docs.dolphindb.cn/zh/funcs/e/ewmCorr.html), [ewmCov](https://docs.dolphindb.cn/zh/funcs/e/ewmCov.html), [ewmMean](https://docs.dolphindb.cn/zh/funcs/e/ewmMean.html), [ewmStd](https://docs.dolphindb.cn/zh/funcs/e/ewmStd.html)\n"
    },
    "exists": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/exists.html",
        "signatures": [
            {
                "full": "exists(path)",
                "name": "exists",
                "parameters": [
                    {
                        "full": "path",
                        "name": "path"
                    }
                ]
            }
        ],
        "markdown": "### [exists](https://docs.dolphindb.cn/zh/funcs/e/exists.html)\n\n\n\n#### 语法\n\nexists(path)\n\n#### 详情\n\n检查指定的文件或文件夹是否存在。`exists` 函数也能在分布式文件系统中使用。\n\n#### 参数\n\n**path** 字符串标量或向量，表示服务器端文件或文件夹的路径。\n\n#### 返回值\n\n布尔类型标量或向量。\n\n#### 例子\n\n```\nt=table(1..10 as ID, rand(1.0, 10) as x);\nsaveText(t, \"/home/DolphinDB/Data/t.txt\");\n\nexists(\"/home/DolphinDB/Data/t.txt\");\n// output\ntrue\nexists(\"/home/DolphinDB/Data/t1.txt\");\n// output\nfalse\nexists(\"/home/DolphinDB/Data\");\n// output\ntrue\n\nexists([\"/home/DolphinDB/Data/t.txt\",\"/home/DolphinDB/Data/t1.txt\",\"/home/DolphinDB/Data\"]);\n// output\n[true,false,true]\n```\n\n在分布式文件系统中检查文件或文件夹是否存在（以下脚本需要在集群中的数据节点/计算节点中执行）：\n\n```\nn=1000000\nID=rand(10, n)\ndates=2017.08.07..2017.08.11\ndate=rand(dates, n)\nx=rand(10.0, n)\nt=table(ID, date, x)\n\ndb = database(\"dfs://valueDB\", VALUE, 2017.08.07..2017.08.11)\npt = db.createPartitionedTable(t, `pt, `date);\npt.append!(t);\n\nexists(\"dfs://valueDB/20170807\");\n// output\ntrue\n```\n"
    },
    "existsCatalog": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/existsCatalog.html",
        "signatures": [
            {
                "full": "existsCatalog(catalog)",
                "name": "existsCatalog",
                "parameters": [
                    {
                        "full": "catalog",
                        "name": "catalog"
                    }
                ]
            }
        ],
        "markdown": "### [existsCatalog](https://docs.dolphindb.cn/zh/funcs/e/existsCatalog.html)\n\n\n\n#### 语法\n\nexistsCatalog(catalog)\n\n#### 详情\n\n检查指定 catalog 是否存在。\n\n#### 参数\n\n**catalog** 字符串标量，表示 catalog 的名称。\n\n#### 返回值\n\n布尔类型标量。 false 和 true 分别表示指定的 catalog 不存在、存在。\n\n#### 例子\n\n```\n// 检查名为 trading 的 catalog 是否存在\nexistsCatalog(\"trading\")\n// Output: false\n\n// 创建 catalog\ncreateCatalog(\"trading\")\n\nexistsCatalog(\"trading\")\n// Output: true\n```\n"
    },
    "existsDatabase": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/existsDatabase.html",
        "signatures": [
            {
                "full": "existsDatabase(dbUrl)",
                "name": "existsDatabase",
                "parameters": [
                    {
                        "full": "dbUrl",
                        "name": "dbUrl"
                    }
                ]
            }
        ],
        "markdown": "### [existsDatabase](https://docs.dolphindb.cn/zh/funcs/e/existsDatabase.html)\n\n\n\n#### 语法\n\nexistsDatabase(dbUrl)\n\n#### 详情\n\n检查指定数据库是否存在。\n\n#### 参数\n\n**dbUrl** 是一个字符串，表示数据库的路径。\n\n#### 返回值\n\n布尔类型标量。 false 和 true 分别表示指定的数据库不存在、存在。\n\n#### 例子\n\n检查分布式数据库是否存在：\n\n```\nn=1000000\nID=rand(10, n)\ndates=2017.08.07..2017.08.11\ndate=rand(dates, n)\nx=rand(10.0, n)\nt=table(ID, date, x)\n\ndb = database(\"dfs://valueDB\", VALUE, 2017.08.07..2017.08.11)\npt = db.createPartitionedTable(t, `pt, `date);\npt.append!(t);\n\nexistsDatabase(\"dfs://valueDB\");\n```\n\n输出返回：true\n\n```\nexistsDatabase(\"dfs://valueDB/20170807\");\n```\n\n输出返回：false\n"
    },
    "existsPartition": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/existsPartition.html",
        "signatures": [
            {
                "full": "existsPartition(partitionUrl, [tableName])",
                "name": "existsPartition",
                "parameters": [
                    {
                        "full": "partitionUrl",
                        "name": "partitionUrl"
                    },
                    {
                        "full": "[tableName]",
                        "name": "tableName",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [existsPartition](https://docs.dolphindb.cn/zh/funcs/e/existsPartition.html)\n\n\n\n#### 语法\n\nexistsPartition(partitionUrl, \\[tableName])\n\n#### 详情\n\n检查指定分区是否存在。\n\n#### 参数\n\n**partitionUrl** 字符串，表示分区文件夹的路径。\n\n**tableName** 字符串，表示表名。\n\n* 若分区粒度为数据库级（ [database](https://docs.dolphindb.cn/zh/funcs/d/database.html) : *chunkGranularity* = 'DATABASE'），可以不指定该参数。\n\n* 若分区粒度为表级（ [database](https://docs.dolphindb.cn/zh/funcs/d/database.html) : *chunkGranularity* = 'TABLE'）\n\n  * 若 *path* 指定的路径包含了物理索引（通过函数 [listTables](https://docs.dolphindb.cn/zh/funcs/l/listTables.html) 获取），可以不指定该参数。\n\n  * 否则，必须指定该参数。\n\n#### 返回值\n\n布尔类型标量。 false 和 true 分别表示指定的分区不存在、存在。\n\n#### 例子\n\n检查分区是否在分布式文件系统中（以下脚本需要在集群的数据节点/计算节点中执行）：\n\n```\nn=1000000\nID=rand(10, n)\ndates=2017.08.07..2017.08.11\ndate=rand(dates, n)\nx=rand(10.0, n)\nt=table(ID, date, x)\n\ndb = database(\"dfs://valueDB\", VALUE, 2017.08.07..2017.08.11)\npt = db.createPartitionedTable(t, `pt, `date);\npt.append!(t);\n\nlistTables(\"dfs://valueDB\")\n```\n\n| tableName | physicalIndex |\n| --------- | ------------- |\n| pt        | s             |\n\n```\nexistsPartition(\"dfs://valueDB/20170807/s\");\n// output\ntrue\n\n//表级分区时，path 不包含物理索引，检查分区时需指定表名，否则查找不到分区信息\nexistsPartition(\"dfs://valueDB/20170807\", `pt)\n// output\ntrue\n\nexistsPartition(\"dfs://valueDB/20170807\");\n// output\nfalse\n\nexistsPartition(\"dfs://valueDB\");\n// output\nfalse\n\nexistsPartition(\"dfs://valueDB/20170807/s/pt\");\n// output\nfalse\n```\n"
    },
    "existsStreamTable": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/existsStreamTable.html",
        "signatures": [
            {
                "full": "existsStreamTable(tableName)",
                "name": "existsStreamTable",
                "parameters": [
                    {
                        "full": "tableName",
                        "name": "tableName"
                    }
                ]
            }
        ],
        "markdown": "### [existsStreamTable](https://docs.dolphindb.cn/zh/funcs/e/existsStreamTable.html)\n\n\n\n#### 语法\n\nexistsStreamTable(tableName)\n\n#### 详情\n\n查询指定的流数据表是否存在。\n\n#### 参数\n\n**tableName** 字符串，表示流数据表名称。可以是普通流表、共享流表、持久化流表或高可用流表。\n\n#### 返回值\n\n布尔类型标量。true 表示该流数据表存在；false 表示该数据表不存在。\n\n#### 例子\n\n```\nid=`XOM`GS`AAPL\nx=102.1 33.4 73.6\nrt=streamTable(id, x);\nexistsStreamTable(`rt) \n```\n\n返回：true\n\n```\nexistsStreamTable(`srt)\n```\n\n返回：false\n\n```\nshare rt as srt\nexistsStreamTable(`srt)  \n```\n\n返回：true\n"
    },
    "existsSubscriptionTopic": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/existsSubscriptionTopic.html",
        "signatures": [
            {
                "full": "existsSubscriptionTopic([server], tableName, [actionName])",
                "name": "existsSubscriptionTopic",
                "parameters": [
                    {
                        "full": "[server]",
                        "name": "server",
                        "optional": true
                    },
                    {
                        "full": "tableName",
                        "name": "tableName"
                    },
                    {
                        "full": "[actionName]",
                        "name": "actionName",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [existsSubscriptionTopic](https://docs.dolphindb.cn/zh/funcs/e/existsSubscriptionTopic.html)\n\n\n\n#### 语法\n\nexistsSubscriptionTopic(\\[server], tableName, \\[actionName])\n\n别名：existSubscriptionTopic\n\n#### 详情\n\n查询共享流数据表的订阅主题是否存在。存在返回 true，不存在则返回 false。\n\n#### 参数\n\n**server** 是一个字符串，表示订阅的流数据表所在节点的别名或远程连接的句柄。如果未指定或者为空字符串，表示流数据所在的服务器是本地实例。\n\n**tableName** 是一个字符串，表示一个共享流数据表的名称。\n\n**actionName** 是一个字符串，表示订阅任务的名称。它可以包含字母，数字和下划线。如果创建订阅时指定了 *actionName*，查询订阅时必须指定 *actionName*。\n\n#### 返回值\n\n布尔类型标量。\n\n#### 例子\n\n```\nt=streamTable(1000000:0,`date`time`sym`qty`price`exch,[DATE,TIME,SYMBOL,INT,DOUBLE,SYMBOL])\nshare t as trades\ntrades_1=streamTable(1000000:0,`date`time`sym`qty`price`exch,[DATE,TIME,SYMBOL,INT,DOUBLE,SYMBOL])\nsubscribeTable(tableName=`trades, actionName=`vwap, offset=-1, handler=append!{trades_1})\nexistsSubscriptionTopic(,`trades,`vwap)\n// output\ntrue\n```\n"
    },
    "existsTable": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/existsTable.html",
        "signatures": [
            {
                "full": "existsTable(dbUrl, tableName)",
                "name": "existsTable",
                "parameters": [
                    {
                        "full": "dbUrl",
                        "name": "dbUrl"
                    },
                    {
                        "full": "tableName",
                        "name": "tableName"
                    }
                ]
            }
        ],
        "markdown": "### [existsTable](https://docs.dolphindb.cn/zh/funcs/e/existsTable.html)\n\n\n\n#### 语法\n\nexistsTable(dbUrl, tableName)\n\n#### 详情\n\n检查指定表是否存在于指定数据库中。\n\n#### 参数\n\n**dbUrl** 是一个字符串，表示数据库的路径。\n\n**tableName** 是表的名称。它需要用反引号(\\`)或双引号。\n\n#### 返回值\n\n布尔类型标量。 false 和 true 分别表示指定表不存在、存在。\n\n#### 例子\n\n检查分区是否在分布式文件系统中（以下脚本需要在集群的数据节点/计算节点中执行）：\n\n```\nn=1000000\nID=rand(10, n)\ndates=2017.08.07..2017.08.11\ndate=rand(dates, n)\nx=rand(10.0, n)\nt=table(ID, date, x)\n\ndb = database(\"dfs://valueDB\", VALUE, 2017.08.07..2017.08.11)\npt = db.createPartitionedTable(t, `pt, `date);\npt.append!(t);\n\nexistsTable(\"dfs://valueDB\", `pt);\n// output\ntrue\n\nexistsTable(\"dfs://valueDB/20170807\", `pt);\n// output\ntrue\n```\n"
    },
    "exp": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/exp.html",
        "signatures": [
            {
                "full": "exp(X)",
                "name": "exp",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [exp](https://docs.dolphindb.cn/zh/funcs/e/exp.html)\n\n\n\n#### 语法\n\nexp(X)\n\n#### 详情\n\n返回 e 的 *X* 次方。e 是一个常数，为2.71828。\n\n**Note:**\n\n* 与 `numpy.exp` 及 `scipy.stats.exp` 的功能都基本相同，区别在于 DolphinDB 的 `exp` 函数只接受一个参数 *X*，不支持 `numpy.exp` 中的 *out*、*where* 等参数。\n* DolphinDB `exp` 与 TA-Lib [EXP](https://ta-lib.github.io/ta-lib-python/func_groups/math_transform.html) 的核心功能相同，区别在于 DolphinDB `exp` 支持标量、向量、矩阵和表作为输入；而 TA-Lib `EXP` 仅接受一维数组（numpy array）输入。若输入数据相同，二者返回结果一致。\n\n#### 参数\n\n**X** 可以是标量、数据对、向量、矩阵或表。\n\n#### 返回值\n\nDOUBLE 类型，其数据形式同 *X*。\n\n#### 例子\n\n```\nexp(1 2 3);\n// output\n[2.718282,7.389056,20.085537]\n\nlog(exp(1));\n// output\n1\n```\n"
    },
    "exp2": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/exp2.html",
        "signatures": [
            {
                "full": "exp2(X)",
                "name": "exp2",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [exp2](https://docs.dolphindb.cn/zh/funcs/e/exp2.html)\n\n\n\n#### 语法\n\nexp2(X)\n\n#### 详情\n\n返回2的 *X* 次方。\n\n#### 参数\n\n**X** 可以是标量、数据对、向量、矩阵或表。\n\nDolphinDB 的 `exp2` 与 NumPy 的 `exp2` 在核心功能上是一致的，但 DolphinDB `exp2` 强调向量化和分布式计算能力，而 NumPy 作为通用数值计算库，其函数基于 ufunc 机制，提供了更丰富的底层控制参数，例如：\n\n* *out*：支持将结果写入指定数组，实现原地计算\n* *where*：支持按条件进行选择性计算\n* *dtype*：控制计算和输出的数据类型\n* *casting*：控制类型转换规则\n* *order*：指定输出数组的内存布局\n* *subok*：控制是否保留子类类型\n\n需要注意的是，这些参数并非 `exp2` 特有，而是 NumPy ufunc 的通用特性。\n\n#### 返回值\n\nDOUBLE 类型，其数据形式同 *X*。\n\n#### 例子\n\n```\nexp2(3);\n// output\n8\n\nexp2(2 4 NULL 6);\n// output\n[4,16,,64]\n\nexp2(1..4$2:2);\n```\n\n| #0 | #1 |\n| -- | -- |\n| 2  | 8  |\n| 4  | 16 |\n"
    },
    "expm1": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/expm1.html",
        "signatures": [
            {
                "full": "expm1(X)",
                "name": "expm1",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [expm1](https://docs.dolphindb.cn/zh/funcs/e/expm1.html)\n\n\n\n#### 语法\n\nexpm1(X)\n\n#### 详情\n\n返回 exp(X)-1 的结果。\n\nDolphinDB 的 `expm1` 与 NumPy 的 `expm1` 在核心功能上是一致的，但 DolphinDB `expm1` 强调向量化和分布式计算能力，而 NumPy 作为通用数值计算库，其函数基于 ufunc 机制，提供了更丰富的底层控制参数，例如：\n\n* *out*：支持将结果写入指定数组，实现原地计算\n* *where*：支持按条件进行选择性计算\n* *dtype*：控制计算和输出的数据类型\n* *casting*：控制类型转换规则\n* *order*：指定输出数组的内存布局\n* *subok*：控制是否保留子类类型\n\n需要注意的是，这些参数并非 `expm1` 特有，而是 NumPy ufunc 的通用特性。\n\n#### 参数\n\n**X** 可以是标量、数据对、向量、矩阵或表。\n\n#### 返回值\n\nDOUBLE 类型，其数据形式同 *X*。\n\n#### 例子\n\n```\nexpm1(5);\n// output\n147.413159\n\nexpm1(1 2 3 NULL);\n// output\n[1.718282,6.389056,19.085537,]\n\nexpm1(1..4$2:2);\n```\n\n| #0       | #1        |\n| -------- | --------- |\n| 1.718282 | 19.085537 |\n| 6.389056 | 53.59815  |\n"
    },
    "expr": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/expr.html",
        "signatures": [
            {
                "full": "expr(args...)",
                "name": "expr",
                "parameters": [
                    {
                        "full": "args...",
                        "name": "args..."
                    }
                ]
            }
        ],
        "markdown": "### [expr](https://docs.dolphindb.cn/zh/funcs/e/expr.html)\n\n\n\n#### 语法\n\nexpr(args...)\n\n#### 详情\n\n函数 `expr`从对象、运算符或其他元代码生成元代码。\n\n#### 参数\n\n**args** 可以是对象、运算符或元代码。元代码是由\"<\"和\">\"包围的对象和/或表达式。参数的最小数量为2。\n\n#### 返回值\n\nCODE 类型元代码。\n\n#### 例子\n\n```\nexpr(6,<,8);\n// output\n< 6 < 8 >\n\nexpr(sum, 1 2 3);\n// output\n< sum [1,2,3] >\n\na=6;\nexpr(a,+,1);\n// output\n< 6 + 1 >\n\nexpr(<a>,+,1);\n// output\n< a + 1 >\n\nexpr(<a>,+,<b>);\n// output\n< a + b >\n\nexpr(a+7,*,8);\n// output\n< 13 * 8 >\n\nexpr(<a+7>,*,8);\n// output\n< (a + 7) * 8 >\n\nexpr(not, < a >);\n// output\n< ! a >\n```\n"
    },
    "extractInstrument": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/extractInstrument.html",
        "signatures": [
            {
                "full": "extractInstrument(instrument)",
                "name": "extractInstrument",
                "parameters": [
                    {
                        "full": "instrument",
                        "name": "instrument"
                    }
                ]
            }
        ],
        "markdown": "### [extractInstrument](https://docs.dolphindb.cn/zh/funcs/e/extractInstrument.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\nextractInstrument(instrument)\n\n#### 详情\n\n提取 INSTRUMENT 类型对象内部的数据。\n\n#### 参数\n\n**instrument** INSTRUMENT 类型标量，或由多个 INSTRUMENT 组成的元组。\n\n#### 返回值\n\n* *instrument* 是标量时，返回一个字典。\n\n* *instrument* 是元组时，返回一个由字典组成的元组。\n\n#### 例子\n\n```\nfxFwd1 = {\n    \"productType\": \"Forward\",\n    \"forwardType\": \"FxForward\",\n    \"expiry\": 2025.10.08,\n    \"delivery\": 2025.10.10,\n    \"currencyPair\": \"USDCNY\",\n    \"direction\": \"Buy\",\n    \"notionalCurrency\": \"USD\",\n    \"notionalAmount\": 1E6,\n    \"strike\": 7.2\n}\nfxFwdUsdCny = parseInstrument(fxFwd1)\nfxFwd2 = {\n    \"productType\": \"Forward\",\n    \"forwardType\": \"FxForward\",\n    \"expiry\": 2025.10.08,\n    \"delivery\": 2025.10.10,\n    \"currencyPair\": \"EURCNY\",\n    \"direction\": \"Buy\",\n    \"notionalCurrency\": \"EUR\",\n    \"notionalAmount\": 1E6,\n    \"strike\": 8.2\n}\nfxFwdEurCny = parseInstrument(fxFwd2)\n\nprint extractInstrument([fxFwdUsdCny, fxFwdEurCny])\n\n/* output\n(productType->Forward\nforwardType->FxForward\nversion->1\ninstrumentId->\nexpiry->2025.10.08\ndelivery->2025.10.10\ncurrencyPair->USDCNY\ndirection->Buy\nnotionalCurrency->USD\nnotionalAmount->1000000\nstrike->7.200000000000001\ndomesticCurve->\nforeignCurve->\n,productType->Forward\nforwardType->FxForward\nversion->1\ninstrumentId->\nexpiry->2025.10.08\ndelivery->2025.10.10\ncurrencyPair->EURCNY\ndirection->Buy\nnotionalCurrency->EUR\nnotionalAmount->1000000\nstrike->8.199999999999999\ndomesticCurve->\nforeignCurve->\n)\n*/\n```\n\n**相关函数：**[parseInstrument](https://docs.dolphindb.cn/zh/funcs/p/parseInstrument.html)\n"
    },
    "extractMktData": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/extractMktData.html",
        "signatures": [
            {
                "full": "extractMktData(mktData)",
                "name": "extractMktData",
                "parameters": [
                    {
                        "full": "mktData",
                        "name": "mktData"
                    }
                ]
            }
        ],
        "markdown": "### [extractMktData](https://docs.dolphindb.cn/zh/funcs/e/extractMktData.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\nextractMktData(mktData)\n\n#### 详情\n\n提取 MKTDATA 类型对象内部的数据。\n\n#### 参数\n\n**mktData** MKTDATA 类型标量，或由多个 MKTDATA 组成的元组。\n\n#### 返回值\n\n* *mktData* 是标量时，返回一个字典。\n\n* *mktData* 是元组时，返回一个由字典组成的元组。\n\n#### 例子\n\n```\ncurve = {\n    \"mktDataType\": \"Curve\",\n    \"curveType\": \"IrYieldCurve\",\n    \"referenceDate\": 2025.07.01,\n    \"currency\": \"CNY\",\n    \"curveName\": \"CNY_FR_007\",\n    \"dayCountConvention\": \"Actual365\",\n    \"compounding\": \"Continuous\",\n    \"interpMethod\": \"Linear\",\n    \"extrapMethod\": \"Flat\",\n    \"dates\":[2025.07.07,2025.07.10,2025.07.17,2025.07.24,2025.08.04,2025.09.03,2025.10.09,2026.01.05,\n        2026.04.03,2026.07.03,2027.01.04,2027.07.05,2028.07.03],\n    \"values\":[0.015785,0.015931,0.016183,0.016381,0.016493,0.016503,0.016478,0.016234,0.016321,\n        0.016378,0.015508,0.015185,0.014901],\n    \"settlement\": 2025.07.01\n}\n\nmktData = parseMktData(curve)\n//打印mktData数据类型\nprint(typestr(mktData))  //MKTDATA\n\n//提取mktData里面的信息\nd = extractMktData(mktData)\nprint(d)\n/*\n  mktDataType->Curve\n  version->1\n  curveType->IrYieldCurve\n  referenceDate->2025.07.01\n  dayCountConvention->Actual365\n  curveName->CNY_FR_007\n  dates->[2025.07.07,2025.07.10,2025.07.17,2025.07.24,2025.08.04,2025.09.03,2025.10.09,2026.01.05,2026.04.03,2026.07.03,2027.01.04,2027.07.05,2028.07.03]\n  years->[0.016438356164384,0.024657534246575,0.043835616438356,0.063013698630137,0.093150684931507,0.175342465753425,0.273972602739726,0.515068493150685,0.756164383561644,1.005479452054794,1.512328767123288,2.010958904109589,3.008219178082192]\n  values->[0.015785,0.015931,0.016183,0.016381,0.016493,0.016503,0.016478,0.016234,0.016321,0.016378,0.015508,0.015185,0.014901]\n  interpMethod->Linear\n  extrapMethod->Flat\n  currency->CNY\n  compounding->Continuous\n  curveModel->Bootstrap\n  settlement->2025.07.01\n  frequency->Annual\n*/\n```\n\n**相关函数：**[parseMktData](https://docs.dolphindb.cn/zh/funcs/p/parseMktData.html)\n"
    },
    "extractTextSchema": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/extractTextSchema.html",
        "signatures": [
            {
                "full": "extractTextSchema(filename, [delimiter], [skipRows=0])",
                "name": "extractTextSchema",
                "parameters": [
                    {
                        "full": "filename",
                        "name": "filename"
                    },
                    {
                        "full": "[delimiter]",
                        "name": "delimiter",
                        "optional": true
                    },
                    {
                        "full": "[skipRows=0]",
                        "name": "skipRows",
                        "optional": true,
                        "default": "0"
                    }
                ]
            }
        ],
        "markdown": "### [extractTextSchema](https://docs.dolphindb.cn/zh/funcs/e/extractTextSchema.html)\n\n\n\n#### 语法\n\nextractTextSchema(filename, \\[delimiter], \\[skipRows=0])\n\n#### 详情\n\n生成输入数据文件的表的结构。表的结构有两列：列名和数据类型。\n\n数据文件中包含了表达时间、日期的数据时：\n\n* 满足分隔符要求的这部分数据（日期数据分隔符包含\"-\"、\"/\"和\".\"，时间数据分隔符为\":\"）会转换为相应的类型。例如，\"12:34:56\"转换为SECOND类型；\"23.04.10\"转换为DATE类型。\n* 对于不包含分隔符的数据，形如\"yyMMdd\"的数据同时满足0<=yy<=99，0<=MM<=12，1<=dd<=31，会被优先解析成DATE；形如\"yyyyMMdd\"的数据同时满足1900<=yyyy<=2100，0<=MM<=12，1<=dd<=31会被优先解析成DATE。\n\n**Note:** 从 2.00.10 版本开始，`loadText` 支持加载一条记录中包含多个换行符的数据文件。\n\n#### 参数\n\n**filename** 字符串，表示输入数据的绝对路径或相对路径。仅支持 CSV 格式的文件。若传入其他格式文件，则无法保证数据准确性。\n\n**delimiter** 字符串标量，表示数据文件中各列的分隔符。分隔符可以是一个或多个字符，默认是逗号（\",\"）。\n\n**skipRows** 是0到1024之间的整数，表示从文件头开始忽略的行数。它是一个可选参数。默认值为0。\n\n#### 返回值\n\n返回一个表，包含两列：\n\n* name：字符串，表示列名。\n* type：字符串，表示数据类型。\n\n#### 例子\n\n```\nn=1000000\ntimestamp=09:30:00+rand(18000,n)\nID=rand(100,n)\nqty=100*(1+rand(100,n))\nprice=5.0+rand(100.0,n)\nt1 = table(timestamp,ID,qty,price)\nsaveText(t1, \"/home/DolphinDB/Data/t1.txt\")\nschema=extractTextSchema(\"/home/DolphinDB/Data/t1.txt\");\nschema;\n```\n\n| name      | type   |\n| --------- | ------ |\n| timestamp | SECOND |\n| ID        | INT    |\n| qty       | INT    |\n| price     | DOUBLE |\n"
    },
    "eye": {
        "url": "https://docs.dolphindb.cn/zh/funcs/e/eye.html",
        "signatures": [
            {
                "full": "eye(n)",
                "name": "eye",
                "parameters": [
                    {
                        "full": "n",
                        "name": "n"
                    }
                ]
            }
        ],
        "markdown": "### [eye](https://docs.dolphindb.cn/zh/funcs/e/eye.html)\n\n\n\n#### 语法\n\neye(n)\n\n#### 详情\n\n生成一个维度为 *n* 的单位矩阵。\n\n与 Python 中 `numpy.eye` 的区别：`numpy.eye` 可指定行数、列数、对角线偏移和 *dtype*，生成矩形矩阵或偏移对角线矩阵；DolphinDB 的 `eye` 只生成 *n* 阶 DOUBLE 单位矩阵。\n\n#### 参数\n\n**n** 是一个正整数，表示维度。\n\n#### 返回值\n\n一个 DOUBLE 类型矩阵。\n\n#### 例子\n\n```\neye(3);\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1  | 0  | 0  |\n| 0  | 1  | 0  |\n| 0  | 0  | 1  |\n"
    },
    "cacheDSNow": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cacheDSNow.html",
        "signatures": [
            {
                "full": "cacheDSNow(ds)",
                "name": "cacheDSNow",
                "parameters": [
                    {
                        "full": "ds",
                        "name": "ds"
                    }
                ]
            }
        ],
        "markdown": "### [cacheDSNow](https://docs.dolphindb.cn/zh/funcs/c/cacheDSNow.html)\n\n\n\n#### 语法\n\ncacheDSNow(ds)\n\n#### 详情\n\n函数 `cacheDSNow` 立即执行并缓存数据源和缓存行的总数。\n\n#### 参数\n\n**ds** 是数据源或数据源列表。\n\n#### 返回值\n\nINT 类型标量。\n\n#### 例子\n\n```\nPTNDB_DIR = \"/home/db_testing\"\ndbName = database(PTNDB_DIR + \"/NYSETAQByName\")\nTrades = dbName.loadTable(`Trades)\n\nds=sqlDS(<select Time,Exchange,Symbol,Trade_Volume as Vol, Trade_Price as Price from Trades>)\nds.cacheDSNow()        # cache the data immediately\nds.clearDSCacheNow()  # clear the cache immediately\n```\n"
    },
    "cacheDS!": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cacheDS_.html",
        "signatures": [
            {
                "full": "cacheDS!(ds)",
                "name": "cacheDS!",
                "parameters": [
                    {
                        "full": "ds",
                        "name": "ds"
                    }
                ]
            }
        ],
        "markdown": "### [cacheDS!](https://docs.dolphindb.cn/zh/funcs/c/cacheDS_.html)\n\n\n\n#### 语法\n\ncacheDS!(ds)\n\n#### 详情\n\n函数 `cacheDS!` 会在下次执行，并缓存数据。\n\n#### 参数\n\n**ds** 是数据源或数据源列表。\n\n#### 返回值\n\n返回 true 或 false 表示此操作成功或失败。\n\n#### 例子\n\n```\nPTNDB_DIR = \"/home/db_testing\"\ndbName = database(PTNDB_DIR + \"/NYSETAQByName\")\nTrades = dbName.loadTable(`Trades)\n\nds=sqlDS(<select Time,Exchange,Symbol,Trade_Volume as Vol, Trade_Price as Price from Trades>)\nds.cacheDS!()        // cache the data\nds.clearDSCache!()  // clear the cache\n```\n"
    },
    "cachedTable": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cachedTable.html",
        "signatures": [
            {
                "full": "cachedTable(updateFunc, retentionSeconds)",
                "name": "cachedTable",
                "parameters": [
                    {
                        "full": "updateFunc",
                        "name": "updateFunc"
                    },
                    {
                        "full": "retentionSeconds",
                        "name": "retentionSeconds"
                    }
                ]
            }
        ],
        "markdown": "### [cachedTable](https://docs.dolphindb.cn/zh/funcs/c/cachedTable.html)\n\n\n\n#### 语法\n\ncachedTable(updateFunc, retentionSeconds)\n\n#### 详情\n\n创建一种特殊类型的内存表：缓存表。如果查询缓存表的时间与上次数据更新时间相距等于或超过 *retentionSeconds* 秒，会自动执行 *updateFunc* 以更新缓存表。\n\n如果需要多线程访问缓存表，需要将缓存表共享。\n\n#### 参数\n\n**updateFunc** 是一个函数。它必须是无参数的，并且返回对象是一个表。\n\n**retentionSeconds** 是一个正整数，表示数据更新的时间间隔，单位是秒。\n\n#### 返回值\n\n一个表。\n\n#### 例子\n\n下例定义一个一元函数 f1，在传入 cachedTable 时，需要通过部分应用的方式将 f1 转为无参数函数，即为 cachedTable 的 *updateFunc* 参数传入 f1{t}。\n\n```\ndef f1(mutable t){\n    update t set id=id+1\n    return t\n}\nt=table(1..5 as id, 15 25 35 45 55 as val)\nct=cachedTable(f1{t}, 2);\n\nselect * from ct;\n```\n\n| id | val |\n| -- | --- |\n| 2  | 15  |\n| 3  | 25  |\n| 4  | 35  |\n| 5  | 45  |\n| 6  | 55  |\n\n```\nsleep(2100)\nselect * from ct\n```\n\n| id | val |\n| -- | --- |\n| 3  | 15  |\n| 4  | 25  |\n| 5  | 35  |\n| 6  | 45  |\n| 7  | 55  |\n\n```\nct=NULL;\n```\n"
    },
    "callMCPTool": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/callMCPTool.html",
        "signatures": [
            {
                "full": "callMCPTool(name, [args], [published])",
                "name": "callMCPTool",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "[args]",
                        "name": "args",
                        "optional": true
                    },
                    {
                        "full": "[published]",
                        "name": "published",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [callMCPTool](https://docs.dolphindb.cn/zh/funcs/c/callMCPTool.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\ncallMCPTool(name, \\[args], \\[published])\n\n#### 详情\n\n调用指定的 MCP Tool。\n\n#### 参数\n\n**name**STRING 类型标量，表示 tool 的名称。\n\n**args** 可选参数，一个字典，键是 STRING 类型，值是 ANY 或 STRING 类型，表示传入 tool 的参数。\n\n**published** 可选参数，布尔值，表示是否调用已发布的版本。默认为 false，表示调用尚未发布的版本。\n\n#### 返回值\n\nSTRING 类型标量。\n\n#### 例子\n\n```\n// 定义 tool 并发布\ndef myTool(x) {\n   return x * 2 + 1\n}\n\ninfo = {\n    \"title\": \"DolphinDB Tool\"\n}\n\naddMCPTool(name=\"myTool\", func=myTool, argNames=[\"a\"], argTypes=[\"number\"], description=\"This is a tool\", extraInfo=info)\n\npublishMCPTools(names=\"myTool\")\n\n// 更新 tool，不发布\ndef myNewTool(x) {\n   return 100 * x\n}\n\nupdateMCPTool(name=\"myTool\", func=myNewTool)\n\n// 调用发布的 myTool\ncallMCPTool(name=\"myTool\", args={\"a\":3}, published=true)\n//output:'7'\n\n// 调用更新后未发布的 myTool\ncallMCPTool(name=\"myTool\", args={\"a\":3}, published=false)\n//output: '300'\n```\n"
    },
    "cancelConsoleJob": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cancelConsoleJob.html",
        "signatures": [
            {
                "full": "cancelConsoleJob(rootJobId)",
                "name": "cancelConsoleJob",
                "parameters": [
                    {
                        "full": "rootJobId",
                        "name": "rootJobId"
                    }
                ]
            }
        ],
        "markdown": "### [cancelConsoleJob](https://docs.dolphindb.cn/zh/funcs/c/cancelConsoleJob.html)\n\n\n\n#### 语法\n\ncancelConsoleJob(rootJobId)\n\n#### 详情\n\n取消已经提交但是尚未完成的交互式任务。如果要取消批处理作业，请使用 [cancelJob](https://docs.dolphindb.cn/zh/funcs/c/cancelJob.html)。\n\n`cancelConsoleJob` 在当前正在执行的子任务完成后，才会取消任务。因此， `cancelConsoleJob` 并不是马上生效。如果 `cancelConsoleJob` 的对象是没有子任务的任务，该命令不生效。\n\n#### 参数\n\n**rootJobId** 是作业的 ID，是一个字符串标量或者向量。若为向量，表示同时取消多个作业。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n在一个节点的某个会话中，执行以下代码：\n\n```\npt = loadTable(\"dfs://TAQ\", `quotes)\nselect count(*) from pt;\n```\n\n在同一个节点的其他会话中，使用 [getConsoleJobs](https://docs.dolphindb.cn/zh/funcs/g/getConsoleJobs.html) 获取要取消的交互式任务的 ID，然后使用 `cancelConsoleJob` 来取消该任务。\n\n```\ncancelConsoleJob(\"bf768327-776d-40a7-8a8d-00a6cfd054e3\");\n```\n"
    },
    "cancelJob": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cancelJob.html",
        "signatures": [
            {
                "full": "cancelJob(jobId)",
                "name": "cancelJob",
                "parameters": [
                    {
                        "full": "jobId",
                        "name": "jobId"
                    }
                ]
            }
        ],
        "markdown": "### [cancelJob](https://docs.dolphindb.cn/zh/funcs/c/cancelJob.html)\n\n\n\n#### 语法\n\ncancelJob(jobId)\n\n#### 详情\n\n取消已经提交但尚未完成的批处理作业。2.00.7 版本后，若执行 cancelJob 时，发现某个 jobId 不存在，系统不再抛出异常，而是将包含 jobId 的报错信息输出到日志。\n\n从 2.00.11 版本开始，系统对该操作进行了权限管理的增强。管理员（包括普通管理员和超级管理员）具有取消任何用户创建的批处理作业的权限，而普通用户只能取消自己创建的批处理作业。\n\n#### 参数\n\n**jobId** 是批处理作业的 ID，是一个字符串标量或向量。若为向量，表示同时取消多个批处理作业。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\ndef writeData(num){\n   n=10\n   month=take(2000.01M..2016.12M, n)\n   x=rand(1.0, n)\n   tt=table(month, x)\n   if(existsDatabase(\"dfs://test_db\")){\n       dropDatabase(\"dfs://test_db\")\n   }\n   db=database(\"dfs://test_db\", VALUE, 2000.01M..2016.12M)\n   pt = db.createPartitionedTable(tt, `pt, `month)\n   for(x in 1..num){\n       pt.append!(tt)\n       sleep(1000)\n   }\n}\n\nmyJobId=\"writeData\"+temporalFormat(datetime(now()),\"yyyyMMddHHmmss\")\nsubmitJob(myJobId,\"write data to dfs table\",writeData,120);\ncancelJob(myJobId);\n```\n\n取消集群中所有未完成的 job。\n\n```\ndef cancelAllBatchJob(){\n   jobids=exec jobid from getRecentJobs() where endTime=NULL\n   cancelJob(jobids)\n}\npnodeRun(cancelAllBatchJob)\n```\n"
    },
    "cancelPKEYCompactionTask": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cancelpkeycompactiontask.html",
        "signatures": [
            {
                "full": "cancelPKEYCompactionTask(chunkId)",
                "name": "cancelPKEYCompactionTask",
                "parameters": [
                    {
                        "full": "chunkId",
                        "name": "chunkId"
                    }
                ]
            }
        ],
        "markdown": "### [cancelPKEYCompactionTask](https://docs.dolphindb.cn/zh/funcs/c/cancelpkeycompactiontask.html)\n\n\n\n#### 语法\n\ncancelPKEYCompactionTask(chunkId)\n\n#### 详情\n\n取消目标分区正在执行的 compaction 任务。\n\n#### 参数\n\n**chunkId** STRING 类型标量，表示 chunk 对应的 ID。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\ntriggerPKEYCompaction(chunkId=\"1486f935-6f87-479c-b341-34c6a303d4f9\", async=false)\n```\n"
    },
    "cancelRebalanceTask": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cancelRebalanceTask.html",
        "signatures": [
            {
                "full": "cancelRebalanceTask(taskId)",
                "name": "cancelRebalanceTask",
                "parameters": [
                    {
                        "full": "taskId",
                        "name": "taskId"
                    }
                ]
            }
        ],
        "markdown": "### [cancelRebalanceTask](https://docs.dolphindb.cn/zh/funcs/c/cancelRebalanceTask.html)\n\n\n\n#### 语法\n\ncancelRebalanceTask(taskId)\n\n#### 详情\n\n取消已经提交但尚未开始执行的再平衡任务。该命令只能由管理员在控制节点上执行。\n\n#### 参数\n\n**taskId** 是一个字符串标量或向量，表示再平衡任务的 ID，可以通过 [getRecoveryTaskStatus](https://docs.dolphindb.cn/zh/funcs/g/getRecoveryTaskStatus.html) 获得。\n\n#### 返回值\n\n无。\n"
    },
    "cancelRecoveryTask": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cancelRecoveryTask.html",
        "signatures": [
            {
                "full": "cancelRecoveryTask(taskId)",
                "name": "cancelRecoveryTask",
                "parameters": [
                    {
                        "full": "taskId",
                        "name": "taskId"
                    }
                ]
            }
        ],
        "markdown": "### [cancelRecoveryTask](https://docs.dolphindb.cn/zh/funcs/c/cancelRecoveryTask.html)\n\n\n\n#### 语法\n\ncancelRecoveryTask(taskId)\n\n#### 详情\n\n取消已经提交但尚未开始执行的副本恢复任务。该命令只能由管理员在控制节点上执行。\n\n#### 参数\n\n**taskId** 是一个字符串标量或向量，表示副本恢复任务的 ID，可以通过 [getRecoveryTaskStatus](https://docs.dolphindb.cn/zh/funcs/g/getRecoveryTaskStatus.html) 获得。\n\n#### 返回值\n\n无。\n"
    },
    "cast": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cast.html",
        "signatures": [
            {
                "full": "cast(X, Y)",
                "name": "cast",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [cast](https://docs.dolphindb.cn/zh/funcs/c/cast.html)\n\n\n\n#### 语法\n\ncast(X, Y) 或 X $ Y\n\n#### 详情\n\n* 把一个数据类型转换成另一个\n* 改变一个矩阵的形状\n* 将向量转换成矩阵\n\n#### 参数\n\n**X** 可以是任意数据形式。\n\n**Y** 是数据类型或数据对。\n\n#### 返回值\n\n取决于 *Y* 的数据类型与形式。\n\n#### 例子\n\n```\nx=8.9$INT;\nx;\n```\n\n返回：9\n\n```\nx=1..10;\nx;\n```\n\n返回：\\[1,2,3,4,5,6,7,8,9,10]\n\n```\ntypestr x;\n```\n\n返回：FAST INT VECTOR\n\n```\nx/2;\n```\n\n返回：\\[0,1,1,2,2,3,3,4,4,5]\n\n```\nx=x$DOUBLE;\ntypestr x;\n```\n\n返回：FAST DOUBLE VECTOR\n\n```\nx/2;\n```\n\n返回：\\[0.5,1,1.5,2,2.5,3,3.5,4,4.5,5]\n\n```\nx=`IBM`MS;\ntypestr x;\n```\n\n返回：STRING VECTOR\n\n```\nx=x$SYMBOL;\ntypestr x;\n```\n\n返回：FAST SYMBOL VECTOR\n\n```\nx=`128.9;\ntypestr x;\n```\n\n返回：STRING\n\n```\nx=x$INT;\nx;\n```\n\n返回：128\n\n```\ntypestr x;\n```\n\n返回：INT\n\n以下这个例子将向量转换为矩阵：\n\n```\nm=1..8$2:4;\nm;\n```\n\n得到：\n\n| 0 | 1 | 2 | 3 |\n| - | - | - | - |\n| 1 | 3 | 5 | 7 |\n| 2 | 4 | 6 | 8 |\n\n以下例子改变一个矩阵的形状：\n\n```\nm$4:2;\n```\n\n得到：\n\n| 0 | 1 |\n| - | - |\n| 1 | 5 |\n| 2 | 6 |\n| 3 | 7 |\n| 4 | 8 |\n\n```\nm$1:size(m);\n```\n\n得到：\n\n| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |\n| - | - | - | - | - | - | - | - |\n| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |\n"
    },
    "cbrt": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cbrt.html",
        "signatures": [
            {
                "full": "cbrt(X)",
                "name": "cbrt",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [cbrt](https://docs.dolphindb.cn/zh/funcs/c/cbrt.html)\n\n\n\n#### 语法\n\ncbrt(X)\n\n#### 详情\n\n返回 *X* 的立方根。\n\n**Note:**\n\n与 [numpy.cbrt](https://numpy.org/doc/stable/reference/generated/numpy.cbrt.html) 函数的核心功能相同，区别在于 DolphinDB 中 `cbrt` 函数只接受一个参数 *X*，不支持 `numpy.cbrt` 中的 *out*、*where*、*dtype*、*casting* 和 *order* 等参数。\n\n#### 参数\n\n**X** 可以是标量、数据对、向量、矩阵或表。\n\n#### 返回值\n\nDOUBLE 类型，数据形式同 *X*。\n\n#### 例子\n\n```\ncbrt(8);\n// output\n2\n\ncbrt(8 12 16);\n// output\n[2,2.289428,2.519842]\n\ncbrt(1..6$2:3);\n```\n\n| 0        | 1        | 2        |\n| -------- | -------- | -------- |\n| 1        | 1.44225  | 1.709976 |\n| 1.259921 | 1.587401 | 1.817121 |\n"
    },
    "cdfBeta": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cdfBeta.html",
        "signatures": [
            {
                "full": "cdfBeta(alpha, beta, X)",
                "name": "cdfBeta",
                "parameters": [
                    {
                        "full": "alpha",
                        "name": "alpha"
                    },
                    {
                        "full": "beta",
                        "name": "beta"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [cdfBeta](https://docs.dolphindb.cn/zh/funcs/c/cdfBeta.html)\n\n\n\n#### 语法\n\ncdfBeta(alpha, beta, X)\n\n#### 详情\n\n返回 Beta 分布的累计密度函数的值。\n\n#### 参数\n\n形状参数 **alpha** 和 **beta** 都是正数。\n\n**X** 是数值型标量或向量。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\ncdfBeta(2.31, 0.627, [0.001, 0.5, 0.999]);\n// output\n[0, 0.116056, 0.976416]\n\ncdfBeta(2.31, 0.627, [0.1, 0.3, 0.5, 0.7, 0.9]);\n// output\n[0.002451, 0.032995, 0.116056, 0.280532, 0.597694]\n```\n"
    },
    "cdfBinomial": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cdfBinomial.html",
        "signatures": [
            {
                "full": "cdfBinomial(trials, p, X)",
                "name": "cdfBinomial",
                "parameters": [
                    {
                        "full": "trials",
                        "name": "trials"
                    },
                    {
                        "full": "p",
                        "name": "p"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [cdfBinomial](https://docs.dolphindb.cn/zh/funcs/c/cdfBinomial.html)\n\n\n\n#### 语法\n\ncdfBinomial(trials, p, X)\n\n#### 详情\n\n返回二项分布的累计密度函数的值。\n\n#### 参数\n\n**trials** 是正整数。\n\n**p** 是0到1之间的浮点数。\n\n**trials** 和 **p** 是形状参数。\n\n**X** 是数值型标量或向量。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\ncdfBinomial(10, 0.1, [1, 5, 9]);\n// output\n[0.736099, 0.999853, 1]\n\ncdfBinomial(12,0.627, [1, 3, 5, 7, 9]);\n// output\n[0.000154, 0.009085, 0.114844, 0.483879, 0.88373]\n```\n"
    },
    "cdfChiSquare": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cdfChiSquare.html",
        "signatures": [
            {
                "full": "cdfChiSquare(df, X)",
                "name": "cdfChiSquare",
                "parameters": [
                    {
                        "full": "df",
                        "name": "df"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [cdfChiSquare](https://docs.dolphindb.cn/zh/funcs/c/cdfChiSquare.html)\n\n\n\n#### 语法\n\ncdfChiSquare(df, X)\n\n#### 详情\n\n返回卡方分布的累计密度函数的值。\n\n#### 参数\n\n**df** 是正数，表示卡方分布的自由度。\n\n**X** 是数值型标量或向量。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\ncdfChiSquare(1, [-1, 0, 0.5, 1, 2]);\n// output\n[0, 0, 0.5205, 0.682689, 0.842701]\n\ncdfChiSquare(1, [0.1, 0.3, 0.5, 0.7, 0.9]);\n// output\n[0.24817, 0.416118, 0.5205, 0.597216, 0.657218]\n```\n"
    },
    "cdfExp": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cdfExp.html",
        "signatures": [
            {
                "full": "cdfExp(mean, X)",
                "name": "cdfExp",
                "parameters": [
                    {
                        "full": "mean",
                        "name": "mean"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [cdfExp](https://docs.dolphindb.cn/zh/funcs/c/cdfExp.html)\n\n\n\n#### 语法\n\ncdfExp(mean, X)\n\n#### 详情\n\n返回指数分布的累计密度函数的值。\n\n#### 参数\n\n**mean** 是指数分布的均值。\n\n**X** 是数值型标量或向量。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\ncdfExp(1, [-1, 0, 0.5, 1, 2]);\n// output\n[0, 0, 0.393469, 0.632121, 0.864665]\n\ncdfExp(1, [0.1, 0.3, 0.5, 0.7, 0.9]);\n// output\n[0.095163, 0.259182, 0.393469, 0.503415, 0.59343]\n```\n"
    },
    "cdfF": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cdfF.html",
        "signatures": [
            {
                "full": "cdfF(numeratorDF, denominatorDF, X)",
                "name": "cdfF",
                "parameters": [
                    {
                        "full": "numeratorDF",
                        "name": "numeratorDF"
                    },
                    {
                        "full": "denominatorDF",
                        "name": "denominatorDF"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [cdfF](https://docs.dolphindb.cn/zh/funcs/c/cdfF.html)\n\n\n\n#### 语法\n\ncdfF(numeratorDF, denominatorDF, X)\n\n#### 详情\n\n返回 F 分布的累计密度函数的值。\n\n#### 参数\n\n**numeratorDF** 和 **denominatorDF** 都是正数，表示 F 分布的自由度。\n\n**X** 是数值型标量或向量。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\ncdfF(2.31, 0.627, [0.001, 0.5, 0.999]);\n// output\n[0.000444, 0.245679, 0.35098]\n\ncdfF(2.31,0.627, [0.1, 0.3, 0.5, 0.7, 0.9]);\n// output\n[0.07078, 0.176153, 0.245679, 0.295996, 0.334766]\n```\n"
    },
    "cdfGamma": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cdfGamma.html",
        "signatures": [
            {
                "full": "cdfGamma(shape, scale, X)",
                "name": "cdfGamma",
                "parameters": [
                    {
                        "full": "shape",
                        "name": "shape"
                    },
                    {
                        "full": "scale",
                        "name": "scale"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [cdfGamma](https://docs.dolphindb.cn/zh/funcs/c/cdfGamma.html)\n\n\n\n#### 语法\n\ncdfGamma(shape, scale, X)\n\n#### 详情\n\n返回 Gamma 分布的累计密度函数的值。\n\n#### 参数\n\n形状参数 **shape** 是正数。\n\n尺度参数 **scale** 是正数。\n\n**X** 是数值型标量或向量。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\ncdfGamma(2.31, 0.627, [0.001, 0.5, 0.999]);\n// output\n[0, 0.127367, 0.38032]\n\ncdfGamma(2.31,0.627, [0.1, 0.3, 0.5, 0.7, 0.9]);\n// output\n[0.004754, 0.048388, 0.127367, 0.225351, 0.329391]\n```\n"
    },
    "cdfKolmogorov": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cdfKolmogorov.html",
        "signatures": [
            {
                "full": "cdfKolmogorov(X)",
                "name": "cdfKolmogorov",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [cdfKolmogorov](https://docs.dolphindb.cn/zh/funcs/c/cdfKolmogorov.html)\n\n\n\n#### 语法\n\ncdfKolmogorov(X)\n\n#### 详情\n\n返回 Kolmogorov 分布的累计密度函数的值。\n\n#### 参数\n\n**X** 是数值型标量或向量。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\ncdfKolmogorov([0.1, 0.3, 0.5, 0.7, 0.9]);\n// output\n[1, 0.999991, 0.963945, 0.711235, 0.392731]\n\ncdfKolmogorov([1,2,3]);\n// output\n[0.27, 0.000671, 3.045996E-8]\n```\n"
    },
    "cdfLogistic": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cdfLogistic.html",
        "signatures": [
            {
                "full": "cdfLogistic(mean, s, X)",
                "name": "cdfLogistic",
                "parameters": [
                    {
                        "full": "mean",
                        "name": "mean"
                    },
                    {
                        "full": "s",
                        "name": "s"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [cdfLogistic](https://docs.dolphindb.cn/zh/funcs/c/cdfLogistic.html)\n\n\n\n#### 语法\n\ncdfLogistic(mean, s, X)\n\n#### 详情\n\n返回 Logistic 分布的累计密度函数的值。\n\n#### 参数\n\n**mean** 是 Logistic 分布的均值。\n\n**s** 是 Logistic 分布的尺度参数。\n\n**X** 是数值型标量或向量。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\ncdfLogistic( 2.31, 0.627, [0.5, 0.3, 0.5, 0.7, 0.1]);\n```\n\n输出返回：\\[0.052812, 0.03895, 0.052812, 0.071241, 0.028617]\n"
    },
    "cdfNormal": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cdfNormal.html",
        "signatures": [
            {
                "full": "cdfNormal(mean, stdev, X)",
                "name": "cdfNormal",
                "parameters": [
                    {
                        "full": "mean",
                        "name": "mean"
                    },
                    {
                        "full": "stdev",
                        "name": "stdev"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [cdfNormal](https://docs.dolphindb.cn/zh/funcs/c/cdfNormal.html)\n\n\n\n#### 语法\n\ncdfNormal(mean, stdev, X)\n\n#### 详情\n\n返回均值为 *mean*，标准差为 *stdev* 的正态分布的累计密度函数的值。\n\n#### 参数\n\n**mean** 是正态分布的均值。\n\n**stdev** 是正态分布的标准差。\n\n**X** 是数值型标量或向量。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\ncdfNormal(0,1,-2.33);\n// output\n0.009903\n\ncdfNormal(10, 20, -30);\n// output\n0.02275\n```\n"
    },
    "cdfPoisson": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cdfPoisson.html",
        "signatures": [
            {
                "full": "cdfPoisson(mean, X)",
                "name": "cdfPoisson",
                "parameters": [
                    {
                        "full": "mean",
                        "name": "mean"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [cdfPoisson](https://docs.dolphindb.cn/zh/funcs/c/cdfPoisson.html)\n\n\n\n#### 语法\n\ncdfPoisson(mean, X)\n\n#### 详情\n\n返回泊松分布的累计分布函数的值。\n\n#### 参数\n\n**mean** 是泊松分布的均值。\n\n**X** 是整型标量或向量。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\ncdfPoisson(1, [-1, 0, 1, 2, 3]);\n// output\n[0, 0.367879, 0.735759, 0.919699, 0.981012]\n\ncdfPoisson(1, [1, 3, 5, 7, 9]);\n// output\n[0.735759, 0.981012, 0.999406, 0.99999, 1]\n```\n"
    },
    "cdfStudent": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cdfStudent.html",
        "signatures": [
            {
                "full": "cdfStudent(df, X)",
                "name": "cdfStudent",
                "parameters": [
                    {
                        "full": "df",
                        "name": "df"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [cdfStudent](https://docs.dolphindb.cn/zh/funcs/c/cdfStudent.html)\n\n\n\n#### 语法\n\ncdfStudent(df, X)\n\n#### 详情\n\n返回 t 分布的累计密度函数的值。\n\n#### 参数\n\n**df** 是正数，表示 t 分布的自由度。\n\n**X** 是数值型标量或向量。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\ncdfStudent(1, [-1, 0, 0.5, 1, 2]);\n// output\n[0.25, 0.5, 0.647584, 0.75, 0.852416]\n\ncdfStudent(1, [0.1, 0.3, 0.5, 0.7, 0.9]);\n// output\n[0.531726, 0.592774, 0.647584, 0.6944, 0.733262]\n```\n"
    },
    "cdfUniform": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cdfUniform.html",
        "signatures": [
            {
                "full": "cdfUniform(lower, upper, X)",
                "name": "cdfUniform",
                "parameters": [
                    {
                        "full": "lower",
                        "name": "lower"
                    },
                    {
                        "full": "upper",
                        "name": "upper"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [cdfUniform](https://docs.dolphindb.cn/zh/funcs/c/cdfUniform.html)\n\n\n\n#### 语法\n\ncdfUniform(lower, upper, X)\n\n#### 详情\n\n返回均匀分布的累计密度函数的值。\n\n#### 参数\n\n**lower** 和 **upper** 是数值型标量，表示连续均匀分布的下限和上限。\n\n**X** 是数值型标量或向量。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\ncdfUniform(0.627, 2.31, [0.001, 0.5, 0.999]);\n// output\n[0, 0, 0.221034]\n\ncdfUniform(0.627, 2.31, [0.1, 0.3, 0.5, 0.7, 0.9]);\n// output\n[0, 0, 0, 0.043375, 0.16221]\n```\n"
    },
    "cdfWeibull": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cdfWeibull.html",
        "signatures": [
            {
                "full": "cdfWeibull(alpha, beta, X)",
                "name": "cdfWeibull",
                "parameters": [
                    {
                        "full": "alpha",
                        "name": "alpha"
                    },
                    {
                        "full": "beta",
                        "name": "beta"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [cdfWeibull](https://docs.dolphindb.cn/zh/funcs/c/cdfWeibull.html)\n\n\n\n#### 语法\n\ncdfWeibull(alpha, beta, X)\n\n#### 详情\n\n返回 Weibull 分布的累计密度函数的值。\n\n#### 参数\n\n形状参数 **alpha** 和 **beta** 都是正数。\n\n**X** 是数值型标量或向量。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\ncdfWeibull(2.31, 0.627, [0.001, 0.5, 0.999]);\n// output\n[0, 0.447241, 0.946762]\n\ncdfWeibull(2.31,0.627, [0.1, 0.3, 0.5, 0.7, 0.9]);\n// output\n[0.014295, 0.166535, 0.447241, 0.724646, 0.90021]\n```\n"
    },
    "cdfZipf": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cdfZipf.html",
        "signatures": [
            {
                "full": "cdfZipf(num, exponent, X)",
                "name": "cdfZipf",
                "parameters": [
                    {
                        "full": "num",
                        "name": "num"
                    },
                    {
                        "full": "exponent",
                        "name": "exponent"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [cdfZipf](https://docs.dolphindb.cn/zh/funcs/c/cdfZipf.html)\n\n\n\n#### 语法\n\ncdfZipf(num, exponent, X)\n\n#### 详情\n\n返回 Zipf 分布的累计密度函数的值。\n\n#### 参数\n\n**num** 是正整数。\n\n**exponent** 是非负数。\n\n**X** 是数值型向量。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\ncdfZipf(10, 0.5, [1, 3, 5, 7, 9]);\n// output\n[0.199164, 0.454981, 0.643631, 0.800216, 0.937019]\n```\n"
    },
    "ceil": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/ceil.html",
        "signatures": [
            {
                "full": "ceil(X)",
                "name": "ceil",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [ceil](https://docs.dolphindb.cn/zh/funcs/c/ceil.html)\n\n\n\n#### 语法\n\nceil(X)\n\n#### 详情\n\n函数 [floor](https://docs.dolphindb.cn/zh/funcs/f/floor.html) 和 `ceil` 分别把一个实数映射到小于等于它的最大整数，和大于等于它的最小整数。函数 [round](https://docs.dolphindb.cn/zh/funcs/r/round.html) 根据四舍五入规则把一个实数映射到最接近的整数。\n\n**Note:**\n\n与 [numpy.ceil](https://numpy.org/doc/stable/reference/generated/numpy.ceil.html) 函数的核心功能相同，区别在于 DolphinDB 中的 `ceil` 函数只接受一个参数 *X*，不支持 `numpy.ceil` 中的 *out*、*where*、*dtype*、*casting* 和 *order* 等参数。\n\n与 Python TA-Lib 中 `CEIL` 的区别：二者均进行向上取整。TA-Lib 的 `CEIL(close)` 是 Math Transform 函数，输入和输出主要为一维数组，Python 返回浮点数组；DolphinDB 的 `ceil(X)` 可用于标量、向量或矩阵，返回整数类型。\n\n#### 参数\n\n**X** 可以是标量、向量或矩阵。\n\n#### 返回值\n\n整数类型标量、向量或矩阵。\n\n#### 例子\n\n```\nceil(2.1);\n// output\n3\nceil(2.9);\n// output\n3\nceil(-2.1);\n// output\n-2\n\nfloor(2.1);\n// output\n2\nfloor(2.9);\n// output\n2\nfloor(-2.1);\n// output\n-3\n\nround(2.1);\n// output\n2\nround(2.9);\n// output\n3\nround(-2.1);\n// output\n-2\n\nm = 1.1 2.2 3.3 4.4 5.5 6.6 7.7 8.8 9.9 10$2:5;\nm;\n```\n\n| 0   | 1   | 2   | 3   | 4   |\n| --- | --- | --- | --- | --- |\n| 1.1 | 3.3 | 5.5 | 7.7 | 9.9 |\n| 2.2 | 4.4 | 6.6 | 8.8 | 10  |\n\n```\nceil(m);\n```\n\n| 0 | 1 | 2 | 3 | 4  |\n| - | - | - | - | -- |\n| 2 | 4 | 6 | 8 | 10 |\n| 3 | 5 | 7 | 9 | 10 |\n"
    },
    "cell": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cell.html",
        "signatures": [
            {
                "full": "cell(obj, row, col)",
                "name": "cell",
                "parameters": [
                    {
                        "full": "obj",
                        "name": "obj"
                    },
                    {
                        "full": "row",
                        "name": "row"
                    },
                    {
                        "full": "col",
                        "name": "col"
                    }
                ]
            }
        ],
        "markdown": "### [cell](https://docs.dolphindb.cn/zh/funcs/c/cell.html)\n\n\n\n#### 语法\n\ncell(obj, row, col)\n\n#### 详情\n\n返回一个位于对应行列的标量，等价于 `obj[row, col]`。*cell* 函数通常比 `obj[row, col]` 运行地更快。\n\n#### 参数\n\n**obj** 矩阵或表。\n\n**row** 非负整数，表示行坐标。\n\n**col** 非负整数，表示列坐标。\n\n#### 返回值\n\n一个标量，与 *obj* 中对应位置元素的数据类型保持一致。\n\n#### 例子\n\n```\nx=(1..6).reshape(3:2);\nx;\n```\n\n| 0 | 1 |\n| - | - |\n| 1 | 4 |\n| 2 | 5 |\n| 3 | 6 |\n\n```\nx.cell(0,0);\n// output\n1\nx.cell(0,1);\n// output\n4\ncell(x,1,1);\n// output\n5\n\ncell(x,2,0);\n// output\n3\n```\n"
    },
    "cells": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cells.html",
        "signatures": [
            {
                "full": "cells(obj, row, col)",
                "name": "cells",
                "parameters": [
                    {
                        "full": "obj",
                        "name": "obj"
                    },
                    {
                        "full": "row",
                        "name": "row"
                    },
                    {
                        "full": "col",
                        "name": "col"
                    }
                ]
            }
        ],
        "markdown": "### [cells](https://docs.dolphindb.cn/zh/funcs/c/cells.html)\n\n\n\n#### 语法\n\ncells(obj, row, col)\n\n#### 详情\n\n返回一个由矩阵中 *row* 和 *col* 定位的元素组成的向量。\n\n#### 参数\n\n**obj** 矩阵。\n\n**row** 整型向量，表示行坐标。\n\n**col** 与 *row* 等长的整型向量，表示列坐标。\n\n#### 返回值\n\n一个向量，与 *obj* 中对应位置元素的数据类型保持一致。\n\n#### 例子\n\n```\nm=(1..15).reshape(3:5)\nm;\n```\n\n| col1 | col2 | col3 | col4 | col5 |\n| ---- | ---- | ---- | ---- | ---- |\n| 1    | 4    | 7    | 10   | 13   |\n| 2    | 5    | 8    | 11   | 14   |\n| 3    | 6    | 9    | 12   | 15   |\n\n```\n// 取矩阵中下标为 [0,1] 和 [0,2] 两个元素\ncells(m, 0 0, 1 2)\n// output\n[4,7]\n// 取矩阵对角线上的元素\nindex = 0..2\ncells(m, index, index)\n// output\n[1, 5, 9]\n```\n"
    },
    "changelogStreamTable": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/changelogStreamTable.html",
        "signatures": [
            {
                "full": "changelogStreamTable(keyColumn, X, [X1], [X2], .....)",
                "name": "changelogStreamTable",
                "parameters": [
                    {
                        "full": "keyColumn",
                        "name": "keyColumn"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[X1]",
                        "name": "X1",
                        "optional": true
                    },
                    {
                        "full": "[X2]",
                        "name": "X2",
                        "optional": true
                    },
                    {
                        "full": ".....",
                        "name": "....."
                    }
                ]
            },
            {
                "full": "changelogStreamTable(keyColumn, capacity:size, colNames, colTypes)",
                "name": "changelogStreamTable",
                "parameters": [
                    {
                        "full": "keyColumn",
                        "name": "keyColumn"
                    },
                    {
                        "full": "capacity:size",
                        "name": "capacity:size"
                    },
                    {
                        "full": "colNames",
                        "name": "colNames"
                    },
                    {
                        "full": "colTypes",
                        "name": "colTypes"
                    }
                ]
            }
        ],
        "markdown": "### [changelogStreamTable](https://docs.dolphindb.cn/zh/funcs/c/changelogStreamTable.html)\n\n首发版本：3.00.5\n\n\n\n#### 语法\n\nchangelogStreamTable(keyColumn, X, \\[X1], \\[X2], .....)\n\n或\n\nchangelogStreamTable(keyColumn, capacity:size, colNames, colTypes)\n\n#### 详情\n\n创建包含状态列的键值流数据表。\n\n* 该表包含一个内部状态列（statusColumn，不展示），CHAR 类型，用于跟踪数据变更状态，目前支持两种状态：\n\n  1. 'N'：NEW，表示 key 不存在时的新增记录；\n\n  2. 'U'：UPDATE，表示 key 已存在时的更新记录。\n\n* 状态列的状态也支持用户自行写入。\n\n* 查询时只返回每个 key 的最新一条记录。\n\n**Note:**\n\n目前 TimeSeriesEngine 和 ReactiveStateEngine 处理 *dummyTable* 为包含状态列的流数据表时，仅支持部分算子，具体如下：\n\n* **TimeSeriesEngine** 在设置了 *keyColumn* 且 *updateTime*=0 时，支持以下算子：\n\n  * sum、avg、sum2、sum3、sum4、count、std、stdp、var、varp\n\n* **ReactiveStateEngine** 支持以下算子：\n\n  * cumavg、cumsum、cumstd、cumstdp、cumvar、cumvarp、cumprod、cumcount、mcount、msum、mavg、mstd、mstdp、mvar、mvarp 以及无状态算子（表达式、无状态函数等）\n\n#### 参数\n\n**keyColumn** 是一个字符串或向量，表示主键。主键的数据类型必须属于以下类别：INTEGRAL, TEMPORAL, LITERAL 或 FLOATING。\n\n第一种用法中，**X**, **X1**, **X2** ... 可以是向量、数组向量、矩阵或元组。每个向量、元组、数组向量的长度，以及矩阵中每列长度都必须相同。**当 Xk 是元组时：**\n\n* 若 Xk 的元素是等长的向量，\\*\\*元组的每个元素将作为表的一列。\\*\\*元组的长度必须等于表的行数。\n\n* 若 Xk 包含不同类型或不等长元素，\\*\\*则将单独作为表的一列（列类型为 ANY），其每个元素将作为该列每行的元素值。\\*\\*Xk 的长度仍然必须和表的行数保持一致。\n\n第二种用法中：\n\n* **capacity** 是正整数，表示建表时系统为该表分配的内存（以记录数为单位）。当记录数超过 *capacity* 时，系统首先会分配 *capacity* 1.2\\~2倍的新的内存空间，然后复制数据到新的内存空间，最后释放原来的内存。对于规模较大的表，此类操作的内存占用会很高。因此，建议建表时预先分配一个合理的 *capacity*。\n\n* **size** 是整数，表示该表新建时的行数。若 *size* =0，创建一个空表。 若 *size*>0，则建立一个只包含 size 条记录的表，记录初始值如下：\n\n  * BOOL 类型默认值为 false；\n\n  * 数值类型、时间类型、IPADDR、COMPLEX、POINT 的默认值为 0；\n\n  * Literal, INT128 类型的默认值为 NULL。\n\n  **Note:** 如果 *colTypes* 指定为数组向量， *size* 必须为0。\n\n* **colNames** 是一个向量，表示列名。\n\n* **colTypes** 是一个向量，表示每列的数据类型，允许主键外的其它列指定为数组向量类型或元组（ANY）类型。可使用表示数据类型的系统保留字或相应的字符串。\n\n#### 返回值\n\n一个表。\n\n#### 例子\n\n```\nshare changelogStreamTable(`sym`time, 100:0, `sym`time`price, [STRING,DATETIME,DOUBLE]) as tickStream\nn=4\ndata1 = table(take(\"000001.SH\", n) as sym, take(2021.02.08T09:30:00 + 1..2, n) as time, 10+rand(100.0, n) as price)\ntickStream.append!(data1)\nselect * from tickStream\n```\n\n|   | sym       | time                | price             |\n| - | --------- | ------------------- | ----------------- |\n| 0 | 000001.SH | 2021.02.08 09:30:01 | 89.723076797026   |\n| 1 | 000001.SH | 2021.02.08 09:30:02 | 69.34098429496888 |\n\n**相关函数**：[keyedStreamTable](https://docs.dolphindb.cn/zh/funcs/k/keyedStreamTable.html)、[getStreamTableChangelog](https://docs.dolphindb.cn/zh/funcs/g/getStreamTableChangelog.html)\n"
    },
    "changePwd": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/changePwd.html",
        "signatures": [
            {
                "full": "changePwd(oldPwd, newPwd)",
                "name": "changePwd",
                "parameters": [
                    {
                        "full": "oldPwd",
                        "name": "oldPwd"
                    },
                    {
                        "full": "newPwd",
                        "name": "newPwd"
                    }
                ]
            }
        ],
        "markdown": "### [changePwd](https://docs.dolphindb.cn/zh/funcs/c/changePwd.html)\n\n\n\n#### 语法\n\nchangePwd(oldPwd, newPwd)\n\n#### 详情\n\n修改用户密码。\n\n#### 参数\n\n**oldPwd** 表示用户旧密码的字符串。\n\n**newPwd** 表示用户新密码的字符串。它不能包含空格或控制字符。\n\n从 2.00.10.10 开始，用户可以通过配置项 *enhancedSecurityVerification* 控制是否对 newPwd 进行复杂性校验。若不设置 *enhancedSecurityVerification*，则不校验；若设置 *enhancedSecurityVerification*=true，则要求新密码必须满足以下条件：\n\n* 字符个数为8\\~20\n* 至少包含一个大写字母\n* 至少包含以下字符之一：!\"#$%&'()\\*+,-./:;<=>?@\\[]^\\_\\`{|}\\~。\n\n**Note:** 该函数只能在控制节点、数据节点和计算节点运行。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\nchangePwd(\"LTmp4389.\", \"T5139pm.\");\n```\n"
    },
    "char": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/char.html",
        "signatures": [
            {
                "full": "char(X)",
                "name": "char",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [char](https://docs.dolphindb.cn/zh/funcs/c/char.html)\n\n\n\n#### 语法\n\nchar(X)\n\n#### 详情\n\n把输入转换为 CHAR 数据类型。\n\n#### 参数\n\n**X** 可以是任意数据类型。\n\n#### 返回值\n\nCHAR 类型标量。\n\n#### 例子\n\n```\nx=char();\nx;\n```\n\n返回：null\n\n```\ntypestr x;\n```\n\n返回：CHAR\n\n```\na=char(99);\na;\n```\n\n返回：'c'\n\n```\ntypestr a;\n```\n\n返回：CHAR\n\n```\nchar(a+5);\n```\n\n返回：'h'\n\n```\nchar(\"990\");\n```\n\n返回：`Failed to convert the string to CHAR`\n\n**Note:** `char` 函数会把输入的字符串识别为 ASCII 码，超出 ASCII 码范围的输入字符无法转换。\n"
    },
    "charAt": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/charAt.html",
        "signatures": [
            {
                "full": "charAt(X, Y)",
                "name": "charAt",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [charAt](https://docs.dolphindb.cn/zh/funcs/c/charAt.html)\n\n\n\n#### 语法\n\ncharAt(X, Y)\n\n#### 详情\n\n返回字符串中指定位置的字符。返回的结果是 CHAR 类型。\n\n#### 参数\n\n**X** 是字符串标量或向量。\n\n**Y** 是整型标量或与 *X* 长度相同的整型向量。\n\n#### 返回值\n\nCHAR 类型标量或向量。\n\n#### 例子\n\n```\ns=charAt(\"abc\",2);\ns;\n// output\n'c'\n\ntypestr(s);\n// output\nCHAR\n\ncharAt([\"hello\",\"world\"],[3,4]);\n// output\n['l','d']\n```\n"
    },
    "checkBackup": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/checkBackup.html",
        "signatures": [
            {
                "full": "checkBackup(backupDir, dbPath, [tableName], [partition])",
                "name": "checkBackup",
                "parameters": [
                    {
                        "full": "backupDir",
                        "name": "backupDir"
                    },
                    {
                        "full": "dbPath",
                        "name": "dbPath"
                    },
                    {
                        "full": "[tableName]",
                        "name": "tableName",
                        "optional": true
                    },
                    {
                        "full": "[partition]",
                        "name": "partition",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [checkBackup](https://docs.dolphindb.cn/zh/funcs/c/checkBackup.html)\n\n\n\n#### 语法\n\ncheckBackup(backupDir, dbPath, \\[tableName], \\[partition])\n\n#### 详情\n\n检查备份文件的的完整性和准确性。若所有备份文件均完整且准确，则返回一个空表；否则返回异常的备份文件信息，此时可通过在 `backup` 函数设置 *force* = true 开启强制备份以恢复受损的备份分区数据。\n\n#### 参数\n\n**backupDir** 字符串，表示存放备份数据的目录。\n\n**dbPath** 字符串，表示数据库路径。\n\n**tableName** 字符串标量或向量，表示表名。若不指定，表示指定数据库下的所有表。\n\n**partition** 表示分区。是字符串，表示备份分区的相对路径。分区路径可以包含通配符(\"%\"和\"?\")，\"?\"表示单个字符，\"%\"表示0，1或多个字符。\n\n* 若仅检查某个分区，输入分区的相对路径或者\"%/\"+”分区名称”。举例：要检查 \"dfs\\://compoDB\" 下的分区”20170810/50\\_100”，输入 \"/compoDB/20170807/0\\_50\" 或者 \"%/20170807/0\\_50\"。\n* 若需要检查所有分区，直接输入\"%\"。\n\n#### 返回值\n\n一个表。\n\n#### 例子\n\n```\ndbName = \"dfs://compoDB2\"\nn=1000\nID=rand(\"a\"+string(1..10), n)\ndates=2017.08.07..2017.08.11\ndate=rand(dates, n)\nx=rand(10, n)\nt=table(ID, date, x)\ndb1 = database(, VALUE, 2017.08.07..2017.08.11)\ndb2 = database(, HASH,[INT, 20])\nif(existsDatabase(dbName)){\n   dropDatabase(dbName)\n}\ndb = database(dbName, COMPO,[ db1,db2])\n\n// 创建2个表\npt1 = db.createPartitionedTable(t, `pt1, `date`x).append!(t)\npt2 = db.createPartitionedTable(t, `pt2, `date`x).append!(t)\n\n// SQL 元代码方式备份 pt1\nbackup(backupDir=backupDir1, sqlObj=<select * from pt1>, parallel=true)\n// 拷贝文件方式备份 pt2\nbackup(backupDir=backupDir2, dbPath=dbName, parallel=true, tableName=`pt2)\n\n// pt2 备份文件都正常，pt1 中一个 chunk 文件出现问题\ncheckBackup(backupDir=backupDir2, dbPath=dbName, tableName=\"pt2\")  // 返回一个空表\ncheckBackup(backupDir=backupDir1, dbPath=dbName, tableName=\"pt1\")  // 返回出错的 chunk 信息\n```\n\n| dbName          | tableName | chunkPath                 | chunkID                              | partitionPath  |\n| --------------- | --------- | ------------------------- | ------------------------------------ | -------------- |\n| dfs\\://compoDB2 | pt1       | /compoDB2/20170807/Key2/9 | 4ae71414-8bfe-4283-b04c-b2e48e90be08 | /20170807/Key2 |\n\n上例中，通过调用 *checkBackup* 函数，可以发现在 pt1 中存在损坏的 chunk 文件。此时，设置 *force* = true 再次强制备份，以恢复受损文件。\n\n```\nbackup(backupDir1, <select * from pt1>,force=true, parallel=true)\ncheckBackup(backupDir=backupDir1, dbPath=dbName, tableName=\"pt1\")  // 返回一个空表\n```\n"
    },
    "checkpointHaMvcc": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/checkpointHaMvcc.html",
        "signatures": [
            {
                "full": "checkpointHaMvcc(groupId)",
                "name": "checkpointHaMvcc",
                "parameters": [
                    {
                        "full": "groupId",
                        "name": "groupId"
                    }
                ]
            }
        ],
        "markdown": "### [checkpointHaMvcc](https://docs.dolphindb.cn/zh/funcs/c/checkpointHaMvcc.html)\n\n首发版本：3.00.5\n\n\n\n#### 语法\n\ncheckpointHaMvcc(groupId)\n\n#### 详情\n\n手动触发指定 MVCC Raft 组的 checkpoint。\n\n#### 参数\n\n**groupId** 是一个整数，表示 MVCC Raft 组 ID。\n\n#### 例子\n\n```\ncheckpointHaMvcc(5)\n```\n\n**相关函数**：[haMvccTable](https://docs.dolphindb.cn/zh/funcs/h/haMvccTable.html)\n"
    },
    "chiSquareTest": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/chiSquareTest.html",
        "signatures": [
            {
                "full": "chiSquareTest(X, [Y])",
                "name": "chiSquareTest",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[Y]",
                        "name": "Y",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [chiSquareTest](https://docs.dolphindb.cn/zh/funcs/c/chiSquareTest.html)\n\n\n\n#### 语法\n\nchiSquareTest(X, \\[Y])\n\n#### 详情\n\n如果 *X* 是一个向量，进行 Chi-square Goodness-of-fit 检验 *X* 是否与 *Y* 的概率分布一致；如果 *X* 是矩阵或表，对 *X* 进行 Pearson's Chi-squared 检验。\n\n#### 参数\n\n**X** 是一个数值向量、矩阵或表。\n\n如果 *X* 是一个向量，那么 *Y* 是一个与 *X* 长度相同的向量；如果 *X* 是矩阵或表，那么无需指定 *Y*。\n\n#### 返回值\n\n返回一个字典，包含以下 key：\n\n* pValue：p 值\n* df：自由度\n* chiSquaredValue：chi-square 统计量\n* method：如果 *X* 为向量，*method* 为字符串 \"Chi-squared test for given expected values\"；如果 *X* 为矩阵或表，*method* 为字符串 \"Pearson's Chi-squared test\"。\n\n#### 例子\n\n例1. *X* 是一个向量。\n\n```\nx=rand(10.0,50)\ny=rand(10.0,50)\nchiSquareTest(x,y);\n\n// output\npValue->0\ndf->49\nchiSquaredValue->947.388015\nmethod->Chi-squared test for given expected values\n```\n\n例2. *X* 是一个矩阵。\n\n```\nx = matrix([762, 484], [327, 239], [468, 477])\nx.rename!(`female`male, `Democrat`Independent`Republican)\nx;\n```\n\n|        | Democrat | Independent | Republican |\n| ------ | -------- | ----------- | ---------- |\n| female | 762      | 327         | 468        |\n| male   | 484      | 239         | 477        |\n\n```\nchiSquareTest(x);\n// output\npValue->2.953589E-7\ndf->2\nchiSquaredValue->30.070149\nmethod->Pearson's Chi-squared test\n```\n"
    },
    "cholesky": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cholesky.html",
        "signatures": [
            {
                "full": "cholesky(obj, [lower=true])",
                "name": "cholesky",
                "parameters": [
                    {
                        "full": "obj",
                        "name": "obj"
                    },
                    {
                        "full": "[lower=true]",
                        "name": "lower",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [cholesky](https://docs.dolphindb.cn/zh/funcs/c/cholesky.html)\n\n\n\n#### 语法\n\ncholesky(obj, \\[lower=true])\n\n#### 详情\n\n对矩阵进行 Cholesky 分解。\n\n**Note:**\n\n与 [scipy.linalg.cholesky](https://docs.scipy.org/doc/scipy-1.17.0/reference/generated/scipy.linalg.cholesky.html) 函数的核心功能相同，区别如下：\n\n* DolphinDB 中，`cholesky` 函数的 *lower* 参数默认值为 true；而 `scipy.linalg.cholesky` 函数中 *lower* 参数默认值为 false。\n\n* DolphinDB 中， `cholesky` 函数不支持 `scipy.linalg.cholesky` 函数中的 *overwrite\\_a* 和*check\\_finite* 参数。\n\n#### 参数\n\n**obj** 是一个对称正定矩阵。\n\n**lower** 是一个布尔值，表示是否使用输入矩阵的下三角来计算分解。默认值为 true，表示使用下三角计算。如果 *lower* 为 false，表示使用上三角计算。\n\n#### 返回值\n\nDOUBLE 类型矩阵。\n\n#### 例子\n\n```\nm=[1, 0, 1, 0, 2, 0, 1, 0, 3]$3:3\nL=cholesky(m);\nL;\n```\n\n| #0 | #1       | #2       |\n| -- | -------- | -------- |\n| 1  | 0        | 0        |\n| 0  | 1.414214 | 0        |\n| 1  | 0        | 1.414214 |\n\n```\nL**transpose(L);\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1  | 0  | 1  |\n| 0  | 2  | 0  |\n| 1  | 0  | 3  |\n\n```\ncholesky(m, false);\n```\n\n| #0 | #1       | #2       |\n| -- | -------- | -------- |\n| 1  | 0        | 1        |\n| 0  | 1.414214 | 0        |\n| 0  | 0        | 1.414214 |\n"
    },
    "cj": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cj.html",
        "signatures": [
            {
                "full": "cj(X, Y)",
                "name": "cj",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [cj](https://docs.dolphindb.cn/zh/funcs/c/cj.html)\n\n\n\n#### 语法\n\ncj(X, Y)\n\n#### 详情\n\n这个函数对两个表执行交叉连接，产生它们的笛卡儿积。如果 *X* 有 n 行，*Y* 有 m 行，那么 cj(X,Y) 有 n\\*m 行。\n\n#### 参数\n\n**X** 和 **Y** 是表。\n\n#### 返回值\n\n一个表。\n\n#### 例子\n\n```\na=table(1..3 as x,`IBM`C`AAPL as y)\nb=table(172.3 25 106.5 as z)\nc=cj(a,b);\nc;\n```\n\n| x | y    | z     |\n| - | ---- | ----- |\n| 1 | IBM  | 172.3 |\n| 1 | IBM  | 25    |\n| 1 | IBM  | 106.5 |\n| 2 | C    | 172.3 |\n| 2 | C    | 25    |\n| 2 | C    | 106.5 |\n| 3 | AAPL | 172.3 |\n| 3 | AAPL | 25    |\n| 3 | AAPL | 106.5 |\n\n```\n// 与此相对，join(<-) 只是将两个表的列合并\na join b;\n```\n\n| x | y    | z     |\n| - | ---- | ----- |\n| 1 | IBM  | 172.3 |\n| 2 | C    | 25    |\n| 3 | AAPL | 106.5 |\n"
    },
    "cleanOutdateLogFiles": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cleanOutdateLogFiles.html",
        "signatures": [
            {
                "full": "cleanOutdateLogFiles([retentionTime=30])",
                "name": "cleanOutdateLogFiles",
                "parameters": [
                    {
                        "full": "[retentionTime=30]",
                        "name": "retentionTime",
                        "optional": true,
                        "default": "30"
                    }
                ]
            }
        ],
        "markdown": "### [cleanOutdateLogFiles](https://docs.dolphindb.cn/zh/funcs/c/cleanOutdateLogFiles.html)\n\n\n\n#### 语法\n\ncleanOutdateLogFiles(\\[retentionTime=30])\n\n#### 详情\n\n手动触发超过 *retentionTime* 时间的系统日志的清理。\n\n#### 参数\n\n**retentionTime** 系统日志的保留时间，默认是 30（单位：天）。\n\n#### 返回值\n\n无。\n"
    },
    "clearAllCache": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/clearAllCache.html",
        "signatures": [
            {
                "full": "clearAllCache()",
                "name": "clearAllCache",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [clearAllCache](https://docs.dolphindb.cn/zh/funcs/c/clearAllCache.html)\n\n\n\n#### 语法\n\nclearAllCache()\n\n#### 详情\n\n清除以下缓存数据：\n\n* 维度表在内存中的缓存\n* OLAP 引擎分区表中已经载入内存的数据\n* TSDB 引擎的 Level File 索引的缓存\n* TSDB 引擎中 SYMBOL 类型的字典编码的缓存\n* 分布式计算中 map-reduce 任务的中间结果\n\n#### 参数\n\n无。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\nclearAllCache();\n```\n"
    },
    "clearAllIOTDBLatestKeyCache": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/clearalliotdblatestkeycache.html",
        "signatures": [
            {
                "full": "clearAllIOTDBLatestKeyCache()",
                "name": "clearAllIOTDBLatestKeyCache",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [clearAllIOTDBLatestKeyCache](https://docs.dolphindb.cn/zh/funcs/c/clearalliotdblatestkeycache.html)\n\n\n\n#### 语法\n\nclearAllIOTDBLatestKeyCache()\n\n#### 详情\n\n用于清理最新值缓存表缓存。\n\n#### 参数\n\n无。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\nclearAllIOTDBLatestKeyCache()\n```\n"
    },
    "clearAllIOTDBStaticTableCache": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/clearalliotdbstatictablecache.html",
        "signatures": [
            {
                "full": "clearAllIOTDBStaticTableCache()",
                "name": "clearAllIOTDBStaticTableCache",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [clearAllIOTDBStaticTableCache](https://docs.dolphindb.cn/zh/funcs/c/clearalliotdbstatictablecache.html)\n\n\n\n#### 语法\n\nclearAllIOTDBStaticTableCache()\n\n#### 详情\n\n用于清理静态表缓存。\n\n#### 参数\n\n无。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\nclearAllIOTDBStaticTableCache()\n```\n"
    },
    "clearAllTSDBSymbolBaseCache": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/clearalltsdbsymbolbasecache.html",
        "signatures": [
            {
                "full": "clearAllTSDBSymbolBaseCache()",
                "name": "clearAllTSDBSymbolBaseCache",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [clearAllTSDBSymbolBaseCache](https://docs.dolphindb.cn/zh/funcs/c/clearalltsdbsymbolbasecache.html)\n\n\n\n#### 语法\n\nclearAllTSDBSymbolBaseCache()\n\n#### 详情\n\n清除缓存中所有未被使用的 symbolBase。其中，未被使用的 symbolBase 是指其对应分区的数据不在 Cache Engine 中，也不在执行的任何事务中。\n\n#### 参数\n\n无。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\nclearAllTSDBSymbolBaseCache();\n```\n"
    },
    "clearCachedDatabase": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/clearCachedDatabase.html",
        "signatures": [
            {
                "full": "clearCachedDatabase(dbUrl, [tableName])",
                "name": "clearCachedDatabase",
                "parameters": [
                    {
                        "full": "dbUrl",
                        "name": "dbUrl"
                    },
                    {
                        "full": "[tableName]",
                        "name": "tableName",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [clearCachedDatabase](https://docs.dolphindb.cn/zh/funcs/c/clearCachedDatabase.html)\n\n\n\n#### 语法\n\nclearCachedDatabase(dbUrl, \\[tableName])\n\n#### 详情\n\n清理从数据库加载到内存的数据表的缓存。通过函数 [getSessionMemoryStat](https://docs.dolphindb.cn/zh/g/getSessionMemoryStat.dita) 可以查看系统中的不同缓存的占用情况。\n\n#### 参数\n\n**dbUrl** 一个字符串，表示分布式数据库的路径。\n\n**tableName** 一个字符串，表示数据表的表名，可以是维度表或分布式表。\n\n#### 返回值\n\n无。\n"
    },
    "clearCachedModules": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/clearCachedModules.html",
        "signatures": [
            {
                "full": "clearCachedModules()",
                "name": "clearCachedModules",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [clearCachedModules](https://docs.dolphindb.cn/zh/funcs/c/clearCachedModules.html)\n\n\n\n#### 语法\n\nclearCachedModules()\n\n#### 详情\n\n清除缓存的 module。更新 module 文件后，通过该命令清除 module 缓存，执行 use 语句时，会重新从文件加载 module，无需重启节点。\n\n**Note:** 只有管理员（admin）才能执行该命令。\n\n#### 参数\n\n无\n\n#### 返回值\n\n无。\n\n#### 例子\n\n定义并导入一个 module\n\n```\nmodule printLog\ndef printLog(){\nprint \"hello\"\n}\n```\n\n加载模块\n\n```\nuse printLog\nprintLog()\n// output\nhello\n```\n\n修改 module\n\n```\nmodule printLog\ndef printLog(){\nprint \"hello new\"\n}\n```\n\n再次加载模块前，需要调用 `clearCachedModules` 以清除之前缓存的 module。\n\n```\nlogin(\"admin\", \"123456\")\n\nclearCachedModules();\n\nuse printLog\nprintLog()\n// output\nhello new\n```\n"
    },
    "clearComputeNodeCache": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/clearcomputenodecache.html",
        "signatures": [
            {
                "full": "clearComputeNodeCache(database, [table], [partition])",
                "name": "clearComputeNodeCache",
                "parameters": [
                    {
                        "full": "database",
                        "name": "database"
                    },
                    {
                        "full": "[table]",
                        "name": "table",
                        "optional": true
                    },
                    {
                        "full": "[partition]",
                        "name": "partition",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [clearComputeNodeCache](https://docs.dolphindb.cn/zh/funcs/c/clearcomputenodecache.html)\n\n\n\n#### 语法\n\nclearComputeNodeCache(database, \\[table], \\[partition])\n\n#### 详情\n\n应用于计算组中的计算节点上，尝试清空该节点的内存缓存和磁盘缓存。\n\n#### 参数\n\n**database** 字符串，表示数据库名称。\n\n**table** 字符串，表示数据表名。可以包含以下通配符：\n\n* \"\\*\" 表示匹配所有（默认值）\n* \"?\" 表示单个字符\n* \"%\" 表示0，1或多个字符。\n\n**partition** 字符串标量或向量，表示分区的逻辑路径。若不指定，则表示所有分区。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n清除 database\\_compute 数据库的内存缓存和磁盘缓存。\n\n```\nclearComputeNodeCache(\"dfs://database_compute\")      \n```\n\n清除 database\\_compute 数据库中以 pt 开头的表的内存缓存和磁盘缓存。\n\n```\nclearComputeNodeCache(\"dfs://database_compute\",\"pt%\")           \n```\n"
    },
    "clearComputeNodeDiskCache": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/clearcomputenodediskcache.html",
        "signatures": [
            {
                "full": "clearComputeNodeDiskCache(database, [table], [partition])",
                "name": "clearComputeNodeDiskCache",
                "parameters": [
                    {
                        "full": "database",
                        "name": "database"
                    },
                    {
                        "full": "[table]",
                        "name": "table",
                        "optional": true
                    },
                    {
                        "full": "[partition]",
                        "name": "partition",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [clearComputeNodeDiskCache](https://docs.dolphindb.cn/zh/funcs/c/clearcomputenodediskcache.html)\n\n\n\n#### 语法\n\nclearComputeNodeDiskCache(database, \\[table], \\[partition])\n\n#### 详情\n\n应用于计算组中的计算节点上，尝试清空该节点的磁盘缓存。\n\n#### 参数\n\n**database** 字符串，表示数据库名称。\n\n**table** 字符串，表示数据表名。可以包含以下通配符：\n\n* \"\\*\" 表示匹配所有（默认值）\n* \"?\" 表示单个字符\n* \"%\" 表示0，1或多个字符。\n\n**partition** 字符串标量或向量，表示分区的逻辑路径。若不指定，则表示所有分区。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n清除 database\\_compute 数据库的磁盘缓存。\n\n```\nclearComputeNodeDiskCache(\"dfs://database_compute\") \n```\n\n清除 database\\_compute 数据库中以 pt 开头的表的磁盘缓存。\n\n```\nclearComputeNodeDiskCache(\"dfs://database_compute\",\"pt%\") \n```\n"
    },
    "clearDSCacheNow": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/clearDSCacheNow.html",
        "signatures": [
            {
                "full": "clearDSCacheNow(ds)",
                "name": "clearDSCacheNow",
                "parameters": [
                    {
                        "full": "ds",
                        "name": "ds"
                    }
                ]
            }
        ],
        "markdown": "### [clearDSCacheNow](https://docs.dolphindb.cn/zh/funcs/c/clearDSCacheNow.html)\n\n\n\n#### 语法\n\nclearDSCacheNow(ds)\n\n#### 详情\n\n函数 `clearDSCacheNow` 立即清除数据源和缓存。\n\n#### 参数\n\n**ds** 是数据源或数据源列表。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\nPTNDB_DIR = \"/home/db_testing\"\ndbName = database(PTNDB_DIR + \"/NYSETAQByName\")\nTrades = dbName.loadTable(`Trades)\n\nds=sqlDS(<select Time,Exchange,Symbol,Trade_Volume as Vol, Trade_Price as Price from Trades>)\nds.cacheDSNow()        // cache the data immediately\nds.clearDSCacheNow()  // clear the cache immediately\n```\n"
    },
    "clearDSCache!": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/clearDSCache_.html",
        "signatures": [
            {
                "full": "clearDSCache!(ds)",
                "name": "clearDSCache!",
                "parameters": [
                    {
                        "full": "ds",
                        "name": "ds"
                    }
                ]
            }
        ],
        "markdown": "### [clearDSCache!](https://docs.dolphindb.cn/zh/funcs/c/clearDSCache_.html)\n\n\n\n#### 语法\n\nclearDSCache!(ds)\n\n#### 详情\n\n`clearDSCache!` 函数指示系统在下次执行数据源之后清除缓存。\n\n#### 参数\n\n**ds** 是数据源或数据源列表。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\nPTNDB_DIR = \"/home/db_testing\"\ndbName = database(PTNDB_DIR + \"/NYSETAQByName\")\nTrades = dbName.loadTable(`Trades)\n\nds=sqlDS(<select Time,Exchange,Symbol,Trade_Volume as Vol, Trade_Price as Price from Trades>)\nds.cacheDS!()        // cache the data\nds.clearDSCache!()  // clear the cache\n```\n"
    },
    "clearTablePersistence": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/clearTablePersistence.html",
        "signatures": [
            {
                "full": "clearTablePersistence(table)",
                "name": "clearTablePersistence",
                "parameters": [
                    {
                        "full": "table",
                        "name": "table"
                    }
                ]
            }
        ],
        "markdown": "### [clearTablePersistence](https://docs.dolphindb.cn/zh/funcs/c/clearTablePersistence.html)\n\n\n\n#### 语法\n\nclearTablePersistence(table)\n\n#### 详情\n\n停止将流数据表持久化到磁盘，然后删除磁盘上表的内容，但仍然保留表的结构。\n\n#### 参数\n\n**table** 是一个表。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\ncolName=[\"time\",\"x\"]\ncolType=[\"timestamp\",\"int\"]\nt = streamTable(100:0, colName, colType);\nenableTableShareAndPersistence(table=t, tableName=`st, cacheSize=1200000)\ngo;\n```\n\n```\nfor(s in 0:200){\n    n=10000\n    time=2019.01.01T00:00:00.000+s*n+1..n\n    x=rand(10.0, n)\n    insert into st values(time, x)\n}\nclearTablePersistence(st);\n```\n\n相关函数：[enableTablePersistence](https://docs.dolphindb.cn/zh/funcs/e/enableTablePersistence.html), [disableTablePersistence](https://docs.dolphindb.cn/zh/funcs/d/disableTablePersistence.html)\n"
    },
    "clear!": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/clear_.html",
        "signatures": [
            {
                "full": "clear!(X)",
                "name": "clear!",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [clear!](https://docs.dolphindb.cn/zh/funcs/c/clear_.html)\n\n\n\n#### 语法\n\nclear!(X)\n\n#### 详情\n\n函数 `clear!` 用来清除 *X* 中的所有内容。对 *X* 执行该函数后，*X* 仍然存在，保持原有的数据类型，可以追加新的数据。\n\n#### 参数\n\n**X** 可以是向量、矩阵、集合、字典、内存表。\n\n#### 返回值\n\n返回一个与输入 *X* 相同数据类型和形式的对象。\n\n#### 例子\n\n```\nx=1 2 3;\nclear!(x);\n\n// output\n[]\ntypestr x;\n\n// output\nFAST INT VECTOR\nsize x;\n\n// output\n0\nx.append!(1..6);\n\n// output\n[1,2,3,4,5,6]\n\ny=set(8 9 4 6);\ny.clear!();\n\n// output\nset()\n\nx=1..3;\ny=4..6;\nz=dict(x,y);\nz;\n\n// output\n3->6\n1->4\n2->5\nz.clear!();\n\nt = table(1 2 3 as id, 1.0 2.0 3.0 as value)\nt.clear!()\n```\n"
    },
    "clip": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/clip.html",
        "signatures": [
            {
                "full": "clip(X,Y,Z)",
                "name": "clip",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "Z",
                        "name": "Z"
                    }
                ]
            }
        ],
        "markdown": "### [clip](https://docs.dolphindb.cn/zh/funcs/c/clip.html)\n\n\n\n#### 语法\n\nclip(X,Y,Z)\n\n#### 详情\n\n返回一个与 X 数据形式和数据类型完全相同的 X'。\n\nX' 的值满足以下规则（当 X 为字典时，下述\"X'的元素\"表示字典 X' 的 value）：\n\n* 当 Y 和 Z 为标量时，X' 的元素被限制在 \\[Y, Z] 区间内：\n\n  * 1.1 Y 或 Z 为 NULL 表示对区间下界或上界不做限制。\n\n  * 1.2 若 Y 大于 Z，则 X' 中所有元素设为 Z。\n\n  * 1.3 对于 X 中落在 \\[Y, Z] 范围内的元素，其在 X' 中保留原值；对于超出该范围的元素，X' 中相应位置的值将被替换为最近的边界值，即小于 Y 的元素被设为 Y，大于 Z 的元素被设为 Z。\n\n* 当 Y 和 Z 为向量、矩阵或表时，对 X 中每个元素 x，根据相应位置的 \\[y, z] 组成的范围进行限制：\n\n  * 2.1 超出该范围的 x 依然按照上述规则进行处理。\n\n  * 2.2 若 Y 或 Z 某个位置元素为 NULL，则 X' 对应位置元素也为 NULL。\n\n  * 2.3 若 Y 或 Z 某个位置元素满足 y >z，则 X' 对应位置元素设为 z。\n\n* 当 Y 或 Z 其中之一为标量，另一个为向量、矩阵或表时：\n\n  * 3.1 标量值代表区间下界或上界固定，向量、矩阵或表中的元素代表不同位置的限制区间的下界或上界。\n\n  * 3.2 标量值为 NULL 表示对下界或上界不做限制，向量、矩阵或表的某一元素为 NULL 代表将 X‘ 对应位置元素设置为空值。\n\n  * 3.3 某个位置元素满足 y >z，则 X' 对应位置元素设为 z。\n\n**Note:**\n\n与 [numpy.clip](https://numpy.org/doc/stable/reference/generated/numpy.clip.html) 函数的核心功能相同，区别如下：\n\n* DolphinDB 中，`clip` 函数的原地修改版本为 [clip!](https://docs.dolphindb.cn/zh/funcs/c/clip_.html)；而在 `numpy.clip` 函数中，原地修改通过参数 *out* 实现。\n\n* DolphinDB 中，`clip` 函数不支持 `numpy.clip` 函数中的 *out*、*min*、*max* 等参数。\n\n#### 参数\n\n**X** 是一个数值型或时间类型的标量、向量、矩阵、表或 value 为数值型或时间类型的字典。\n\n**Y** 是一个数值型或时间类型的标量、向量、矩阵或表。\n\n**Z** 是一个数值型或时间类型的标量、向量、矩阵或表。\n\n*X*, *Y*, *Z* 数据类型必须匹配：\n\n* 若 *X* 为整型，*Y*、*Z* 必须为整型。\n\n* 若 *X* 为浮点型或 DECIMAL，*Y*、*Z* 可以为整型、浮点型或 DECIMAL 类型。\n\n* 若 *X* 为时间类型，*Y*、*Z* 必须为同类型的时间类型。\n\nX, Y, Z 的数据形式须满足以下要求：\n\n* 当 *X* 是标量或字典时，*Y* 和 *Z* 必须为标量。\n\n* 当 *X* 是向量时，*Y* 和 *Z* 可以是标量或与 *X*维度相同的向量。\n\n* 当 *X* 是矩阵时，*Y* 和 *Z* 可以是标量或与 *X* 维度相同的矩阵。\n\n* 当 *X* 是表时，*Y* 和 *Z* 可以是标量或与 *X* 维度相同的表。\n\n#### 返回值\n\n返回一个与输入 *X* 相同数据类型和形式的对象。\n\n#### 例子\n\n##### Y 和 Z 是标量\n\nY = NULL ，Z = 5 ，根据规则1.1，表示不限制下界，上界为 5，此时仅将表中大于 5 的值置为 5。\n\n```\nX = table(1..10 as val1, 10..1 as val2)\nY = NULL\nZ = 5\nclip(X,Y,Z)\n```\n\n| val1 | val2 |\n| ---- | ---- |\n| 1    | 5    |\n| 2    | 5    |\n| 3    | 5    |\n| 4    | 5    |\n| 5    | 5    |\n| 5    | 5    |\n| 5    | 4    |\n| 5    | 3    |\n| 5    | 2    |\n| 5    | 1    |\n\nY 大于 Z （6>3），根据规则1.2， X' 中所有元素被置为 3。\n\n```\nX = 1..10\nY = 6\nZ = 3\nclip(X,Y,Z)\n// output:[3,3,3,3,3,3,3,3,3,3]\n```\n\nY 和 Z 组成区间 \\[3,5]，根据规则1.3，X’ 中 value 小于3的值（1和2）被置为3，大于5的值（6）被置为5，其他元素得到保留。\n\n```\nX = dict(`a`b`c`d`e`f,[1,2,3,4,5,6])\nY = 3\nZ = 5\nclip(X,Y,Z)\n/*\noutput:\na->3\nb->3\nc->3\nd->4\ne->5\nf->5\n*/\n```\n\n##### Y 和 Z 是向量、矩阵或表\n\nY 和 Z 为与 X 维度相同的向量，用区间 \\[y\\[i], z\\[i]] 对 X\\[i] 进行限制：\n\n* X\\[0] 在 \\[Y\\[0],Z\\[0]] 区间内（1属于\\[0,3]），根据规则2.1，保留其值\n\n* X\\[3] 小于 Y\\[3]（4<5），根据规则2.1，X'\\[3] 置为 5（Y\\[3]）\n\n* X\\[9] 大于 Z\\[9]（10>9），根据规则2.1，X'\\[9] 置为 9（Z\\[9]）\n\n* Y\\[7] 和 Z\\[6] 为 NULL，根据规则2.2 ，X'\\[6] 和 X'\\[7] 为 NULL\n\n* Y\\[8] 大于 Z\\[8]（7>5），根据规则2.3，X'\\[8] 置为 5（Z\\[8]）\n\n```\nX = [1,2,3,4,5,6,7,8,9,10]\nY = [0,1,2,5,6,6,6,NULL,7,7]\nZ = [3,4,5,6,7,8,NULL,5,5,9]\nclip(X,Y,Z)\n// output:[1,2,3,5,6,6,,,5,9]\n```\n\n##### Y 或 Z 其中之一为标量，另一个为向量、矩阵或表\n\n下例中 Y 为 4，Z 为与 X 维度相同的矩阵，对 X 中元素 x\\[i,j]，用区间 \\[4,Z\\[i,j]] 对其进行限制：\n\n* X\\[0,0] 小于 Y（1<4），根据规则3.1， X'\\[0,0] 置为 4\n\n* Z\\[0,2] 为 NULL，根据规则3.2，X'\\[0,2] 置为 NULL\n\n* Y 大于 Z\\[1,2]（4>3），根据规则3.3， X'\\[1,2] 置为 3（Z\\[1,2]）\n\n```\nX = 1..8$2:4\nY = 4\nZ = [5,6,5,6,NULL,3,5,6]$2:4\nclip(X,Y,Z)\n// output:\n#0 #1 #2 #3\n-- -- -- --\n4  4     5 \n4  4  3  6 \n```\n"
    },
    "clip!": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/clip_.html",
        "signatures": [
            {
                "full": "clip!(X, Y, Z)",
                "name": "clip!",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "Z",
                        "name": "Z"
                    }
                ]
            }
        ],
        "markdown": "### [clip!](https://docs.dolphindb.cn/zh/funcs/c/clip_.html)\n\n\n\n#### 语法\n\nclip!(X, Y, Z)\n\n#### 详情\n\n函数 `clip` 的原地修改版本，它会修改输入对象 X 的值，修改规则参考 [clip](https://docs.dolphindb.cn/zh/funcs/c/clip.html)。\n\n#### 返回值\n\n无。\n"
    },
    "close": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/close.html",
        "signatures": [
            {
                "full": "close(X)",
                "name": "close",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [close](https://docs.dolphindb.cn/zh/funcs/c/close.html)\n\n\n\n#### 语法\n\nclose(X)\n\n#### 详情\n\n关闭一个已打开的文件或远程连接。该函数必须要用户登录后才能执行。\n\n#### 参数\n\n**X** 是一个文件句柄或远程连接。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\nfout=file(\"test.txt\",\"w\");\nfout.writeLine(\"hello world!\");\n// output\n1\nfout.close();\nfin = file(\"test3.txt\");\nprint fin.readLine();\nhello world!\nfin.close();\n```\n"
    },
    "closeSessions": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/closeSessions.html",
        "signatures": [
            {
                "full": "closeSessions(sessionId)",
                "name": "closeSessions",
                "parameters": [
                    {
                        "full": "sessionId",
                        "name": "sessionId"
                    }
                ]
            }
        ],
        "markdown": "### [closeSessions](https://docs.dolphindb.cn/zh/funcs/c/closeSessions.html)\n\n\n\n#### 语法\n\ncloseSessions(sessionId)\n\n#### 详情\n\n关闭一个或多个 session。\n\n#### 参数\n\n**sessionId** 是一个 LONG 类型的标量或向量，表示一个或多个 session ID。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\ngetSessionMemoryStat();\n```\n\n| userId                   | sessionId     | memSize | remoteIP    | remotePort | createTime              | lastActiveTime          |\n| ------------------------ | ------------- | ------- | ----------- | ---------- | ----------------------- | ----------------------- |\n| \\_DimensionalTable\\_     | 0             | 0.0.0.0 |             |            |                         |                         |\n| \\_SharedTable\\_          | 0             | 0.0.0.0 |             |            |                         |                         |\n| \\_OLAPTablet\\_           | 0             | 0.0.0.0 |             |            |                         |                         |\n| \\_OLAPCacheEngine\\_      | 0             | 0.0.0.0 |             |            |                         |                         |\n| \\_OLAPCachedSymbolBase\\_ | 0             | 0.0.0.0 |             |            |                         |                         |\n| \\_DFSMetadata\\_          | 13,571        | 0.0.0.0 |             |            |                         |                         |\n| \\_TSDBCacheEngine\\_      | 0             | 0.0.0.0 |             |            |                         |                         |\n| \\_TSDBLevelFileIndex\\_   | 0             | 0.0.0.0 |             |            |                         |                         |\n| \\_TSDBCachedSymbolBase\\_ | 0             | 0.0.0.0 |             |            |                         |                         |\n| \\_StreamingPubQueue\\_    | 0             | 0.0.0.0 |             |            |                         |                         |\n| \\_StreamingSubQueue\\_    | 0             | 0.0.0.0 |             |            |                         |                         |\n| guest                    | 1,769,725,800 | 16      | 36.27.51.13 | 63,133     | 1970.01.01T00:00:00.000 | 2023.08.31T22:35:27.385 |\n| admin                    | 2,882,591,513 | 6,449   | 36.27.51.13 | 60,812     | 1970.01.01T00:00:00.000 | 2023.08.31T22:18:27.562 |\n\n```\ncloseSessions(getSessionMemoryStat().sessionId[11]);\n```\n"
    },
    "cmFutAmericanOptionPricer": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cmfutamericanoptionpricer.html",
        "signatures": [
            {
                "full": "cmFutAmericanOptionPricer(instrument, pricingDate, futPrice, discountCurve, volSurf, [setting], [model], [method])",
                "name": "cmFutAmericanOptionPricer",
                "parameters": [
                    {
                        "full": "instrument",
                        "name": "instrument"
                    },
                    {
                        "full": "pricingDate",
                        "name": "pricingDate"
                    },
                    {
                        "full": "futPrice",
                        "name": "futPrice"
                    },
                    {
                        "full": "discountCurve",
                        "name": "discountCurve"
                    },
                    {
                        "full": "volSurf",
                        "name": "volSurf"
                    },
                    {
                        "full": "[setting]",
                        "name": "setting",
                        "optional": true
                    },
                    {
                        "full": "[model]",
                        "name": "model",
                        "optional": true
                    },
                    {
                        "full": "[method]",
                        "name": "method",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [cmFutAmericanOptionPricer](https://docs.dolphindb.cn/zh/funcs/c/cmfutamericanoptionpricer.html)\n\n首发版本：3.00.5\n\n\n\n#### 语法\n\ncmFutAmericanOptionPricer(instrument, pricingDate, futPrice, discountCurve, volSurf, \\[setting], \\[model], \\[method])\n\n#### 详情\n\n对商品期货美式期权进行定价。\n\n#### 参数\n\n**instrument** INSTRUMENT 类型标量或向量 ，表示待定价的商品期货美式期权。商品期货美式期权所需的关键字段详见产品字段要求。\n\n**pricingDate** DATE 类型标量或向量，表示定价日期。\n\n**futPrice** DOUBLE 类型标量或向量，表示标的期货的现价。\n\n**domesticCurve** MKTDATA 类型（IrYieldCurve）的标量或向量，表示折现曲线。\n\n**volSurf** MKTDATA 类型（VolatilitySurface）的标量或向量，表示波动率曲面。\n\n**setting** 可选参数，一个字典，用于设置定价输出。包含以下 key：\n\n* calcDelta：value 是布尔值，指定是否计算 delta\n\n* calcGamma：value 是布尔值，指定是否计算 gamma\n\n* calcVega：value 是布尔值，指定是否计算 vega\n\n* calcTheta：value 是布尔值，指定是否计算 theta\n\n* calcRho：value 是布尔值，指定是否计算 rho\n\n**model** 可选参数，STRING 类型标量，表示使用的模型。可选值为：\n\n* “Black76”：Black76 公式\n\n* “BAW”（默认值）：Barone-Adesi-Whaley公式\n\n* “AmericanBinomialTree”：美式二叉树定价模型\n\n**method** 可选参数，STRING 类型标量，表示使用的方法。可选值为：\n\n* “Analytic”（默认值）：解析法\n\n* “Tree”：树方法，支持 *model* 为 AmericanBinomialTree\n\n#### 返回值\n\n* 当未指定 *setting* 时：返回 DOUBLE 类型标量，表示期权的净现值（NPV）。\n\n* 当指定 *setting* 时：返回一个字典，包含 NPV 及按 *setting* 指定的 Greeks 结果。\n\n#### 例子\n\n```\n// ================================================================\n// AUTO-GENERATED DolphinDB Script\n// Function   : cmFutAmericanOptionPricer  商品期货美式期权定价示例\n// Underlying : 上海期货交易所铜期货期权（cu）\n// PricingDate: 2026-02-13\n//\n// 数据来源:\n//   期货结算价  : akshare get_futures_daily(market='SHFE')\n//   期权结算价  : akshare option_hist_shfe('铜期权', '20260213')\n//   利率曲线    : 中国货币网 外币隐含利率曲线（CNY, USD.CNY/Shibor/掉期点）\n//                https://www.chinamoney.com.cn/chinese/bkcurvuiruuh/\n//                API: POST /ags/ms/cm-u-bk-fx/IuirCurvHis  2026-02-13\n//\n// 定价标的    : CU2605 铜期货美式看涨 Call\n//               strike=102000  opt_expiry=2026-04-24\n//               fut_price=101230\n// ================================================================\n\npricingDate   = 2026.02.13\nreferenceDate = pricingDate\n\n// ------------------------------------------------------------------\n// 1. 折现曲线 (CNY_FR_007) ── 中国货币网外币隐含利率曲线\n//    数据源: https://www.chinamoney.com.cn/chinese/bkcurvuiruuh/\n//    USD.CNY / Shibor / 即期询价报价均值 / 掉期点  →  rmbRateStr 字段\n// ------------------------------------------------------------------\ndiscountCurveDict = {\n    \"mktDataType\"       : \"Curve\",\n    \"curveType\"         : \"IrYieldCurve\",\n    \"referenceDate\"     : referenceDate,\n    \"currency\"          : \"CNY\",\n    \"dayCountConvention\": \"Actual365\",\n    \"compounding\"       : \"Continuous\",\n    \"interpMethod\"      : \"Linear\",\n    \"extrapMethod\"      : \"Flat\",\n    \"frequency\"         : \"Annual\",\n    \"dates\"             : [referenceDate + 1, referenceDate + 7, referenceDate + 14, referenceDate + 21, referenceDate + 30, referenceDate + 61, referenceDate + 91, referenceDate + 182, referenceDate + 273, referenceDate + 365, referenceDate + 547, referenceDate + 730, referenceDate + 1095],\n    \"values\"            : [0.016134, 0.016107, 0.016102, 0.016102, 0.016102, 0.016103, 0.016029, 0.015832, 0.015889, 0.015898, 0.015561, 0.015583, 0.015892],\n    \"name\"              : \"CNY_FR_007\"\n}\ndiscountCurve = parseMktData(discountCurveDict)\n\n// ------------------------------------------------------------------\n// 2. 期货价格曲线 (AssetPriceCurve)\n//    各到期月份铜期货结算价\n// ------------------------------------------------------------------\nfutPriceCurveDict = {\n    \"mktDataType\" : \"Curve\",\n    \"curveType\"   : \"AssetPriceCurve\",\n    \"referenceDate\": referenceDate,\n    \"currency\"    : \"CNY\",\n    \"asset\"       : \"CU\",\n    \"interpMethod\": \"Linear\",\n    \"extrapMethod\": \"Flat\",\n    \"dates\"       : [2026.04.15, 2026.05.15, 2026.06.15, 2026.07.15, 2026.08.17, 2026.09.15],\n    \"values\"      : [100980.0, 101230.0, 101240.0, 101100.0, 101230.0, 101250.0]\n}\nfutPriceCurve = parseMktData(futPriceCurveDict)\n\n// ------------------------------------------------------------------\n// 3. 期权市场数据 ── 构建波动率曲面\n//    到期日数: 6\n//    使用虚值期权: K < F → Put, K >= F → Call\n// ------------------------------------------------------------------\noptionExpiries = [2026.03.25, 2026.04.24, 2026.05.25, 2026.06.24, 2026.07.27, 2026.08.25]\nfutMaturities  = [2026.04.15, 2026.05.15, 2026.06.15, 2026.07.15, 2026.08.17, 2026.09.15]\n\nstrikes = [\n    [82000, 84000, 86000, 88000, 90000, 92000, 94000, 96000, 98000, 100000, 102000, 104000, 106000, 108000, 110000, 112000, 114000, 116000, 118000, 120000],\n    [82000, 84000, 86000, 88000, 90000, 92000, 94000, 96000, 98000, 100000, 102000, 104000, 106000, 108000, 110000, 112000, 114000, 116000, 118000, 120000],\n    [82000, 84000, 86000, 88000, 90000, 92000, 94000, 96000, 98000, 100000, 102000, 104000, 106000, 108000, 110000, 112000, 114000, 116000, 118000, 120000],\n    [82000, 84000, 86000, 88000, 90000, 92000, 94000, 96000, 98000, 100000, 102000, 104000, 106000, 108000, 110000, 112000, 114000, 116000, 118000, 120000],\n    [82000, 84000, 86000, 88000, 90000, 92000, 94000, 96000, 98000, 100000, 102000, 104000, 106000, 108000, 110000, 112000, 114000, 116000, 118000, 120000],\n    [82000, 84000, 86000, 88000, 90000, 92000, 94000, 96000, 98000, 100000, 102000, 104000, 106000, 108000, 110000, 112000, 114000, 116000, 118000, 120000]\n]\n\noptionPrices = [\n    [118, 208, 344, 544, 826, 1204, 1702, 2322, 3078, 3986, 4012, 3192, 2506, 1946, 1490, 1124, 836, 612, 442, 316],\n    [396, 580, 826, 1144, 1552, 2052, 2652, 3360, 4178, 5108, 5382, 4536, 3792, 3146, 2590, 2114, 1718, 1388, 1114, 886],\n    [828, 1112, 1464, 1888, 2392, 2980, 3660, 4440, 5312, 6276, 6570, 5712, 4950, 4276, 3672, 3132, 2664, 2264, 1908, 1596],\n    [1218, 1566, 1980, 2474, 3048, 3702, 4432, 5240, 6142, 7138, 7308, 6450, 5696, 5006, 4370, 3820, 3324, 2870, 2490, 2146],\n    [2054, 2508, 3014, 3614, 4272, 4986, 5792, 6666, 7586, 8616, 8924, 8076, 7304, 6566, 5926, 5306, 4768, 4258, 3808, 3390],\n    [1938, 2374, 2876, 3460, 4104, 4804, 5608, 6472, 7386, 8410, 8734, 7886, 7116, 6378, 5742, 5132, 4592, 4094, 3644, 3240]\n]\n\npayoffTypes = [\n    [\"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\"],\n    [\"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\"],\n    [\"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\"],\n    [\"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\"],\n    [\"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\"],\n    [\"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Put\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\", \"Call\"]\n]\n\n// ------------------------------------------------------------------\n// 4. 构建波动率曲面 ── BAW 公式 + SVI 模型\n//    使用 BAW 公式计算美式期权隐含波动率\n// ------------------------------------------------------------------\nvolSurf = cmFutVolatilitySurfaceBuilder(\n    referenceDate, futMaturities, optionExpiries,\n    strikes, optionPrices, payoffTypes,\n    discountCurve, futPriceCurve,\n    formula=\"BAW\", model=\"SVI\",\n    surfaceName=\"cu_vol_surface_20260213\"\n)\nprint(volSurf)\n\n// ------------------------------------------------------------------\n// 5. 定义定价合约 ── 铜期货美式看涨期权\n//    标的: CU2605  行权价: 102000  到期: 2026-04-24\n// ------------------------------------------------------------------\ncmFutAmericanOption = {\n    \"productType\"       : \"Option\",\n    \"optionType\"        : \"AmericanOption\",\n    \"assetType\"         : \"CmFutAmericanOption\",\n    \"instrumentId\"      : \"CU2605C102000\",\n    \"notionalAmount\"    : 5.0,\n    \"notionalCurrency\"  : \"CNY\",\n    \"strike\"            : 102000.0,\n    \"maturity\"          : 2026.04.24,\n    \"payoffType\"        : \"Call\",\n    \"dayCountConvention\": \"Actual365\",\n    \"underlying\"        : \"CU2605\",\n    \"domesticCurve\"     : \"CNY_FR_007\"\n}\ninstrument = parseInstrument(cmFutAmericanOption)\n\n// ------------------------------------------------------------------\n// 6. 定价 ── 单合约 NPV (BAW 模型)\n// ------------------------------------------------------------------\nspot = 101230.0\nnpv = cmFutAmericanOptionPricer(instrument, pricingDate, spot, discountCurve, volSurf, model=\"BAW\")\nprint(\"NPV = \" + string(npv))\n\n// ------------------------------------------------------------------\n// 7. 定价 ── 含希腊字母 (Greeks)\n// ------------------------------------------------------------------\nsetting = {\n    \"calcDelta\" : true,\n    \"calcGamma\" : true,\n    \"calcVega\"  : true,\n    \"calcTheta\" : true,\n    \"calcRho\"   : true\n}\nresult = cmFutAmericanOptionPricer(instrument, pricingDate, spot, discountCurve, volSurf, setting, model=\"BAW\")\nprint(result)\n\n// ------------------------------------------------------------------\n// 8. 批量定价 ── 对 CU2605 到期的多个行权价 Call 合约定价\n// ------------------------------------------------------------------\nallStrikes = [82000, 84000, 86000, 88000, 90000, 92000, 94000, 96000, 98000, 100000, 102000, 104000, 106000, 108000, 110000, 112000, 114000, 116000, 118000, 120000]\nresults = array(DOUBLE, 0)\nfor (k in allStrikes) {\n    iDict = {\n        \"productType\"       : \"Option\",\n        \"optionType\"        : \"AmericanOption\",\n        \"assetType\"         : \"CmFutAmericanOption\",\n        \"instrumentId\"      : \"CU2605C\" + string(int(k)),\n        \"notionalAmount\"    : 5.0,\n        \"notionalCurrency\"  : \"CNY\",\n        \"strike\"            : k,\n        \"maturity\"          : 2026.04.24,\n        \"payoffType\"        : \"Call\",\n        \"dayCountConvention\": \"Actual365\",\n        \"underlying\"        : \"CU2605\",\n        \"domesticCurve\"     : \"CNY_FR_007\"\n    }\n    iOpt = parseInstrument(iDict)\n    results.append!(cmFutAmericanOptionPricer(iOpt, pricingDate, spot, discountCurve, volSurf, model=\"BAW\"))\n}\nt = table(allStrikes as strike, results as npv)\nprint(t)\n\n```\n\n#### 产品字段说明\n\n| 字段名                | 类型      | 描述                                                                          | 是否必填 |\n| ------------------ | ------- | --------------------------------------------------------------------------- | ---- |\n| productType        | STRING  | 固定填 \"Option\"                                                                | 是    |\n| optionType         | STRING  | 固定填 \"AmericanOption\"                                                        | 是    |\n| assetType          | STRING  | 固定填 \"CmFutAmericanOption\"                                                   | 是    |\n| notionalAmount     | DOUBLE  | 名义本金额                                                                       | 是    |\n| notionalCurrency   | STRING  | 名义本金货币                                                                      | 是    |\n| instrumentId       | STRING  | 合约代码，标准格式为：标的期货合约代码+合约到期月份+期权类型代码+行权价格，如白糖期权为 SR2509P6300 = SR+2509+P+6300  | 否    |\n| direction          | SRTRING | 买卖方向，可选值为 Buy，Sell。默认值为 Buy。                                                | 否    |\n| maturity           | DATE    | 到期日                                                                         | 是    |\n| strike             | DOUBLE  | 执行利率                                                                        | 是    |\n| payoffType         | STRING  | 收益类型，可选 Call 和 Put                                                          | 是    |\n| underlying         | STRING  | 标的期货合约代码，如 SR2509                                                           | 是    |\n| dayCountConvention | STRING  | 日期计数惯例, 可选 \"ActualActualISDA\", \"ActualActualISMA\", \"Actual365\", \"Actual360\" | 是    |\n| discountCurve      | STRING  | 定价时参考的贴现曲线名称，人民币存款默认为 \"CNY\\_FR\\_007\"                                        | 否    |\n\n**相关函数：** [parseInstrument](https://docs.dolphindb.cn/zh/funcs/p/parseInstrument.html)、[parseMktData](https://docs.dolphindb.cn/zh/funcs/p/parseMktData.html)、[cmFutVolatilitySurfaceBuilder](https://docs.dolphindb.cn/zh/funcs/c/cmFutVolatilitySurfaceBuilder.html)\n"
    },
    "cmFutEuropeanOptionPricer": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cmfuteuropeanoptionpricer.html",
        "signatures": [
            {
                "full": "cmFutEuropeanOptionPricer(instrument, pricingDate, futPrice, discountCurve, futPriceCurve, volSurf, [setting], [model], [method])",
                "name": "cmFutEuropeanOptionPricer",
                "parameters": [
                    {
                        "full": "instrument",
                        "name": "instrument"
                    },
                    {
                        "full": "pricingDate",
                        "name": "pricingDate"
                    },
                    {
                        "full": "futPrice",
                        "name": "futPrice"
                    },
                    {
                        "full": "discountCurve",
                        "name": "discountCurve"
                    },
                    {
                        "full": "futPriceCurve",
                        "name": "futPriceCurve"
                    },
                    {
                        "full": "volSurf",
                        "name": "volSurf"
                    },
                    {
                        "full": "[setting]",
                        "name": "setting",
                        "optional": true
                    },
                    {
                        "full": "[model]",
                        "name": "model",
                        "optional": true
                    },
                    {
                        "full": "[method]",
                        "name": "method",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [cmFutEuropeanOptionPricer](https://docs.dolphindb.cn/zh/funcs/c/cmfuteuropeanoptionpricer.html)\n\n首发版本：3.00.5\n\n\n\n#### 语法\n\ncmFutEuropeanOptionPricer(instrument, pricingDate, futPrice, discountCurve, futPriceCurve, volSurf, \\[setting], \\[model], \\[method])\n\n#### 详情\n\n对商品期货欧式期权进行定价。\n\n#### 参数\n\n**instrument** INSTRUMENT 类型标量或向量，表示需要定价的商品期货欧式期权。\n\n**pricingDate** DATE 类型标量或向量，表示定价日期。\n\n**futPrice** DOUBLE 类型标量或向量, 表示标的期货的现价。\n\n**discountCurve** MKTDATA 标量或向量，表示[折现曲线（IrYieldCurve）](https://docs.dolphindb.cn/zh/funcs/p/parseMktData.md#)。\n\n**futPriceCurve** MKTDATA 标量或向量，表示[期货价格曲线（AssetPriceCurve）](https://docs.dolphindb.cn/zh/funcs/p/parseMktData.md#)。\n\n**volSurf** MKTDATA 标量或向量，表示波动率曲面（VolatilitySurface），该曲面由 `cmFutVolatilitySurfaceBuilder` 构建。\n\n**setting** 可选参数，字典（Dictionary\\<STRING, BOOL>），用于指定是否计算希腊字母（Greeks）所代表的期权价格敏感性指标。可选值：\n\n| 键         | 值             | 描述                                  |\n| --------- | ------------- | ----------------------------------- |\n| calcDelta | 布尔值，默认为 false | 是否计算 Delta，即期权价格相对于标的资产价格的敏感性。      |\n| calcGamma | 布尔值，默认为 false | 是否计算 Gamma，即期权 Delta 相对于标的资产价格的敏感性。 |\n| calcVega  | 布尔值，默认为 false | 是否计算 Vega，即期权价格相对于标的资产波动率的敏感性。      |\n| calcTheta | 布尔值，默认为 false | 是否计算 Theta，即期权价格相对于时间变化的敏感性。        |\n| calcRho   | 布尔值，默认为 false | 是否计算 Rho，即期权价格相对于无风险利率的敏感性。         |\n\n**model** 可选参数，STRING 类型标量。默认且唯一支持的值为“Black76”，表示采用 Black76 模型进行定价。\n\n**method** 可选参数，STRING 类型标量。默认且唯一支持的值为“ Analytic”，表示采用解析法。\n\n#### 返回值\n\n* 若不指定 *setting*参数，返回 DOUBLE 类型标量，表示期权的净现值，即期权的理论价格。\n* 若指定 *setting*参数，返回字典（Dictionary\\<STRING, DOUBLE>），包含期权的净现值以及希腊字母（Greeks）所代表的期权价格敏感性指标。有关敏感性指标的说明请参考 *settings* 参数说明。\n\n#### 例子\n\n```\npricingDate = 2019.07.08\nspot = 2800.0\nstrike = spot * 1.2\nnominal = 1.0\n\n// Discount curve (CNY FR007) — zero rates\ndiscountCurveInfo = {\n    \"mktDataType\": \"Curve\",\n    \"curveType\": \"IrYieldCurve\",\n    \"referenceDate\": pricingDate,\n    \"currency\": \"CNY\",\n    \"dayCountConvention\": \"Actual365\",\n    \"compounding\": \"Continuous\",\n    \"interpMethod\": \"Linear\",\n    \"extrapMethod\": \"Flat\",\n    \"frequency\": \"Annual\",\n    \"dates\": [pricingDate+2, pricingDate+8, pricingDate+93, pricingDate+185, pricingDate+276, pricingDate+367,\n              pricingDate+732, pricingDate+1099, pricingDate+1463, pricingDate+1828, pricingDate+2558, pricingDate+3654],\n    \"values\": [0.0145993931630537, 0.0229075517972275, 0.0253020667393029, 0.0257564866303201,\n               0.0259751440992468, 0.0260355181479988, 0.0265336263144786, 0.0272721454114050,\n               0.0282024453631075, 0.0290231222075799, 0.0304665029488732, 0.0319855013976250]\n}\ndiscountCurve = parseMktData(discountCurveInfo)\n\n// Futures price curve (Soymeal)\nfutPriceCurveInfo = {\n    \"mktDataType\": \"Curve\",\n    \"curveType\": \"AssetPriceCurve\",\n    \"referenceDate\": pricingDate,\n    \"currency\": \"CNY\",\n    \"asset\": \"SOY_MEAL\",\n    \"interpMethod\": \"Linear\",\n    \"extrapMethod\": \"Flat\",\n    \"dates\": [2019.09.16, 2019.11.14, 2019.12.13, 2020.01.15, 2020.03.13],\n    \"values\": [2784, 2821, 2772, 2847, 2775]\n}\nfutPriceCurve = parseMktData(futPriceCurveInfo)\n\n// Option expiries, futures maturities, strikes, market prices, payoff types\noptionExpiries = [2019.08.07, 2019.10.11, 2019.11.07, 2019.12.06, 2020.02.07]\nfutMaturities = [2019.09.16, 2019.11.14, 2019.12.13, 2020.01.15, 2020.03.13]\nstrikes = [\n    [2600,2650,2700,2750,2800,2850,2900,2950,3000,3050],\n    [2600,2650,2700,2750,2800,2850,2900,2950,3000,3050],\n    [2650,2700,2750,2800,2850,2900,2950,3000],\n    [2650,2700,2750,2800,2850,2900,2950,3000],\n    [2600,2650,2700,2750,2800,2850,2900]\n]\noptionPrices = [\n    [9,17,30,48.5,57,37.5,23,13.5,7.5,4],\n    [29,41.5,56.5,75.5,98,95.5,75,58.5,44.5,33.5],\n    [50,68.5,90.5,89,69,52.5,39,29],\n    [56,72,91,113,134.5,112.5,93,76.5],\n    [58.5,75.5,95,118,119.5,98.5,80.5]\n]\npayoffTypes = [\n    [\"Put\",\"Put\",\"Put\",\"Put\",\"Call\",\"Call\",\"Call\",\"Call\",\"Call\",\"Call\"],\n    [\"Put\",\"Put\",\"Put\",\"Put\",\"Put\",\"Call\",\"Call\",\"Call\",\"Call\",\"Call\"],\n    [\"Put\",\"Put\",\"Put\",\"Call\",\"Call\",\"Call\",\"Call\",\"Call\"],\n    [\"Put\",\"Put\",\"Put\",\"Put\",\"Call\",\"Call\",\"Call\",\"Call\"],\n    [\"Put\",\"Put\",\"Put\",\"Put\",\"Call\",\"Call\",\"Call\"]\n]\n\n// Build vol surface from quotes\nvolSurf = cmFutVolatilitySurfaceBuilder(pricingDate, futMaturities, optionExpiries, strikes, optionPrices, payoffTypes, discountCurve, futPriceCurve)\nprint(volSurf)\n// Instrument\ncmFutEuropeanOption = {\n    \"productType\": \"Option\",\n    \"optionType\": \"EuropeanOption\",\n    \"assetType\": \"CmFutEuropeanOption\",\n    \"instrumentId\": \"SOYMEAL_CALL\",\n    \"notionalAmount\": nominal,\n    \"notionalCurrency\": \"CNY\",\n    \"strike\": strike,\n    \"maturity\": pricingDate + 180,\n    \"payoffType\": \"Call\",\n    \"dayCountConvention\": \"Actual365\",\n    \"underlying\": \"SOY_MEAL\",\n    \"domesticCurve\": \"CNY_FR_007\"\n}\ninstrument = parseInstrument(cmFutEuropeanOption)\n\n// Price\nresult = cmFutEuropeanOptionPricer(instrument, pricingDate, spot, discountCurve, volSurf)\n```\n\n**相关函数：**[parseMktData](https://docs.dolphindb.cn/zh/funcs/p/parseMktData.html)、[parseInstrument](https://docs.dolphindb.cn/zh/funcs/p/parseInstrument.html)、[cmFutVolatilitySurfaceBuilder](https://docs.dolphindb.cn/zh/funcs/c/cmFutVolatilitySurfaceBuilder.html)\n"
    },
    "cmFutVolatilitySurfaceBuilder": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cmFutVolatilitySurfaceBuilder.html",
        "signatures": [
            {
                "full": "cmFutVolatilitySurfaceBuilder(referenceDate, futMaturities, optionExpiries, strikes, optionPrices, payoffTypes, discountCurve, futPriceCurve, [formula=\"Black76\"], [model=\"SVI\"], [surfaceName])",
                "name": "cmFutVolatilitySurfaceBuilder",
                "parameters": [
                    {
                        "full": "referenceDate",
                        "name": "referenceDate"
                    },
                    {
                        "full": "futMaturities",
                        "name": "futMaturities"
                    },
                    {
                        "full": "optionExpiries",
                        "name": "optionExpiries"
                    },
                    {
                        "full": "strikes",
                        "name": "strikes"
                    },
                    {
                        "full": "optionPrices",
                        "name": "optionPrices"
                    },
                    {
                        "full": "payoffTypes",
                        "name": "payoffTypes"
                    },
                    {
                        "full": "discountCurve",
                        "name": "discountCurve"
                    },
                    {
                        "full": "futPriceCurve",
                        "name": "futPriceCurve"
                    },
                    {
                        "full": "[formula=\"Black76\"]",
                        "name": "formula",
                        "optional": true,
                        "default": "\"Black76\""
                    },
                    {
                        "full": "[model=\"SVI\"]",
                        "name": "model",
                        "optional": true,
                        "default": "\"SVI\""
                    },
                    {
                        "full": "[surfaceName]",
                        "name": "surfaceName",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [cmFutVolatilitySurfaceBuilder](https://docs.dolphindb.cn/zh/funcs/c/cmFutVolatilitySurfaceBuilder.html)\n\n首发版本：3.00.5\n\n\n\n#### 语法\n\ncmFutVolatilitySurfaceBuilder(referenceDate, futMaturities, optionExpiries, strikes, optionPrices, payoffTypes, discountCurve, futPriceCurve, \\[formula=\"Black76\"], \\[model=\"SVI\"], \\[surfaceName])\n\n#### 详情\n\n构建商品期货期权波动率曲面。\n\n#### 参数\n\n**注**：所有输入向量必须等长。\n\n**referenceDate**DATE 类型标量，表示参考日期，即曲线的生成日期。\n\n**futMaturities** DATE 类型向量，表示标的期货合约的到期日。\n\n**optionExpiries** DATE 类型向量，表示期权合约的到期日。\n\n**strikes** 元组，其中每个元素是一个 DOUBLE 类型向量，表示期权合约的执行价。\n\n**optionPrices** 元组，其中每个元素是一个 DOUBLE 类型向量，表示期权合约价格。\n\n**payoffTypes** 元组，其中每个元素是一个 STRING 类型向量， 表示期权类型，可选 “Call”（看涨）或 “Put”（看跌）。\n\n**注**：*strikes*、*optionPrices*、*payoffTypes*每个对应位置的向量元素长度相同。\n\n**discountCurve** IrYieldCurve 对象，表示折现曲线。\n\n**futPriceCurve** AssetPriceCurve 对象，表示期货价格曲线。\n\n**formula** 可选参数，STRING 类型标量，表示计算隐含波动率的公式，可选值为：\n\n* “Black76”：默认值，Black76 公式，一般用于欧式期权\n\n* “BAW”：Barone-Adesi-Whaley 公式，一般用于美式期权\n\n**model** 可选参数，STRING 类型标量，指定构建波动率曲面所用模型。支持以下选项：\n\n* “SVI”：默认值，Stochastic Volatility Inspired 模型\n\n* “SABR”：Stochastic Alpha Beta Rho 模型\n\n* “Linear”：线性模型\n\n* “CubicSpline”：三次样条模型\n\n**surfaceName** 可选参数，STRING 类型标量，表示曲面名称。\n\n#### 返回值\n\n一个 MKTDATA 类型 VolatilitySurface 对象。\n\n#### 例子\n\n例1. 下例展示如何使用棉花期货期权市场数据构建波动率曲面，并通过三维图表可视化波动率随到期时间和行权价的变化趋势：\n\n```\n// CF 棉花期货期权波动率曲面构建示例\n\n// 曲线构建的参考日期\nreferenceDate = 2026.02.11\n// 期权到期日\noptionExpiries = [2026.04.13,2026.06.11,2026.08.12,2026.12.11]\n// 标的期货合约到期日（与期权到期日一一对应）\nfutMaturities  = [2026.05.22,2026.07.17,2026.09.17,2027.01.19]\n// strikes: list of strike vectors (每个期权到期日对应一组 strikes)\nstrikes = [\n    [11600.0,11800.0,12000.0,12200.0,12400.0,12600.0,12800.0,13000.0,13200.0,13400.0,13600.0,13800.0,14000.0,14200.0,14400.0,14600.0,14800.0,15000.0,15200.0,15400.0,15600.0,15800.0,16000.0,16200.0,16400.0],\n    [13200.0,13400.0,13600.0,13800.0,14000.0,14200.0,14400.0,14600.0,14800.0,15000.0,15200.0,15400.0,15600.0,15800.0,16000.0,16200.0,16400.0],\n    [12200.0,12400.0,12600.0,12800.0,13000.0,13200.0,13400.0,13600.0,13800.0,14000.0,14200.0,14400.0,14600.0,14800.0,15000.0,15200.0,15400.0,15600.0,15800.0,16000.0,16200.0,16400.0,16600.0],\n    [13600.0,13800.0,14000.0,14200.0,14400.0,14600.0,14800.0,15000.0,15200.0,15400.0,15600.0,15800.0,16000.0,16200.0,16400.0,16600.0]\n]\n\n// optionPrices: 每个到期日对应的 option price 向量\noptionPrices = [\n    [2.0,2.0,3.0,4.0,6.0,8.0,10.0,14.0,20.0,28.0,40.0,57.0,84.0,125.0,187.0,276.0,299.0,240.0,200.0,171.0,149.0,133.0,118.0,107.0,98.0],\n    [35.0,49.0,69.0,99.0,145.0,212.0,303.0,416.0,422.0,367.0,321.0,285.0,251.0,226.0,200.0,182.0,164.0],\n    [23.0,28.0,33.0,41.0,51.0,64.0,82.0,106.0,140.0,189.0,255.0,340.0,444.0,563.0,503.0,451.0,408.0,372.0,342.0,313.0,291.0,269.0,249.0],\n    [147.0,185.0,234.0,290.0,362.0,446.0,540.0,653.0,772.0,713.0,658.0,617.0,580.0,546.0,523.0,500.0]\n]\n\n// payoffTypes: 期权类型，用字符串 \"Put\"/\"Call\" 表示\npayoffTypes = [\n    [\"Put\",\"Put\",\"Put\",\"Put\",\"Put\",\"Put\",\"Put\",\"Put\",\"Put\",\"Put\",\"Put\",\"Put\",\"Put\",\"Put\",\"Put\",\"Put\",\"Call\",\"Call\",\"Call\",\"Call\",\"Call\",\"Call\",\"Call\",\"Call\",\"Call\"],\n    [\"Put\",\"Put\",\"Put\",\"Put\",\"Put\",\"Put\",\"Put\",\"Put\",\"Call\",\"Call\",\"Call\",\"Call\",\"Call\",\"Call\",\"Call\",\"Call\",\"Call\"],\n    [\"Put\",\"Put\",\"Put\",\"Put\",\"Put\",\"Put\",\"Put\",\"Put\",\"Put\",\"Put\",\"Put\",\"Put\",\"Put\",\"Put\",\"Call\",\"Call\",\"Call\",\"Call\",\"Call\",\"Call\",\"Call\",\"Call\",\"Call\"],\n    [\"Put\",\"Put\",\"Put\",\"Put\",\"Put\",\"Put\",\"Put\",\"Put\",\"Put\",\"Call\",\"Call\",\"Call\",\"Call\",\"Call\",\"Call\",\"Call\"]\n]\n\n// 构建折现曲线\ndiscountCurve = parseMktData({\n    \"mktDataType\": \"Curve\", \"curveType\": \"IrYieldCurve\", \"referenceDate\": referenceDate,\n    \"currency\": \"CNY\", \"dayCountConvention\": \"Actual365\", \"compounding\": \"Continuous\",\n    \"interpMethod\": \"Linear\", \"extrapMethod\": \"Flat\",\n    \"dates\": [referenceDate+1, referenceDate+365], \"values\": [0.02, 0.02], \"name\": \"CONST_IR\"\n})\n\n// 商品远期曲线\nfutPriceCurve = parseMktData({\n    \"mktDataType\": \"Curve\", \"curveType\": \"AssetPriceCurve\", \"referenceDate\": referenceDate,\n    \"dates\": [2026.05.22,2026.07.17,2026.09.17,2027.01.19], \"values\": [14705.0,14675.0,14800.0,15200.0]\n})\n\n// 构建波动率曲面\nsurf = cmFutVolatilitySurfaceBuilder(referenceDate, futMaturities, optionExpiries, strikes, optionPrices, payoffTypes, discountCurve, futPriceCurve, formula='Black76', model='SVI', surfaceName='CF_surface');\nprint(surf);\n\n// 生成波动率预测数据用于可视化\ndts = (0..20)*0.05\nks = (0..40)*((max(strikes[0])-min(strikes[0]))\\40)+min(strikes[0])\nm = optionVolPredict(surf, dts, ks).rename!(dts, ks)\n\n// 绘制曲面图\nplot(\n    m,\n    title=[\"棉花期货期权 2026-02-11\", \"K\", \"T\", \"vol\"],\n    chartType=SURFACE)\n```\n\n输出返回：\n\n![](https://docs.dolphindb.cn/zh/funcs/images/cmFutVolatilitySurfaceBuilder/eg_1.png)\n\n例2. 下例展示如何使用铜期货期权市场数据构建波动率曲面，并通过三维图表可视化波动率随到期时间和行权价的变化趋势：\n\n```\n// cu 铜期货期权波动率曲面构建示例\n\n// 曲线构建的参考日期\nreferenceDate = 2025.12.02\n// 期权到期日\noptionExpiries = [2025.12.25, 2026.01.26, 2026.02.13, 2026.03.25, 2026.04.24, 2026.05.25, 2026.06.24, 2026.07.27]\n// 标的期货合约到期日（与期权到期日一一对应）\nfutMaturities  = [2026.01.15, 2026.02.24, 2026.03.16, 2026.04.15, 2026.05.15, 2026.06.15, 2026.07.15, 2026.08.17]\n\n// strikes: list of strike vectors (每个期权到期日对应一组 strikes)\nstrikes = [\n    [64000, 65000, 66000, 67000, 68000, 69000, 70000, 71000, 72000, 73000, 74000, 75000, 76000, 77000, 78000, 79000, 80000, 82000, 84000, 86000, 88000, 90000, 92000, 94000, 96000, 98000, 100000],  //1\n    [64000, 65000, 66000, 67000, 68000, 69000, 70000, 71000, 72000, 73000, 74000, 75000, 76000, 77000, 78000, 79000, 80000, 82000, 84000, 86000, 88000, 90000, 92000, 94000, 96000, 98000, 100000], //2\n    [64000, 65000, 66000, 67000, 68000, 69000, 70000, 71000, 72000, 73000, 74000, 75000, 76000, 77000, 78000, 79000, 80000, 82000, 84000, 86000, 88000, 90000, 92000, 94000, 96000, 98000, 100000], //3\n    [68000, 69000, 70000, 71000, 72000, 73000, 74000, 75000, 76000, 77000, 78000, 79000, 80000, 82000, 84000, 86000, 88000, 90000, 92000, 94000, 96000, 98000, 100000], //4\n    [70000, 71000, 72000, 73000, 74000, 75000, 76000, 77000, 78000, 79000, 80000, 82000, 84000, 86000, 88000, 90000, 92000, 94000, 96000, 98000, 100000], //5\n    [76000, 77000, 78000, 79000, 80000, 82000, 84000, 86000, 88000, 90000, 92000, 94000, 96000, 98000], //6\n    [76000, 77000, 78000, 79000, 80000, 82000, 84000, 86000, 88000, 90000, 92000, 94000, 96000, 98000], //7\n    [76000, 77000, 78000, 79000, 80000, 82000, 84000, 86000, 88000, 90000, 92000, 94000, 96000, 98000] //8\n]\n\n// optionPrices: 每个到期日对应的 option price 向量\noptionPrices = [\n    [25090, 24090, 23090, 22090, 21090, 20090, 19090, 18090, 17090, 16090, 15090, 14090, 13090, 12092, 11100, 10114, 9138 , 7240 , 5468 , 3898 , 2600 , 1608 , 914  , 482  , 232  , 102  , 40   ], // 1\n    [25080, 24080, 23080, 22080, 21080, 20080, 19080, 18080, 17080, 16080, 15084, 14092, 13106, 12132, 11168, 10218, 9290 , 7520 , 5896 , 4462 , 3246 , 2266 , 1516 , 972  , 596  , 350  , 196  ], // 2\n    [25030, 24030, 23030, 22030, 21030, 20030, 19030, 18030, 17034, 16044, 15058, 14082, 13116, 12164, 11230, 10316, 9426 , 7736 , 6196 , 4832 , 3660 , 2696 , 1930 , 1338 , 894  , 586  , 370   ], // 3\n    [20970, 19970, 18970, 17972, 16980, 15996, 15018, 14052, 13100, 12162, 11244, 10348, 9478 , 7830 , 6336 , 5010 , 3864 , 2906 , 2136 , 1522 , 1066 , 722  , 480   ], // 4\n    [18952, 17958, 16974, 15996, 15030, 14076, 13136, 12214, 11314, 10438, 9590 , 7986 , 6522 , 5228 , 4102 , 3150 , 2370 , 1742 , 1254 , 886  , 608   ], // 5\n    [12830, 11924, 11040, 10182, 9350 , 7786 , 6372 , 5110 , 4030 , 3104 , 2354 , 1740 , 1270 , 904  ], // 6\n    [13176, 12314, 11476, 10670, 9888 , 8416 , 7068 , 5874 , 4814 , 3890 , 3102 , 2450 , 1908 , 1468  ], // 7\n    [12848, 11988, 11148, 10346, 9568 , 8102 , 6772 , 5590 , 4546 , 3644 , 2890 , 2260 , 1740 , 1320  ] // 8\n]\n\n// payoffTypes: 期权类型，用字符串 \"Put\"/\"Call\" 表示\npayoffTypes = [\n    take(\"Call\", size(optionPrices[0])),\n    take(\"Call\", size(optionPrices[1])),\n    take(\"Call\", size(optionPrices[2])),\n    take(\"Call\", size(optionPrices[3])),\n    take(\"Call\", size(optionPrices[4])),\n    take(\"Call\", size(optionPrices[5])),\n    take(\"Call\", size(optionPrices[6])),\n    take(\"Call\", size(optionPrices[7]))\n]\n\n// 构建折现曲线\npillar_dates = [\n    referenceDate + 2,\n    referenceDate + 8,\n    referenceDate + 93,\n    referenceDate + 185,\n    referenceDate + 276,\n    referenceDate + 367,\n    referenceDate + 732,\n    referenceDate + 1099,\n    referenceDate + 1463,\n    referenceDate + 1828,\n    referenceDate + 2558,\n    referenceDate + 3654\n]\n\npillar_values = [\n    0.0145993931630537,\n    0.0229075517972275,\n    0.0253020667393029,\n    0.0257564866303201,\n    0.0259751440992468,\n    0.0260355181479988,\n    0.0265336263144786,\n    0.0272721454114050,\n    0.0282024453631075,\n    0.0290231222075799,\n    0.0304665029488732,\n    0.0319855013976250\n]\n\ncurve_dict = {\n    \"mktDataType\": \"Curve\",\n    \"curveType\": \"IrYieldCurve\",\n    \"referenceDate\": referenceDate,\n    \"currency\": \"CNY\",\n    \"dayCountConvention\": \"Actual365\",\n    \"compounding\": \"Continuous\",\n    \"interpMethod\": \"Linear\",\n    \"extrapMethod\": \"Flat\",\n    \"frequency\": \"\", \n    \"dates\": pillar_dates,\n    \"values\": pillar_values,\n    \"name\": \"CNY_FR_007\"\n}\n\ndiscountCurve = parseMktData(curve_dict)\n\nprint(discountCurve)\n\n// 构建期货价格曲线\ncurve_dict = {\n    \"mktDataType\": \"Curve\",\n    \"curveType\": \"AssetPriceCurve\",\n    \"referenceDate\": referenceDate,\n    \"dates\":[2025.12.15, 2026.01.15, 2026.02.24, 2026.03.16, 2026.04.15, 2026.05.15, 2026.06.15, 2026.07.15, 2026.08.17, 2026.09.15, 2026.10.15, 2026.11.16],\n    \"values\":[88770, 89090, 89080, 89030, 88970, 88950, 88590, 88660, 88350, 88120, 87910, 87840]\n}\nfutPriceCurve = parseMktData(curve_dict)\nprint(futPriceCurve)\n\n// 构建波动率曲面\nsurf = cmFutVolatilitySurfaceBuilder(referenceDate, futMaturities, optionExpiries, strikes, optionPrices, payoffTypes, discountCurve, futPriceCurve, formula='Black76', model='SVI', surfaceName='cu_future_option_vol_surface');\n\n// 生成波动率预测数据用于可视化\ndts = (0..20)*0.05\nks = (0..40)*((max(strikes[0])-min(strikes[0]))\\40)+min(strikes[0])\nm = optionVolPredict(surf, dts, ks).rename!(dts, ks)\n\n// 绘制曲面图\nplot(\n    m,\n    title=[\"Vol Surface\", \"K\", \"T\", \"vol\"],\n    chartType=SURFACE)\n```\n\n输出返回：\n\n![](https://docs.dolphindb.cn/zh/funcs/images/cmFutVolatilitySurfaceBuilder/eg_2.png)\n\n**相关函数**：[parseMktData](https://docs.dolphindb.cn/zh/funcs/p/parseMktData.html)\n"
    },
    "coevent": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/coevent.html",
        "signatures": [
            {
                "full": "coevent(event, eventTime, window, [orderSensitive=false])",
                "name": "coevent",
                "parameters": [
                    {
                        "full": "event",
                        "name": "event"
                    },
                    {
                        "full": "eventTime",
                        "name": "eventTime"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "[orderSensitive=false]",
                        "name": "orderSensitive",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [coevent](https://docs.dolphindb.cn/zh/funcs/c/coevent.html)\n\n\n\n#### 语法\n\ncoevent(event, eventTime, window, \\[orderSensitive=false])\n\n#### 详情\n\n统计给定的时间间隔内出现事件对的次数。如果 *eventTime* 中包含 NULL 值，系统会忽略这条记录。\n\n返回的结果是一个表，包含 event1, event2 和 hits 三个字段。event1 和 event2 的数据类型与 *event* 相同，hits 是整数，表示事件对出现的次数。\n\n#### 参数\n\n**event** 是一个向量，表示事件。\n\n**eventTime** 是一个时间类型或整型类型的向量，表示事件发生时间。它的长度必须与 *event* 相同。\n\n**window** 是一个非负整数，表示时间间隔长度。\n\n**orderSensitive** 是一个可选的布尔值，表示是否区分两个事件的先后顺序。默认值是 false。\n\n#### 返回值\n\n返回的结果是一个表，包含 event1, event2 和 hits 三个字段。event1 和 event2 的数据类型与 *event* 相同，hits 是整数，表示事件对出现的次数。\n\n#### 例子\n\n下例中，sensor\\_id 与 time 分别为发现异常的传感器编号以及发现异常时刻。使用 `coevent` 函数统计2秒钟内两个传感器同时出现异常的次数。\n\n```\nsensor_id=`A`B`C`D`C`A`B\ntime=[2012.06.13T12:30:00,2012.06.13T12:30:02,2012.06.13T12:30:04,2012.06.13T12:30:05,2012.06.13T12:30:06,2012.06.13T12:30:09,2012.06.13T12:30:10];\n\ncoevent(sensor_id, time, 2);\n```\n\n| event1 | event2 | hits |\n| ------ | ------ | ---- |\n| B      | C      | 1    |\n| C      | D      | 2    |\n| C      | C      | 1    |\n| A      | B      | 2    |\n\n```\ncoevent(sensor_id, time, 2, true);\n```\n\n| event1 | event2 | hits |\n| ------ | ------ | ---- |\n| C      | C      | 1    |\n| B      | C      | 1    |\n| C      | D      | 1    |\n| D      | C      | 1    |\n| A      | B      | 2    |\n"
    },
    "coint": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/coint.html",
        "signatures": [
            {
                "full": "coint(Y0, Y1, [trend=\"c\"], [method=\"aeg\"], [maxLag], [autoLag=\"aic\"])",
                "name": "coint",
                "parameters": [
                    {
                        "full": "Y0",
                        "name": "Y0"
                    },
                    {
                        "full": "Y1",
                        "name": "Y1"
                    },
                    {
                        "full": "[trend=\"c\"]",
                        "name": "trend",
                        "optional": true,
                        "default": "\"c\""
                    },
                    {
                        "full": "[method=\"aeg\"]",
                        "name": "method",
                        "optional": true,
                        "default": "\"aeg\""
                    },
                    {
                        "full": "[maxLag]",
                        "name": "maxLag",
                        "optional": true
                    },
                    {
                        "full": "[autoLag=\"aic\"]",
                        "name": "autoLag",
                        "optional": true,
                        "default": "\"aic\""
                    }
                ]
            }
        ],
        "markdown": "### [coint](https://docs.dolphindb.cn/zh/funcs/c/coint.html)\n\n#### 语法\n\ncoint(Y0, Y1, \\[trend=\"c\"], \\[method=\"aeg\"], \\[maxLag], \\[autoLag=\"aic\"])\n\n#### 详情\n\n检验单变量方程中是否存在协整性。\n\n#### 参数\n\n**Y0** 数值向量，元素不可为空值，表示协整系统中的第一个元素。\n\n**Y1** 数值向量或数值矩阵，元素不可为空值，且元素个数与 Y0 相同。表示协整系统中的其余元素。\n\n**trend**字符串，指定协整方程的回归中使用的趋势项。取值有如下选择：\n\n* \"c\"：默认值，表示只使用常数。\n* \"ct\"：使用常数和趋势。\n* \"ctt\"：使用常数、线性趋势和二次趋势。\n* \"n\"：不使用常数和趋势。\n\n**method**字符串，指定协整检验所使用的方法，支持取值为 “aeg”，代表增广 Engle-Granger 两步协整性检验。\n\n**maxLag**非负整数，作为调用 adfuller 时传递的参数，指定 adfuller 检验中使用的最大滞后期。\n\n**autoLag**字符串，作为调用 `adfuller` 时传递的参数，指定在 0\\~maxLag 中自动确定滞后期长度时使用的方法。取值有如下选择：\n\n* \"aic\"：默认值，表示使用 Akaike Information Criterion 来确定滞后期数值。\n* \"bic\"：表示使用 Bayesian information criterion 来确定滞后期数值。\n* \"tstat\"：将滞后期初始值设为 maxLag，然后逐步减 1，直到上一个滞后期数值的 t 统计量在 5% 显著性水平上显著。\n* \"max\"：将滞后期数值设置为 maxLag。\n\n#### 返回值\n\n结果以字典的形式返回，包括：\n\n* tStat：浮点数标量，表示残差的单位根检验的 t 统计量\n* pValue：浮点数标量，表示 MacKinnon 近似 p 值\n* criticalValues：字典，表示基于回归曲线，在1％、5％和10％水平上的检验统计量的临界值\n\n#### 例子\n\n```\nY0 = 234 267 289 301 312 323 334 345 356;\nY1 = 267 289 301 312 323 334 345 356 367;\ncoint(Y0, Y1);\n```\n\n输出为字典：\n\n```\ntValue->-1.498236972489574\npValue->0.761867238199341\ncriticalValues->[-5.789286875000001,-4.206501875,-3.6171]\n```\n\n"
    },
    "col": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/col.html",
        "signatures": [
            {
                "full": "col(obj, index)",
                "name": "col",
                "parameters": [
                    {
                        "full": "obj",
                        "name": "obj"
                    },
                    {
                        "full": "index",
                        "name": "index"
                    }
                ]
            }
        ],
        "markdown": "### [col](https://docs.dolphindb.cn/zh/funcs/c/col.html)\n\n\n\n#### 语法\n\ncol(obj, index) 或 column(obj, index)\n\n#### 详情\n\n返回向量、矩阵或表的一列或多列。参见相关函数：[row](https://docs.dolphindb.cn/zh/funcs/r/row.html)。\n\n#### 参数\n\n**obj** 可以是向量、矩阵或表。\n\n**index** 是一个整数标量或数据对。\n\n#### 返回值\n\n返回一个与输入 *obj* 相同数据类型和形式的对象。\n\n#### 例子\n\n```\nx=1..6$3:2;\nx;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 4  |\n| 2  | 5  |\n| 3  | 6  |\n\n```\ncol(x,0);\n// output\n[1,2,3]\n\nx.col(1);\n// output\n[4,5,6]\n\na=table(1..3 as x,`IBM`C`AAPL as y);\na;\n```\n\n| x | y    |\n| - | ---- |\n| 1 | IBM  |\n| 2 | C    |\n| 3 | AAPL |\n\n```\na col 1;\n// output\n[\"IBM\",\"C\",\"AAPL\"]\n\ncol(a, 0:2)\n```\n\n| x | y    |\n| - | ---- |\n| 1 | IBM  |\n| 2 | C    |\n| 3 | AAPL |\n"
    },
    "cols": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cols.html",
        "signatures": [
            {
                "full": "cols(X)",
                "name": "cols",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [cols](https://docs.dolphindb.cn/zh/funcs/c/cols.html)\n\n\n\n#### 语法\n\ncols(X)\n\n#### 详情\n\n返回 *X* 中列的数目。参见相关函数：[rows](https://docs.dolphindb.cn/zh/funcs/r/rows.html)。\n\n#### 参数\n\n**X** 可以是任意数据形式的对象。\n\n#### 返回值\n\nINT 类型标量。\n\n#### 例子\n\n```\nx=1..6$2:3;\nx;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1  | 3  | 5  |\n| 2  | 4  | 6  |\n\n```\ncols x;\n// output\n3\n\na=table(1..3 as x,`IBM`C`AAPL as y);\na;\n```\n\n| x | y    |\n| - | ---- |\n| 1 | IBM  |\n| 2 | C    |\n| 3 | AAPL |\n\n```\ncols a;\n// output\n2\n\ny=1 2 3;\ncols(y);\n// output\n1\n// 向量可以被视为一个 n*1 的矩阵\n```\n"
    },
    "columnNames": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/columnNames.html",
        "signatures": [
            {
                "full": "columnNames(X)",
                "name": "columnNames",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [columnNames](https://docs.dolphindb.cn/zh/funcs/c/columnNames.html)\n\n\n\n#### 语法\n\ncolumnNames(X)\n\n#### 详情\n\n返回 *X* 的列名的向量。参见相关函数：[rowNames](https://docs.dolphindb.cn/zh/funcs/r/rowNames.html)。\n\n#### 参数\n\n**X** 可以是矩阵或表。\n\n#### 返回值\n\nSTRING 类型向量。\n\n#### 例子\n\n```\nx=1..6$2:3;\nx;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1  | 3  | 5  |\n| 2  | 4  | 6  |\n\n```\nx.rename!(`a`b`c);\n```\n\n| a | b | c |\n| - | - | - |\n| 1 | 3 | 5 |\n| 2 | 4 | 6 |\n\n```\nx.columnNames();\n// output\n[\"a\",\"b\",\"c\"]\n\nt = table(1 2 3 as id, 4 5 6 as value, `IBM`MSFT`GOOG as name);\nt;\n```\n\n| id | value | name |\n| -- | ----- | ---- |\n| 1  | 4     | IBM  |\n| 2  | 5     | MSFT |\n| 3  | 6     | GOOG |\n\n```\ncolumnNames t;\n// output\n[\"id\",\"value\",\"name\"]\n\nt[t.columnNames().tail()];\n// output\n[\"IBM\",\"MSFT\",\"GOOG\"]\n// 获取表的最后一列，返回的结果是一个向量\n```\n"
    },
    "complex": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/complex.html",
        "signatures": [
            {
                "full": "complex(X, Y)",
                "name": "complex",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [complex](https://docs.dolphindb.cn/zh/funcs/c/complex.html)\n\n\n\n#### 语法\n\ncomplex(X, Y)\n\n#### 详情\n\n创建复数 X+Y\\*i。\n\n复数类型的数据长度为16字节，其中低8位的数据存储于 *X* 中，高8位的数据存储于 *Y* 中。\n\n#### 参数\n\n**X** 和 **Y** 是数值型的标量、数据对、向量或矩阵，支持的数据类型为 INTEGRAL 类（COMPRESSED、INT128 除外）和 FLOATING 类。\n\n#### 返回值\n\nCOMPLEX 类型标量或向量。\n\n#### 例子\n\n```\ncomplex(2, 5)\n// output: 2.0+5.0i\n\na=1.0 2.3\nb=3 4\ncomplex(a,b)\n\n// output：[1+3i,2.3+4i]\n```\n\n**相关函数**：[highDouble](https://docs.dolphindb.cn/zh/funcs/h/highDouble.html)，[lowDouble](https://docs.dolphindb.cn/zh/funcs/l/lowDouble.html)\n"
    },
    "compose": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/compose.html",
        "signatures": [
            {
                "full": "compose(first, second)",
                "name": "compose",
                "parameters": [
                    {
                        "full": "first",
                        "name": "first"
                    },
                    {
                        "full": "second",
                        "name": "second"
                    }
                ]
            }
        ],
        "markdown": "### [compose](https://docs.dolphindb.cn/zh/funcs/c/compose.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\ncompose(first, second)\n\n#### 详情\n\n创建一个由两个函数组成的复合函数，效果等同于`second(first())`\\*。\\*该函数执行逻辑如下：\n\n1. 先调用 *first*函数，将传入的所有参数传给它；\n2. 然后将 *first*的返回结果作为唯一参数，传给 *second*函数；\n3. 最终返回 `second(first(...))` 的计算结果。\n\n例如，对于复合函数 `f=compose(add,sin)`， `f(x,y)` 的返回值等同于`sin(add(x，y))`。\n\n**函数使用场景**：将多个函数按顺序组合成一个新的函数，可用于数据处理流水线、函数复用、逻辑封装以及函数式编程等场景，提升代码的可读性、可维护性、简化复杂的逻辑表达。\n\n#### 参数\n\n**first**第一个被调用的函数，接受一个或多个参数。\n\n**second**第二个被调用的函数，只接受一个参数（即*first* 的返回值）。\n\n#### 返回值\n\n一个新的函数（FUNCTIONDEF 类型），入参与 *first* 函数一致。\n\n#### 例子\n\n```\ng=def(x,y,z){return x*y+z}\nf=def(x){return abs(x*3)}\ncompo_func=compose(g, f) //等同于f(g(*))\n\ncompo_func(-1, 5, 3) // Output: 6\n```\n"
    },
    "compress": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/compress.html",
        "signatures": [
            {
                "full": "compress(X, [method='lz4'])",
                "name": "compress",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[method='lz4']",
                        "name": "method",
                        "optional": true,
                        "default": "'lz4'"
                    }
                ]
            }
        ],
        "markdown": "### [compress](https://docs.dolphindb.cn/zh/funcs/c/compress.html)\n\n\n\n#### 语法\n\ncompress(X, \\[method='lz4'])\n\n#### 详情\n\n使用指定压缩算法对向量或数据表进行压缩。压缩某个变量后，需要使用函数 [decompress](https://docs.dolphindb.cn/zh/funcs/d/decompress.html) 将其解压缩后方可使用该变量。\n\n#### 参数\n\n**X** 是一个向量或数据表。\n\n**method** 是一个字符串，为压缩算法，可取值为 \"lz4\", \"delta\" (delta-of-delta encoding), \"zstd\" 或 \"chimp\"，默认值为 \"lz4\"。其中，\n\n* lz4 适用于几乎所有数据类型，它侧重于压缩和解压速度，虽然压缩比不是最高的，但解压速度快，适用于需要快速解压的场景。\n* zstd 同样适用于几乎所有数据类型，其压缩比高于 lz4，但解压缩速度较 lz4 慢约1倍。它适用于对压缩比有较高要求的场景。\n* delta 使用 delta of delta 算法，适用于 SHORT, INT, LONG 与时间或日期类型数据。\n* chimp 适用于小数部分长度在三位以内的 DOUBLE 类型的数据。\n\n#### 返回值\n\n返回一个压缩后的向量或表。\n\n#### 例子\n\n```\nx=1..100000000\ny=compress(x, \"delta\");\n\ny.typestr();\n// output: HUGE COMPRESSED VECTOR\n\nz=compress(x, \"zstd\");\nz.typestr();\n// output: HUGE COMPRESSED VECTOR\n\nselect name, bytes from objs() where name in `x`y;\n```\n\n| name | bytes     |\n| ---- | --------- |\n| x    | 402653952 |\n| y    | 13634544  |\n\n**Note:** 对向量 x 压缩后的结果（y ）使用 `size` 函数，结果为 y 的长度，而不是 x 的长度。若要从 y 中获取 x 的长度或其它信息，需先将 y 解压缩：\n\n```\ny.size();\n// output: 12670932\n\nz=decompress(y);\nz.size();\n// output: 100000000\n```\n\n相关函数：[decompress](https://docs.dolphindb.cn/zh/funcs/d/decompress.html)\n"
    },
    "concat": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/concat.html",
        "signatures": [
            {
                "full": "concat(X, Y)",
                "name": "concat",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [concat](https://docs.dolphindb.cn/zh/funcs/c/concat.html)\n\n\n\n#### 语法\n\nconcat(X, Y)\n\n#### 详情\n\n如果 *X* 是字符串或字符：\n\n* 当 *X* 为空时，若 *Y* 是空字符串或空字符，该函数返回一个空字符串；若 *Y* 是非空字符串或非空字符，该函数返回字符串 *Y*。\n* 当 *X* 非空时，无论 *Y* 是否为空，该函数将 *Y* 连接到 *X* 之后，返回新的字符串。\n\n如果 *X* 是字符串向量或字符向量：\n\n* 当 *X* 为空时，无论 *Y* 是否为空，该函数总是返回一个空字符串。\n* 当 *X* 非空时，若 *Y* 是空字符串或空字符，该函数将 *X* 的每个元素依次连接成一个新的字符串并返回；若 *Y* 非空，该函数依次连接 *X* 中每个字符串（字符），并使用 *Y* 对它们分隔，返回新的字符串。\n\n**Note:** `concat` 在进行连接之前会将所有参数隐式转换为字符串类型，将空值隐式转换为空字符串。\n\n#### 参数\n\n**X** 可以是字符串标量/向量、字符标量/向量。\n\n**Y** 是字符串或字符。\n\n若 *X* 或 *Y* 未指定，则它们将被处理为空字符串。\n\n#### 返回值\n\n字符串（STRING）\n\n#### 例子\n\n```\n// 连接两个字符串\nconcat (`hello, `world);\n// output\nhelloworld\n\n// 返回在 IBM, GOOG 和 APPL 间用 \",\" 分隔的结果\nx = concat(`IBM`GOOG`APPL, \",\");\nx;\n// output\nIBM,GOOG,APPL\n\ntypestr x;\n// output\nSTRING\n\nsize x;\n// output\n1\n\nconcat(string([]),\"a\")\n// output\nNULL\n\nconcat(\"55\",\"\")\n// output\n55\n\n// Y 未指定，将 X 的每个元素直接拼接为1个字符串\nconcat(`a`b`c`d,)\n// output\nabcd\n```\n"
    },
    "concatDateTime": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/concatDateTime.html",
        "signatures": [
            {
                "full": "concatDateTime(date, time)",
                "name": "concatDateTime",
                "parameters": [
                    {
                        "full": "date",
                        "name": "date"
                    },
                    {
                        "full": "time",
                        "name": "time"
                    }
                ]
            }
        ],
        "markdown": "### [concatDateTime](https://docs.dolphindb.cn/zh/funcs/c/concatDateTime.html)\n\n\n\n#### 语法\n\nconcatDateTime(date, time)\n\n别名：concatDT\n\n#### 详情\n\n合并日期和时间。\n\n#### 参数\n\n**date** 可以是 DATE 类型的标量或向量。\n\n**time** 可以是 SECOND、TIME 或 NANOTIME 类型的标量或向量。\n\n如果 *date* 和 *time* 都是向量，它们的长度必须相同。\n\n#### 返回值\n\n一个标量或向量：\n\n如果 *time* 是 SECOND 类型，返回的结果是 DATETIME 类型；\n\n如果 *time* 是 TIME 类型，返回的结果是 TIMESTAMP 类型；\n\n如果 *time* 是 NANOTIME，返回的结果是 NANOTIMESTAMP 类型。\n\n#### 例子\n\n```\nconcatDateTime(2019.06.15,13:25:10);\n// output\n2019.06.15T13:25:10\n\nconcatDateTime(2019.06.15,[13:25:10, 13:25:12, 13:25:13]);\n// output\n[2019.06.15T13:25:10,2019.06.15T13:25:12,2019.06.15T13:25:13]\n\ndate=[2019.06.18, 2019.06.20, 2019.06.21, 2019.06.19, 2019.06.18, 2019.06.20]\ntime = [09:34:07,09:36:42,09:36:51,09:36:59,09:32:47,09:35:26]\nsym = `C`MS`MS`MS`IBM`IBM$SYMBOL\nprice= 49.6 29.46 29.52 30.02 174.97 175.23\nqty = 2200 1900 2100 3200 6800 5400\nt = table(date, time, sym, qty, price);\n\nselect concatDateTime(date,time) as datetime, sym, qty, price from t;\n```\n\n| datetime            | sym | qty  | price  |\n| ------------------- | --- | ---- | ------ |\n| 2019.06.18T09:34:07 | C   | 2200 | 49.6   |\n| 2019.06.20T09:36:42 | MS  | 1900 | 29.46  |\n| 2019.06.21T09:36:51 | MS  | 2100 | 29.52  |\n| 2019.06.19T09:36:59 | MS  | 3200 | 30.02  |\n| 2019.06.18T09:32:47 | IBM | 6800 | 174.97 |\n| 2019.06.20T09:35:26 | IBM | 5400 | 175.23 |\n"
    },
    "concatMatrix": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/concatMatrix.html",
        "signatures": [
            {
                "full": "concatMatrix(X, [horizontal=true])",
                "name": "concatMatrix",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[horizontal=true]",
                        "name": "horizontal",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [concatMatrix](https://docs.dolphindb.cn/zh/funcs/c/concatMatrix.html)\n\n\n\n#### 语法\n\nconcatMatrix(X, \\[horizontal=true])\n\n#### 详情\n\n水平或垂直拼接多个矩阵。\n\n如果水平拼接多个矩阵，它们的行数必须相同；如果垂直拼接多个矩阵，它们的列数必须相同。\n\n#### 参数\n\n**X** 由多个矩阵构成的元组。\n\n**horizontal** 布尔值，是否水平拼接矩阵，默认值为 true。若为 false 表示垂直拼接。\n\n#### 返回值\n\n返回一个拼接后的矩阵对象。\n\n#### 例子\n\n```\nm1 = matrix(4 0 5, 2 1 8);\nm2 = matrix(2 9 8, 3 7 -3, 6 4 2, 0 5 8);\nm3 = matrix(1 -1 6 2, 1 -3 1 9, 5 3 0 -4, 1 NULL 3 4);\nconcatMatrix([m1, m2]);\n```\n\n| col1 | col2 | col3 | col4 | col5 | col6 |\n| ---- | ---- | ---- | ---- | ---- | ---- |\n| 4    | 2    | 2    | 3    | 6    | 0    |\n| 0    | 1    | 9    | 7    | 4    | 5    |\n| 5    | 8    | 8    | -3   | 2    | 8    |\n\n```\nprint concatMatrix([m2, m3], false);\n```\n\n| col1 | col2 | col3 | col4 |\n| ---- | ---- | ---- | ---- |\n| 2    | 3    | 6    | 0    |\n| 9    | 7    | 4    | 5    |\n| 8    | -3   | 2    | 8    |\n| 1    | 1    | 5    | 1    |\n| -1   | -3   | 3    |      |\n| 6    | 1    | 0    | 3    |\n| 2    | 9    | 4    | 4    |\n"
    },
    "conditionalFilter": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/conditionalFilter.html",
        "signatures": [
            {
                "full": "conditionalFilter(X, condition, filterMap)",
                "name": "conditionalFilter",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "condition",
                        "name": "condition"
                    },
                    {
                        "full": "filterMap",
                        "name": "filterMap"
                    }
                ]
            }
        ],
        "markdown": "### [conditionalFilter](https://docs.dolphindb.cn/zh/funcs/c/conditionalFilter.html)\n\n\n\n#### 语法\n\nconditionalFilter(X, condition, filterMap)\n\n#### 详情\n\n根据给定的字典参数 *filterMap*，若向量 *condition* 中某元素为该字典的 key，而且向量 *X* 中相应位置元素为字典中该 key 值对应的 value 表示的向量中一个元素，或在该 value 表示的数据对的范围中时，返回 true，否则返回 false。\n\n如果 *X* 和 *condition* 都是向量，返回的结果是与它们等长的向量。\n\n#### 参数\n\n**X** 是标量或者向量。\n\n**condition** 是标量，或与 *X* 等长的向量。\n\n**filterMap** 是字典，表示过滤条件。\n\n#### 返回值\n\nBOOL 类型标量或向量。\n\n#### 例子\n\n例1：\n\n```\nconditionalFilter(1 2 3,`a`b`c, dict(`a`b,1 2));\n// output\n[1,1,0]\n\nconditionalFilter(1 2 3,`a`b`b, dict(`a`b,[1 2,3 4]))\n// output\n[1,0,1]\n```\n\n例2：\n\n从数据表 t 中，提取如下天内指定股票的数据：\n\n2012.06.01: C, MS 2012.06.02: IBM, MS 2012.06.03: MS 2012.06.04: IBM\n\n```\nsym = `C`MS`MS`MS`IBM`IBM`C`C`C$SYMBOL\ndate = 2012.06.01 2012.06.01 2012.06.02 2012.06.03 2012.06.01 2012.06.02 2012.06.02 2012.06.03 2012.06.04\nprice = 49.6 29.46 29.52 30.02 174.97 175.23 50.76 50.32 51.29\nqty = 2200 1900 2100 3200 6800 5400 1300 2500 8800\nt = table(sym, date, price, qty)\nt;\n```\n\n| sym | date       | price  | qty  |\n| --- | ---------- | ------ | ---- |\n| C   | 2012.06.01 | 49.60  | 2200 |\n| MS  | 2012.06.01 | 29.46  | 1900 |\n| MS  | 2012.06.02 | 29.52  | 2100 |\n| MS  | 2012.06.03 | 30.02  | 3200 |\n| IBM | 2012.06.01 | 174.97 | 6800 |\n| IBM | 2012.06.02 | 175.23 | 5400 |\n| C   | 2012.06.02 | 50.76  | 1300 |\n| C   | 2012.06.03 | 50.32  | 2500 |\n| C   | 2012.06.04 | 51.29  | 8800 |\n\n```\nfilter = dict(2012.06.01..2012.06.04, [`C`MS, `IBM`MS, `MS, `IBM])\nselect * from t where conditionalFilter(sym, date, filter) order by date, sym;\n```\n\n| sym | date       | price  | qty  |\n| --- | ---------- | ------ | ---- |\n| C   | 2012.06.01 | 49.6   | 2200 |\n| MS  | 2012.06.01 | 29.46  | 1900 |\n| IBM | 2012.06.02 | 175.23 | 5400 |\n| MS  | 2012.06.02 | 29.52  | 2100 |\n| MS  | 2012.06.03 | 30.02  | 3200 |\n\n例3：\n\n*filterMap* 的 value 亦可采用数据对的形式。\n\n```\nt=table(`aaa`aaa`bbb`bbb as id, 2020.09.03 2020.09.10 2020.09.06 2020.09.09 as date)\nt\n```\n\n| id  | date       |\n| --- | ---------- |\n| aaa | 2020.09.03 |\n| aaa | 2020.09.10 |\n| bbb | 2020.09.06 |\n| bbb | 2020.09.09 |\n\n```\nmydict = dict(`aaa`bbb, [2020.09.01 : 2020.09.09,  2020.09.05 : 2020.09.09])\nselect * from t where conditionalFilter(date, id, mydict);\n```\n\n| id  | date       |\n| --- | ---------- |\n| aaa | 2020.09.03 |\n| bbb | 2020.09.06 |\n| bbb | 2020.09.09 |\n"
    },
    "conditionalIterate": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/conditionalIterate.html",
        "signatures": [
            {
                "full": "conditionalIterate(cond, trueValue, falseIterFunc)",
                "name": "conditionalIterate",
                "parameters": [
                    {
                        "full": "cond",
                        "name": "cond"
                    },
                    {
                        "full": "trueValue",
                        "name": "trueValue"
                    },
                    {
                        "full": "falseIterFunc",
                        "name": "falseIterFunc"
                    }
                ]
            }
        ],
        "markdown": "### [conditionalIterate](https://docs.dolphindb.cn/zh/funcs/c/conditionalIterate.html)\n\n\n\n#### 语法\n\nconditionalIterate(cond, trueValue, falseIterFunc)\n\n该函数只能用作响应式状态引擎 metrics 中的函数。\n\n#### 详情\n\n通过条件迭代实现因子中的递归逻辑。\n\n假设该函数计算结果对应输出表的列为 factor，且迭代仅基于前一个值，对于第 k 条记录(k = 0, 1, 2 …)，其计算逻辑为：\n\n* cond\\[k] == true：factor\\[k] = trueValue\n* cond\\[k] == false：factor\\[k] = falseIterFunc(factor)\\[k-1]\n\n**Note:** 若 *falseIterFunc* 为窗口函数，则会基于前多个 factor 值进行计算。\n\n#### 参数\n\n**cond** 布尔表达式/返回值是布尔类型的函数。需要包含输入表中的字段，不支持常量/常量表达式。\n\n**trueValue** 计算公式。计算结果将作为 *cond* 为 true 时的输出值。\n\n**falseIterFunc** 用于进行迭代计算的函数。必须是一个单目函数，其唯一参数是 `conditionalIterate` 对应输出表中的字段。目前只支持以下函数（非单目函数以部分应用形式给出其他参数）：\n\n* 滑动窗口函数：`tmove`, `tmavg`, `tmmax`, `tmmin`, `tmsum`, `mavg`, `mmax`, `mmin`, `mcount`, `msum`\n* 累计窗口函数：`cumlastNot`, `cumfirstNot`\n* 序列相关函数：`ffill`, `move`\n\n若当前记录的 *cond* 为 true 时，触发 *trueValue* 的计算；若当前记录的 *cond* 为 false，则基于 `conditionalIterate` 的历史结果，调用 *falseIterFunc* 进行迭代计算。\n\n**Note:**\n\n* 由于迭代是基于历史数据进行的，因此当前记录的输出是由输出表中的历史结果计算得到的。\n* tm 系列函数计算时，时间窗口由当前记录的时间戳确定，且计算窗口范围为 (*T* - window, *T*)。\n* *trueValue* 和 *falseIterFunc* 计算结果的类型需要兼容，且需要确保 *trueValue* 结果的精度和数据范围大于 *falseIterFunc*。\n\n#### 例子\n\n例1. 通过一个简单的例子，快速了解 `conditionalIterate` 函数的计算逻辑：\n\n```\ntrade = table(take(\"A\", 10) as sym,  take(1 3 6, 10) as val0,  take(10, 10) as val1)\ntrade\n```\n\n| sym | val0 | val1 |\n| --- | ---- | ---- |\n| A   | 1    | 10   |\n| A   | 3    | 10   |\n| A   | 6    | 10   |\n| A   | 1    | 10   |\n| A   | 3    | 10   |\n| A   | 6    | 10   |\n| A   | 1    | 10   |\n| A   | 3    | 10   |\n| A   | 6    | 10   |\n| A   | 1    | 10   |\n\n创建一个响应式状态引擎，并按 sym 列分组进行计算。组内的计算逻辑如下：\n\n* 若满足 val0 > 5，若返回 true，则 *factor\\[k]=trueValue*，即以 val1 值作为输出。\n* 若不满足 val0 > 5，则对应计算公式为 factor\\[k]=falseIterFunc(factor)\\[k-1]。当 k=3 时，对应 val0=1，val1=10，factor=\\[NULL, NULL, 10]，带入公式计算即 msum(\\[NULL, NULL, 10], 3)\\[2]=10；当 k=4 时，对应 val0=3，val1=10，factor=\\[NULL, NULL, 10, 10]，带入公式计算即 msum(\\[NULL, NULL, 10, 10], 3)\\[3]=20，以此类推。\n\n```\ninputTable = streamTable(1:0, `sym`val0`val1, [SYMBOL, INT, INT])\noutputTable = table(100:0, `sym`factor, [STRING, DOUBLE])\nrse = createReactiveStateEngine(name=\"rsTest\", metrics=<conditionalIterate(val0 > 5, val1, msum{, 3})>, dummyTable=inputTable, outputTable=outputTable, keyColumn=\"sym\")\nrse.append!(trade)\nselect * from outputTable\n```\n\n| sym | factor |\n| --- | ------ |\n| A   |        |\n| A   |        |\n| A   | 10     |\n| A   | 10     |\n| A   | 20     |\n| A   | 10     |\n| A   | 40     |\n| A   | 70     |\n| A   | 10     |\n| A   | 120    |\n\n例2. 某因子在函数中算法逻辑如下：\n\n```\ndef factor(TotalVolumeTrade, TotalValueTrade, HighPx, LowPx){\n    factorValue = iif(TotalVolumeTrade < 1500000, pow(HighPx*LowPx, 0.5)-(TotalVolumeTrade/TotalValueTrade), mavg(factor(TotalVolumeTrade, TotalValueTrade, HighPx, LowPx), 3))\n    return factorValue\n}\n```\n\n该函数包含了一个递归操作。若需要在响应式状态引擎中实现上述逻辑，可以通过函数 `conditionalIterate` 实现。具体实现脚本如下：\n\n```\n@state\ndef factor1(TotalVolumeTrade, TotalValueTrade, HighPx, LowPx){\n   factorValue = conditionalIterate(TotalVolumeTrade < 1500000, (pow(HighPx*LowPx, 0.5)-(TotalVolumeTrade/TotalValueTrade)), mavg{,3})\n   return factorValue\n}\n\nSecurityID =  [\"000001.SZ\",\"000001.SZ\",\"000001.SZ\",\"000001.SZ\",\"000001.SZ\",\"000001.SZ\",\"000001.SZ\",\"000001.SZ\",\"000001.SZ\",\"000001.SZ\"]$SYMBOL\nDate = [2022.04.01,2022.04.01,2022.04.01,2022.04.01,2022.04.01,2022.04.01,2022.04.01,2022.04.01,2022.04.01,2022.04.01]\nTime = [09:30:00.000,09:30:03.000,09:30:06.000,09:30:09.000,09:30:12.000,09:30:15.000,09:30:18.000,09:30:21.000,09:30:24.000,09:30:27.000]\nTotalVolumeTrade = [844800,1035700,1240100,1304500,1457800,1522400,1550900,1663800,1692100,1767100]\nTotalValueTrade = [12982101,15908020,19038479,20022525,22363886,23349799,23784950,25506625.75,25937850.75,27080561.75]\nHighPx = [15.37,15.37,15.37,15.37,15.37,15.37,15.37,15.37,15.37,15.37]\nLowPx = [15.3,15.3,15.29,15.28,15.24,15.24,15.24,15.22,15.22,15.22]\ntrade = table(SecurityID, Date, Time, TotalVolumeTrade, TotalValueTrade, HighPx, LowPx)\n\nresult = table(1:0, `SecurityID`Date`Time`Factor, `SYMBOL`DATE`TIME`DOUBLE)\n\nfactor=[<Date>,<Time>, <factor1(TotalVolumeTrade, TotalValueTrade, HighPx, LowPx)>]\nrse = createReactiveStateEngine(name=\"rsTest\", metrics=factor, dummyTable=trade, outputTable=result, keyColumn=\"SecurityID\")\nrse.append!(trade)\n\ntrade1 = select *,  (pow(HighPx*LowPx, 0.5)-(TotalVolumeTrade/TotalValueTrade)) as Factor0 from trade\nselect * from lj(trade1, result, `SecurityID`Date`Time)\ndropStreamEngine(\"rsTest\")\n```\n\n部分输出结果如图：\n\n![](https://docs.dolphindb.cn/zh/images/conditionalIterate_output.png)\n\n对于上述蓝框部分的数据，触发 *trueValue* 计算逻辑，因此 Factor 的值等于 Factor0 的计算结果；红框部分的数据触发 *falseIterFunc* 计算逻辑，每条记录的 Factor 是输出表中该记录前三条 Factor 的平均值。\n\n**Related information**\n\n[stateIterate](https://docs.dolphindb.cn/zh/funcs/s/stateIterate.html)\n"
    },
    "constantDesc": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/constantdesc.html",
        "signatures": [
            {
                "full": "constantDesc(obj)",
                "name": "constantDesc",
                "parameters": [
                    {
                        "full": "obj",
                        "name": "obj"
                    }
                ]
            }
        ],
        "markdown": "### [constantDesc](https://docs.dolphindb.cn/zh/funcs/c/constantdesc.html)\n\n\n\n#### 语法\n\nconstantDesc(obj)\n\n#### 详情\n\n返回一个字典，描述对象 *obj*的相关属性。字典可能包含的 key 及说明如下：\n\n| key                      | 说明                                     |\n| ------------------------ | -------------------------------------- |\n| form                     | 数据形式                                   |\n| vectorType               | 向量类型，仅当 *obj*是向量时才有此 key               |\n| isIndexedMatrix          | 是否是索引矩阵，仅当 obj 是矩阵时才有此 key             |\n| isIndexedSeries          | 是否是索引序列，仅当 obj 是矩阵时才有此 key             |\n| nullFlag                 | 是否存在 NULL 值，仅当 *obj*是向量、数据对或矩阵时才有此 key |\n| isView                   | 是否是视图，仅当 *obj*是向量、数据对或矩阵时才有此 key       |\n| tableType                | 表的类型，仅当 obj 是表时才有此 key                 |\n| type                     | 数据类型                                   |\n| codeType                 | 元代码的类型，仅当 obj 是元代码时才有此 key             |\n| functionDefType          | 函数类型，仅当 obj 是函数是才有此 key                |\n| isTransformFunction      | 是否是转换函数                                |\n| isAggregateFunction      | 是否是聚合函数                                |\n| isOrderSensitiveFunction | 是否是顺序敏感函数                              |\n| isHigherOrderFunction    | 是否是高阶函数                                |\n| scale                    | 保留的小数位数，仅当 obj 是 DECIMAL 类型数据时才有此 key  |\n| isColumnarTuple          | 是否是列式元组，仅当 obj 是元组且不是视图时才有此 key        |\n| category                 | 数据类型分类                                 |\n| isTemporary              | 是否是临时对象                                |\n| isIndependent            | 是否独立对象                                 |\n| isReadonly               | 是否只读对象                                 |\n| isReadonlyArgument       | 是否是只读参数                                |\n| isStatic                 | 是否是静态对象                                |\n| isTransient              | 是否是瞬态对象                                |\n| copyOnWrite              | 是否写时拷贝                                 |\n| refCount                 | 被引用的次数                                 |\n| address                  | 地址的十六进制表示                              |\n| rows                     | 包含行数                                   |\n| columns                  | 包含列数                                   |\n| memoryAllocated          | 已分配的内存                                 |\n\n#### 参数\n\n**obj**一个对象。\n\n#### 例子\n\n```\nt = table(1..3 as id, 4..6 as val)\nconstantDesc(t)\n/*\nform->TABLE\ntableType->BASIC\ntype->DICTIONARY\ncategory->MIXED\nisTemporary->false\nisIndependent->true\nisReadonly->false\nisReadonlyArgument->false\nisStatic->false\nisTransient->false\ncopyOnWrite->false\nrefCount->1\naddress->0000000028d2d1e0\nrows->3\ncolumns->2\nmemoryAllocated->208\n*/\n\n\nconstantDesc(lj)\n/*\nform->SCALAR\ntype->FUNCTIONDEF\nfunctionDefType->SYSTEM FUNCTION\ncategory->SYSTEM\nisTemporary->true\nisIndependent->true\nisReadonly->false\nisReadonlyArgument->false\nisStatic->false\nisTransient->false\ncopyOnWrite->false\nrefCount->6\naddress->000000000cabce00\nrows->1\ncolumns->1\nmemoryAllocated->10\n*/\n```\n"
    },
    "contextCount": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/contextCount.html",
        "signatures": [
            {
                "full": "contextCount(X, Y)",
                "name": "contextCount",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [contextCount](https://docs.dolphindb.cn/zh/funcs/c/contextCount.html)\n\n\n\n#### 语法\n\ncontextCount(X, Y)\n\n#### 详情\n\n计算 *X* 和 *Y* 中相同位置都不为 NULL 的元素个数。\n\n#### 参数\n\n**X** 和 **Y** 必须是相同长度的向量。\n\n#### 返回值\n\nINT 类型标量。\n\n#### 例子\n\n```\ncontextCount(1 2 3, 1 NULL 3)\n// output\n2\n\ncontextCount(1..3,true false true)\n// output\n3\n\ncontextCount(1 2 NULL, 1 NULL 3)\n// output\n1\n```\n\n相关函数：[contextSum](https://docs.dolphindb.cn/zh/funcs/c/contextSum.html), [contextSum2](https://docs.dolphindb.cn/zh/funcs/c/contextSum2.html)\n"
    },
    "contextSum": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/contextSum.html",
        "signatures": [
            {
                "full": "contextSum(X, Y)",
                "name": "contextSum",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [contextSum](https://docs.dolphindb.cn/zh/funcs/c/contextSum.html)\n\n\n\n#### 语法\n\ncontextSum(X, Y)\n\n#### 详情\n\n找出 *X* 和 *Y* 中元素都不为 NULL 的位置，并计算 *X* 中这些位置对应的元素的和。\n\n#### 参数\n\n**X** 和 **Y** 是向量、矩阵或表。\n\n#### 返回值\n\nLONG/DOUBLE 类型标量/向量/表。\n\n#### 例子\n\n```\ncontextSum(1 2 3 4 5, 2 3 4 5 6)\n// output\n15\n\ncontextSum(1..3, true false true)\n// output\n6\n\ncontextSum(1 2 NULL, 1 NULL 3)\n// output\n1\n```\n\n相关函数：[contextCount](https://docs.dolphindb.cn/zh/funcs/c/contextCount.html), [contextSum2](https://docs.dolphindb.cn/zh/funcs/c/contextSum2.html)\n"
    },
    "contextSum2": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/contextSum2.html",
        "signatures": [
            {
                "full": "contextSum2(X, Y)",
                "name": "contextSum2",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [contextSum2](https://docs.dolphindb.cn/zh/funcs/c/contextSum2.html)\n\n\n\n#### 语法\n\ncontextSum2(X, Y)\n\n#### 详情\n\n找出 *X* 和 *Y* 中元素都不为 NULL 的位置，并计算 *X* 中这些位置对应的元素的平方和。\n\n即使 *X* 的数据类型是 INT 或 LONG，返回结果的数据类型总是 DOUBLE 类型。\n\n#### 参数\n\n**X** 和 **Y** 是向量、矩阵或表。\n\n#### 返回值\n\nDOUBLE 类型标量/向量/表。\n\n#### 例子\n\n```\ncontextSum2(1 2 3, 10 NULL 30);\n// output\n10\n\ncontextSum2(1 2 3, true false true);\n// output\n14\n```\n\n相关函数：[contextCount](https://docs.dolphindb.cn/zh/funcs/c/contextCount.html), [contextSum](https://docs.dolphindb.cn/zh/funcs/c/contextSum.html)\n"
    },
    "convertEncode": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/convertEncode.html",
        "signatures": [
            {
                "full": "convertEncode(str, srcEncode, destEncode)",
                "name": "convertEncode",
                "parameters": [
                    {
                        "full": "str",
                        "name": "str"
                    },
                    {
                        "full": "srcEncode",
                        "name": "srcEncode"
                    },
                    {
                        "full": "destEncode",
                        "name": "destEncode"
                    }
                ]
            }
        ],
        "markdown": "### [convertEncode](https://docs.dolphindb.cn/zh/funcs/c/convertEncode.html)\n\n\n\n#### 语法\n\nconvertEncode(str, srcEncode, destEncode)\n\n#### 详情\n\n转换字符串编码。DolphinDB 对编码名称的大小写敏感，所有编码名称必须用小写表示。\n\nWindow 版本目前仅支持 gbk 和 utf-8 两种编码的相互转换。Linux 版本支持任意两种编码之间的转换。\n\n#### 参数\n\n**str** 是一个字符串标量/向量，值为字符串类型的字典，或表。\n\n**srcEncode** 是一个字符串，表示 *str* 原来的编码名称。\n\n**destEncode** 是一个字符串，表示 *str* 的目标编码名称。\n\n#### 返回值\n\nSTRING 类型标量/向量/字典/表。\n\n#### 例子\n\n```\nconvertEncode(\"高性能分布式时序数据库\",\"utf-8\",\"gbk\");\n// output: 高性能分布式时序数据库\n\nconvertEncode([\"hello\",\"DolphinDB\"],\"gbk\",\"utf-8\");\n// output: [\"hello\",\"DolphinDB\"]\n```\n\n`convertEncode` 可以对字典中的符串类型的值进行转换。\n\n```\nx=1 2 3\ny= `C1`C2`D1\nd=dict(x,y)\nconvertEncode(d, \"UTF-8\", \"GBK\")\n// output: \n1: C1\n2: C2\n3: D1\n*/\n```\n\n`convertEncode` 函数会自动识别并转换表中所有字符串类型的列，其他数据类型的列将被自动忽略。\n\n```\nt=table([\"t1\", \"t1\", \"t2\", \"t3\"] as type, [11, 11.5, 10, 14] as price)\nconvertEncode(t, \"UTF-8\", \"GBK\")\n```\n\n| type | price |\n| ---- | ----- |\n| t1   | 11    |\n| t1   | 11.5  |\n| t2   | 10    |\n| t3   | 14    |\n\n相关函数：[fromUTF8](https://docs.dolphindb.cn/zh/funcs/f/fromUTF8.html), [toUTF8](https://docs.dolphindb.cn/zh/funcs/t/toUTF8.html)\n"
    },
    "convertExcelFormula": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/convertExcelFormula.html",
        "signatures": [
            {
                "full": "convertExcelFormula(formula, colStart, colEnd, rowStart, rowEnd)",
                "name": "convertExcelFormula",
                "parameters": [
                    {
                        "full": "formula",
                        "name": "formula"
                    },
                    {
                        "full": "colStart",
                        "name": "colStart"
                    },
                    {
                        "full": "colEnd",
                        "name": "colEnd"
                    },
                    {
                        "full": "rowStart",
                        "name": "rowStart"
                    },
                    {
                        "full": "rowEnd",
                        "name": "rowEnd"
                    }
                ]
            }
        ],
        "markdown": "### [convertExcelFormula](https://docs.dolphindb.cn/zh/funcs/c/convertExcelFormula.html)\n\n\n\n#### 语法\n\nconvertExcelFormula(formula, colStart, colEnd, rowStart, rowEnd)\n\n#### 详情\n\n将 Excel 表达式转换为对应的 DolphinDB 表达式。\n\n该函数目前只支持包含四则运算，逻辑运算，聚合函数的转换。\n\n该函数目前不支持对行和列同时操作的表达式的转换。聚合函数对单列进行计算时，如果处理的行数与实际的行数相同，则将该列进行聚合操作；如果处理行数与实际行数不同，则进行移动聚合操作。\n\n#### 参数\n\n**formula** 是字符串标量或向量，表示 Excel 公式。\n\n**colStart** 是字符串标量，表示数据在 Excel 中起始列。\n\n**colEnd** 是字符串标量，表示数据在 Excel 中结束列。\n\n**rowStart** 是整型标量，表示数据在 Excel 中起始行。*rowStart* 值应大于0。\n\n**rowEnd** 是整型标量，表示数据在 Excel 中起始行。*rowEnd* 值应大于等于 *rowStart*。\n\n#### 返回值\n\nSTRING 类型标量或向量。\n\n#### 例子\n\n```\nconvertExcelFormula(\"A2+B2\", \"A\", \"Z\", 2, 10);\n// output\ncol0+col1\n\nconvertExcelFormula(\"SUM(A2:C2)\", \"A\", \"Z\", 2, 10);\n// output\nrowSum(col0, col1, col2)\n\nconvertExcelFormula(\"SUM(A2)\", \"A\", \"Z\", 2, 10);\n// output\ncumsum(col0)\n\nconvertExcelFormula(\"SUM(A2:A5)\", \"A\", \"Z\", 2, 10);\n// output\nmsum(col0, 4)\n\nconvertExcelFormula(\"SUM(A2:A10)\", \"A\", \"Z\", 2, 10);\n// output\nsum(col0)\n\nconvertExcelFormula([\"=SUM(A1:A10)\",\"IF(A1>0,B1,0\"], \"A\", \"D\", 1, 10)\n// output\n[\"sum(col0)\",\"iif(col0>0,col1,0)\"]\n```\n"
    },
    "convertTZ": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/convertTZ.html",
        "signatures": [
            {
                "full": "convertTZ(obj, srcTZ, destTZ)",
                "name": "convertTZ",
                "parameters": [
                    {
                        "full": "obj",
                        "name": "obj"
                    },
                    {
                        "full": "srcTZ",
                        "name": "srcTZ"
                    },
                    {
                        "full": "destTZ",
                        "name": "destTZ"
                    }
                ]
            }
        ],
        "markdown": "### [convertTZ](https://docs.dolphindb.cn/zh/funcs/c/convertTZ.html)\n\n\n\n#### 语法\n\nconvertTZ(obj, srcTZ, destTZ)\n\n#### 详情\n\n把 *srcTZ* 时区的时间 *obj* 转换成 *destTZ* 时区的时间。\n\n#### 参数\n\n**obj** 可以是 DATETIME, TIMESTAMP, NANOTIMESTAMP 类型的时间标量或向量。\n\n**srcTZ** 和 **destTZ** 都是字符串，表示时区。\n\n#### 返回值\n\n返回一个与输入 *obj* 相同数据类型和形式的对象。\n\n#### 例子\n\n```\nconvertTZ(2016.04.25T08:25:45,\"US/Eastern\",\"Asia/Shanghai\");\n// output\n2016.04.25T20:25:45\n```\n"
    },
    "copy": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/copy.html",
        "signatures": [
            {
                "full": "copy(obj)",
                "name": "copy",
                "parameters": [
                    {
                        "full": "obj",
                        "name": "obj"
                    }
                ]
            }
        ],
        "markdown": "### [copy](https://docs.dolphindb.cn/zh/funcs/c/copy.html)\n\n\n\n#### 语法\n\ncopy(obj)\n\n#### 详情\n\n返回 *obj* 的浅拷贝。即复制最外层结构，内部子对象仍与原对象共享引用。\n\n`copy`（浅拷贝）和 `deepCopy`（深拷贝）的区别主要体现在嵌套结构（如元组或 ANY 类型字典）中：\n\n* 使用 `copy` 时，子对象的引用会被共享（即子对象的地址保持不变）。\n* 使用 `deepCopy` 时，所有子对象都会被递归复制，引用也会完全分离。\n\n**Note:**\n\nDolphinDB 中的 copy 函数只支持浅拷贝；而 [pandas.DataFrame.copy](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.copy.html) 函数支持深拷贝和浅拷贝（通过 *deep* 参数控制）。\n\n#### 参数\n\n**obj** 可以是任意数据类型。\n\n#### 返回值\n\n返回 *obj* 的浅拷贝对象。\n\n#### 例子\n\n例1. 拷贝向量\n\n```\nx = 1 2 3\na = x.copy()\nb = x.deepCopy();\n\nprint constantDesc(x[0]).address  // 000000000dd3d640\nprint constantDesc(a[0]).address  // 000000000cb5a4c0\nprint constantDesc(b[0]).address  // 000000000de92c20\n```\n\n例2. 拷贝元组\n\n```\nx = ([[1, 2], [3, 4]], \"a\")\na = x.copy()\nb = x.deepCopy();\n\nprint constantDesc(x[0]).address  // 000000000c7ce880\nprint constantDesc(a[0]).address  // 000000000c7ce880\nprint constantDesc(b[0]).address  // 000000000c89be00\n```\n\n例3. 拷贝 ANY 字典\n\n```\ny = dict(`A`B`C, (1 2, 3 4, 5 6))\nc = y.copy()\nd = y.deepCopy();\n\nprint constantDesc(y[`A]).address  // 000000000c88c450\nprint constantDesc(c[`A]).address  // 000000000c88c450\nprint constantDesc(d[`A]).address  // 000000000c7cde00\n```\n\n相关函数：[asis](https://docs.dolphindb.cn/zh/funcs/a/asIs.html), [deepCopy](https://docs.dolphindb.cn/zh/funcs/d/deepCopy.html)\n"
    },
    "copyReplicas": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/copyReplicas.html",
        "signatures": [
            {
                "full": "copyReplicas(srcNode, destNode, chunkId)",
                "name": "copyReplicas",
                "parameters": [
                    {
                        "full": "srcNode",
                        "name": "srcNode"
                    },
                    {
                        "full": "destNode",
                        "name": "destNode"
                    },
                    {
                        "full": "chunkId",
                        "name": "chunkId"
                    }
                ]
            }
        ],
        "markdown": "### [copyReplicas](https://docs.dolphindb.cn/zh/funcs/c/copyReplicas.html)\n\n\n\n#### 语法\n\ncopyReplicas(srcNode, destNode, chunkId)\n\n#### 详情\n\n把源节点上的一个或多个 chunk 的副本复制到目标节点。如果目标节点上已经存在该 chunk，那么系统将忽略本次操作。该命令只能由管理员在控制节点上执行。\n\n通过 [getRecoveryTaskStatus](https://docs.dolphindb.cn/zh/funcs/g/getRecoveryTaskStatus.html) 函数可以查看任务状态。\n\n#### 参数\n\n**srcNode** 是一个字符串，表示源节点的别名。\n\n**destNode** 是一个字符串，表示目标节点的别名。\n\n**chunkId** 是字符串标量或向量，表示 chunk 的 ID。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n把 \"node1\" 上所有 chunk 的副本复制到 \"node2\"。\n\n```\nchunkIds=exec chunkId from pnodeRun(getChunksMeta) where node=\"node1\"\ncopyReplicas(\"node1\", \"node2\", string(chunkIds));\n```\n"
    },
    "corr": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/corr.html",
        "signatures": [
            {
                "full": "corr(X,Y)",
                "name": "corr",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [corr](https://docs.dolphindb.cn/zh/funcs/c/corr.html)\n\n\n\n#### 语法\n\ncorr(X,Y)\n\n#### 详情\n\n计算 *X* 和 *Y* 之间的相关性（correlation）。\n\n当 *X* 或 *Y* 的方差小于10^-12 时，方差会被视为 0，此时 `corr` 的计算结果为 NULL。\n\n#### 参数\n\n**Y** 和 **X** 是相同长度的数值型向量、维度相同的矩阵或表。若 *X* 是表，只对其内数值型和布尔型的列进行计算。\n\n#### 返回值\n\nDOUBLE 类型标量/向量/表。\n\n#### 例子\n\n```\nx = 7 4 5 8 9 3 3 5 2 6 12 1 0 -5 32\ny=1.1 7 8 9 9 5 4 8.6 2 1 -9 -3 5 8 13\ncorr(x,y);\n// output\n0.238769\n```\n"
    },
    "corrMatrix": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/corrMatrix.html",
        "signatures": [
            {
                "full": "corrMatrix(X)",
                "name": "corrMatrix",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [corrMatrix](https://docs.dolphindb.cn/zh/funcs/c/corrMatrix.html)\n\n\n\n#### 语法\n\ncorrMatrix(X)\n\n#### 详情\n\n设矩阵 *X* 有 n 列，将其每一列作为一维向量，求 n 维向量的相关矩阵（correlation matrix）。\n\n**Note:**\n\n* 如果矩阵中含有空值，会默认将空值转化为0，然后进行计算。而由于 [corr](https://docs.dolphindb.cn/zh/funcs/c/corr.html) 函数计算时忽略 NULL 值，因此调用 [cross/pcross(corr, X)](https://docs.dolphindb.cn/zh/funcs/ho_funcs/cross.html) 函数计算相关矩阵时也会忽略 NULL 值。\n* 在不含 NULL 值的情况下，虽然该函数计算结果等价于 `cross(corr, X)`，但该函数内部进行了优化，其性能较 [cross/pcross(corr, X)](https://docs.dolphindb.cn/zh/funcs/ho_funcs/cross.html) 函数有大幅提升。\n\n#### 参数\n\n**X** 是一个矩阵。\n\n#### 返回值\n\nDOUBLE 类型矩阵。\n\n#### 例子\n\n```\nm = rand(10.0, 30)$10:3\ncorrMatrix(m)\n```\n\n输出返回：\n\n| #0                | #1                | #2                |\n| ----------------- | ----------------- | ----------------- |\n| 1                 | 0.167257129736134 | 0.224955585716037 |\n| 0.167257129736134 | 1                 | -0.12066768907057 |\n| 0.224955585716037 | -0.12066768907057 | 1                 |\n\n```\na = rand(1.0, 30000000).reshape(10000:3000)\na.rename!(\"s\" + string(1..3000))\ntimer corrMatrix(a)\n```\n\n输出返回：Time elapsed: 2986.932 ms\n\n```\ntimer pcross(corr, a)\n```\n\n输出返回：Time elapsed: 45629.6 ms\n\n相关函数： [covarMatrix](https://docs.dolphindb.cn/zh/funcs/c/covarMatrix.html)\n"
    },
    "cos": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cos.html",
        "signatures": [
            {
                "full": "cos(X)",
                "name": "cos",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [cos](https://docs.dolphindb.cn/zh/funcs/c/cos.html)\n\n\n\n#### 语法\n\ncos(X)\n\n#### 详情\n\n返回 *X* 的余弦。\n\n**Note:**\n\n* 与 [numpy.cos](https://numpy.com.cn/doc/stable/reference/generated/numpy.cos.html) 的功能相同，区别在于 DolphinDB `cos` 只接受一个参数 *X*，不支持 `numpy.cos` 中的 *out*、*where* 等参数。\n* 与 TA-Lib `COS` 的功能相同，区别在于 DolphinDB `cos` 接受标量、向量、矩阵作为输入参数，而 TA-Lib `COS` 主要面向一维 NumPy 数组设计，不支持标量或矩阵输入。\n\n#### 参数\n\n**X** 可以是标量、向量或矩阵。\n\n#### 返回值\n\nDOUBLE 类型标量、向量或矩阵。\n\n#### 例子\n\n```\ncos 0 1 2;\n// output\n[1,0.540302,-0.416147]\n```\n\n相关函数：[asin](https://docs.dolphindb.cn/zh/funcs/a/asin.html), [acos](https://docs.dolphindb.cn/zh/funcs/a/acos.html), [atan](https://docs.dolphindb.cn/zh/funcs/a/atan.html), [sin](https://docs.dolphindb.cn/zh/funcs/s/sin.html), [tan](https://docs.dolphindb.cn/zh/funcs/t/tan.html), [asinh](https://docs.dolphindb.cn/zh/funcs/a/asinh.html), [acosh](https://docs.dolphindb.cn/zh/funcs/a/acosh.html), [atanh](https://docs.dolphindb.cn/zh/funcs/a/atanh.html), [sinh](https://docs.dolphindb.cn/zh/funcs/s/sinh.html), [cosh](https://docs.dolphindb.cn/zh/funcs/c/cosh.html), [tanh](https://docs.dolphindb.cn/zh/funcs/t/tanh.html)\n"
    },
    "cosh": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cosh.html",
        "signatures": [
            {
                "full": "cosh(X)",
                "name": "cosh",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [cosh](https://docs.dolphindb.cn/zh/funcs/c/cosh.html)\n\n\n\n#### 语法\n\ncosh(X)\n\n#### 详情\n\n返回 *X* 的双曲余弦。\n\n**Note:**\n\n* 与 [numpy.cosh](https://numpy.com.cn/doc/stable/reference/generated/numpy.cosh.html) 的功能相同，区别在于 DolphinDB `cosh` 只接受一个参数 *X*，不支持 `numpy.cosh` 中的 *out*、*where* 等参数。\n* 与 TA-Lib `COSH` 的功能相同，区别在于 DolphinDB `cosh` 接受标量、向量、矩阵作为输入参数，而 TA-Lib `COSH` 主要面向一维 NumPy 数组设计，不支持标量或矩阵输入。\n\n#### 参数\n\n**X** 可以是标量、向量或矩阵。\n\n#### 返回值\n\nDOUBLE 类型标量、向量或矩阵。\n\n#### 例子\n\n```\ncosh 0 1 2;\n// output\n[1,1.543081,3.762196]\n```\n\n相关函数：[asin](https://docs.dolphindb.cn/zh/funcs/a/asin.html), [acos](https://docs.dolphindb.cn/zh/funcs/a/acos.html), [atan](https://docs.dolphindb.cn/zh/funcs/a/atan.html), [sin](https://docs.dolphindb.cn/zh/funcs/s/sin.html), [cos](https://docs.dolphindb.cn/zh/funcs/c/cos.html), [tan](https://docs.dolphindb.cn/zh/funcs/t/tan.html), [asinh](https://docs.dolphindb.cn/zh/funcs/a/asinh.html), [acosh](https://docs.dolphindb.cn/zh/funcs/a/acosh.html), [atanh](https://docs.dolphindb.cn/zh/funcs/a/atanh.html), [sinh](https://docs.dolphindb.cn/zh/funcs/s/sinh.html), [tanh](https://docs.dolphindb.cn/zh/funcs/t/tanh.html)\n"
    },
    "cosine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cosine.html",
        "signatures": [
            {
                "full": "cosine(X, Y)",
                "name": "cosine",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [cosine](https://docs.dolphindb.cn/zh/funcs/c/cosine.html)\n\n首发版本：3.00.5，3.00.4.3\n\n\n\n#### 语法\n\ncosine(X, Y)\n\n#### 详情\n\n计算 *X* 和 *Y* 之间的余弦相似度，即 (X · Y) / (||X|| × ||Y||)。\n\n**Note:**\n\n与 SciPy 的 [scipy.spatial.distance.cosine](https://docs.scipy.org.cn/doc/scipy/reference/generated/scipy.spatial.distance.cosine.html) 函数的功能类似，区别在于：\n\n* DolphinDB 的 `cosine` 函数计算余弦相似度（值越大越相似），SciPy 的 `scipy.spatial.distance.cosine` 计算余弦距离（值越小越相似），两者的关系是余弦距离 = 1 - 余弦相似度。\n* `cosine` 只接受参数 *X*、*Y*，不支持 `scipy.spatial.distance.cosine` 中的权重参数参数 *w*。\n\n#### 参数\n\n**X** 和 **Y** 是长度相同的数值型向量。\n\n#### 返回值\n\nDOUBLE 类型标量，取值范围为 \\[-1, 1]。\n\n#### 例子\n\n```\nx = [1, 2, 3]  \ny = [4, 5, 6]  \ncosine(x, y);  \n// 输出：0.9746318\n```\n\n相关函数：[euclidean](https://docs.dolphindb.cn/zh/funcs/e/euclidean.html)、[minkowski](https://docs.dolphindb.cn/zh/funcs/m/minkowski.html)、[seuclidean](https://docs.dolphindb.cn/zh/funcs/s/seuclidean.html)、[mahalanobis](https://docs.dolphindb.cn/zh/funcs/m/mahalanobis.html)\n"
    },
    "count": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/count.html",
        "signatures": [
            {
                "full": "count(X)",
                "name": "count",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [count](https://docs.dolphindb.cn/zh/funcs/c/count.html)\n\n\n\n#### 语法\n\ncount(X)\n\n#### 详情\n\n[size](https://docs.dolphindb.cn/zh/funcs/s/size.html) 和 `count` 不同。`size` 返回向量/矩阵中元素的个数，而 `count` 返回向量/矩阵中非 NULL 的元素个数。`count` 可以用在 SQL 查询中，而 `size` 不可以。对于表而言，`size` 和 `count` 都返回行数。参见相关函数 [size](https://docs.dolphindb.cn/zh/funcs/s/size.html)。\n\n`count` 用于 SQL 查询时，有如下三种常见用法：\n\n* `select count(*) from pt` ：返回 pt 表中的数据条数。\n* `select count(1) from pt` ：若 pt 为空表，则返回1；否则返回 pt 表中数据涉及到的分区数量。\n* `select count(colName) from pt` ：返回列 colName 中的非空数据的个数。\n\n#### 参数\n\n**X** 可以是标量、向量、矩阵或表。\n\n#### 返回值\n\nINT 类型标量。\n\n#### 例子\n\n```\ncount(3 NULL 5 6);\n// output\n3\nsize(3 NULL 5 6);\n// output\n4\n\nm=1 2 3 NULL 4 5$2:3;\nm;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1  | 3  | 4  |\n| 2  |    | 5  |\n\n```\ncount(m);\n// output\n5\nsize(m);\n// output\n6\n\nt = table(1 NULL 3 as id, 3 NULL 9 as qty);\nt;\n```\n\n| id | qty |\n| -- | --- |\n| 1  | 3   |\n|    |     |\n| 3  | 9   |\n\n```\ncount(t);\n// output\n3\nsize(t);\n// output\n3\n```\n\n```\ndata = table(2023.10.01 + take(0..9,100) as date, take(['A','B','C','D'],100) as sym, 1..100 as val) \n\ndb = database(\"dfs://demo\",VALUE,2023.10.01..2023.10.10)\npt = db.createPartitionedTable(data,`pt,`date)//创建一个分区表\n \npt.append!(data)  //向表中插入数据\n\nselect count(*) from pt;//返回数据条数\n```\n\n| count |\n| ----- |\n| 100   |\n\n```\nselect count(1) from pt;//返回分区数\n```\n\n| count |\n| ----- |\n| 10    |\n\n如需查询分布式表的行数，必须在 SQL 查询中使用 `count`。单独对分布式表的句柄使用 `count`，返回结果始终为 0。\n\n正例：\n\n```\n// 例 1\nt=loadTable(\"dfs://csmar_l2\", `SSEL2_BOND_ORDER)\nselect count(*) from t // 输出一张包含 SSEL2_BOND_ORDER 行数的表\n// 例 2\nt=loadTable(\"dfs://csmar_l2\", `SSEL2_BOND_ORDER)\nt1=select * from t\nt1.count() // 输出 INT 类型的数值，表示 SSEL2_BOND_ORDER 的行数\n```\n\n反例：\n\n```\nt=loadTable(\"dfs://csmar_l2\", `SSEL2_BOND_ORDER)\nt.count() // 输出 0\n```\n"
    },
    "countNanInf": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/countNanInf.html",
        "signatures": [
            {
                "full": "countNanInf(X, [includeNull=false])",
                "name": "countNanInf",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[includeNull=false]",
                        "name": "includeNull",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [countNanInf](https://docs.dolphindb.cn/zh/funcs/c/countNanInf.html)\n\n\n\n#### 语法\n\ncountNanInf(X, \\[includeNull=false])\n\n#### 详情\n\n聚合函数，用于统计 *X* 中 NaN 或 Inf 值的数量。若 *includeNull* 设为 true，NULL 值也会被统计，默认为 false。\n\n#### 参数\n\n**X** 是 DOUBLE 类型 的标量/向量/矩阵。\n\n**includeNull** 是一个布尔值。\n\n#### 返回值\n\nINT 类型标量。\n\n#### 例子\n\n```\nx = [1.5, float(`nan), 2.3, float(`inf), NULL, 3.7]  \n  \n// includeNull = false (默认)，不统计 NULL 值  \ncountNanInf(x)  \n// output: 2\n\n// includeNull = true，统计 NULL 值 \ncountNanInf(x,true) \n// output: 3\n```\n\n相关函数：[isNanInf](https://docs.dolphindb.cn/zh/funcs/i/isNanInf.html)\n"
    },
    "covar": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/covar.html",
        "signatures": [
            {
                "full": "covar(X,Y)",
                "name": "covar",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [covar](https://docs.dolphindb.cn/zh/funcs/c/covar.html)\n\n\n\n#### 语法\n\ncovar(X,Y)\n\n别名：cov\n\n#### 详情\n\n计算 *X* 和 *Y* 的协方差（covariance）。\n\n#### 参数\n\n**Y** 和 **X** 是相同长度的数值型向量、维度相同的矩阵或表。若 *X* 是表，只对其内数值型和布尔型的列进行计算。\n\n#### 返回值\n\nDOUBLE 类型标量/向量/表。\n\n#### 例子\n\n```\nx=7 4 5 8 9 3 3 5 2 6 12 1 0 -5 32\ny=1.1 7 8 9 9 5 4 8.6 2 1 -9 -3 5 8 13\ncovar(x,y);\n// output\n10.881429\n```\n\n相关函数：[covarp](https://docs.dolphindb.cn/zh/funcs/c/covarp.html)\n"
    },
    "covarMatrix": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/covarMatrix.html",
        "signatures": [
            {
                "full": "covarMatrix(X)",
                "name": "covarMatrix",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [covarMatrix](https://docs.dolphindb.cn/zh/funcs/c/covarMatrix.html)\n\n\n\n#### 语法\n\ncovarMatrix(X)\n\n#### 详情\n\n设矩阵 *X* 有 n 列，将其每一列作为一维向量，求 n 维随机变量的协方差矩阵（covariance matrix）。\n\n**Note:**\n\n* 如果矩阵中含有空值，会默认将空值转化为0，然后进行计算。而由于 [covar](https://docs.dolphindb.cn/zh/funcs/c/covar.html) 函数计算时忽略 NULL 值，因此调用 [cross/pcross(covar, X)](https://docs.dolphindb.cn/zh/funcs/ho_funcs/cross.html) 函数计算相关矩阵时也会忽略 NULL 值。\n* 在不含 NULL 值的情况下，虽然该函数计算结果等价于 `cross(covar, X)`，但该函数内部进行了优化，其性能较 [cross/pcross](https://docs.dolphindb.cn/zh/funcs/ho_funcs/cross.html) 函数有大幅提升。\n\n#### 参数\n\n**X** 是一个矩阵。\n\n#### 返回值\n\nDOUBLE 类型矩阵。\n\n#### 例子\n\n```\nm = rand(10.0, 30)$10:3\ncovarMatrix(m)\n```\n\n| #0                | #1                 | #2                 |\n| ----------------- | ------------------ | ------------------ |\n| 6.116181845352529 | 1.107026927999891  | 1.306707566911273  |\n| 1.107026927999891 | 7.162534080771522  | -0.758517799304199 |\n| 1.306707566911273 | -0.758517799304199 | 5.516744365930221  |\n\n```\na = rand(1.0, 30000000).reshape(10000:3000)\na.rename!(\"s\" + string(1..3000))\ntimer covarMatrix(a)\n// output\nTime elapsed: 2927.264 ms\ntimer pcross(covar, a)\n// output\nTime elapsed: 29484.85 ms\n```\n\n相关函数： [corrMatrix](https://docs.dolphindb.cn/zh/funcs/c/corrMatrix.html)\n"
    },
    "covarp": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/covarp.html",
        "signatures": [
            {
                "full": "covarp(X, Y)",
                "name": "covarp",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [covarp](https://docs.dolphindb.cn/zh/funcs/c/covarp.html)\n\n首发版本：3.00.5\n\n\n\n#### 语法\n\ncovarp(X, Y)\n\n#### 详情\n\n计算 *X* 和 *Y* 的总体协方差。\n\n#### 参数\n\n**Y** 和 **X** 是标量、相同长度的数值型向量、维度相同的矩阵或表。若 *X* 是表，只对其内数值列进行计算。\n\n#### 返回值\n\n* 当 *X* 和 *Y* 均为标量或等长向量时，返回 DOUBLE 类型标量。\n\n* 当 *X* 或 *Y* 为矩阵时，返回 DOUBLE 类型向量。\n\n* 当*X* 或 *Y* 为表时，返回一个表。\n\n#### 例子\n\n```\nx = [100, 100, 100, 1100]\ny = [0.98, 0.95, 0.92, 0.88]\ncovarp(x,y);\n\n// output: -13.13\n\nx=matrix([0.010,  0.012, -0.005, 0.008], [0.009,  0.011, -0.004, 0.007], [0.011,  0.013, -0.006, 0.009])\ny=[0.008, 0.010, -0.003, 0.006]\ncovarp(x,y)\n\n// output: 3\n```\n\n相关函数：[covar](https://docs.dolphindb.cn/zh/funcs/c/covar.html)\n"
    },
    "crc32": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/crc32.html",
        "signatures": [
            {
                "full": "crc32(str, [cksum=0])",
                "name": "crc32",
                "parameters": [
                    {
                        "full": "str",
                        "name": "str"
                    },
                    {
                        "full": "[cksum=0]",
                        "name": "cksum",
                        "optional": true,
                        "default": "0"
                    }
                ]
            }
        ],
        "markdown": "### [crc32](https://docs.dolphindb.cn/zh/funcs/c/crc32.html)\n\n\n\n#### 语法\n\ncrc32(str, \\[cksum=0])\n\n#### 详情\n\n根据 CRC32 算法，对字符串进行哈希，生成 INT 类型数据。\n\n#### 参数\n\n**str** 是一个字符串标量、向量或表。\n\n**cksum** 是整型标量或向量。\n\n#### 返回值\n\nINT 类型标量/向量/表。\n\n#### 例子\n\n```\na=crc32(`aa`cc,1);\na;\n// output\n[512829590,-1029100744]\n\ntypestr(a);\n// output\nFAST INT VECTOR\n```\n"
    },
    "createAnomalyDetectionEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/createAnomalyDetectionEngine.html",
        "signatures": [
            {
                "full": "createAnomalyDetectionEngine(name, metrics, dummyTable, outputTable, timeColumn, [keyColumn], [windowSize], [step], [garbageSize], [roundTime=true], [snapshotDir], [snapshotIntervalInMsgCount], [raftGroup],[anomalyDescription])",
                "name": "createAnomalyDetectionEngine",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "metrics",
                        "name": "metrics"
                    },
                    {
                        "full": "dummyTable",
                        "name": "dummyTable"
                    },
                    {
                        "full": "outputTable",
                        "name": "outputTable"
                    },
                    {
                        "full": "timeColumn",
                        "name": "timeColumn"
                    },
                    {
                        "full": "[keyColumn]",
                        "name": "keyColumn",
                        "optional": true
                    },
                    {
                        "full": "[windowSize]",
                        "name": "windowSize",
                        "optional": true
                    },
                    {
                        "full": "[step]",
                        "name": "step",
                        "optional": true
                    },
                    {
                        "full": "[garbageSize]",
                        "name": "garbageSize",
                        "optional": true
                    },
                    {
                        "full": "[roundTime=true]",
                        "name": "roundTime",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[snapshotDir]",
                        "name": "snapshotDir",
                        "optional": true
                    },
                    {
                        "full": "[snapshotIntervalInMsgCount]",
                        "name": "snapshotIntervalInMsgCount",
                        "optional": true
                    },
                    {
                        "full": "[raftGroup]",
                        "name": "raftGroup",
                        "optional": true
                    },
                    {
                        "full": "[anomalyDescription]",
                        "name": "anomalyDescription",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [createAnomalyDetectionEngine](https://docs.dolphindb.cn/zh/funcs/c/createAnomalyDetectionEngine.html)\n\n\n\n#### 语法\n\ncreateAnomalyDetectionEngine(name, metrics, dummyTable, outputTable, timeColumn, \\[keyColumn], \\[windowSize], \\[step], \\[garbageSize], \\[roundTime=true], \\[snapshotDir], \\[snapshotIntervalInMsgCount], \\[raftGroup],\\[anomalyDescription])\n\n#### 详情\n\n创建异常检测引擎，返回一个表对象，向该表写入数据意味着将数据注入异常检测引擎进行计算。异常检测引擎会根据异常指标，对每条记录进行检测。\n\n异常检测引擎不支持在 *metrics* 中使用以下函数：`next`, `talibNull`, `linearTimeTrend`, `iterate`；亦不支持在序列相关函数内部嵌套聚合函数，如：`tmsum(sum())`。\n\n为了便于观察和对比计算结果，系统会对第一个数据窗口的起始时间进行调整。调整规则与 [createTimeSeriesEngine](https://docs.dolphindb.cn/zh/funcs/c/createTimeSeriesEngine.html) 相同。\n\n更多流数据引擎的应用场景说明可以参考 [流计算引擎](https://docs.dolphindb.cn/zh/funcs/themes/streamingEngine.html)。\n\n#### 计算规则\n\n异常检测引擎会根据不同类型的异常指标采用不同的计算规则。异常指标一般有以下三种类型：\n\n* 某个列与常量对比、列与列之间对比或非聚合函数中没有嵌套聚合函数，例如 qty < 4, qty > price, lt(qty, prev(qty)), isNull(qty) == false 等。对于这类指标，异常检测引擎会对每一条数据进行计算，判断是否符合条件并决定输出。\n* 聚合函数的结果与某个常量值对比、聚合函数结果之间的对比、非聚合函数中仅嵌套聚合函数和常量，例如 avg(qty - price) > 10, percentile(qty, 90) < 100, max(qty) < avg(qty) \\* 2, le(sum(qty), 5) 等。对于这类指标，异常检测引擎会在每个窗口计算时判断计算结果是否符合条件并决定输出。\n* 聚合函数的结果与列对比、非聚合函数中同时嵌套聚合函数和列，例如 avg(qty) > qty, le(med(qty), price) 等。对于这类指标，每当数据到达时，异常检测引擎会将数据与上一个计算窗口的聚合结果对比，判断计算结果是否符合条件并决定输出，直到触发下一次聚合计算。\n\n**Note:**\n\n* 当指标中包含聚合函数，则必须指定窗口长度（由参数 *windowSize* 设置）和计算的时间间隔（由参数 *step* 设置）。每隔一段时间，在固定长度的移动窗口中计算指标。为了便于观察和对比计算结果，系统会对第一个数据窗口的起始时间进行调整，起始窗口的规整规则同时间序列引擎。\n* 乱序数据处理规则：\n  * 如果需要聚合计算，输入流数据表中时间列（*timeColumn*）所指示的时间戳必须为非递减序列；如果同时指定了分组列（*keyColumn*），则按照分组分别进行计算，组内数据的时间戳必须为非递减序列。否则，乱序数据将被直接丢弃，不参与计算。\n  * 如果不需要聚合计算，引擎可以接收乱序数据。\n\n#### 引擎的其它功能\n\n* 支持数据/状态清理：若 *metrics* 参数指定的指标中使用了聚合函数或序列相关函数，异常检测引擎会保留历史数据，可通过配置 *garbageSize* 参数，使系统清理本次计算不需要的历史数据。若指定了 *keyColumn*，则各分组独立进行数据清理。\n* 快照机制：启用快照机制之后，系统若出现异常，可及时将流数据引擎恢复到最新的快照状态。（详情请参考 *snapshotDir* 和 *snapshotIntervalInMsgCount* 的参数说明）\n\n#### 参数\n\n**name** 字符串标量，表示异常检测引擎的名称，作为其在一个数据节点/计算节点上的唯一标识。可包含字母，数字和下划线，但必须以字母开头。\n\n**metrics** 以元代码或元组的格式表示异常指标，每个异常指标必须是布尔表达式，如<\\[sum(qty) > 5, avg(qty) > qty, qty < 4]>。有关元代码的更多信息可参考 [元编程](https://docs.dolphindb.cn/zh/progr/objs/meta_progr.html)。\n\n**Note:** *metrics* 中使用的列名大小写不敏感，不需要与输入表的列名大小写保持一致。\n\n**dummyTable** 一个表对象，和输入的流数据表的 schema 一致，可以含有数据，亦可为空表。\n\n**outputTable** 计算结果的输出表，可以是内存表或分布式表。在调用 `createAnomalyDetectionEngine` 函数之前，需要预先设立输出表。异常检测引擎会将计算结果注入该表。\n\n输出表的各列的顺序如下：\n\n(1) 时间列。其数据类型与 *dummyTable* 的时间列一致，用于存放检测到异常的时间戳。\n\n(2) 分组列。如果 *keyColumn* 不为空，则其后几列和 *keyColumn* 设置的列及其顺序保持一致。\n\n(3) 之后两列分别为 INT类型列 type 和 STRING / SYMBOL 类型列 metric，分别用于记录异常的类型（在 *metrics* 中的下标）和异常条件的内容。\n\n**timeColumn** 字符串标量，该参数用于指定订阅的流数据表中时间列的名称。\n\n**keyColumn** 可选参数，字符串标量或向量，表示分组列名。异常检测引擎会按照 *keyColumn* 对输入的数据分组，计算将在各分组分别进行。\n\n**windowSize** 可选参数，正整数。如果 *metrics* 中包含聚合函数，必须指定 *windowSize*，它表示计算的数据窗口的长度，数据窗口只包含上边界不包含下边界。如果 *metrics* 中不包含聚合函数，该参数无效。\n\n**step** 可选参数，正整数。如果 *metrics* 中包含聚合函数，必须指定 *step*，并且必须能够被 *windowSize* 整除，它表示计算的时间间隔。如果 *metrics* 中不包含聚合函数，该参数无效。\n\n**garbageSize** 可选参数，正整数。它是可选参数，默认值是 2,000（单位为行）。如果没有指定 *keyColumn*，当内存中历史数据的数量超过 *garbageSize* 时，系统会清理本次计算不需要的历史数据。如果指定了 *keyColumn*，意味着需要分组计算时，内存清理是各分组独立进行的。当一个组的历史数据记录数超出 *garbageSize* 时，会清理该组不再需要的历史数据。若一个组的历史数据记录数未超出 *garbageSize*，则该组数据不会被清理。如果 *metrics* 中没有聚合函数，这个参数不起作用。\n\n**roundTime** 可选参数，布尔值，表示若数据时间精度为毫秒或者秒且 *step* > 一分钟，如何对窗口边界值进行规整处理。默认值为 true，表示按照既定的多分钟规则（见以上表格）进行规整。若为 false，则按一分钟规则（见以上表格）进行窗口规整（详情参考 `规整规则表`）。\n\n若要开启快照机制 (snapshot)，必须指定 *snapshotDir* 与 *snapshotIntervalInMsgCount*。\n\n**snapshotDir** 可选参数，字符串，表示保存引擎快照的文件目录。\n\n* 指定的目录必须存在，否则系统会提示异常。\n* 创建流数据引擎时，如果指定了 *snapshotDir*，会检查该目录下是否存在快照。如果存在，会加载该快照，恢复引擎的状态。\n* 多个引擎可以指定同一个目录存储快照，用引擎的名称来区分快照文件。\n* 一个引擎的快照可能会使用三个文件名：\n* 临时存储快照信息：文件名为 \\<engineName>.tmp；\n* 快照生成并刷到磁盘：文件保存为 \\<engineName>.snapshot；\n* 存在同名快照：旧快照自动重命名为 \\<engineName>.old。\n\n**snapshotIntervalInMsgCount** 可选参数，为整数类型，表示每隔多少条数据保存一次流数据引擎快照。\n\n**raftGroup** 是流数据高可用订阅端 raft 组的 ID (大于1的整数，由流数据高可用相关的配置项 *streamingRaftGroups* 指定)。设置该参数表示开启计算引擎高可用。在 leader 节点创建流数据引擎后，会同步在 follower 节点创建该引擎。每次保存的 snapshot 也会同步到 follower。当 raft 组的 leader 节点宕机时，会自动切换新 leader 节点重新订阅流数据表。请注意，若要指定 *raftGroup*，必须同时指定 *snapshotDir*。\n\n注意，自 3.00.5 版本起，流计算引擎暂不支持高可用功能，*raftGroup* 参数将不生效。\n\n**anomalyDescription** 可选参数，字符串向量，长度和 *metrics* 中定义的指标数量相同。指定该参数后，输出表的最后一列将显示异常条件对应的字符串。\n\n#### 返回值\n\n一个表。\n\n#### 例子\n\n例1. 下面的例子使用 `createAnomalyDetectionEngine` 函数创建了一个表 engine，然后通过订阅流数据表 trades 把数据写入到 engine 中，按照 sym 列进行分组聚合运算，并把结果保存在表 outputTable 中。\n\n```\nshare streamTable(1000:0, `time`sym`qty, [TIMESTAMP, SYMBOL, INT]) as trades\nshare table(1000:0, `time`sym`type`metric, [TIMESTAMP, SYMBOL, INT, STRING]) as outputTable\nengine = createAnomalyDetectionEngine(name=\"anomalyDetection1\", metrics=<[sum(qty) > 5, avg(qty) > qty, qty < 4]>, dummyTable=trades, outputTable=outputTable, timeColumn=`time, keyColumn=`sym, windowSize=3, step=3)\nsubscribeTable(tableName=\"trades\", actionName=\"anomalyDetectionSub1\", offset=0, handler=append!{engine}, msgAsTable=true)\n\ndef writeData(n){\n     timev = 2018.10.08T01:01:01.001 + 1..n\n     symv =take(`A`B, n)\n     qtyv = n..1\n     insert into trades values(timev, symv, qtyv)\n}\n\nwriteData(6);\n\nselect * from trades;\n```\n\n| time                    | sym | qty |\n| ----------------------- | --- | --- |\n| 2018.10.08T01:01:01.002 | A   | 6   |\n| 2018.10.08T01:01:01.003 | B   | 5   |\n| 2018.10.08T01:01:01.004 | A   | 4   |\n| 2018.10.08T01:01:01.005 | B   | 3   |\n| 2018.10.08T01:01:01.006 | A   | 2   |\n| 2018.10.08T01:01:01.007 | B   | 1   |\n\n```\nselect * from outputTable;\n```\n\n| time                    | sym | type | metric         |\n| ----------------------- | --- | ---- | -------------- |\n| 2018.10.08T01:01:01.003 | A   | 0    | sum(qty) > 5   |\n| 2018.10.08T01:01:01.004 | A   | 1    | avg(qty) > qty |\n| 2018.10.08T01:01:01.005 | B   | 2    | qty < 4        |\n| 2018.10.08T01:01:01.006 | A   | 1    | avg(qty) > qty |\n| 2018.10.08T01:01:01.006 | A   | 2    | qty < 4        |\n| 2018.10.08T01:01:01.006 | B   | 0    | sum(qty) > 5   |\n| 2018.10.08T01:01:01.007 | B   | 1    | avg(qty) > qty |\n| 2018.10.08T01:01:01.007 | B   | 2    | qty < 4        |\n\n下面详细解释异常检测引擎的计算过程：\n\n(1) 指标 sum(qty) > 5 是聚合函数的结果与常量的对比，因此异常检测引擎会在每个窗口计算时进行检测。第一个数据窗口是 2018.10.08T01:01:01.000 到 2018.10.08T01:01:01.002，分别计算 A, B 的 sum(qty)，在 2018.10.08T01:01:01.003 时判断是否符合条件 sum(qty)>5，第二个数据窗口是 2018.10.08T01:01:01.003 到 2018.10.08T01:01:01.005，在 2018.10.08T01:01:01.006 时判断是否符合条件 sum(qty)>5，如此类推。\n\n(2) 指标 avg(qty) > qty 是聚合函数的结果与某列对比，因此每当数据到达时，异常检测引擎会将数据与上一个计算窗口的聚合结果对比，判断计算结果是否符合条件并决定输出，直到触发下一次聚合计算。第一个数据窗口是 2018.10.08T01:01:01.000 到 2018.10.08T01:01:01.002，分别计算 A, B 的 avg(qty)，2018.10.08T01:01:01.003 到 2018.10.08T01:01:01.005 之间的 qty 会与上一个窗口的 avg(qty) 比较，2018.10.08T01:01:01.005 时窗口发生移动，第二个数据窗口为 2018.10.08T01:01:01.003 到 2018.10.08T01:01:01.005，此时计算 A, B 的 avg(qty)，2018.10.08T01:01:01.006 到 2018.10.08T01:01:01.008 之间的 qty 会与上一个窗口的 avg(qty) 比较，如此类推。\n\n(3) 指标 qty < 4 是列与常量对比，因此每次数据进入时，异常检测引擎都会进行判断。\n\n例2. 下例通过 *anomalyDescription* 参数指定输出的异常指标对应的文字信息\n\n```\nshare streamTable(1000:0, `time`temp, [TIMESTAMP, DOUBLE]) as sensordata\n\nshare streamTable(1000:0, `time`anomalyType`anomalyString, [TIMESTAMP, INT, SYMBOL]) as outputTable\nengine = createAnomalyDetectionEngine(name = \"engineB\", metrics=<[temp > 65, temp > percentile(temp, 75)]>, dummyTable = sensordata, outputTable = outputTable, timeColumn = `time, windowSize = 6, step = 3, anomalyDescription=[\"The temperature is higher than 65°C\", \"The temperature is larger than 75% values of the last window\"])\nsubscribeTable(,tableName = \"sensordata\", actionName = \"sensorAnomalyDetection\", offset = 0, handler = append!{engine}, msgAsTable = true)\n\ntimev = 2018.10.08T01:01:01.001 + 1..10\ntempv = 59 66 57 60 63 51 53 52 56 55\ninsert into sensordata values(timev, tempv)\n\nsleep(10)\nselect * from outputTable\n```\n\n| time                    | anomalyType | anomalyString                                                |\n| ----------------------- | ----------- | ------------------------------------------------------------ |\n| 2018.10.08T01:01:01.003 | 0           | The temperature is higher than 65°C                          |\n| 2018.10.08T01:01:01.003 | 1           | The temperature is larger than 75% values of the last window |\n| 2018.10.08T01:01:01.005 | 1           | The temperature is larger than 75% values of the last window |\n| 2018.10.08T01:01:01.006 | 1           | The temperature is larger than 75% values of the last window |\n"
    },
    "createAsofJoinEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/createAsofJoinEngine.html",
        "signatures": [
            {
                "full": "createAsofJoinEngine(name, leftTable, rightTable, outputTable, metrics, matchingColumn, [timeColumn], [useSystemTime=false], [delayedTime], [garbageSize], [sortByTime], [outputElapsedMicroseconds=false], [snapshotDir], [snapshotIntervalInMsgCount])",
                "name": "createAsofJoinEngine",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "leftTable",
                        "name": "leftTable"
                    },
                    {
                        "full": "rightTable",
                        "name": "rightTable"
                    },
                    {
                        "full": "outputTable",
                        "name": "outputTable"
                    },
                    {
                        "full": "metrics",
                        "name": "metrics"
                    },
                    {
                        "full": "matchingColumn",
                        "name": "matchingColumn"
                    },
                    {
                        "full": "[timeColumn]",
                        "name": "timeColumn",
                        "optional": true
                    },
                    {
                        "full": "[useSystemTime=false]",
                        "name": "useSystemTime",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[delayedTime]",
                        "name": "delayedTime",
                        "optional": true
                    },
                    {
                        "full": "[garbageSize]",
                        "name": "garbageSize",
                        "optional": true
                    },
                    {
                        "full": "[sortByTime]",
                        "name": "sortByTime",
                        "optional": true
                    },
                    {
                        "full": "[outputElapsedMicroseconds=false]",
                        "name": "outputElapsedMicroseconds",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[snapshotDir]",
                        "name": "snapshotDir",
                        "optional": true
                    },
                    {
                        "full": "[snapshotIntervalInMsgCount]",
                        "name": "snapshotIntervalInMsgCount",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [createAsofJoinEngine](https://docs.dolphindb.cn/zh/funcs/c/createAsofJoinEngine.html)\n\n\n\n#### 语法\n\ncreateAsofJoinEngine(name, leftTable, rightTable, outputTable, metrics, matchingColumn, \\[timeColumn], \\[useSystemTime=false], \\[delayedTime], \\[garbageSize], \\[sortByTime], \\[outputElapsedMicroseconds=false], \\[snapshotDir], \\[snapshotIntervalInMsgCount])\n\n#### 详情\n\n创建流数据 asof join 引擎。返回一个左、右两表 asof join 后的表对象。注入 asof join 引擎的左、右两表将以 `matchingColumn` + `timeColumn` (或系统时间) 作为连接列，在右表中选取与连接列匹配的，在给定的左表时间戳前且最接近的记录。该引擎适用于两个数据源没有完全匹配的记录，需要按时间段作连接，以获取最新信息的场景。\n\n**Note:** asof join 左表和右表的数据必须按照时间顺序排序。\n\n* 如果没有指定 `delayedTime`，则当右表数据的最新时间大于左表数据的最新时间，才会触发 join, 计算输出。\n* 如果指定了 `delayedTime`，则当左表中数据最新时间与上一条未计算的时间差大于 *delayedTime* 设置值，或者左表中数据在经过 2 \\* *delayedTime* （小于2秒按2秒计算）后还没有 join 输出，就直接触发左右两表 join。\n\n更多流数据引擎的应用场景说明可以参考 [流计算引擎](https://docs.dolphindb.cn/zh/funcs/themes/streamingEngine.html)。\n\n#### 参数\n\n**name** 字符串标量，表示 asof join 引擎的名称，作为其在一个数据节点/计算节点上的唯一标识。可包含字母，数字和下划线，但必须以字母开头。\n\n**leftTable** 和 **rightTable** 表对象。结构必须与输入的的流数据表相同。从 2.00.11 版本开始左、右表支持 array vector 类型。\n\n**outputTable** 计算结果的输出表，可以是内存表或分布式表。从 2.00.11 版本开始输出表支持 array vector 类型。在使用 `createAsofJoinEngine` 函数之前，需要将输出表预先设立为一个空表，并指定各列列名以及数据类型。asof join 引擎会将计算结果注入该表。输出表的各列的顺序如下：\n\n1. 时间列。其中：\n   * 若 *useSystemTime* = true，为 TIMESTAMP 类型；\n   * 若 *useSystemTime* = false，数据类型与 *timeColumn* 列一致。\n2. 连接列。与 *matchingColumn* 中的列以及其顺序一致，可为多列。\n3. 计算结果列。可为多列。\n4. 耗时列。如果指定 *outputElapsedMicroseconds* = true，则指定一个 LONG 类型的列用于记录单次响应计算耗时（单位：微秒）。\n5. batchSize 列。如果指定 *outputElapsedMicroseconds* = true, 则指定一个 INT 类型的列，记录单次响应的数据条数。\n\n**metrics** 以元代码的格式表示计算指标，支持输入元组。有关元代码的更多信息可参考 [Metaprogramming](https://docs.dolphindb.cn/zh/progr/objs/meta_progr.html)。\n\n* 计算指标可以是一个或多个表达式、系统内置或用户自定义函数、一个常量标量/向量，但不能是聚合函数。当指定为常量向量时，对应的输出列必须设置为数组向量类型，例子参见 [createReactiveStateEngine](https://docs.dolphindb.cn/zh/funcs/c/createReactiveStateEngine.html) 中的例4。\n* *metrics* 内支持调用具有多个返回值的函数，且必须指定列名，例如 \\<func(price) as \\`col1\\`col2>。若在 *metrics* 指定了 *leftTable* 和 *rightTable* 中具有相同名称的列，默认取左表的列，可以通过 \"tableName.colName\" 指定该列来自哪个表。\n\n  **Note:** *metrics* 中使用的列名大小写不敏感，不需要与输入表的列名大小写保持一致。\n\n**matchingColumn** 表示连接列的字符串标量/向量/字符串组成的 tuple，支持 Integral, Temporal 或 Literal（UUID 除外）类型。*matchingColumn* 指定规则为：\n\n1. 只有一个连接列：当左表和右表的连接列名相同时，*matchingColumn* 是一个字符串标量，否则是一个长度为 2 的 tuple，例如：左表连接列名为 sym，右表连接列名为 sym1，则 *matchingColumn* = \\[\\[\\`sym],\\[\\`sym1]]。\n2. 有多个连接列：当左表和右表的连接列名相同时，*matchingColumn* 是一个字符串向量，否则是一个长度为 2 的 tuple，例如：左表连接列名为 orderNo, sym，右表连接列名为 orderNo, sym1，则 *matchingColumn* = \\[\\[\\`orderNo, \\`sym], \\[\\`orderNo,\\`sym1]]。\n\n**timeColumn** 可选参数，字符串标量或向量。当 *useSystemTime* = false 时，指定要连接的两个表中时间列的名称。 *leftTable* 和 *rightTable* 时间列名称可以不同，但数据类型需保持一致。当 *leftTable* 和 *rightTable* 时间列名称不同时，*timeColumn* 为一个长度为2的字符串向量。\n\n**useSystemTime** 可选参数，布尔值。表示是否使用数据注入引擎时的系统时间作为时间列进行计算。\n\n* 当 *useSystemTime* = true 时，按照数据进入引擎的时刻（毫秒精度的本地系统时间，与数据中的时间列无关）进行计算。\n* 当 *useSystemTime* = false（缺省值）时，按照数据中的时间列进行计算。\n\n**delayedTime** 可选参数，正整数，单位同 timeColumn 精度一致。表示左表中未联结数据被触发联结并计算输出的最大等待时间。要设置 *delayedTime*， 必须指定 *timeColumn*，更多介绍见详情。\n\n**garbageSize** 可选参数，正整数，默认值是 5,000（单位为行）。随着订阅的流数据不断注入 asof join 引擎，存放在内存中的数据会越来越多，当各分组对应的缓存表（左表或右表）中数据行数超过 *garbageSize* 值时，系统会清理该表中已经触发计算的历史数据。\n\n**sortByTime** 布尔值，表示是否按全局时间顺序输出数据。默认值为 false，表示不按全局时间输出数据，仅在组内按时间顺序输出数据。\n\n**Note:** 当设置 *sortByTime* = true 时，必须保证输入的左表和右表的数据分别全局有序，且不可设置 *delayedTime*。\n\n**outputElapsedMicroseconds** 布尔值，表示是否输出数据的单次响应计算耗时（从触发计算的数据注入引擎到计算完成的耗时），默认为 false。指定参数 *outputElapsedMicroseconds* 后，在定义 *outputTable* 时需要在计算结果列后增加一个 LONG 类型的列和 INT 类型的列，详见 *outputTable* 参数说明。\n\n若要开启快照机制 (snapshot)，必须指定 *snapshotDir* 与 *snapshotIntervalInMsgCount*。\n\n**snapshotDir** 可选参数，字符串，表示保存引擎快照的文件目录。\n\n* 指定的目录必须存在，否则系统会提示异常。\n* 创建流数据引擎时，如果指定了 *snapshotDir*，会检查该目录下是否存在快照。如果存在，会加载该快照，恢复引擎的状态。\n* 多个引擎可以指定同一个目录存储快照，用引擎的名称来区分快照文件。\n* 一个引擎的快照可能会使用三个文件名：\n* 临时存储快照信息：文件名为 \\<engineName>.tmp；\n* 快照生成并刷到磁盘：文件保存为 \\<engineName>.snapshot；\n* 存在同名快照：旧快照自动重命名为 \\<engineName>.old。\n\n**snapshotIntervalInMsgCount** 可选参数，为整数类型，表示每隔多少条数据保存一次流数据引擎快照。\n\n#### 返回值\n\n一个表。\n\n#### 例子\n\n```\nshare streamTable(1:0, `time`sym`price, [TIMESTAMP, SYMBOL, DOUBLE]) as trades\nshare streamTable(1:0, `time`sym`bid`ask, [TIMESTAMP, SYMBOL, DOUBLE, DOUBLE]) as quotes\nshare table(100:0, `time`sym`price`bid`ask`spread, [TIMESTAMP, SYMBOL, DOUBLE, DOUBLE, DOUBLE, DOUBLE]) as prevailingQuotes\n\najEngine=createAsofJoinEngine(name=\"aj1\", leftTable=trades, rightTable=quotes, outputTable=prevailingQuotes, metrics=<[price, bid, ask, abs(price-(bid+ask)/2)]>, matchingColumn=`sym, timeColumn=`time, useSystemTime=false)\ntmp1=table(2020.08.27T09:30:00.000+2 8 20 22 23 24 as time, take(`A`B, 6) as sym, 20.01 20.04 20.07 20.08 20.4 20.5 as price)\ntmp2=table(2020.08.27T09:30:00.000+1 5 6 11 19 20 21 as time, take(`A`B, 7) as sym, 20 20.02 20.03 20.05 20.06 20.6 20.4 as bid,  20.01 20.03 20.04 20.06 20.07 20.5 20.6 as ask)\ntmp1.sortBy!(`time)\ntmp2.sortBy!(`time)\n\nsubscribeTable(tableName=\"trades\", actionName=\"joinLeft\", offset=0, handler=appendForJoin{ajEngine, true}, msgAsTable=true)\nsubscribeTable(tableName=\"quotes\", actionName=\"joinRight\", offset=0, handler=appendForJoin{ajEngine, false}, msgAsTable=true)\n\ntrades.append!(tmp1)\nquotes.append!(tmp2)\n\nsleep(100)\nselect time, sym, bid from prevailingQuotes\n```\n\n| time                    | sym | bid   |\n| ----------------------- | --- | ----- |\n| 2020.08.27T09:30:00.002 | A   | 20    |\n| 2020.08.27T09:30:00.020 | A   | 20.06 |\n| 2020.08.27T09:30:00.008 | B   | 20.02 |\n\n```\n// 清理引擎及变量\nunsubscribeTable(tableName=\"trades\", actionName=\"joinLeft\")\nunsubscribeTable(tableName=\"quotes\", actionName=\"joinRight\")\nundef(`trades,SHARED)\nundef(`quotes,SHARED)\ndropAggregator(name=\"aj1\")\n\n// 定义引擎，设置 sortByTime=true\nshare streamTable(1:0, `time`sym`price, [TIMESTAMP, SYMBOL, DOUBLE]) as trades\nshare streamTable(1:0, `time`sym`bid`ask, [TIMESTAMP, SYMBOL, DOUBLE, DOUBLE]) as quotes\nshare table(100:0, `time`sym`price`bid`ask`spread, [TIMESTAMP, SYMBOL, DOUBLE, DOUBLE, DOUBLE, DOUBLE]) as prevailingQuotes\najEngine=createAsofJoinEngine(name=\"aj1\", leftTable=trades, rightTable=quotes, outputTable=prevailingQuotes, metrics=<[price, bid, ask, abs(price-(bid+ask)/2)]>, matchingColumn=`sym, timeColumn=`time, useSystemTime=false, sortByTime=true)\n\ntmp1=table(2020.08.27T09:30:00.000+2 8 20 22 23 24 as time, take(`A`B, 6) as sym, 20.01 20.04 20.07 20.08 20.4 20.5 as price)\ntmp2=table(2020.08.27T09:30:00.000+1 5 6 11 19 20 21 as time, take(`A`B, 7) as sym, 20 20.02 20.03 20.05 20.06 20.6 20.4 as bid,  20.01 20.03 20.04 20.06 20.07 20.5 20.6 as ask)\ntmp1.sortBy!(`time)\ntmp2.sortBy!(`time)\n// 只能使用 appendForJoin 插入数据\nsubscribeTable(tableName=\"trades\", actionName=\"joinLeft\", offset=0, handler=appendForJoin{ajEngine, true}, msgAsTable=true)\nsubscribeTable(tableName=\"quotes\", actionName=\"joinRight\", offset=0, handler=appendForJoin{ajEngine, false}, msgAsTable=true)\n\ntrades.append!(tmp1)\nquotes.append!(tmp2)\n\nsleep(100)\n// 查看结果表，数据按照全局时间顺序输出\nselect time, sym, bid from prevailingQuotes\n```\n\n| time                    | sym | bid   |\n| ----------------------- | --- | ----- |\n| 2020.08.27T09:30:00.002 | A   | 20    |\n| 2020.08.27T09:30:00.008 | B   | 20.02 |\n| 2020.08.27T09:30:00.020 | A   | 20.06 |\n"
    },
    "createCatalog": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/createCatalog.html",
        "signatures": [
            {
                "full": "createCatalog(catalog)",
                "name": "createCatalog",
                "parameters": [
                    {
                        "full": "catalog",
                        "name": "catalog"
                    }
                ]
            }
        ],
        "markdown": "### [createCatalog](https://docs.dolphindb.cn/zh/funcs/c/createCatalog.html)\n\n\n\n#### 语法\n\ncreateCatalog(catalog)\n\n#### 详情\n\n创建一个 catalog。\n\n#### 参数\n\n**catalog** 字符串标量，表示 catalog 的名称。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\ncreateCatalog(\"catalog1\")\n```\n"
    },
    "createCEPEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/createCEPEngine.html",
        "signatures": [
            {
                "full": "createCEPEngine(name, monitors, dummyTable, eventSchema, [deserializeParallelism=1], [timeColumn], [eventQueueDepth=1024], [outputTable], [dispatchKey], [dispatchBucket], [useSystemTime=true], [eventTimeField=\"eventTime\"])",
                "name": "createCEPEngine",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "monitors",
                        "name": "monitors"
                    },
                    {
                        "full": "dummyTable",
                        "name": "dummyTable"
                    },
                    {
                        "full": "eventSchema",
                        "name": "eventSchema"
                    },
                    {
                        "full": "[deserializeParallelism=1]",
                        "name": "deserializeParallelism",
                        "optional": true,
                        "default": "1"
                    },
                    {
                        "full": "[timeColumn]",
                        "name": "timeColumn",
                        "optional": true
                    },
                    {
                        "full": "[eventQueueDepth=1024]",
                        "name": "eventQueueDepth",
                        "optional": true,
                        "default": "1024"
                    },
                    {
                        "full": "[outputTable]",
                        "name": "outputTable",
                        "optional": true
                    },
                    {
                        "full": "[dispatchKey]",
                        "name": "dispatchKey",
                        "optional": true
                    },
                    {
                        "full": "[dispatchBucket]",
                        "name": "dispatchBucket",
                        "optional": true
                    },
                    {
                        "full": "[useSystemTime=true]",
                        "name": "useSystemTime",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[eventTimeField=\"eventTime\"]",
                        "name": "eventTimeField",
                        "optional": true,
                        "default": "\"eventTime\""
                    }
                ]
            }
        ],
        "markdown": "### [createCEPEngine](https://docs.dolphindb.cn/zh/funcs/c/createCEPEngine.html)\n\n\n\n#### 语法\n\ncreateCEPEngine(name, monitors, dummyTable, eventSchema, \\[deserializeParallelism=1], \\[timeColumn], \\[eventQueueDepth=1024], \\[outputTable], \\[dispatchKey], \\[dispatchBucket], \\[useSystemTime=true], \\[eventTimeField=\"eventTime\"])\n\n#### 详情\n\n创建一个复杂事件处理（CEP）引擎实例，用于处理实时事件流。\n\n#### 参数\n\n**name** 字符串标量，表示 CEP 引擎的名称。可包含字母，数字和下划线，但必须以字母开头。\n\n**monitors** 元代码或元代码元组，可包含一个或多个 Monitor 类的构造函数调用。如果指定了多个 Monitor 类的构造函数调用，在创建 subEngine 时，将按照指定的顺序构造这些对象。Monitor 的创建方法参见 [简单的 Monitor 实例](https://docs.dolphindb.cn/zh/stream/cep_monitor_defining.md#)。\n\n**dummyTable** 一个表对象，和输入的流数据表的 schema 一致。\n\n**eventSchema** 事件类型类的声明，用于指定为外部输入的事件类型，可以是一个标量或向量。例如：\n\n```\nclass event1 {\n  var1:: STRING\n  var2:: INT\n  def event1(){\n    var1 = \"\"\n    var2 = 0\n  }\n}\n\nclass event2 {\n  var1:: DOUBLE\n  var2:: INT\n  def event2(){\n    var1 = 0.0\n    var2 = 0\n  }\n}\n\n//指定为标量\neventSchema = event1\n//指定为向量\neventSchema = [event1, event2]\n```\n\n**deserializeParallelism** 整型标量，用于指定反序化的线程数，默认值为1。\n\n**timeColumn** 可选参数，字符串标量或向量，用于指定 *dummyTable* 中的时间列。指定后，通过事件流序列化器（Stream Event Serializer）向 CEP 引擎插入事件时，该列将作为事件时间。\n\n**eventQueueDepth** 整型标量，用于指定子引擎接收事件队列和输出队列的最大深度，默认值是1024。\n\n**outputTable** 可选参数，可以指定为一个或多个 `StreamEventSerializer` 返回的序列化器。用于配合 emitEvent 函数将事件输出到序列化器指定的输出表中。不同序列化器之间的序列化与输出过程相互独立，并发执行。\n\n**dispatchKey** 字符串标量，用于指定事件中的属性，该属性中的每个唯一值被视为一个 key。若不指定 *dispatchKey*，则引擎将创建一个名为 *name* 的子引擎（与 CEP 引擎同名）。\n\n**dispatchBucket** 整型标量，表示哈希分组的数量。如果指定该参数，引擎将对 *dispatchKey*指定的字段进行哈希分组\\*。\\*\n\n注意：\n\n* CEP 引擎根据 *dispatchKey* 和 *dispatchBucket* 自动创建子引擎，并行处理数据。各个子引擎之间互相独立。若未指定 *dispatchKey*，则 CEP 引擎只有一个处理线程，即只创建一个子引擎。\n* 当监听多种事件类型时，事件分发遵循以下规则：\n\n  * 包含 `dispatchKey` 指定字段的事件：根据字段值哈希分发到对应的特定子引擎\n  * 不包含 `dispatchKey` 指定字段的事件：将被广播发送到所有子引擎\n\n**useSystemTime** 布尔值，表示是否使用数据注入引擎时的系统时间进行计算。\n\n* 当 *useSystemTime* = true 时（缺省值）时，CEP 引擎中的计算都基于数据注入引擎的时刻（以毫秒精度表示的本地系统时间）进行，与数据中的时间列无关。\n* 当 *useSystemTime* = false 时，CEP 引擎中的计算都基于数据中的 *timeColumn* 列进行。\n\n**eventTimeField** 可选参数，字符串标量或向量，用于指定事件中的时间字段，仅在 *useSystemTime* = false 有效。如果所有事件的时间字段名都相同，则 *eventTimeField* 是一个标量；否则，*eventTimeField* 是一个向量，其长度和 *eventSchema* 的长度相同，每个元素分别代表每个事件的时间字段。通过 `appendEvent` 直接向 CEP 引擎插入事件时，必须通过该参数指定事件的时间。\n\n#### 返回值\n\n一个表。\n\n#### 例子\n\n例 1. 本例创建三种类型的事件（市场数据、订单、成交），且为每种事件类型创建了独立的序列化器。最后，通过 `appendEvent` 将事件注入引擎，由引擎根据事件类型选择对应的序列化器，并输出到不同的流表中。此外，例子中通过设置 *dispatchKey*='code' 和 *dispatchBucket*=4，实现按股票分组并行处理的功能。\n\n```\nclass MarketData{  \n    market :: STRING  \n    code :: STRING  \n    price :: DOUBLE  \n    qty :: INT  \n    def MarketData(m,c,p,q){  \n        market = m  \n        code = c  \n        price = p  \n        qty = q  \n    }  \n}  \n  \nclass Orders{  \n    trader :: STRING  \n    market :: STRING  \n    code :: STRING  \n    price :: DOUBLE  \n    qty :: INT  \n    def Orders(t, m,c,p,q){  \n        trader = t  \n        market = m  \n        code = c  \n        price = p  \n        qty = q  \n    }  \n}  \n  \nclass Trades{  \n    trader :: STRING  \n    market :: STRING  \n    code :: STRING  \n    price :: DOUBLE  \n    qty :: INT  \n    def Trades(t, m,c,p,q){  \n        trader = t  \n        market = m  \n        code = c  \n        price = p  \n        qty = q  \n    }  \n}  \n  \nshare streamTable(array(STRING, 0) as eventType, array(BLOB, 0) as blobs) as MarketDataChannel  \nserializer1 = streamEventSerializer(name=`MarketDataChannel, eventSchema=[MarketData], outputTable=MarketDataChannel)  \n  \nshare streamTable(array(STRING, 0) as eventType, array(BLOB, 0) as blobs) as OrdersChannel  \nserializer2 = streamEventSerializer(name=`OrdersChannel, eventSchema=[Orders], outputTable=OrdersChannel)  \n  \nshare streamTable(array(STRING, 0) as eventType, array(BLOB, 0) as blobs) as TradesChannel  \nserializer3 = streamEventSerializer(name=`TradesChannel, eventSchema=[Trades], outputTable=TradesChannel)  \n  \nclass SimpleShareSearch:CEPMonitor {  \n\t//构造函数  \n\tdef SimpleShareSearch(){  \n\t}  \n\tdef processMarketData(event){  \n        emitEvent(event,,\"MarketDataChannel\")  \n    }  \n    def processOrders(event){  \n        emitEvent(event,,\"OrdersChannel\")  \n    }  \n    def processTrades(event){  \n        emitEvent(event,,\"TradesChannel\")  \n    }  \n\t// 创建 CEP 子引擎之后，系统会自动构造 SimpleShareSearch 类对象为 Monitor 实例并调用 onload 函数  \n\tdef onload() {  \n\t\t//监听StockTick事件  \n\t\taddEventListener(handler=processMarketData, eventType=\"MarketData\", times=\"all\")  \n\t\taddEventListener(handler=processOrders, eventType=\"Orders\", times=\"all\")  \n\t\taddEventListener(handler=processTrades, eventType=\"Trades\", times=\"all\")  \n\t}  \n}  \n  \ndummy = table(array(STRING, 0) as eventType, array(BLOB, 0) as blobs)  \n\nengine = createCEPEngine(name='cep1', monitors=<SimpleShareSearch()>, dummyTable=dummy,   \n                        eventSchema=[MarketData,Orders,Trades],   \n                        outputTable=[serializer1,serializer2,serializer3],  \n                        dispatchKey=`code, dispatchBucket=4)  // 按股票代码分组，创建4个并行处理组  \n  \nm= MarketData(\"m\", \"c\", 10.0, 100)  \nappendEvent(engine, m)  \n  \no = Orders(\"a\",\"m\", \"c\", 10.0, 100)  \nt = Trades(\"a\",\"m\", \"c\", 10.0, 100)  \n  \nappendEvent(engine, o)  \nappendEvent(engine, t)\n```\n\n例 1 中未指定 *useSystemTime*，因此引擎默认使用系统时间作为计算基准。在引擎内部的事件监听器（`addEventListener`）中，时间相关参数（例如 *within*、*exceedTime* 等）均使用时间注入引擎时的系统时间进行计算。\n\n若希望使用事件自身的时间作为计算基准，则可以通过参数进行配置，示例如下。\n\n例 2. 本例介绍如何使用数据中的时间列（事件时间）作为计算基准。CEP 引擎中的关键参数设置如下：\n\n* *useSystemTime*=false：引擎使用事件时间而非系统时间进行计算\n* *timeColumn*：指定 dummy 表中的时间列\n* *eventTimeField*：指定事件中的时间字段名\n\n```\n// 首先清理环境\ndef cleanupCEPEngine(){  \n    try { dropStreamEngine(\"cep1\") } catch(ex) {}  \n    try { dropStreamEngine(\"MarketDataChannel\") } catch(ex) {}  \n    try { dropStreamEngine(\"OrdersChannel\") } catch(ex) {}  \n    try { dropStreamEngine(\"TradesChannel\") } catch(ex) {}  \n      \n    try { dropStreamTable(\"MarketDataChannel\") } catch(ex) {}  \n    try { dropStreamTable(\"OrdersChannel\") } catch(ex) {}  \n    try { dropStreamTable(\"TradesChannel\") } catch(ex) {}  \n      \n    try { undef(\"MarketDataChannel\", SHARED) } catch(ex) {}  \n    try { undef(\"OrdersChannel\", SHARED) } catch(ex) {}  \n    try { undef(\"TradesChannel\", SHARED) } catch(ex) {}  \n      \n    print(\"CEP 引擎环境清理完成\")  \n}  \ncleanupCEPEngine()  \n\nclass MarketData{  \n    market :: STRING  \n    code :: STRING  \n    price :: DOUBLE  \n    qty :: INT  \n    eventTime :: TIMESTAMP  \n    def MarketData(m,c,p,q,et){  \n        market = m  \n        code = c  \n        price = p  \n        qty = q  \n        eventTime = et  \n    }  \n}  \n  \nclass Orders{  \n    trader :: STRING  \n    market :: STRING  \n    code :: STRING  \n    price :: DOUBLE  \n    qty :: INT  \n    eventTime :: TIMESTAMP  \n    def Orders(t, m,c,p,q,et){  \n        trader = t  \n        market = m  \n        code = c  \n        price = p  \n        qty = q  \n        eventTime = et  \n    }  \n}  \n  \nclass Trades{  \n    trader :: STRING  \n    market :: STRING  \n    code :: STRING  \n    price :: DOUBLE  \n    qty :: INT  \n    eventTime :: TIMESTAMP  \n    def Trades(t, m,c,p,q,et){  \n        trader = t  \n        market = m  \n        code = c  \n        price = p  \n        qty = q  \n        eventTime = et  \n    }  \n}  \n  \nshare streamTable(array(STRING, 0) as eventType, array(BLOB, 0) as blobs) as MarketDataChannel  \nserializer1 = streamEventSerializer(name=`MarketDataChannel, eventSchema=[MarketData], outputTable=MarketDataChannel)  \n  \nshare streamTable(array(STRING, 0) as eventType, array(BLOB, 0) as blobs) as OrdersChannel  \nserializer2 = streamEventSerializer(name=`OrdersChannel, eventSchema=[Orders], outputTable=OrdersChannel)  \n  \nshare streamTable(array(STRING, 0) as eventType, array(BLOB, 0) as blobs) as TradesChannel  \nserializer3 = streamEventSerializer(name=`TradesChannel, eventSchema=[Trades], outputTable=TradesChannel)  \n  \nclass SimpleShareSearch:CEPMonitor {  \n    def SimpleShareSearch(){  \n    }  \n    def processMarketData(event){  \n        emitEvent(event,,\"MarketDataChannel\")  \n    }  \n    def processOrders(event){  \n        emitEvent(event,,\"OrdersChannel\")  \n    }  \n    def processTrades(event){  \n        emitEvent(event,,\"TradesChannel\")  \n    }  \n    def onload() {  \n        addEventListener(handler=processMarketData, eventType=\"MarketData\", times=\"all\")  \n        addEventListener(handler=processOrders, eventType=\"Orders\", times=\"all\")  \n        addEventListener(handler=processTrades, eventType=\"Trades\", times=\"all\")  \n    }  \n}  \n  \n// 创建 CEP 引擎，修改 dummy 表结构，添加 eventTime 列  \ndummy = table(array(TIMESTAMP, 0) as eventTime, array(STRING, 0) as eventType, array(BLOB, 0) as blobs)  \n  \n// 创建 CEP 引擎，同时指定 timeColumn 和 eventTimeField  \nengine = createCEPEngine(name='cep1', monitors=<SimpleShareSearch()>, dummyTable=dummy,   \n                        eventSchema=[MarketData,Orders,Trades],   \n                        outputTable=[serializer1,serializer2,serializer3],  \n                        dispatchKey=`market, dispatchBucket=4,  \n                        useSystemTime=false, timeColumn=`eventTime,  \n                        eventTimeField=`eventTime)  \n  \n// 创建和注入事件\n// 创建事件时指定 eventTime  \ncurrentTime = 2026.03.01T09:30:00.000  \nm1 = MarketData(\"NASDAQ\", \"AAPL\", 10.0, 100, currentTime)  \nm2 = MarketData(\"NYSE\", \"IBM\", 150.0, 200, currentTime)  \n  \ncurrentTime = 2026.03.01T09:30:01.000  \no1 = Orders(\"trader1\",\"NASDAQ\", \"AAPL\", 10.0, 100, currentTime)  \no2 = Orders(\"trader2\",\"NYSE\", \"IBM\", 150.0, 200, currentTime)  \n  \ncurrentTime = 2026.03.01T09:30:02.000  \nt1 = Trades(\"trader1\",\"NASDAQ\", \"AAPL\", 10.0, 100, currentTime)  \nt2 = Trades(\"trader2\",\"NYSE\", \"IBM\", 150.0, 200, currentTime)  \n  \n// 注入事件  \nappendEvent(engine, m1)  \nappendEvent(engine, m2)  \nappendEvent(engine, o1)  \nappendEvent(engine, o2)  \nappendEvent(engine, t1)  \nappendEvent(engine, t2)\n```\n\n**相关函数**：[addEventListener](https://docs.dolphindb.cn/zh/funcs/a/addEventListener.html), [dropStreamEngine](https://docs.dolphindb.cn/zh/funcs/d/dropStreamEngine.html), [getCEPEngineStat](https://docs.dolphindb.cn/zh/funcs/g/getCEPEngineStat%20.html), [stopSubEngine](https://docs.dolphindb.cn/zh/funcs/s/stopSubEngine.html)\n"
    },
    "createCrossSectionalAggregator": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/createCrossSectionalAggregator.html",
        "signatures": [
            {
                "full": "createCrossSectionalEngine(name, [metrics], dummyTable, [outputTable], keyColumn, [triggeringPattern='perBatch'], [triggeringInterval=1000], [useSystemTime=true], [timeColumn], [lastBatchOnly=false], [contextByColumn], [snapshotDir], [snapshotIntervalInMsgCount], [raftGroup], [outputElapsedMicroseconds=false], [roundTime=true], [keyFilter], [updatedContextGroupsOnly=false])",
                "name": "createCrossSectionalEngine",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "[metrics]",
                        "name": "metrics",
                        "optional": true
                    },
                    {
                        "full": "dummyTable",
                        "name": "dummyTable"
                    },
                    {
                        "full": "[outputTable]",
                        "name": "outputTable",
                        "optional": true
                    },
                    {
                        "full": "keyColumn",
                        "name": "keyColumn"
                    },
                    {
                        "full": "[triggeringPattern='perBatch']",
                        "name": "triggeringPattern",
                        "optional": true,
                        "default": "'perBatch'"
                    },
                    {
                        "full": "[triggeringInterval=1000]",
                        "name": "triggeringInterval",
                        "optional": true,
                        "default": "1000"
                    },
                    {
                        "full": "[useSystemTime=true]",
                        "name": "useSystemTime",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[timeColumn]",
                        "name": "timeColumn",
                        "optional": true
                    },
                    {
                        "full": "[lastBatchOnly=false]",
                        "name": "lastBatchOnly",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[contextByColumn]",
                        "name": "contextByColumn",
                        "optional": true
                    },
                    {
                        "full": "[snapshotDir]",
                        "name": "snapshotDir",
                        "optional": true
                    },
                    {
                        "full": "[snapshotIntervalInMsgCount]",
                        "name": "snapshotIntervalInMsgCount",
                        "optional": true
                    },
                    {
                        "full": "[raftGroup]",
                        "name": "raftGroup",
                        "optional": true
                    },
                    {
                        "full": "[outputElapsedMicroseconds=false]",
                        "name": "outputElapsedMicroseconds",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[roundTime=true]",
                        "name": "roundTime",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[keyFilter]",
                        "name": "keyFilter",
                        "optional": true
                    },
                    {
                        "full": "[updatedContextGroupsOnly=false]",
                        "name": "updatedContextGroupsOnly",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [createCrossSectionalAggregator](https://docs.dolphindb.cn/zh/funcs/c/createCrossSectionalAggregator.html)\n\n是 [createCrossSectionalEngine](https://docs.dolphindb.cn/zh/funcs/c/createCrossSectionalEngine.html) 的别名。\n\n\n以下是 `createCrossSectionalEngine` 函数的文档：\n### [createCrossSectionalEngine](https://docs.dolphindb.cn/zh/funcs/c/createCrossSectionalEngine.html)\n\n\n\n#### 语法\n\ncreateCrossSectionalEngine(name, \\[metrics], dummyTable, \\[outputTable], keyColumn, \\[triggeringPattern='perBatch'], \\[triggeringInterval=1000], \\[useSystemTime=true], \\[timeColumn], \\[lastBatchOnly=false], \\[contextByColumn], \\[snapshotDir], \\[snapshotIntervalInMsgCount], \\[raftGroup], \\[outputElapsedMicroseconds=false], \\[roundTime=true], \\[keyFilter], \\[updatedContextGroupsOnly=false])\n\n别名：createCrossSectionalAggregator\n\n#### 详情\n\n创建横截面引擎，返回一个以 *keyColumn* 作为键值的键值表。\n\n该表记录了每组最新记录的时间戳（可以是数据自身的时间戳或者系统时间，由参数 *timeColumn* 和 *useSystemTime* 指定）。每次新数据的到来都会更新该表。若指定了 *lastBatchOnly* = true，此时引擎维护的键值表只会保留最新时间戳上不同组的数据。\n\n* 如果没有指定 *metrics* 或*outputTable*，横截面引擎不会利用表中的数据进行任何运算和输出，仅更新表中记录。\n* 如果指定了 *metrics* 和 *outputTable*，横截面引擎会首先更新表中记录，然后对表中的最新记录进行运算，并把结果输出到 *outputTable* 中。\n\n更多流数据引擎的应用场景说明可以参考 [流计算引擎](https://docs.dolphindb.cn/zh/funcs/themes/streamingEngine.html)。\n\n##### 计算规则\n\n可选按数据量或时间触发计算。如果设置 *triggeringPattern* = “keyCount”，输入流数据表中时间列（*timeColumn*）所指示的时间戳必须为非递减序列；如果同时指定了分组列（*keyColumn*），组内数据的时间戳必须为非递减序列。否则，乱序数据将被直接丢弃，不参与计算。详情请参考 *triggeringPattern* 和 *triggeringInterval* 的参数说明。\n\n**Note:** 若指定了 *contextByColumn*，则数据将按照指定字段分组后在组内进行计算。\n\n##### 引擎的其他功能\n\n* 快照机制：启用快照机制之后，系统若出现异常，可及时将流数据引擎恢复到最新的快照状态。（详情请参考 *snapshotDir* 和 *snapshotIntervalInMsgCount* 的参数说明）\n\n#### 参数\n\n**name** 字符串标量，表示横截面引擎的名称，作为其在一个数据节点/计算节点上的唯一标识。可包含字母，数字和下划线，但必须以字母开头。\n\n**metrics** 以元代码的格式表示计算指标，支持输入元组。有关元代码的更多信息可参考[元编程](https://docs.dolphindb.cn/zh/progr/objs/meta_progr.html)。\n\n* 计算指标可以是系统内置或用户自定义的函数，如 <\\[sum(qty), avg(price)]>；可以对计算结果使用表达式，如 <\\[avg(price1)-avg(price2)]>；也可以对多列进行运算，如 <\\[std(price1-price2)]>。\n* *metrics* 内支持调用具有多个返回值的函数，例如 \\<func(price) as \\`col1\\`col2>（可不指定列名）。\n* *metrics* 中使用的列名大小写不敏感，不要求与输入表的列名大小写保持一致。\n\n**dummyTable** 一个表对象，和输入的流数据表的 schema 一致，可以含有数据，亦可为空表。从 3.00.2 版本开始 *dummyTable* 支持包含 array vector 类型列。\n\n**outputTable** 计算结果的输出表，可以是内存表或分布式表。使用 `createCrossSectionalEngine` 函数之前，需要将输出表预先设立为一个空表，并指定各列列名以及数据类型。\n\n* 如果没有指定 *contextByColumn*， 则输出表各列的顺序如下：\n  * 第一列为 TIMESTAMP 类型，用于存放发生计算的时间戳（如果指定了 *timeColumn* 则是对应记录的时间戳）；\n  * 计算结果列，可为多列。其数据类型必须与 *metrics* 返回结果的数据类型一致。\n  * 耗时列，存储引擎内每个 batch 的计算耗时（单位：微秒），数据类型为 LONG。仅在指定 *outputElapsedMicroseconds*= true 时输出。\n  * 记录数列。存储引擎内每个 batch 的记录数，数据类型为 INT，仅在指定 *outputElapsedMicroseconds*= true 时输出。\n* 如果指定 *contextByColumn*， 则输出表各列的顺序如下：\n  * 第一列为 TIMESTAMP 类型，用于存放发生计算的时间戳（如果指定了 *timeColumn* 则是对应记录的时间戳）；\n  * 第二列为 *contextByColumn* 指定的列；\n  * 计算结果列，可为多列。其数据类型必须与 *metrics* 返回结果的数据类型一致。\n  * 耗时列，存储引擎内每个 batch 的计算耗时（单位：微秒），数据类型为 LONG。仅在指定 *outputElapsedMicroseconds*= true 时输出。\n  * 记录数列。存储引擎内每个 batch 的记录数，数据类型为 INT，仅在指定 *outputElapsedMicroseconds*= true 时输出。\n\n**keyColumn** 字符串标量或向量，指定流数据表中某列的值为横截面引擎的键值。横截面引擎的计算时，仅使用每个键值对应的最新一行记录。\n\n**triggeringPattern** 字符串标量，表示触发计算的方式，每触发一次计算，输出一条结果到输出表。该字符串可选值如下：\n\n* 'perBatch'：*triggeringPattern* 的默认值。每插入一次数据触发一次计算。\n* 'perRow'：插入的每一行数据都会触发一次计算。\n* 'interval'：基于系统时间间隔触发计算。\n* 'keyCount'：若相同时间戳的数据分批次到达，则只有在当前时间戳的记录数达到 *triggeringInterval*，或有更新时间戳的数据到达时，才会触发计算。使用该参数值时，必须指定 *timeColumn*，且 *useSystemTime* = false。若设置 *triggeringPattern* = 'keyCount'，收到的数据中出现的乱序数据会被丢弃，不参与计算。\n* 'dataInterval'：基于数据时间间隔触发计算。使用该参数值时，必须指定 *timeColumn*，且指定 *useSystemTime* = false。\n\n**triggeringInterval** 整数或元组，触发计算规则如下：\n\n* *triggeringPattern* 取值为 'interval' 时，*triggeringInterval* 是一个正整数，表示触发计算的时间间隔，单位为毫秒，默认值为 1000。每经过 *triggeringInterval* 指定的时间间隔，检查引擎中的数据是否被计算。若存在未被计算的数据，则触发一次计算。\n* *triggeringPattern* 取值为 'keyCount' 时：\n  * *triggeringInterval* 可以是一个整数。设置后，在更新的时间戳的数据到来前，当前时间戳的记录数需要累积到 *triggeringInterval* 才会触发计算。\n  * *triggeringInterval* 也可以是一个长度为 2 的 元组。元组的第一个元素是整数，表示触发计算的最新时间戳的记录数量。元组的第二个值可以是整数或者 duration 类型数据。假设设置 *triggeringInterval* = (c1, c2):\n    * 当 c2 为整数时，若收到的最新时间戳 t1 的数据数量小于 c1，这批数据不会触发计算，系统可以继续缓存更新时间戳 t2(t2>t1) 的数据，当 t2 的数据量达到 c2 或者收到更新的时间戳 t3(t3>t2) 的数据时，会触发时间戳 t1 对应数据的计算。注意必须满足 c2 < c1。\n    * 当 c2 为 duration 时，若收到的最新时间戳 t1 的数据数量小于 c1，这批数据不会触发计算，系统收到更新的时间戳 t2(t2>t1) 的数据后，会等待 duration 指定的时间，若在此期间继续收到了 t1 的数据且满足 t1 时间戳的数据总量达到 c1，或者在此期间又收到了更新的时间戳 t3(t3>t2) 的数据，则直接触发 t1 对应数据的计算，等待时间结束后不再触发计算。否则，等待 duration 设置的时间后才会触发 t1 数据的计算。\n* *triggeringPattern* 取值为 'dataInterval' 时，*triggeringInterval* 是一个正整数，单位和数据时间的单位一致，默认值为 1000。从第一条数据的时间戳开始一个窗口，窗口长度为 *triggeringInterval*。一个窗口结束后到达的第一条数据会触发当前窗口内数据的计算输出。输出表的时间为窗口结束的时间戳。\n\n**Note:**\n\n* 在 2.00.11.2 及之前版本，每个窗口都会输出。\n* 从版本 2.00.11.3 起，仅当窗口内有数据插入时才会触发输出。\n\n**useSystemTime** 可选参数，布尔值，表示是否使用数据注入引擎时的系统时间作为计算参照的时间列。\n\n* 若 *useSystemTime* = true，*outputTable* 中第一列（时间列）为系统时间；\n* 若 *useSystemTime* = false，必须指定 *timeColumn*，*outputTable* 中第一列（时间列）为数据的时间戳。\n\n**timeColumn** 是一个字符串。当 *useSystemTime* = false 时，指定订阅的流数据表中时间列的名称。仅支持 TIMESTAMP 类型。\n\n**lastBatchOnly** 可选参数。横截面引擎是否只保留最新时间戳上的数据。当 *lastBatchOnly* = true 时，只能指定 *triggeringPattern* = 'keyCount'，此时横截面引擎维护的键值表只保存最新时间戳的键值数据；否则，更新并保留所有时间戳上的键值数据。\n\n**contextByColumn** 可选参数，字符串标量或向量。设置后，将对横截面引擎中数据按照指定的字段或字段组合分组，并在组内进行指定计算。\n\n* 设置该参数，必须指定 *metrics* 和 *outputTable*.\n* 如果 *metrics* 全为聚合函数，则分组计算结果和 groupby 分组计算结果一致，否则和 contextby 分组计算结果一致。\n\n若要开启快照机制 (snapshot)，必须指定 **snapshotDir** 与 **snapshotIntervalInMsgCount**。\n\n**snapshotDir** 可选参数，字符串，表示保存引擎快照的文件目录。\n\n* 指定的目录必须存在，否则系统会提示异常。\n* 创建流数据引擎时，如果指定了 *snapshotDir*，会检查该目录下是否存在快照。如果存在，会加载该快照，恢复引擎的状态。\n* 多个引擎可以指定同一个目录存储快照，用引擎的名称来区分快照文件。\n* 一个引擎的快照可能会使用三个文件名：\n  * 临时存储快照信息：文件名为 \\<engineName>.tmp；\n  * 快照生成并刷到磁盘：文件保存为 \\<engineName>.snapshot；\n  * 存在同名快照：旧快照自动重命名为 \\<engineName>.old。\n\n**snapshotIntervalInMsgCount** 可选参数，为整数类型，表示每隔多少条数据保存一次流数据引擎快照。\n\n**raftGroup** 是流数据高可用订阅端 raft 组的 ID (大于 1 的整数，由流数据高可用相关的配置项 *streamingRaftGroups* 指定)。设置该参数表示开启计算引擎高可用。在 leader 节点创建流数据引擎后，会同步在 follower 节点创建该引擎。每次保存的 snapshot 也会同步到 follower。当 raft 组的 leader 节点宕机时，会自动切换新 leader 节点重新订阅流数据表。注意，若要指定 *raftGroup*，必须同时指定 *snapshotDir*。\n\n注意，自 3.00.5 版本起，流计算引擎暂不支持高可用功能，*raftGroup* 参数将不生效。\n\n**outputElapsedMicroseconds**布尔值，表示是否输出每个 batch 中数据从注入引擎到计算输出的总耗时，以及每个 batch 包含的总记录数，默认为 false，不输出。\n\n**Note:** *outputElapsedMicroseconds*= true 时，若同时指定 *useSystemTime*=true，则*metrics*中不可使用聚合函数。\n\n**roundTime** 可选参数，布尔值。用于对第一个数据窗口的起始时间进行规整，仅在 *triggeringPattern*=dataInterval 时有效。系统将根据该参数、triggeringInterval 和时间精度来确定规整尺度（alignmentSize）。窗口规整规则同[时序引擎](https://docs.dolphindb.cn/zh/funcs/c/createTimeSeriesEngine.html)。\n\n**keyFilter** 可选参数，以元代码形式表示的过滤条件。过滤条件是一个表达式或者函数调用，应用于截面数据中的列（列值为 key），返回一个布尔向量。引擎会从截面数据中过滤出 key 满足条件的数据进行计算。\n\n**updatedContextGroupsOnly** 可选参数，布尔标量，默认值为 false。决定是否仅计算相较上次输出存在更新的分组数据。\n\n#### 返回值\n\n一个表。\n\n#### 例子\n\n例1. 横截面引擎 csEngineDemo1 触发计算的方式为 \"perRow\"。6 行数据写入流数据表 trades1，结果亦为 6 行。\n\n```\nshare streamTable(10:0,`time`sym`price`volume,[TIMESTAMP,SYMBOL,DOUBLE,INT]) as trades1\nshare table(1:0, `time`avgPrice`volume`dollarVolume`count, [TIMESTAMP,DOUBLE,INT,DOUBLE,INT]) as outputTable\ncsEngine1=createCrossSectionalEngine(name=\"csEngineDemo1\", metrics=<[avg(price), sum(volume), sum(price*volume), count(price)]>, dummyTable=trades1, outputTable=outputTable, keyColumn=`sym, triggeringPattern=\"perRow\", useSystemTime=false, timeColumn=`time)\nsubscribeTable(tableName=\"trades1\", actionName=\"tradesStats\", offset=-1, handler=append!{csEngine1}, msgAsTable=true)\ninsert into trades1 values(2020.08.12T09:30:00.000 + 123 234 456 678 890 901, `A`B`A`B`B`A, 10 20 10.1 20.1 20.2 10.2, 20 10 20 30 40 20);\n\nselect * from trades1;\n```\n\n| time                    | sym | price | volume |\n| ----------------------- | --- | ----- | ------ |\n| 2020.08.12T09:30:00.123 | A   | 10    | 20     |\n| 2020.08.12T09:30:00.234 | B   | 20    | 10     |\n| 2020.08.12T09:30:00.456 | A   | 10.1  | 20     |\n| 2020.08.12T09:30:00.678 | B   | 20.1  | 30     |\n| 2020.08.12T09:30:00.890 | B   | 20.2  | 40     |\n| 2020.08.12T09:30:00.901 | A   | 10.2  | 20     |\n\n```\nselect * from outputTable;\n```\n\n| time                    | avgPrice | volume | dollarVolume | count |\n| ----------------------- | -------- | ------ | ------------ | ----- |\n| 2020.08.12T09:30:00.123 | 10       | 20     | 200          | 1     |\n| 2020.08.12T09:30:00.234 | 15       | 30     | 400          | 2     |\n| 2020.08.12T09:30:00.456 | 15.05    | 30     | 402          | 2     |\n| 2020.08.12T09:30:00.678 | 15.1     | 50     | 805          | 2     |\n| 2020.08.12T09:30:00.890 | 15.15    | 60     | 1010         | 2     |\n| 2020.08.12T09:30:00.901 | 15.2     | 60     | 1012         | 2     |\n\n例2. 横截面引擎 csEngineDemo2 触发计算的方式为 \"perBatch\"。数据分为 2 个批次写入流数据表 trades2，结果为 2 行。\n\n```\nshare streamTable(10:0,`time`sym`price`volume,[TIMESTAMP,SYMBOL,DOUBLE,INT]) as trades2\nshare table(1:0, `time`avgPrice`volume`dollarVolume`count, [TIMESTAMP,DOUBLE,INT,DOUBLE,INT]) as outputTable\ncsEngine2=createCrossSectionalEngine(name=\"csEngineDemo2\", metrics=<[avg(price), sum(volume), sum(price*volume), count(price)]>, dummyTable=trades2, outputTable=outputTable, keyColumn=`sym, triggeringPattern=\"perBatch\", useSystemTime=false, timeColumn=`time)\nsubscribeTable(tableName=\"trades2\", actionName=\"tradesStats\", offset=-1, handler=append!{csEngine2}, msgAsTable=true)\ninsert into trades2 values(2020.08.12T09:30:00.000 + 123 234 456, `A`B`A, 10 20 10.1, 20 10 20);\nsleep(1)\ninsert into trades2 values(2020.08.12T09:30:00.000 + 678 890 901, `B`B`A, 20.1 20.2 10.2, 30 40 20);\n\nselect * from outputTable;\n```\n\n| time                    | avgPrice | volume | dollarVolume | count |\n| ----------------------- | -------- | ------ | ------------ | ----- |\n| 2020.08.12T09:30:00.456 | 15.05    | 30     | 402          | 2     |\n| 2020.08.12T09:30:00.901 | 15.2     | 60     | 1012         | 2     |\n\n例3. 横截面引擎 csEngineDemo4 触发计算的方式为 \"keyCount\"。设置 *lastBatchOnly* = true，只有最新时间戳上的数据会参与计算。因为 *metrics* 里聚合函数和非聚合函数混合使用，所以，输出记录行数等于输入记录行数，聚合结果重复输出多行。\n\n```\nshare streamTable(10:0,`time`sym`price`volume,[TIMESTAMP,SYMBOL,DOUBLE,INT]) as trades1\nshare table(1:0, `time`factor1`factor2, [TIMESTAMP, DOUBLE,INT]) as outputTable\nagg=createCrossSectionalAggregator(name=\"csEngineDemo4\", metrics=<[price+ 0.1, sum(volume)]>, dummyTable=trades1, outputTable=outputTable, keyColumn=`sym, triggeringPattern=\"keyCount\", triggeringInterval=5, useSystemTime=false, timeColumn=`time,lastBatchOnly=true)\nsubscribeTable(tableName=`trades1, actionName=\"csEngineDemo4\", msgAsTable=true, handler=append!{agg})\nnum=10\ntime=array(TIMESTAMP)\ntime=take(2018.01.01T09:30:00.000,num)\nsym=take(\"A\"+string(1..10),num)\nprice=1..num\nvolume=1..num\ntmp=table(time, sym, price, volume)\ntrades1.append!(tmp)\n\n// 第二次输入 5 条数据，lastBatchOnly=true，所以只有最新的 5 条数据参与计算。\nnum=5\ntime = array(TIMESTAMP)\ntime=take(2018.01.01T09:30:01.000,num)\nsym=take(\"A\"+string(1..10),num)\nprice=6..10\nvolume=6..10\ntmp=table(time, sym, price, volume)\ntrades1.append!(tmp)\n```\n\n| time                    | factor1 | factor2 |\n| ----------------------- | ------- | ------- |\n| 2018.01.01T09:30:00.000 | 1.1     | 55      |\n| 2018.01.01T09:30:00.000 | 2.1     | 55      |\n| 2018.01.01T09:30:00.000 | 3.1     | 55      |\n| 2018.01.01T09:30:00.000 | 4.1     | 55      |\n| 2018.01.01T09:30:00.000 | 5.1     | 55      |\n| 2018.01.01T09:30:00.000 | 6.1     | 55      |\n| 2018.01.01T09:30:00.000 | 7.1     | 55      |\n| 2018.01.01T09:30:00.000 | 8.1     | 55      |\n| 2018.01.01T09:30:00.000 | 9.1     | 55      |\n| 2018.01.01T09:30:00.000 | 10.1    | 55      |\n| 2018.01.01T09:30:01.000 | 6.1     | 40      |\n| 2018.01.01T09:30:01.000 | 7.1     | 40      |\n| 2018.01.01T09:30:01.000 | 8.1     | 40      |\n| 2018.01.01T09:30:01.000 | 9.1     | 40      |\n| 2018.01.01T09:30:01.000 | 10.1    | 40      |\n\n例4. 横截面引擎 csEngineDemo3 触发计算的方式为 \"interval\"，每 500 毫秒触发一次计算。向流数据表中写入6行数据，第一次批量写入，间隔 500 毫秒后再次写入。请注意，这里没有指定 *useSystemTime* 参数为 false，会返回计算发生的时刻。\n\n```\nshare streamTable(10:0,`time`sym`price`volume,[TIMESTAMP,SYMBOL,DOUBLE,INT]) as trades3\nshare table(1:0, `time`avgPrice`volume`dollarVolume`count, [TIMESTAMP,DOUBLE,INT,DOUBLE,INT]) as outputTable\ncsEngine3=createCrossSectionalEngine(name=\"csEngineDemo3\", metrics=<[avg(price), sum(volume), sum(price*volume), count(price)]>, dummyTable=trades3, outputTable=outputTable, keyColumn=`sym, triggeringPattern=\"interval\", triggeringInterval=500)\nsubscribeTable(tableName=\"trades3\", actionName=\"tradesStats\", offset=-1, handler=append!{csEngine3}, msgAsTable=true);\n\ninsert into trades3 values(2020.08.12T09:30:00.000, `A, 10, 20)\ninsert into trades3 values(2020.08.12T09:30:00.000 + 500, `B, 20, 10)\ninsert into trades3 values(2020.08.12T09:30:00.000 + 1000, `A, 10.1, 20)\ninsert into trades3 values(2020.08.12T09:30:00.000 + 2000, `B, 20.1, 30)\nsleep(500)\ninsert into trades3 values(2020.08.12T09:30:00.000 + 2500, `B, 20.2, 40)\ninsert into trades3 values(2020.08.12T09:30:00.000 + 3000, `A, 10.2, 20);\nsleep(500)\n\nselect * from outputTable;\n```\n\n| time                    | avgPrice | volume | dollarVolume | count |\n| ----------------------- | -------- | ------ | ------------ | ----- |\n| 2022.03.02T11:17:02.341 | 15.1     | 50     | 805          | 2     |\n| 2022.03.02T11:17:02.850 | 15.2     | 60     | 1,012        | 2     |\n\n*triggeringPattern* = \"interval\" 时，系统每隔 500ms 触发一次计算，输出一条结果。在计算被触发时，即使同一个 key 有多条记录未被计算，系统也只取最新时间戳上的数据进行计算。\n\n例5. 在股票数据中，有些股票在某一时刻之后就不再更新数据了，此时可通过 *keyFilter* 参数指定过滤条件。当之后收到其它股票数据并触发截面计算时不会计算该股票的数据。以在截面引擎中过滤出1小时内未更新的数据为例：\n\n```\n// 定义休市和过滤数据的逻辑\ndef checkTime(time){\n    maxTime = max(time)\n    if(between(maxTime, 2024.05.22T13:00:00.000:2024.05.22T13:30:00.000)){\n        return time > maxTime - 120*60*1000\n    } else{\n        return time > maxTime - 30*60*1000\n    }\n}\n// 定义截面引擎\nshare streamTable(10:0,`time`sym`price`volume,[TIMESTAMP,SYMBOL,DOUBLE,INT]) as trades1\nt=keyedTable(`sym,10:0,`time`sym`price`volume,[TIMESTAMP,SYMBOL,DOUBLE,INT])\nshare table(1:0, `time`factor1`factor2, [TIMESTAMP, DOUBLE, DOUBLE]) as outputTable\n// 指定 keyFilter 为一个函数，过滤出1小时内未更新的数据。 \ncsEngine5=createCrossSectionalEngine(name=\"csEngineDemo5\", metrics=<[avg(price), sum(volume)]>, dummyTable=trades1, outputTable=outputTable, keyColumn=`sym, keyFilter=<checkTime(time)>)\n// 模拟数据，A1 从 2024.05.22T09:32:00.000 之后未收到新的数据\ntime = 2024.05.22T09:30:00.000 join 2024.05.22T09:31:00.000 join 2024.05.22T09:32:00.000 join 2024.05.22T13:30:00.000 join 2024.05.22T13:31:00.000\nsym=`A1`A2`A1`A2`A2\nprice=100.0 100.5 100.3 100.8 100.6\nvolume=100 110 112 200 120\ntmp=table(time, sym, price, volume)\ncsEngine5.append!(tmp)\n// 查看截面引擎中的数据\nselect * from csEngine5\n```\n\n| time                    | sym | price | volume |\n| ----------------------- | --- | ----- | ------ |\n| 2024.05.22T09:32:00.000 | A1  | 100.3 | 112    |\n| 2024.05.22T13:31:00.000 | A2  | 100.6 | 120    |\n\n上面代码通过 *keyFilter* 找到截面引擎中仅 A2 的数据满足要求，因此结果表中仅 A2 的数据参与了计算。\n\n```\nselect * from outputTable\n```\n\n| time                    | factor1 | factor2 |\n| ----------------------- | ------- | ------- |\n| 2024.05.22T05:11:12.259 | 100.6   | 120     |\n\n在以上的例子中， `createCrossSectionalEngine` 的返回结果（以下称为横截面表）是为计算提供的一个中间结果，但横截面表亦可为最终结果。例如若需要定时刷新某只股票的最新交易价格， 按照常规思路是从实时交易表中按代码筛选股票并取出最后一条记录，而交易表的数据量是随着时间快速增长的，如果频繁做这样的查询，无论从系统的资源消耗还是从查询的效能来看都不是最优的做法。 而横截面表永远只保存所有股票的最近一次交易数据，数据量是稳定的，对于这种定时轮询的场景非常合适。\n\n要将横截面表作为最终结果，需要在对 `createCrossSectionalEngine` 中的 *metrics* 与 *outputTable* 这两个参数置空。\n\n```\ntradesCrossEngine=createCrossSectionalEngine(name=\"CrossSectionalDemo\", dummyTable=trades, keyColumn=`sym, triggeringPattern=`perRow)\n```\n\n例6. 按照 volume 分组，引擎每插入一行数据，就触发一次计算。\n\n```\ntry {\n    dropAggregator(`csEngineDemo)\n} catch(ex) {}\ntry {\n    dropStreamTable(`trades1)\n} catch(ex) {}\nshare streamTable(10:0, `time`sym`price`volume, [SECOND, SYMBOL, DOUBLE, INT]) as trades1\noutputTable = table(1:0, `time`volume`factor1`factor2, [SECOND, INT, DOUBLE, DOUBLE])\nagg1 = createCrossSectionalEngine(\n    name=\"csEngineDemo\",\n    metrics=<[avg(price), sum(volume)]>,\n    dummyTable=trades1,\n    outputTable=outputTable,\n    keyColumn=`sym,\n    triggeringPattern=\"perRow\",\n    useSystemTime=false,\n    timeColumn=`time,\n    outputElapsedMicroseconds=false,\n    contextByColumn=`volume,\n    updatedContextGroupsOnly=false\n)\n\nnum = 4\ntime = take(09:30:00, num)\nsym = take(`A1`B1`C1`D1, num)\nprice = rand(100.0, num)\nvolume = take(1 1 2 2, num)\ntmp = table(time, sym, price, volume)\nagg1.append!(tmp)\noutputTable\n```\n\n以上创建的引擎根据 volume 分组后得到 1 和 2 两个分组。由于设置了 *updatedContextGroupsOnly* = false，引擎不会检查各个分组的数据是否有更新。每当插入一行数据时，都会触发所有分组的计算和输出，因此， outputTable 中将输出 6 行数据。\n\n| time     | volume | factor1 | factor2 |\n| -------- | ------ | ------- | ------- |\n| 09:30:00 | 1      | 82.3447 | 1       |\n| 09:30:00 | 1      | 69.9793 | 2       |\n| 09:30:00 | 1      | 69.9793 | 2       |\n| 09:30:00 | 2      | 95.262  | 2       |\n| 09:30:00 | 1      | 69.9793 | 2       |\n| 09:30:00 | 2      | 80.5988 | 4       |\n\n```\ntry{dropAggregator(`csEngineDemo)}catch(ex){}\ntry{dropStreamTable(`trades1)}catch(ex){}\n\nshare streamTable(10:0,`time`sym`price`volume,[SECOND,SYMBOL,DOUBLE,INT]) as trades1\noutputTable = table(1:0, `time`volume`factor1`factor2, [SECOND, INT, DOUBLE, DOUBLE])\nagg1=createCrossSectionalEngine(name=\"csEngineDemo\", metrics=<[avg(price), sum(volume)]>, dummyTable=trades1, outputTable=outputTable, keyColumn=`sym, triggeringPattern=\"perRow\",useSystemTime=false, timeColumn=`time, outputElapsedMicroseconds=false, contextByColumn=`volume, updatedContextGroupsOnly=false)\nnum=4\ntime = take(09:30:00, num)\nsym= take(`A1`B1`C1`D1, num)\nprice=rand(100.0, num)\nvolume=take(1 1 2 2, num)\ntmp=table(time, sym, price, volume)\nagg1.append!(tmp)\noutputTable\n\n```\n\n设置 *updatedContextGroupsOnly* = true 后，引擎将仅计算本次插入的分组数据，因此，outputTable 中将输出 4 行数据。\n\n| time     | volume | factor1 | factor2 |\n| -------- | ------ | ------- | ------- |\n| 09:30:00 | 1      | 54.6926 | 1       |\n| 09:30:00 | 1      | 40.5904 | 2       |\n| 09:30:00 | 2      | 73.1741 | 2       |\n| 09:30:00 | 2      | 46.0153 | 4       |\n\n例7. 设置 *triggeringPattern*=\"dataInterval\"、*triggeringInterval* 与 *outputElapsedMicroseconds*\n\n本例中，横截面引擎按 branchId 维护各分支机构的最新状态，并按 1 分钟数据窗口输出截面汇总结果。\n\n```\nshare streamTable(1:0, `quoteTime`branchId`marginUsed`riskRate, [TIMESTAMP, SYMBOL, DOUBLE, DOUBLE]) as snapshot\nshare table(100:0, `time`totalMarginUsed`avgRiskRate`elapsedUs`batchRows, [TIMESTAMP, DOUBLE, DOUBLE, LONG, INT]) as outputTable\n\nengine = createCrossSectionalEngine(\n   name=\"csDataIntervalDemo\",\n   metrics=<[sum(marginUsed), avg(riskRate)]>,\n   dummyTable=snapshot,\n   outputTable=outputTable,\n   keyColumn=`branchId,\n   triggeringPattern=\"dataInterval\",\n   triggeringInterval=60000,\n   useSystemTime=false,\n   timeColumn=`quoteTime,\n   outputElapsedMicroseconds=true\n)\n\nsubscribeTable(tableName=`snapshot, actionName=\"csDataIntervalDemo\", msgAsTable=true, handler=append!{engine})\n\ninsert into snapshot values(2024.06.03T09:30:00.000, `BJ01, 12000000.0, 0.42)\ninsert into snapshot values(2024.06.03T09:30:10.000, `SH02, 12000000.0, 0.55)\ninsert into snapshot values(2024.06.03T09:30:40.000, `SZ03, 9800000.0, 0.37)\ninsert into snapshot values(2024.06.03T09:31:05.000, `BJ01, 12300000.0, 0.44)\n\nsleep(500)\n\nselect * from outputTable\n```\n\n输出结果可能如下：\n\n| time                    | totalMarginUsed | avgRiskRate | elapsedUs | batchRows |\n| ----------------------- | --------------- | ----------- | --------- | --------- |\n| 2024.06.03 09:31:00.000 | 33,800,000      | 0.4466667   | 3         | 1         |\n\n* *triggeringPattern*=\"dataInterval\" 表示基于数据时间间隔触发计算。本例中 *triggeringInterva*l=60000，窗口长度为 1 分钟。\n\n* 2024.06.03T09:31:05.000 这条数据是窗口结束后到达的第一条数据，因此会触发前一窗口 \\[09:30:00, 09:31:00) 的计算输出；它本身不参与这次输出。\n\n* 第一个窗口内各分支机构的最新状态分别为：\n\n  * BJ01：marginUsed=12000000；riskRate=0.42\n\n  * SH02：marginUsed=12000000；riskRate=0.55\n\n  * SZ03：marginUsed=9800000；riskRate=0.37\n\n因此 totalMarginUsed=33,800,000，avgRiskRate=(0.42+0.55+0.37)/3=0.4466667。\n\n* 设置 *outputElapsedMicroseconds*=true 后，输出表需要在指标列后追加一个 LONG 列和一个 INT 列，分别记录本次输出的耗时和 batch 记录数。\n\n* elapsedUs 会随部署环境和负载变化而变化。\n\n例8. 设置 *roundTime*和 *triggeringPattern*=“dataInterval” 控制窗口的规整方式。\n\n本例模拟零售企业门店库存快照。两个引擎仅 *roundTime* 设置不同，其余参数完全一致，用于对比首个数据窗口的边界差异。\n\n```\nshare streamTable(1:0, `eventTime`sku`onHandQty, [TIMESTAMP, SYMBOL, INT]) as inventory\nshare table(100:0, `time`totalOnHandQty, [TIMESTAMP, INT]) as outputRTTrue\nshare table(100:0, `time`totalOnHandQty, [TIMESTAMP, INT]) as outputRTFalse\n\nengineRTTrue = createCrossSectionalEngine(\n   name=\"engineRTTrue\",\n   metrics=<[sum(onHandQty)]>,\n   dummyTable=inventory,\n   outputTable=outputRTTrue,\n   keyColumn=`sku,\n   triggeringPattern=\"dataInterval\",\n   triggeringInterval=120000,\n   useSystemTime=false,\n   timeColumn=`eventTime,\n   roundTime=true\n)\n\nengineRTFalse = createCrossSectionalEngine(\n   name=\"engineRTFalse\",\n   metrics=<[sum(onHandQty)]>,\n   dummyTable=inventory,\n   outputTable=outputRTFalse,\n   keyColumn=`sku,\n   triggeringPattern=\"dataInterval\",\n   triggeringInterval=120000,\n   useSystemTime=false,\n   timeColumn=`eventTime,\n   roundTime=false\n)\n\nsubscribeTable(tableName=\"inventory\", actionName=\"engineRTTrue\", offset=0, handler=append!{engineRTTrue}, msgAsTable=true)\nsubscribeTable(tableName=\"inventory\", actionName=\"engineRTFalse\", offset=0, handler=append!{engineRTFalse}, msgAsTable=true)\n\ninsert into inventory values(2024.06.03T10:03:30.500, `SKU1001, 120)\ninsert into inventory values(2024.06.03T10:04:20.000, `SKU2008, 80)\ninsert into inventory values(2024.06.03T10:05:10.000, `SKU3012, 60)\n\n```\n\n对于 *roundTime*=true 的引擎，执行 `select * from outputRTTrue`，输出如下：\n\n| time                    | totalOnHandQty |\n| ----------------------- | -------------- |\n| 2024.06.03 10:04:00.000 | 120            |\n\n对于 *roundTime*=false 的引擎，执行 `select * from outputRTFalse`，输出如下：\n\n| time                    | totalOnHandQty |\n| ----------------------- | -------------- |\n| 2024.06.03 10:05:00.000 | 200            |\n\n* 本例中 *triggeringPattern*=\"dataInterval\" 、*triggeringInterval*=120000，即窗口长度为 2 分钟。\n\n* 首条数据时间为 2024.06.03T10:03:30.500。\n\n* *roundTime*=true 时，首个窗口按 2 分钟规整，首个窗口为 \\[10:02:00, 10:04:00)，因此只有 SKU1001=120 落入首个窗口；10:04:20.000 的数据到达时触发输出，结果为 120。\n\n* *roundTime*=false 时，首个窗口按 1 分钟规整，首个窗口为 \\[10:03:00, 10:05:00)，因此 SKU1001=120 和 SKU2008=80 都落入首个窗口；10:05:10.000 的数据到达时触发输出，结果为 200。\n"
    },
    "createCrossSectionalEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/createCrossSectionalEngine.html",
        "signatures": [
            {
                "full": "createCrossSectionalEngine(name, [metrics], dummyTable, [outputTable], keyColumn, [triggeringPattern='perBatch'], [triggeringInterval=1000], [useSystemTime=true], [timeColumn], [lastBatchOnly=false], [contextByColumn], [snapshotDir], [snapshotIntervalInMsgCount], [raftGroup], [outputElapsedMicroseconds=false], [roundTime=true], [keyFilter], [updatedContextGroupsOnly=false])",
                "name": "createCrossSectionalEngine",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "[metrics]",
                        "name": "metrics",
                        "optional": true
                    },
                    {
                        "full": "dummyTable",
                        "name": "dummyTable"
                    },
                    {
                        "full": "[outputTable]",
                        "name": "outputTable",
                        "optional": true
                    },
                    {
                        "full": "keyColumn",
                        "name": "keyColumn"
                    },
                    {
                        "full": "[triggeringPattern='perBatch']",
                        "name": "triggeringPattern",
                        "optional": true,
                        "default": "'perBatch'"
                    },
                    {
                        "full": "[triggeringInterval=1000]",
                        "name": "triggeringInterval",
                        "optional": true,
                        "default": "1000"
                    },
                    {
                        "full": "[useSystemTime=true]",
                        "name": "useSystemTime",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[timeColumn]",
                        "name": "timeColumn",
                        "optional": true
                    },
                    {
                        "full": "[lastBatchOnly=false]",
                        "name": "lastBatchOnly",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[contextByColumn]",
                        "name": "contextByColumn",
                        "optional": true
                    },
                    {
                        "full": "[snapshotDir]",
                        "name": "snapshotDir",
                        "optional": true
                    },
                    {
                        "full": "[snapshotIntervalInMsgCount]",
                        "name": "snapshotIntervalInMsgCount",
                        "optional": true
                    },
                    {
                        "full": "[raftGroup]",
                        "name": "raftGroup",
                        "optional": true
                    },
                    {
                        "full": "[outputElapsedMicroseconds=false]",
                        "name": "outputElapsedMicroseconds",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[roundTime=true]",
                        "name": "roundTime",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[keyFilter]",
                        "name": "keyFilter",
                        "optional": true
                    },
                    {
                        "full": "[updatedContextGroupsOnly=false]",
                        "name": "updatedContextGroupsOnly",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [createCrossSectionalEngine](https://docs.dolphindb.cn/zh/funcs/c/createCrossSectionalEngine.html)\n\n\n\n#### 语法\n\ncreateCrossSectionalEngine(name, \\[metrics], dummyTable, \\[outputTable], keyColumn, \\[triggeringPattern='perBatch'], \\[triggeringInterval=1000], \\[useSystemTime=true], \\[timeColumn], \\[lastBatchOnly=false], \\[contextByColumn], \\[snapshotDir], \\[snapshotIntervalInMsgCount], \\[raftGroup], \\[outputElapsedMicroseconds=false], \\[roundTime=true], \\[keyFilter], \\[updatedContextGroupsOnly=false])\n\n别名：createCrossSectionalAggregator\n\n#### 详情\n\n创建横截面引擎，返回一个以 *keyColumn* 作为键值的键值表。\n\n该表记录了每组最新记录的时间戳（可以是数据自身的时间戳或者系统时间，由参数 *timeColumn* 和 *useSystemTime* 指定）。每次新数据的到来都会更新该表。若指定了 *lastBatchOnly* = true，此时引擎维护的键值表只会保留最新时间戳上不同组的数据。\n\n* 如果没有指定 *metrics* 或*outputTable*，横截面引擎不会利用表中的数据进行任何运算和输出，仅更新表中记录。\n* 如果指定了 *metrics* 和 *outputTable*，横截面引擎会首先更新表中记录，然后对表中的最新记录进行运算，并把结果输出到 *outputTable* 中。\n\n更多流数据引擎的应用场景说明可以参考 [流计算引擎](https://docs.dolphindb.cn/zh/funcs/themes/streamingEngine.html)。\n\n##### 计算规则\n\n可选按数据量或时间触发计算。如果设置 *triggeringPattern* = “keyCount”，输入流数据表中时间列（*timeColumn*）所指示的时间戳必须为非递减序列；如果同时指定了分组列（*keyColumn*），组内数据的时间戳必须为非递减序列。否则，乱序数据将被直接丢弃，不参与计算。详情请参考 *triggeringPattern* 和 *triggeringInterval* 的参数说明。\n\n**Note:** 若指定了 *contextByColumn*，则数据将按照指定字段分组后在组内进行计算。\n\n##### 引擎的其他功能\n\n* 快照机制：启用快照机制之后，系统若出现异常，可及时将流数据引擎恢复到最新的快照状态。（详情请参考 *snapshotDir* 和 *snapshotIntervalInMsgCount* 的参数说明）\n\n#### 参数\n\n**name** 字符串标量，表示横截面引擎的名称，作为其在一个数据节点/计算节点上的唯一标识。可包含字母，数字和下划线，但必须以字母开头。\n\n**metrics** 以元代码的格式表示计算指标，支持输入元组。有关元代码的更多信息可参考[元编程](https://docs.dolphindb.cn/zh/progr/objs/meta_progr.html)。\n\n* 计算指标可以是系统内置或用户自定义的函数，如 <\\[sum(qty), avg(price)]>；可以对计算结果使用表达式，如 <\\[avg(price1)-avg(price2)]>；也可以对多列进行运算，如 <\\[std(price1-price2)]>。\n* *metrics* 内支持调用具有多个返回值的函数，例如 \\<func(price) as \\`col1\\`col2>（可不指定列名）。\n* *metrics* 中使用的列名大小写不敏感，不要求与输入表的列名大小写保持一致。\n\n**dummyTable** 一个表对象，和输入的流数据表的 schema 一致，可以含有数据，亦可为空表。从 3.00.2 版本开始 *dummyTable* 支持包含 array vector 类型列。\n\n**outputTable** 计算结果的输出表，可以是内存表或分布式表。使用 `createCrossSectionalEngine` 函数之前，需要将输出表预先设立为一个空表，并指定各列列名以及数据类型。\n\n* 如果没有指定 *contextByColumn*， 则输出表各列的顺序如下：\n  * 第一列为 TIMESTAMP 类型，用于存放发生计算的时间戳（如果指定了 *timeColumn* 则是对应记录的时间戳）；\n  * 计算结果列，可为多列。其数据类型必须与 *metrics* 返回结果的数据类型一致。\n  * 耗时列，存储引擎内每个 batch 的计算耗时（单位：微秒），数据类型为 LONG。仅在指定 *outputElapsedMicroseconds*= true 时输出。\n  * 记录数列。存储引擎内每个 batch 的记录数，数据类型为 INT，仅在指定 *outputElapsedMicroseconds*= true 时输出。\n* 如果指定 *contextByColumn*， 则输出表各列的顺序如下：\n  * 第一列为 TIMESTAMP 类型，用于存放发生计算的时间戳（如果指定了 *timeColumn* 则是对应记录的时间戳）；\n  * 第二列为 *contextByColumn* 指定的列；\n  * 计算结果列，可为多列。其数据类型必须与 *metrics* 返回结果的数据类型一致。\n  * 耗时列，存储引擎内每个 batch 的计算耗时（单位：微秒），数据类型为 LONG。仅在指定 *outputElapsedMicroseconds*= true 时输出。\n  * 记录数列。存储引擎内每个 batch 的记录数，数据类型为 INT，仅在指定 *outputElapsedMicroseconds*= true 时输出。\n\n**keyColumn** 字符串标量或向量，指定流数据表中某列的值为横截面引擎的键值。横截面引擎的计算时，仅使用每个键值对应的最新一行记录。\n\n**triggeringPattern** 字符串标量，表示触发计算的方式，每触发一次计算，输出一条结果到输出表。该字符串可选值如下：\n\n* 'perBatch'：*triggeringPattern* 的默认值。每插入一次数据触发一次计算。\n* 'perRow'：插入的每一行数据都会触发一次计算。\n* 'interval'：基于系统时间间隔触发计算。\n* 'keyCount'：若相同时间戳的数据分批次到达，则只有在当前时间戳的记录数达到 *triggeringInterval*，或有更新时间戳的数据到达时，才会触发计算。使用该参数值时，必须指定 *timeColumn*，且 *useSystemTime* = false。若设置 *triggeringPattern* = 'keyCount'，收到的数据中出现的乱序数据会被丢弃，不参与计算。\n* 'dataInterval'：基于数据时间间隔触发计算。使用该参数值时，必须指定 *timeColumn*，且指定 *useSystemTime* = false。\n\n**triggeringInterval** 整数或元组，触发计算规则如下：\n\n* *triggeringPattern* 取值为 'interval' 时，*triggeringInterval* 是一个正整数，表示触发计算的时间间隔，单位为毫秒，默认值为 1000。每经过 *triggeringInterval* 指定的时间间隔，检查引擎中的数据是否被计算。若存在未被计算的数据，则触发一次计算。\n* *triggeringPattern* 取值为 'keyCount' 时：\n  * *triggeringInterval* 可以是一个整数。设置后，在更新的时间戳的数据到来前，当前时间戳的记录数需要累积到 *triggeringInterval* 才会触发计算。\n  * *triggeringInterval* 也可以是一个长度为 2 的 元组。元组的第一个元素是整数，表示触发计算的最新时间戳的记录数量。元组的第二个值可以是整数或者 duration 类型数据。假设设置 *triggeringInterval* = (c1, c2):\n    * 当 c2 为整数时，若收到的最新时间戳 t1 的数据数量小于 c1，这批数据不会触发计算，系统可以继续缓存更新时间戳 t2(t2>t1) 的数据，当 t2 的数据量达到 c2 或者收到更新的时间戳 t3(t3>t2) 的数据时，会触发时间戳 t1 对应数据的计算。注意必须满足 c2 < c1。\n    * 当 c2 为 duration 时，若收到的最新时间戳 t1 的数据数量小于 c1，这批数据不会触发计算，系统收到更新的时间戳 t2(t2>t1) 的数据后，会等待 duration 指定的时间，若在此期间继续收到了 t1 的数据且满足 t1 时间戳的数据总量达到 c1，或者在此期间又收到了更新的时间戳 t3(t3>t2) 的数据，则直接触发 t1 对应数据的计算，等待时间结束后不再触发计算。否则，等待 duration 设置的时间后才会触发 t1 数据的计算。\n* *triggeringPattern* 取值为 'dataInterval' 时，*triggeringInterval* 是一个正整数，单位和数据时间的单位一致，默认值为 1000。从第一条数据的时间戳开始一个窗口，窗口长度为 *triggeringInterval*。一个窗口结束后到达的第一条数据会触发当前窗口内数据的计算输出。输出表的时间为窗口结束的时间戳。\n\n**Note:**\n\n* 在 2.00.11.2 及之前版本，每个窗口都会输出。\n* 从版本 2.00.11.3 起，仅当窗口内有数据插入时才会触发输出。\n\n**useSystemTime** 可选参数，布尔值，表示是否使用数据注入引擎时的系统时间作为计算参照的时间列。\n\n* 若 *useSystemTime* = true，*outputTable* 中第一列（时间列）为系统时间；\n* 若 *useSystemTime* = false，必须指定 *timeColumn*，*outputTable* 中第一列（时间列）为数据的时间戳。\n\n**timeColumn** 是一个字符串。当 *useSystemTime* = false 时，指定订阅的流数据表中时间列的名称。仅支持 TIMESTAMP 类型。\n\n**lastBatchOnly** 可选参数。横截面引擎是否只保留最新时间戳上的数据。当 *lastBatchOnly* = true 时，只能指定 *triggeringPattern* = 'keyCount'，此时横截面引擎维护的键值表只保存最新时间戳的键值数据；否则，更新并保留所有时间戳上的键值数据。\n\n**contextByColumn** 可选参数，字符串标量或向量。设置后，将对横截面引擎中数据按照指定的字段或字段组合分组，并在组内进行指定计算。\n\n* 设置该参数，必须指定 *metrics* 和 *outputTable*.\n* 如果 *metrics* 全为聚合函数，则分组计算结果和 groupby 分组计算结果一致，否则和 contextby 分组计算结果一致。\n\n若要开启快照机制 (snapshot)，必须指定 **snapshotDir** 与 **snapshotIntervalInMsgCount**。\n\n**snapshotDir** 可选参数，字符串，表示保存引擎快照的文件目录。\n\n* 指定的目录必须存在，否则系统会提示异常。\n* 创建流数据引擎时，如果指定了 *snapshotDir*，会检查该目录下是否存在快照。如果存在，会加载该快照，恢复引擎的状态。\n* 多个引擎可以指定同一个目录存储快照，用引擎的名称来区分快照文件。\n* 一个引擎的快照可能会使用三个文件名：\n  * 临时存储快照信息：文件名为 \\<engineName>.tmp；\n  * 快照生成并刷到磁盘：文件保存为 \\<engineName>.snapshot；\n  * 存在同名快照：旧快照自动重命名为 \\<engineName>.old。\n\n**snapshotIntervalInMsgCount** 可选参数，为整数类型，表示每隔多少条数据保存一次流数据引擎快照。\n\n**raftGroup** 是流数据高可用订阅端 raft 组的 ID (大于 1 的整数，由流数据高可用相关的配置项 *streamingRaftGroups* 指定)。设置该参数表示开启计算引擎高可用。在 leader 节点创建流数据引擎后，会同步在 follower 节点创建该引擎。每次保存的 snapshot 也会同步到 follower。当 raft 组的 leader 节点宕机时，会自动切换新 leader 节点重新订阅流数据表。注意，若要指定 *raftGroup*，必须同时指定 *snapshotDir*。\n\n注意，自 3.00.5 版本起，流计算引擎暂不支持高可用功能，*raftGroup* 参数将不生效。\n\n**outputElapsedMicroseconds**布尔值，表示是否输出每个 batch 中数据从注入引擎到计算输出的总耗时，以及每个 batch 包含的总记录数，默认为 false，不输出。\n\n**Note:** *outputElapsedMicroseconds*= true 时，若同时指定 *useSystemTime*=true，则*metrics*中不可使用聚合函数。\n\n**roundTime** 可选参数，布尔值。用于对第一个数据窗口的起始时间进行规整，仅在 *triggeringPattern*=dataInterval 时有效。系统将根据该参数、triggeringInterval 和时间精度来确定规整尺度（alignmentSize）。窗口规整规则同[时序引擎](https://docs.dolphindb.cn/zh/funcs/c/createTimeSeriesEngine.html)。\n\n**keyFilter** 可选参数，以元代码形式表示的过滤条件。过滤条件是一个表达式或者函数调用，应用于截面数据中的列（列值为 key），返回一个布尔向量。引擎会从截面数据中过滤出 key 满足条件的数据进行计算。\n\n**updatedContextGroupsOnly** 可选参数，布尔标量，默认值为 false。决定是否仅计算相较上次输出存在更新的分组数据。\n\n#### 返回值\n\n一个表。\n\n#### 例子\n\n例1. 横截面引擎 csEngineDemo1 触发计算的方式为 \"perRow\"。6 行数据写入流数据表 trades1，结果亦为 6 行。\n\n```\nshare streamTable(10:0,`time`sym`price`volume,[TIMESTAMP,SYMBOL,DOUBLE,INT]) as trades1\nshare table(1:0, `time`avgPrice`volume`dollarVolume`count, [TIMESTAMP,DOUBLE,INT,DOUBLE,INT]) as outputTable\ncsEngine1=createCrossSectionalEngine(name=\"csEngineDemo1\", metrics=<[avg(price), sum(volume), sum(price*volume), count(price)]>, dummyTable=trades1, outputTable=outputTable, keyColumn=`sym, triggeringPattern=\"perRow\", useSystemTime=false, timeColumn=`time)\nsubscribeTable(tableName=\"trades1\", actionName=\"tradesStats\", offset=-1, handler=append!{csEngine1}, msgAsTable=true)\ninsert into trades1 values(2020.08.12T09:30:00.000 + 123 234 456 678 890 901, `A`B`A`B`B`A, 10 20 10.1 20.1 20.2 10.2, 20 10 20 30 40 20);\n\nselect * from trades1;\n```\n\n| time                    | sym | price | volume |\n| ----------------------- | --- | ----- | ------ |\n| 2020.08.12T09:30:00.123 | A   | 10    | 20     |\n| 2020.08.12T09:30:00.234 | B   | 20    | 10     |\n| 2020.08.12T09:30:00.456 | A   | 10.1  | 20     |\n| 2020.08.12T09:30:00.678 | B   | 20.1  | 30     |\n| 2020.08.12T09:30:00.890 | B   | 20.2  | 40     |\n| 2020.08.12T09:30:00.901 | A   | 10.2  | 20     |\n\n```\nselect * from outputTable;\n```\n\n| time                    | avgPrice | volume | dollarVolume | count |\n| ----------------------- | -------- | ------ | ------------ | ----- |\n| 2020.08.12T09:30:00.123 | 10       | 20     | 200          | 1     |\n| 2020.08.12T09:30:00.234 | 15       | 30     | 400          | 2     |\n| 2020.08.12T09:30:00.456 | 15.05    | 30     | 402          | 2     |\n| 2020.08.12T09:30:00.678 | 15.1     | 50     | 805          | 2     |\n| 2020.08.12T09:30:00.890 | 15.15    | 60     | 1010         | 2     |\n| 2020.08.12T09:30:00.901 | 15.2     | 60     | 1012         | 2     |\n\n例2. 横截面引擎 csEngineDemo2 触发计算的方式为 \"perBatch\"。数据分为 2 个批次写入流数据表 trades2，结果为 2 行。\n\n```\nshare streamTable(10:0,`time`sym`price`volume,[TIMESTAMP,SYMBOL,DOUBLE,INT]) as trades2\nshare table(1:0, `time`avgPrice`volume`dollarVolume`count, [TIMESTAMP,DOUBLE,INT,DOUBLE,INT]) as outputTable\ncsEngine2=createCrossSectionalEngine(name=\"csEngineDemo2\", metrics=<[avg(price), sum(volume), sum(price*volume), count(price)]>, dummyTable=trades2, outputTable=outputTable, keyColumn=`sym, triggeringPattern=\"perBatch\", useSystemTime=false, timeColumn=`time)\nsubscribeTable(tableName=\"trades2\", actionName=\"tradesStats\", offset=-1, handler=append!{csEngine2}, msgAsTable=true)\ninsert into trades2 values(2020.08.12T09:30:00.000 + 123 234 456, `A`B`A, 10 20 10.1, 20 10 20);\nsleep(1)\ninsert into trades2 values(2020.08.12T09:30:00.000 + 678 890 901, `B`B`A, 20.1 20.2 10.2, 30 40 20);\n\nselect * from outputTable;\n```\n\n| time                    | avgPrice | volume | dollarVolume | count |\n| ----------------------- | -------- | ------ | ------------ | ----- |\n| 2020.08.12T09:30:00.456 | 15.05    | 30     | 402          | 2     |\n| 2020.08.12T09:30:00.901 | 15.2     | 60     | 1012         | 2     |\n\n例3. 横截面引擎 csEngineDemo4 触发计算的方式为 \"keyCount\"。设置 *lastBatchOnly* = true，只有最新时间戳上的数据会参与计算。因为 *metrics* 里聚合函数和非聚合函数混合使用，所以，输出记录行数等于输入记录行数，聚合结果重复输出多行。\n\n```\nshare streamTable(10:0,`time`sym`price`volume,[TIMESTAMP,SYMBOL,DOUBLE,INT]) as trades1\nshare table(1:0, `time`factor1`factor2, [TIMESTAMP, DOUBLE,INT]) as outputTable\nagg=createCrossSectionalAggregator(name=\"csEngineDemo4\", metrics=<[price+ 0.1, sum(volume)]>, dummyTable=trades1, outputTable=outputTable, keyColumn=`sym, triggeringPattern=\"keyCount\", triggeringInterval=5, useSystemTime=false, timeColumn=`time,lastBatchOnly=true)\nsubscribeTable(tableName=`trades1, actionName=\"csEngineDemo4\", msgAsTable=true, handler=append!{agg})\nnum=10\ntime=array(TIMESTAMP)\ntime=take(2018.01.01T09:30:00.000,num)\nsym=take(\"A\"+string(1..10),num)\nprice=1..num\nvolume=1..num\ntmp=table(time, sym, price, volume)\ntrades1.append!(tmp)\n\n// 第二次输入 5 条数据，lastBatchOnly=true，所以只有最新的 5 条数据参与计算。\nnum=5\ntime = array(TIMESTAMP)\ntime=take(2018.01.01T09:30:01.000,num)\nsym=take(\"A\"+string(1..10),num)\nprice=6..10\nvolume=6..10\ntmp=table(time, sym, price, volume)\ntrades1.append!(tmp)\n```\n\n| time                    | factor1 | factor2 |\n| ----------------------- | ------- | ------- |\n| 2018.01.01T09:30:00.000 | 1.1     | 55      |\n| 2018.01.01T09:30:00.000 | 2.1     | 55      |\n| 2018.01.01T09:30:00.000 | 3.1     | 55      |\n| 2018.01.01T09:30:00.000 | 4.1     | 55      |\n| 2018.01.01T09:30:00.000 | 5.1     | 55      |\n| 2018.01.01T09:30:00.000 | 6.1     | 55      |\n| 2018.01.01T09:30:00.000 | 7.1     | 55      |\n| 2018.01.01T09:30:00.000 | 8.1     | 55      |\n| 2018.01.01T09:30:00.000 | 9.1     | 55      |\n| 2018.01.01T09:30:00.000 | 10.1    | 55      |\n| 2018.01.01T09:30:01.000 | 6.1     | 40      |\n| 2018.01.01T09:30:01.000 | 7.1     | 40      |\n| 2018.01.01T09:30:01.000 | 8.1     | 40      |\n| 2018.01.01T09:30:01.000 | 9.1     | 40      |\n| 2018.01.01T09:30:01.000 | 10.1    | 40      |\n\n例4. 横截面引擎 csEngineDemo3 触发计算的方式为 \"interval\"，每 500 毫秒触发一次计算。向流数据表中写入6行数据，第一次批量写入，间隔 500 毫秒后再次写入。请注意，这里没有指定 *useSystemTime* 参数为 false，会返回计算发生的时刻。\n\n```\nshare streamTable(10:0,`time`sym`price`volume,[TIMESTAMP,SYMBOL,DOUBLE,INT]) as trades3\nshare table(1:0, `time`avgPrice`volume`dollarVolume`count, [TIMESTAMP,DOUBLE,INT,DOUBLE,INT]) as outputTable\ncsEngine3=createCrossSectionalEngine(name=\"csEngineDemo3\", metrics=<[avg(price), sum(volume), sum(price*volume), count(price)]>, dummyTable=trades3, outputTable=outputTable, keyColumn=`sym, triggeringPattern=\"interval\", triggeringInterval=500)\nsubscribeTable(tableName=\"trades3\", actionName=\"tradesStats\", offset=-1, handler=append!{csEngine3}, msgAsTable=true);\n\ninsert into trades3 values(2020.08.12T09:30:00.000, `A, 10, 20)\ninsert into trades3 values(2020.08.12T09:30:00.000 + 500, `B, 20, 10)\ninsert into trades3 values(2020.08.12T09:30:00.000 + 1000, `A, 10.1, 20)\ninsert into trades3 values(2020.08.12T09:30:00.000 + 2000, `B, 20.1, 30)\nsleep(500)\ninsert into trades3 values(2020.08.12T09:30:00.000 + 2500, `B, 20.2, 40)\ninsert into trades3 values(2020.08.12T09:30:00.000 + 3000, `A, 10.2, 20);\nsleep(500)\n\nselect * from outputTable;\n```\n\n| time                    | avgPrice | volume | dollarVolume | count |\n| ----------------------- | -------- | ------ | ------------ | ----- |\n| 2022.03.02T11:17:02.341 | 15.1     | 50     | 805          | 2     |\n| 2022.03.02T11:17:02.850 | 15.2     | 60     | 1,012        | 2     |\n\n*triggeringPattern* = \"interval\" 时，系统每隔 500ms 触发一次计算，输出一条结果。在计算被触发时，即使同一个 key 有多条记录未被计算，系统也只取最新时间戳上的数据进行计算。\n\n例5. 在股票数据中，有些股票在某一时刻之后就不再更新数据了，此时可通过 *keyFilter* 参数指定过滤条件。当之后收到其它股票数据并触发截面计算时不会计算该股票的数据。以在截面引擎中过滤出1小时内未更新的数据为例：\n\n```\n// 定义休市和过滤数据的逻辑\ndef checkTime(time){\n    maxTime = max(time)\n    if(between(maxTime, 2024.05.22T13:00:00.000:2024.05.22T13:30:00.000)){\n        return time > maxTime - 120*60*1000\n    } else{\n        return time > maxTime - 30*60*1000\n    }\n}\n// 定义截面引擎\nshare streamTable(10:0,`time`sym`price`volume,[TIMESTAMP,SYMBOL,DOUBLE,INT]) as trades1\nt=keyedTable(`sym,10:0,`time`sym`price`volume,[TIMESTAMP,SYMBOL,DOUBLE,INT])\nshare table(1:0, `time`factor1`factor2, [TIMESTAMP, DOUBLE, DOUBLE]) as outputTable\n// 指定 keyFilter 为一个函数，过滤出1小时内未更新的数据。 \ncsEngine5=createCrossSectionalEngine(name=\"csEngineDemo5\", metrics=<[avg(price), sum(volume)]>, dummyTable=trades1, outputTable=outputTable, keyColumn=`sym, keyFilter=<checkTime(time)>)\n// 模拟数据，A1 从 2024.05.22T09:32:00.000 之后未收到新的数据\ntime = 2024.05.22T09:30:00.000 join 2024.05.22T09:31:00.000 join 2024.05.22T09:32:00.000 join 2024.05.22T13:30:00.000 join 2024.05.22T13:31:00.000\nsym=`A1`A2`A1`A2`A2\nprice=100.0 100.5 100.3 100.8 100.6\nvolume=100 110 112 200 120\ntmp=table(time, sym, price, volume)\ncsEngine5.append!(tmp)\n// 查看截面引擎中的数据\nselect * from csEngine5\n```\n\n| time                    | sym | price | volume |\n| ----------------------- | --- | ----- | ------ |\n| 2024.05.22T09:32:00.000 | A1  | 100.3 | 112    |\n| 2024.05.22T13:31:00.000 | A2  | 100.6 | 120    |\n\n上面代码通过 *keyFilter* 找到截面引擎中仅 A2 的数据满足要求，因此结果表中仅 A2 的数据参与了计算。\n\n```\nselect * from outputTable\n```\n\n| time                    | factor1 | factor2 |\n| ----------------------- | ------- | ------- |\n| 2024.05.22T05:11:12.259 | 100.6   | 120     |\n\n在以上的例子中， `createCrossSectionalEngine` 的返回结果（以下称为横截面表）是为计算提供的一个中间结果，但横截面表亦可为最终结果。例如若需要定时刷新某只股票的最新交易价格， 按照常规思路是从实时交易表中按代码筛选股票并取出最后一条记录，而交易表的数据量是随着时间快速增长的，如果频繁做这样的查询，无论从系统的资源消耗还是从查询的效能来看都不是最优的做法。 而横截面表永远只保存所有股票的最近一次交易数据，数据量是稳定的，对于这种定时轮询的场景非常合适。\n\n要将横截面表作为最终结果，需要在对 `createCrossSectionalEngine` 中的 *metrics* 与 *outputTable* 这两个参数置空。\n\n```\ntradesCrossEngine=createCrossSectionalEngine(name=\"CrossSectionalDemo\", dummyTable=trades, keyColumn=`sym, triggeringPattern=`perRow)\n```\n\n例6. 按照 volume 分组，引擎每插入一行数据，就触发一次计算。\n\n```\ntry {\n    dropAggregator(`csEngineDemo)\n} catch(ex) {}\ntry {\n    dropStreamTable(`trades1)\n} catch(ex) {}\nshare streamTable(10:0, `time`sym`price`volume, [SECOND, SYMBOL, DOUBLE, INT]) as trades1\noutputTable = table(1:0, `time`volume`factor1`factor2, [SECOND, INT, DOUBLE, DOUBLE])\nagg1 = createCrossSectionalEngine(\n    name=\"csEngineDemo\",\n    metrics=<[avg(price), sum(volume)]>,\n    dummyTable=trades1,\n    outputTable=outputTable,\n    keyColumn=`sym,\n    triggeringPattern=\"perRow\",\n    useSystemTime=false,\n    timeColumn=`time,\n    outputElapsedMicroseconds=false,\n    contextByColumn=`volume,\n    updatedContextGroupsOnly=false\n)\n\nnum = 4\ntime = take(09:30:00, num)\nsym = take(`A1`B1`C1`D1, num)\nprice = rand(100.0, num)\nvolume = take(1 1 2 2, num)\ntmp = table(time, sym, price, volume)\nagg1.append!(tmp)\noutputTable\n```\n\n以上创建的引擎根据 volume 分组后得到 1 和 2 两个分组。由于设置了 *updatedContextGroupsOnly* = false，引擎不会检查各个分组的数据是否有更新。每当插入一行数据时，都会触发所有分组的计算和输出，因此， outputTable 中将输出 6 行数据。\n\n| time     | volume | factor1 | factor2 |\n| -------- | ------ | ------- | ------- |\n| 09:30:00 | 1      | 82.3447 | 1       |\n| 09:30:00 | 1      | 69.9793 | 2       |\n| 09:30:00 | 1      | 69.9793 | 2       |\n| 09:30:00 | 2      | 95.262  | 2       |\n| 09:30:00 | 1      | 69.9793 | 2       |\n| 09:30:00 | 2      | 80.5988 | 4       |\n\n```\ntry{dropAggregator(`csEngineDemo)}catch(ex){}\ntry{dropStreamTable(`trades1)}catch(ex){}\n\nshare streamTable(10:0,`time`sym`price`volume,[SECOND,SYMBOL,DOUBLE,INT]) as trades1\noutputTable = table(1:0, `time`volume`factor1`factor2, [SECOND, INT, DOUBLE, DOUBLE])\nagg1=createCrossSectionalEngine(name=\"csEngineDemo\", metrics=<[avg(price), sum(volume)]>, dummyTable=trades1, outputTable=outputTable, keyColumn=`sym, triggeringPattern=\"perRow\",useSystemTime=false, timeColumn=`time, outputElapsedMicroseconds=false, contextByColumn=`volume, updatedContextGroupsOnly=false)\nnum=4\ntime = take(09:30:00, num)\nsym= take(`A1`B1`C1`D1, num)\nprice=rand(100.0, num)\nvolume=take(1 1 2 2, num)\ntmp=table(time, sym, price, volume)\nagg1.append!(tmp)\noutputTable\n\n```\n\n设置 *updatedContextGroupsOnly* = true 后，引擎将仅计算本次插入的分组数据，因此，outputTable 中将输出 4 行数据。\n\n| time     | volume | factor1 | factor2 |\n| -------- | ------ | ------- | ------- |\n| 09:30:00 | 1      | 54.6926 | 1       |\n| 09:30:00 | 1      | 40.5904 | 2       |\n| 09:30:00 | 2      | 73.1741 | 2       |\n| 09:30:00 | 2      | 46.0153 | 4       |\n\n例7. 设置 *triggeringPattern*=\"dataInterval\"、*triggeringInterval* 与 *outputElapsedMicroseconds*\n\n本例中，横截面引擎按 branchId 维护各分支机构的最新状态，并按 1 分钟数据窗口输出截面汇总结果。\n\n```\nshare streamTable(1:0, `quoteTime`branchId`marginUsed`riskRate, [TIMESTAMP, SYMBOL, DOUBLE, DOUBLE]) as snapshot\nshare table(100:0, `time`totalMarginUsed`avgRiskRate`elapsedUs`batchRows, [TIMESTAMP, DOUBLE, DOUBLE, LONG, INT]) as outputTable\n\nengine = createCrossSectionalEngine(\n   name=\"csDataIntervalDemo\",\n   metrics=<[sum(marginUsed), avg(riskRate)]>,\n   dummyTable=snapshot,\n   outputTable=outputTable,\n   keyColumn=`branchId,\n   triggeringPattern=\"dataInterval\",\n   triggeringInterval=60000,\n   useSystemTime=false,\n   timeColumn=`quoteTime,\n   outputElapsedMicroseconds=true\n)\n\nsubscribeTable(tableName=`snapshot, actionName=\"csDataIntervalDemo\", msgAsTable=true, handler=append!{engine})\n\ninsert into snapshot values(2024.06.03T09:30:00.000, `BJ01, 12000000.0, 0.42)\ninsert into snapshot values(2024.06.03T09:30:10.000, `SH02, 12000000.0, 0.55)\ninsert into snapshot values(2024.06.03T09:30:40.000, `SZ03, 9800000.0, 0.37)\ninsert into snapshot values(2024.06.03T09:31:05.000, `BJ01, 12300000.0, 0.44)\n\nsleep(500)\n\nselect * from outputTable\n```\n\n输出结果可能如下：\n\n| time                    | totalMarginUsed | avgRiskRate | elapsedUs | batchRows |\n| ----------------------- | --------------- | ----------- | --------- | --------- |\n| 2024.06.03 09:31:00.000 | 33,800,000      | 0.4466667   | 3         | 1         |\n\n* *triggeringPattern*=\"dataInterval\" 表示基于数据时间间隔触发计算。本例中 *triggeringInterva*l=60000，窗口长度为 1 分钟。\n\n* 2024.06.03T09:31:05.000 这条数据是窗口结束后到达的第一条数据，因此会触发前一窗口 \\[09:30:00, 09:31:00) 的计算输出；它本身不参与这次输出。\n\n* 第一个窗口内各分支机构的最新状态分别为：\n\n  * BJ01：marginUsed=12000000；riskRate=0.42\n\n  * SH02：marginUsed=12000000；riskRate=0.55\n\n  * SZ03：marginUsed=9800000；riskRate=0.37\n\n因此 totalMarginUsed=33,800,000，avgRiskRate=(0.42+0.55+0.37)/3=0.4466667。\n\n* 设置 *outputElapsedMicroseconds*=true 后，输出表需要在指标列后追加一个 LONG 列和一个 INT 列，分别记录本次输出的耗时和 batch 记录数。\n\n* elapsedUs 会随部署环境和负载变化而变化。\n\n例8. 设置 *roundTime*和 *triggeringPattern*=“dataInterval” 控制窗口的规整方式。\n\n本例模拟零售企业门店库存快照。两个引擎仅 *roundTime* 设置不同，其余参数完全一致，用于对比首个数据窗口的边界差异。\n\n```\nshare streamTable(1:0, `eventTime`sku`onHandQty, [TIMESTAMP, SYMBOL, INT]) as inventory\nshare table(100:0, `time`totalOnHandQty, [TIMESTAMP, INT]) as outputRTTrue\nshare table(100:0, `time`totalOnHandQty, [TIMESTAMP, INT]) as outputRTFalse\n\nengineRTTrue = createCrossSectionalEngine(\n   name=\"engineRTTrue\",\n   metrics=<[sum(onHandQty)]>,\n   dummyTable=inventory,\n   outputTable=outputRTTrue,\n   keyColumn=`sku,\n   triggeringPattern=\"dataInterval\",\n   triggeringInterval=120000,\n   useSystemTime=false,\n   timeColumn=`eventTime,\n   roundTime=true\n)\n\nengineRTFalse = createCrossSectionalEngine(\n   name=\"engineRTFalse\",\n   metrics=<[sum(onHandQty)]>,\n   dummyTable=inventory,\n   outputTable=outputRTFalse,\n   keyColumn=`sku,\n   triggeringPattern=\"dataInterval\",\n   triggeringInterval=120000,\n   useSystemTime=false,\n   timeColumn=`eventTime,\n   roundTime=false\n)\n\nsubscribeTable(tableName=\"inventory\", actionName=\"engineRTTrue\", offset=0, handler=append!{engineRTTrue}, msgAsTable=true)\nsubscribeTable(tableName=\"inventory\", actionName=\"engineRTFalse\", offset=0, handler=append!{engineRTFalse}, msgAsTable=true)\n\ninsert into inventory values(2024.06.03T10:03:30.500, `SKU1001, 120)\ninsert into inventory values(2024.06.03T10:04:20.000, `SKU2008, 80)\ninsert into inventory values(2024.06.03T10:05:10.000, `SKU3012, 60)\n\n```\n\n对于 *roundTime*=true 的引擎，执行 `select * from outputRTTrue`，输出如下：\n\n| time                    | totalOnHandQty |\n| ----------------------- | -------------- |\n| 2024.06.03 10:04:00.000 | 120            |\n\n对于 *roundTime*=false 的引擎，执行 `select * from outputRTFalse`，输出如下：\n\n| time                    | totalOnHandQty |\n| ----------------------- | -------------- |\n| 2024.06.03 10:05:00.000 | 200            |\n\n* 本例中 *triggeringPattern*=\"dataInterval\" 、*triggeringInterval*=120000，即窗口长度为 2 分钟。\n\n* 首条数据时间为 2024.06.03T10:03:30.500。\n\n* *roundTime*=true 时，首个窗口按 2 分钟规整，首个窗口为 \\[10:02:00, 10:04:00)，因此只有 SKU1001=120 落入首个窗口；10:04:20.000 的数据到达时触发输出，结果为 120。\n\n* *roundTime*=false 时，首个窗口按 1 分钟规整，首个窗口为 \\[10:03:00, 10:05:00)，因此 SKU1001=120 和 SKU2008=80 都落入首个窗口；10:05:10.000 的数据到达时触发输出，结果为 200。\n"
    },
    "createCryptoOrderBookEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/createcryptoorderbookengine.html",
        "signatures": [
            {
                "full": "createCryptoOrderBookEngine(name, dummyTable, inputColMap, [outputTable], depth, [updateRule='direct'], [errorHandler=NULL], [cachingInterval=5000], [timeout=-1], [outputHandler], [msgAsTable=false], [cachedDepth], [snapshotDir], [snapshotIntervalInMsgCount])",
                "name": "createCryptoOrderBookEngine",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "dummyTable",
                        "name": "dummyTable"
                    },
                    {
                        "full": "inputColMap",
                        "name": "inputColMap"
                    },
                    {
                        "full": "[outputTable]",
                        "name": "outputTable",
                        "optional": true
                    },
                    {
                        "full": "depth",
                        "name": "depth"
                    },
                    {
                        "full": "[updateRule='direct']",
                        "name": "updateRule",
                        "optional": true,
                        "default": "'direct'"
                    },
                    {
                        "full": "[errorHandler=NULL]",
                        "name": "errorHandler",
                        "optional": true,
                        "default": "NULL"
                    },
                    {
                        "full": "[cachingInterval=5000]",
                        "name": "cachingInterval",
                        "optional": true,
                        "default": "5000"
                    },
                    {
                        "full": "[timeout=-1]",
                        "name": "timeout",
                        "optional": true,
                        "default": "-1"
                    },
                    {
                        "full": "[outputHandler]",
                        "name": "outputHandler",
                        "optional": true
                    },
                    {
                        "full": "[msgAsTable=false]",
                        "name": "msgAsTable",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[cachedDepth]",
                        "name": "cachedDepth",
                        "optional": true
                    },
                    {
                        "full": "[snapshotDir]",
                        "name": "snapshotDir",
                        "optional": true
                    },
                    {
                        "full": "[snapshotIntervalInMsgCount]",
                        "name": "snapshotIntervalInMsgCount",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [createCryptoOrderBookEngine](https://docs.dolphindb.cn/zh/funcs/c/createcryptoorderbookengine.html)\n\n\n\n#### 语法\n\ncreateCryptoOrderBookEngine(name, dummyTable, inputColMap, \\[outputTable], depth, \\[updateRule='direct'], \\[errorHandler=NULL], \\[cachingInterval=5000], \\[timeout=-1], \\[outputHandler], \\[msgAsTable=false], \\[cachedDepth], \\[snapshotDir], \\[snapshotIntervalInMsgCount])\n\n**Note:**\n\n社区版 License 暂不支持该引擎，如需使用此功能，请联系技术支持。\n\n#### 详情\n\n根据数字货币全量订单簿快照和增量订单簿更新数据，实时更新数字货币交易对的订单簿，并输出指定深度的订单簿信息。\n\n该引擎通常与交易所行情接口配合使用：\n\n1. 通过 REST API 获取一次全量订单簿快照。\n\n2. 通过 WebSocket 订阅订单簿增量更新。\n\n3. 将全量数据和后续增量数据输入引擎，由引擎在本地维护实时订单簿。\n\n4. 若检测到增量数据丢失，可重新请求 REST 快照并重新同步订单簿。\n\n当检测到增量数据丢失或乱序时，可以通过 errorHandler 执行自定义处理逻辑（例如重新请求全量快照）。\n\n该引擎支持通用的订单簿更新规则，同时提供针对 Binance 现货（Binance-spot）和期货（Binance-futures）的专用规则。对于其他交易所，可根据数据格式选择 **general** 或 **direct** 规则，并确保增量数据顺序或更新逻辑正确。\n\n#### 参数\n\n**name** 字符串标量，表示 CryptoOrderBook 引擎的名称，可包含字母，数字和下划线，但必须以字母开头。\n\n**dummyTable** 一个表对象，表示输入表，用于接收来自交易所或其他行情系统的订单簿数据。*dummyTable* 需要通过 *inputColMap* 映射为如下两类字段：基础字段（所有 updateRule 必需）和更新规则字段（根据 updateRule 不同而变化）：\n\n输入表必须字段：\n\n<table id=\"table_oyn_cbx_gdc\"><thead><tr><th>\n\n**列名**\n\n</th><th>\n\n**类型**\n\n</th><th>\n\n**含义**\n\n</th></tr></thead><tbody><tr><td>\n\nsymbol\n\n</td><td>\n\nSYMBOL\n\n</td><td>\n\n数字货币代码。\n\n</td></tr><tr><td>\n\nisIncremental\n\n</td><td>\n\nBOOL\n\n</td><td>\n\n是否为增量数据。-   true 表示订单簿增量更新数据，通常来自 WebSocket 推送。\n\n* false 表示全量订单簿数据，通常来自 REST 接口。\n\n</td></tr><tr><td>\n\neventTime\n\n</td><td>\n\nTIMESTAMP/ NANOTIMESTAMP\n\n</td><td>\n\n事件时间。\n\n</td></tr><tr><td>\n\naskQty\n\n</td><td>\n\nDECIMAL\\[] / DOUBLE\\[]\n\n</td><td>\n\n卖出数量的列表。\n\n</td></tr><tr><td>\n\naskPrice\n\n</td><td>\n\nDECIMAL\\[] / DOUBLE\\[]\n\n</td><td>\n\n卖出价格的列表。\n\n</td></tr><tr><td>\n\nbidQty\n\n</td><td>\n\nDECIMAL\\[] / DOUBLE\\[]\n\n</td><td>\n\n买入数量的列表。\n\n</td></tr><tr><td>\n\nbidPrice\n\n</td><td>\n\nDECIMAL\\[] / DOUBLE\\[]\n\n</td><td>\n\n买入价格的列表。\n\n</td></tr></tbody>\n</table>另外，根据 *updateRule* 的不同，可能需要提供其它字段：\n\n* 当 *updateRule* =“direct“ 时，不需要额外指定字段。\n\n* 当 *updateRule* =“general“ 时，还需要指定以下字段：\n\n| **列名**       | **类型** | **含义**      |\n| ------------ | ------ | ----------- |\n| prevUpdateId | LONG   | 上一条数据的 ID。  |\n| updateId     | LONG   | 当前收到数据的 ID。 |\n\n* 当 *updateRule* =\"Binance-spot\" 时，指定以下字段：\n\n| **列名**        | **类型** | **含义**                    |\n| ------------- | ------ | ------------------------- |\n| lastUpdateId  | LONG   | 从上次推送至今新增的最后一个 update Id。 |\n| firstUpdateId | LONG   | 从上次推送至今新增的第一个 update Id。  |\n\n* 当 *updateRule* =\"Binance-futures\" 时，指定以下字段：\n\n| **列名**           | **类型** | **含义**                                     |\n| ---------------- | ------ | ------------------------------------------ |\n| lastUpdateId     | LONG   | 从上次推送至今新增的最后一个 update Id。                  |\n| firstUpdateId    | LONG   | 从上次推送至今新增的第一个 update Id。                   |\n| prevLastUpdateId | LONG   | 上次推送的最后一个 update Id (即上条消息的 lastUpdateId)。 |\n\n除了上述列之外，输入表中的所有其他列都将被复制到输出表中。\n\n**inputColMap** 字典，将 *dummyTable* 中列字段的名称映射为引擎计算所需要的列。\n\n**outputTable** 可选参数，一个表对象，用于输出最新的订单簿。其结构必须与 *dummyTable* 相同。*outputTable* 和 *outputHandler* 只需指定其一。\n\n**depth** 正整数或字典，用于指定订单簿的深度。\n\n* 正整数：所有数字货币的订单簿深度都为该设置值。\n\n* 字典：键是字符串标量或向量，表示数字货币代码；值是整型，表示订单簿深度。对于指定的数字货币，将按照设定的深度输出订单簿。未被指定的数字货币将不输出订单簿结果。\n\n**updateRule** 可选参数，字符串标量，用于指定订单簿更新规则。可选值为：\n\n* \"direct\"：默认值，表示直接更新，系统将不进行数据丢失判断，仅根据 isIncremental 字段判断是对订单簿执行增量更新（isIncremental=true）还是覆盖（isIncremental-false）。\n* \"general\"：通用更新规则。要求按顺序插入增量数据，并确保数据中 updateId 单调递增。\n* \"Binance-spot\"：基于 Binance 现货交易所订单簿更新机制定义的规则。\n* \"Binance-futures\"：基于 Binance 期货交易所订单簿更新机制定义的规则。\n\n**Note:** 该参数并不限制交易所类型。只要输入数据满足相应规则，即可使用该引擎。\n\n**errorHandler** 可选参数，自定义错误处理函数。当增量数据出现缺失时，可通过该函数进行错误处理。包含 2 个参数：\n\n* 第一个是字符串标量，表示数字货币代码。\n* 第二个是整型标量，表示错误码，包括以下情况：\n  * 1：接收到历史数据。\n  * 2：接收到应在未来时间点到达的乱序数据。\n  * 3：超时错误，指定时间间隔内没有新的订单簿合成。\n  * 4：买卖价格交叉错误。判断交叉的条件为最高买价大于等于最低卖价。\n\n**cachingInterval** 可选参数，整型标量，表示缓存增量深度数据的时间间隔。默认值为 5000，单位为毫秒。对于每个数字货币，当缓存中的数据时间与当前最新一条数据时间的差值小于等于 *cachingInterval* 时，该数据才会被保留在缓存中。\n\n**timeout** 可选参数，整型标量，表示订单簿更新超时时间。单位为毫秒，默认值为 -1，表示不设置超时时间。在 *timeout* 指定的时间内未合成新的订单簿时，将触发超时错误，此时会通过 *errorHandler* 进行错误处理。\n\n**outputHandler** 可选参数，一元函数，用于处理引擎输出结果。设置此参数时，引擎计算结束后，不再将计算结果写到输出表，而是会调用此函数处理计算结果。\n\n**msgAsTable** 可选参数，布尔标量，表示在设置了参数 *outputHandler* 时，将引擎的计算结果以表的结构调用函数。默认值为 false，此时将计算结果的每一列作为元素组成元组。\n\n**cachedDepth** 可选参数，正整数或字典，用于指定缓存中价格和数量（包括 askQty, askPrice, bidQty, bidPrice）的深度。\n\n* 正整数：缓存中所有数字货币的价格和数量将按照该值的深度进行缓存。\n\n* 字典：键是字符串标量或向量，表示数字货币代码；值是整型，表示对应的深度。对于指定的数字货币，将按照设定的深度缓存价格和数量。未被指定的数字货币将保留实际收到的所有价格和数量信息。\n\n若要开启快照机制 (snapshot)，必须指定 *snapshotDir* 与 *snapshotIntervalInMsgCount*。\n\n**snapshotDir** 可选参数，字符串，表示保存引擎快照的文件目录。\n\n* 指定的目录必须存在，否则系统会提示异常。\n\n* 创建流数据引擎时，如果指定了 *snapshotDir*，会检查该目录下是否存在快照。如果存在，会加载该快照，恢复引擎的状态。\n\n* 多个引擎可以指定同一个目录存储快照，用引擎的名称来区分快照文件。\n\n* 一个引擎的快照可能会使用三个文件名：\n\n  * 临时存储快照信息：文件名为 *\\<engineName>.tmp*；\n\n  * 快照生成并刷到磁盘：文件保存为 *\\<engineName>.snapshot*；\n\n  * 存在同名快照：旧快照自动重命名为 *\\<engineName>.old*。\n\n**snapshotIntervalInMsgCount** 可选参数，为整数类型，表示每隔多少条数据保存一次流数据引擎快照。\n\n#### 返回值\n\n一个表。\n\n#### 例子\n\n运行代码前，先下载 [../data/CryptoOrderBookInput.zip](https://docs.dolphindb.cn/zh/funcs/data/CryptoOrderBookInput.zip) 文件。\n\n例1. 创建一个加密货币订单簿引擎，使用 \"Binance-futures\" 规则处理来自 Binance 交易所 U 本位合约的深度数据。根据 Binance 交易所数据发送规则，示例数据中首先为增量深度数据，在 68 行插入 1000 档全量快照数据后，引擎开始输出订单簿。\n\n```\n// 定义输入输出表结构\ncolNames = `isIncremental`exchange`eventTime`transactionTime`symbol`firstUpdateId`lastUpdateId`prevLastUpdateId`bidPrice`bidQty`askPrice`askQty\ncolTypes = [BOOL, SYMBOL, TIMESTAMP, TIMESTAMP, SYMBOL, LONG, LONG, LONG, DECIMAL128(18)[], DECIMAL128(8)[], DECIMAL128(18)[], DECIMAL128(8)[]]\n\n// 创建输入输入输出表\nshare table(1:0, colNames, colTypes) as outputTable\nshare table(1:0, colNames, colTypes) as inputTable\n\ninputTarget = [\"symbol\", \"eventTime\", \"isIncremental\", \"bidPrice\", \"bidQty\", \"askPrice\", \"askQty\", \"lastUpdateId\", \"firstUpdateId\", \"prevLastUpdateId\"]\ninputSource = [\"symbol\", \"eventTime\", 'isIncremental', 'bidPrice', 'bidQty', 'askPrice', 'askQty', 'lastUpdateId', 'firstUpdateId', 'prevLastUpdateId']\n\ninputColMap = dict(inputTarget, inputSource)\n\n\ndepth = dict([\"BTCUSDT\"], [1000])\ncachedDepth = dict([\"BTCUSDT\"], [1500])\n\ndef errorHandler(instrument, code) {\n    if (code == 1) {\n        writeLog(\"handle hisotorical msg...\")\n    } else if (code == 2) {\n        writeLog(\"handle unordered msg...\")\n    } else if (code == 3) {\n        writeLog(\"handle timeout...\")\n    } else if (code == 4) {\n        writeLog(\"handle corssed price...\")\n    } else {\n        writeLog(\"unknown error!\")\n    }\n}\n\n// 创建引擎\nengine = createCryptoOrderBookEngine(name=\"binanceFutures\", dummyTable=inputTable, inputColMap=inputColMap, outputTable=outputTable, \n                                        depth=depth, updateRule=\"Binance-futures\", errorHandler=errorHandler, cachingInterval=5000, \n                                        timeout=6000, msgAsTable=true, cachedDepth=cachedDepth)\n\n\n// 加载示例数据\nfin=file(\"binanceFuturesTestData.bin\")\nbinanceFuturesTestData = fin.readObject()\nfin.close();\n// 数据插入引擎进行合成\ngetStreamEngine(\"binanceFutures\").append!(binanceFuturesTestData)\n\n// 清除环境\nundef(\"inputTable\", SHARED)\nundef(\"outputTable\", SHARED)\ndropStreamEngine(\"binanceFutures\")\n\n```\n\n例2. 创建一个加密货币订单簿引擎，使用 \"general\" 规则处理来自 OKX 交易所永续合约的深度数据。根据 OKX 交易所数据发送规则，示例数据中首行为 400 档快照数据，之后为增量快照数据。\n\n```\n\n// 定义输入输出表结构\ncolNames=['isIncremental', 'symbol', 'askPrice', 'askVolume', 'askNum', 'bidPrice', 'bidVolume', 'bidNum', 'checksum', 'prevSeqId', 'seqId', 'updateTime'];\ncolTypes=[BOOL, SYMBOL, DECIMAL128(18)[], DECIMAL128(8)[], INT[], DECIMAL128(18)[], DECIMAL128(8)[], INT[], LONG, LONG, LONG, TIMESTAMP];\n\n// 创建输入输入输出表\nshare table(1:0, colNames, colTypes) as inputTable\nshare table(1:0, colNames, colTypes) as outputTable\n\ninputTarget = [\"symbol\", \"eventTime\", \"isIncremental\", \"bidPrice\", \"bidQty\", \"askPrice\", \"askQty\", \"prevUpdateId\", \"updateId\"];\ninputSource = [\"symbol\", \"updateTime\", 'isIncremental', 'bidPrice', 'bidVolume', 'askPrice', 'askVolume', 'prevSeqId', 'seqId'];\n\ninputColMap = dict(inputTarget, inputSource)\n\ndepth = dict([\"BTC-USD-SWAP\"], [400])\ncachedDepth = dict([\"BTC-USD-SWAP\"], [800])\n\ndef errorHandler(instrument, code) {\n    if (code == 1) {\n        writeLog(\"handle hisotorical msg...\")\n    } else if (code == 2) {\n        writeLog(\"handle unordered msg...\")\n    } else if (code == 3) {\n        writeLog(\"handle timeout...\")\n    } else if (code == 4) {\n        writeLog(\"handle corssed price...\")\n    } else {\n        writeLog(\"unknown error!\")\n    }\n}\n\n// 创建引擎\nengine = createCryptoOrderBookEngine(name=\"okxSwap\", dummyTable=inputTable, inputColMap=inputColMap, outputTable=outputTable, \n                                        depth=depth, updateRule=\"general\", errorHandler=errorHandler, cachingInterval=5000, \n                                        timeout=6000, msgAsTable=true, cachedDepth=cachedDepth)\n\n\n// 加载示例数据\nfin=file(\"okxTestData.bin\")\nokxTestData = fin.readObject()\nfin.close();\n// 数据插入引擎进行合成\ngetStreamEngine(\"okxSwap\").append!(okxTestData)\n\n// 清除环境\nundef(\"inputTable\", SHARED)\nundef(\"outputTable\", SHARED)\ndropStreamEngine(\"okxSwap\")\n\n```\n"
    },
    "createDailyTimeSeriesEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/createDailyTimeSeriesEngine.html",
        "signatures": [
            {
                "full": "createDailyTimeSeriesEngine(name, windowSize, step, metrics, dummyTable, outputTable, [timeColumn], [useSystemTime=false], [keyColumn], [garbageSize], [updateTime], [useWindowStartTime], [roundTime=true], [snapshotDir], [snapshotIntervalInMsgCount], [fill='none'], [sessionBegin], [sessionEnd], [mergeSessionEnd=false], [forceTriggerTime], [raftGroup], [forceTriggerSessionEndTime], [keyPurgeFreqInSec], [closed='left'], [outputElapsedMicroseconds=false], [subWindow], [parallelism=1],[acceptedDelay=0], [outputHandler], [msgAsTable=false], [keyPurgeDaily=true], [mergeLastWindow=false], [mergeSession])",
                "name": "createDailyTimeSeriesEngine",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "windowSize",
                        "name": "windowSize"
                    },
                    {
                        "full": "step",
                        "name": "step"
                    },
                    {
                        "full": "metrics",
                        "name": "metrics"
                    },
                    {
                        "full": "dummyTable",
                        "name": "dummyTable"
                    },
                    {
                        "full": "outputTable",
                        "name": "outputTable"
                    },
                    {
                        "full": "[timeColumn]",
                        "name": "timeColumn",
                        "optional": true
                    },
                    {
                        "full": "[useSystemTime=false]",
                        "name": "useSystemTime",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[keyColumn]",
                        "name": "keyColumn",
                        "optional": true
                    },
                    {
                        "full": "[garbageSize]",
                        "name": "garbageSize",
                        "optional": true
                    },
                    {
                        "full": "[updateTime]",
                        "name": "updateTime",
                        "optional": true
                    },
                    {
                        "full": "[useWindowStartTime]",
                        "name": "useWindowStartTime",
                        "optional": true
                    },
                    {
                        "full": "[roundTime=true]",
                        "name": "roundTime",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[snapshotDir]",
                        "name": "snapshotDir",
                        "optional": true
                    },
                    {
                        "full": "[snapshotIntervalInMsgCount]",
                        "name": "snapshotIntervalInMsgCount",
                        "optional": true
                    },
                    {
                        "full": "[fill='none']",
                        "name": "fill",
                        "optional": true,
                        "default": "'none'"
                    },
                    {
                        "full": "[sessionBegin]",
                        "name": "sessionBegin",
                        "optional": true
                    },
                    {
                        "full": "[sessionEnd]",
                        "name": "sessionEnd",
                        "optional": true
                    },
                    {
                        "full": "[mergeSessionEnd=false]",
                        "name": "mergeSessionEnd",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[forceTriggerTime]",
                        "name": "forceTriggerTime",
                        "optional": true
                    },
                    {
                        "full": "[raftGroup]",
                        "name": "raftGroup",
                        "optional": true
                    },
                    {
                        "full": "[forceTriggerSessionEndTime]",
                        "name": "forceTriggerSessionEndTime",
                        "optional": true
                    },
                    {
                        "full": "[keyPurgeFreqInSec]",
                        "name": "keyPurgeFreqInSec",
                        "optional": true
                    },
                    {
                        "full": "[closed='left']",
                        "name": "closed",
                        "optional": true,
                        "default": "'left'"
                    },
                    {
                        "full": "[outputElapsedMicroseconds=false]",
                        "name": "outputElapsedMicroseconds",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[subWindow]",
                        "name": "subWindow",
                        "optional": true
                    },
                    {
                        "full": "[parallelism=1]",
                        "name": "parallelism",
                        "optional": true,
                        "default": "1"
                    },
                    {
                        "full": "[acceptedDelay=0]",
                        "name": "acceptedDelay",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[outputHandler]",
                        "name": "outputHandler",
                        "optional": true
                    },
                    {
                        "full": "[msgAsTable=false]",
                        "name": "msgAsTable",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[keyPurgeDaily=true]",
                        "name": "keyPurgeDaily",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[mergeLastWindow=false]",
                        "name": "mergeLastWindow",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[mergeSession]",
                        "name": "mergeSession",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [createDailyTimeSeriesEngine](https://docs.dolphindb.cn/zh/funcs/c/createDailyTimeSeriesEngine.html)\n\n\n\n#### 语法\n\ncreateDailyTimeSeriesEngine(name, windowSize, step, metrics, dummyTable, outputTable, \\[timeColumn], \\[useSystemTime=false], \\[keyColumn], \\[garbageSize], \\[updateTime], \\[useWindowStartTime], \\[roundTime=true], \\[snapshotDir], \\[snapshotIntervalInMsgCount], \\[fill='none'], \\[sessionBegin], \\[sessionEnd], \\[mergeSessionEnd=false], \\[forceTriggerTime], \\[raftGroup], \\[forceTriggerSessionEndTime], \\[keyPurgeFreqInSec], \\[closed='left'], \\[outputElapsedMicroseconds=false], \\[subWindow], \\[parallelism=1],\\[acceptedDelay=0], \\[outputHandler], \\[msgAsTable=false], \\[keyPurgeDaily=true], \\[mergeLastWindow=false], \\[mergeSession])\n\n#### 详情\n\n创建流数据日级时间序列引擎。日级时间序列引擎和时间序列引擎窗口划分和计算规则基本一致，但在此基础上做了如下拓展：\n\n* 该引擎只能在一个自然日的指定时间段内（以下统称为 session）进行窗口的聚合计算。一个自然日内，可以指定多个 session， 如 9:00-12:00，13:00-15:00 等。默认情况下，系统会对 session 的起始时间（*sessionBegin* 和 *sessionEnd*）进行规整，除非特别指定（详见 *mergeLastWindow*）。\n* 出现在一个 session 开始之前的数据，日级时序引擎规定将该部分数据合入该 session 的第一个窗口进行计算。\n* 当日最后一个 session 后到来的数据将被丢弃，不会计入第二天的第一个窗口中。\n\n若指定了 *keyColumn* 进行分组，则上述计算将在各分组内独立进行。有关乱序数据的处理规则，请参考 `createTimeSeriesEngine` 函数中的[计算](https://docs.dolphindb.cn/zh/funcs/c/createTimeSeriesEngine.md#)章节。\n\n更多流数据引擎的应用场景说明可以参考 [流计算引擎](https://docs.dolphindb.cn/zh/funcs/themes/streamingEngine.html)。\n\n#### 参数\n\n该引擎是基于时间序列引擎进行的扩展，继承了 [createTimeSeriesEngine](https://docs.dolphindb.cn/zh/funcs/c/createTimeSeriesEngine.html) 所有的参数，请参照 `createTimeSeriesEngine` 中参数介绍。这里仅介绍与时间序列引擎不同的参数：\n\n**sessionBegin** 为可选参数，可以是与时间列的数据类型对应的 SECOND、TIME 或 NANOTIME 类型的标量或向量，表示每个时间段的起始时刻。如果 *sessionBegin* 是一个向量，它必须是递增的。\n\n**sessionEnd** 为可选参数，可以是与时间列的数据类型对应的 SECOND、TIME 或 NANOTIME 类型的标量或向量，表示每个时间段的结束时刻。可在 *sessionEnd* 中指定 00:00:00 表示的次日的零点（即当日的 24:00:00）。\n\n**Note:**\n\nsession 由 sessionBegin\\[i] 和 sessionEnd\\[i] 确定。\n\n* 若 sessionBegin\\[i] > sessionEnd\\[i]，则 sessionEnd\\[i] 视为下一个自然日的时间，此后 session 均为下一个自然日。例如 sessionBegin=\\[21:00:00, 23:30:00, 09:00:00, 13:00:00], sessionEnd=\\[22:00:00, 02:00:00,11:30:00, 15:00:00]，此时 session 分别为 21:00:00-22:00:00，23:30:00-次日02:00:00, 次日09:00:00-11:30:00， 次日13:00:00-15:00:00。 21:00:00-22:00:00为第一个session，keyPurgeDaily 在21:00:00之前生效，15:00:00-21:00:00之间的数据都会被丢弃。\n\n  * 若 i = 0 ，则该 session 视为该交易日的第一个 session。例如 sessionBegin=\\[21:00:00，09:00:00, 13:00:00]，sessionEnd=\\[01:00:00, 11:30:00, 15:00:00]，此时 session 分别为 21:00:00-次日01:00:00，次日 09:00:00- 11:30:00， 次日13:00:00- 15:00:00。21:00:00-次日01:00:00 为第一个 session，*keyPurgeDaily* 在21:00:00之前生效，15:00:00-21:00:00之间的数据都会被丢弃。\n\n  * 若 i = size(sessionBegin)-1，则该 session 视为该交易日的最后一个 session。例如 sessionBegin=\\[09:00:00, 13:00:00, 21:00:00]，sessionEnd=\\[11:30:00, 15:00:00, 01:00:00]，此时 session 分别为09:00:00-11:30:00，13:00:00-15:00:00，21:00:00-次日01:00:00。09:00:00-11:30:00 为第一个session， keyPurgeDaily 在09:00:00之前生效，01:00:00-09:00:00之间的数据会被丢弃。\n\n* 若 sessionBegin\\[i] < sessionEnd\\[i-1]，则 sessionBegin\\[i] 视为下一个自然日的时间，此后 session 均为下一个自然日。例如 sessionBegin=\\[21:00:00，09:00:00, 13:00:00]，sessionEnd=\\[23:00:00, 11:30:00, 15:00:00]，此时 session 分别为 21:00:00-23:00:00，次日09:00:00-11:30:00， 次日13:00:00-15:00:00。21:00:00-23:00:00为第一个session， keyPurgeDaily 在21:00:00之前生效，15:00:00-21:00:00之间的数据都会被丢弃。\n\n其他示例：\n\n* sessionBegin=\\[00:00:00, 09:00:00, 13:00:00, 21:00:00]，sessionEnd=\\[01:00:00, 11:30:00, 15:00:00, 00:00:00]，此时 session 分别为 21:00:00-次日01:00:00，09:00:00-11:30:00， 13:00:00-15:00:00。 21:00:00-次日01:00:00为第一个session， keyPurgeDaily 在21:00:00之前生效（2.00.14.4 前不会生效），15:00:00-21:00:00之间的数据都会被丢弃（2.00.14.4 前会并入21:00:00的第一个窗口）。\n\n* sessionBegin=\\[09:00:00, 13:00:00]，sessionEnd=\\[11:30:00, 15:00:00]，此时 session 分别为 09:00:00-11:30:00，13:00:00-15:00:00。keyPurgeDaily 在15:00:00之后生效，15:00:00-24:00:00之间的数据都会被丢弃，00:00:00-09:00:00 的数据会被并入第一个窗口。\n\n**mergeSessionEnd** 为可选参数，是一个布尔值。当 *closed* = 'left' 时，表示每个 session 结束时刻的数据是否合入最后一个窗口。默认值为 false，此时该条数据不会合入当前 session 的最后一个窗口，但可以触发最后一个窗口的计算；如果当前 session 不是该自然日内最后一个 session，则该数据会合入下个 session 的第一个窗口。\n\n**forceTriggerSessionEndTime** 为可选参数，正整数，单位与 *timeColumn* 的时间精度一致。若 *sessionEnd* 时刻对应的窗口数据长时间未发生计算，通过该参数可以设置系统经过多少时间后触发计算并输出。若不指定 *fill* ，未包含在该窗口内的分组不会输出结果；若指定了 *fill* ，未包含在该窗口内的分组会按照 *fill* 指定的方式输出结果。\n\n**Note:** 当系统时间达到 sessionEnd + forceTriggerSessionEndTime 时触发计算，因此该参数在回放场景下不适用。\n\n**keyPurgeDaily** 为可选参数，是一个布尔值。默认值为 true，表示引擎在收到第一批包含新日期的数据时，先清空之前保存的所有分组，再对这批新数据进行处理。若设置为 false，则引擎不会清理前一天的分组。\n\n**mergeLastWindow** 为可选参数，是一个布尔值，默认值为 false，可用于处理无法被等长窗口（由 *windowSize* 指定）均分的不规则 session 时段。当设置为 *true* 时，系统将最后一个不完整窗口（即小于 *windowSize* 的窗口）的数据与前一个窗口合并进行计算。该参数不支持和 *subWindow* 同时指定。\n\n**mergeSession** 为 BOOL 类型向量，其长度为 session 的数量减 1。mergeSession\\[i] 为 true 表示 session\\[i] 和 session\\[i+1] 合并，false 表示不合并。若两个 session 合并，则 *mergeSessionEnd*、*forceTriggerSessionEndTime* 和 *mergeLastWindow* 在前一个 session 的 *sessionEnd*处不生效。\n\n#### 返回值\n\n一个表对象。\n\n#### 例子\n\n例1. 设置 *mergeSessionEnd*，将每个 session 结束时刻的数据合入最后一个窗口。\n\n```\nshare streamTable(1000:0, `date`second`sym`volume, [DATE, SECOND, SYMBOL, INT]) as trades\nshare keyedTable(`time`sym, 10000:0, `time`sym`sumVolume, [DATETIME, SYMBOL, INT]) as output1\nengine1 = 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)\nsubscribeTable(tableName=\"trades\", actionName=\"engine1\", offset=0, handler=append!{engine1}, msgAsTable=true);\n\ninsert into trades values(2018.10.08,09:25:31,`A,8)\ninsert into trades values(2018.10.08,09:26:01,`B,10)\ninsert into trades values(2018.10.08,09:30:02,`A,26)\ninsert into trades values(2018.10.08,09:30:10,`B,14)\ninsert into trades values(2018.10.08,11:29:46,`A,30)\ninsert into trades values(2018.10.08,11:29:50,`B,11)\ninsert into trades values(2018.10.08,11:30:00,`A,14)\ninsert into trades values(2018.10.08,11:30:00,`B,4)\ninsert into trades values(2018.10.08,13:00:10,`A,16)\ninsert into trades values(2018.10.08,13:00:12,`B,9)\ninsert into trades values(2018.10.08,14:59:56,`A,20)\ninsert into trades values(2018.10.08,14:59:58,`B,20)\ninsert into trades values(2018.10.08,15:00:00,`A,10)\ninsert into trades values(2018.10.08,15:00:00,`B,29)\n\nsleep(1000)\nselect * from output1\n```\n\n| time                | sym | sumVolume |\n| ------------------- | --- | --------- |\n| 2018.10.08T09:31:00 | A   | 34        |\n| 2018.10.08T09:31:00 | B   | 24        |\n| 2018.10.08T11:30:00 | A   | 44        |\n| 2018.10.08T11:30:00 | B   | 15        |\n| 2018.10.08T13:01:00 | A   | 16        |\n| 2018.10.08T13:01:00 | B   | 9         |\n| 2018.10.08T15:00:00 | A   | 30        |\n| 2018.10.08T15:00:00 | B   | 49        |\n\n例2. 设置 *forceTriggerSessionEndTime*，达到系统时间，强制触发计算。\n\n```\nshare streamTable(1000:0, `date`second`sym`volume, [DATE, SECOND, SYMBOL, INT]) as trades\nshare keyedTable(`time`sym, 10000:0, `time`sym`sumVolume, [DATETIME, SYMBOL, INT]) as output1\nengine1 = 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)\nsubscribeTable(tableName=\"trades\", actionName=\"engine1\", offset=0, handler=append!{engine1}, msgAsTable=true);\n\ninsert into trades values(date(now()),09:25:31,`A,8)\ninsert into trades values(date(now()),09:26:01,`B,10)\ninsert into trades values(date(now()),09:30:02,`A,26)\ninsert into trades values(date(now()),09:30:10,`B,14)\ninsert into trades values(date(now()),11:29:46,`A,30)\ninsert into trades values(date(now()),11:29:50,`B,11)\ninsert into trades values(date(now()),11:30:00,`B,14)\ninsert into trades values(date(now()),11:30:01,`A,4)\n\nselect * from output1\n```\n\n| time                | sym | sumVolume |\n| ------------------- | --- | --------- |\n| 2022.03.24T09:31:00 | A   | 34        |\n| 2022.03.24T09:31:00 | B   | 24        |\n| 2022.03.24T11:30:00 | A   | 30        |\n\n设置 *forceTriggerSessionEndTime* = 10，则系统到达 11:30:00 后，再经过 10s 就会触发右边界为11:30:00的窗口内数据的计算。\n\n```\nsleep(10000)\nselect * from output1\n```\n\n| time                | sym | sumVolume |\n| ------------------- | --- | --------- |\n| 2022.03.24T09:31:00 | A   | 34        |\n| 2022.03.24T09:31:00 | B   | 24        |\n| 2022.03.24T11:30:00 | A   | 30        |\n| 2022.03.24T11:30:00 | B   | 25        |\n\n例3. 最后一个窗口的右边界为 *sessionEnd*。\n\n```\n// 清理变量\ndropStreamEngine(\"engine1\")\nunsubscribeTable(tableName=\"trades\", actionName=\"engine1\")\nundef(`trades, SHARED)\nundef(`output1,SHARED)\n\nshare streamTable(1000:0, `date`time`sym`volume, [DATE, TIME, SYMBOL, INT]) as trades\nshare keyedTable(`timestamp`sym, 10000:0, `timestamp`sym`sumVolume, [TIMESTAMP, SYMBOL, INT]) as output1\n\n//创建引擎，指定窗口长度为 10 分钟。最后一个 sessionEnd 是 14:57:00 \nengine1 = createDailyTimeSeriesEngine(name=\"engine1\", windowSize=600000, step=600000, \n  metrics=<[sum(volume)]>, dummyTable=trades, outputTable=output1, timeColumn=`date`time, garbageSize=50, updateTime=2,\n  useSystemTime=false, keyColumn=`sym,  useWindowStartTime=false, mergeSessionEnd=true,sessionBegin=09:30:00.000 13:00:00.000, sessionEnd=11:30:00.000 14:57:00.000)\n  \nsubscribeTable(tableName=\"trades\", actionName=\"engine1\", offset=0, \n  handler=append!{engine1}, msgAsTable=true);\n\n// 模拟数据插入流表。\n// 最后一条数据时间是 14:56:00，按照一分钟规则进行规整，则该条数据将输出到 14:57:00 的窗口中\ninsert into trades values(2024.09.10,14:00:10.988,`A,16)\ninsert into trades values(2024.09.10,14:00:12.458,`B,9)\ninsert into trades values(2024.09.10,14:21:10.772,`A,13)\ninsert into trades values(2024.09.10,14:22:12.090,`B,15)\ninsert into trades values(2024.09.10,14:29:56.953,`A,20)\ninsert into trades values(2024.09.10,14:29:58.537,`B,20)\ninsert into trades values(2024.09.10,14:31:00.612,`A,10)\ninsert into trades values(2024.09.10,14:57:00.000,`B,29)\n\nsleep(5000)\nselect * from output1\n\n```\n\n| timestamp               | sym | sumVolume |\n| ----------------------- | --- | --------- |\n| 2024.09.10T14:10:00.000 | A   | 16        |\n| 2024.09.10T14:10:00.000 | B   | 9         |\n| 2024.09.10T14:30:00.000 | A   | 33        |\n| 2024.09.10T14:30:00.000 | B   | 35        |\n| 2024.09.10T14:40:00.000 | A   | 10        |\n| 2024.09.10T14:57:00.000 | B   | 29        |\n\n例4.\n\n设置 *keyPurgeDaily*=false, 则在收到第一批日期是 2024.09.11 的数据时，引擎不会清空日期是 2024.09.10 的分组数据。\n\n```\nshare streamTable(1000:0, `date`second`sym`volume, [DATE, SECOND, SYMBOL, INT]) as trades \nshare table(10000:0, `time`sym`sumVolume, [DATETIME, SYMBOL, INT]) as output1\nengine1 = createDailyTimeSeriesEngine(name=\"engine1\", windowSize=30*60, step=30*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, keyPurgeDaily=false, fill=\"null\", forceTriggerTime=60) \n\ninsert into engine1 values(2024.09.10,13:00:10,`A,16) \ninsert into engine1 values(2024.09.10,13:00:12,`B,9) \ninsert into engine1 values(2024.09.10,13:00:12,`C,9) \ninsert into engine1 values(2024.09.10,14:59:56,`A,20) \ninsert into engine1 values(2024.09.10,14:59:58,`B,20) \ninsert into engine1 values(2024.09.10,15:00:00,`A,10) \ninsert into engine1 values(2024.09.10,15:00:00,`B,29) \ninsert into engine1 values(2024.09.11,09:30:02,`A,26) \ninsert into engine1 values(2024.09.11,09:30:10,`B,14) \ninsert into engine1 values(2024.09.11,10:30:46,`A,30) \ninsert into engine1 values(2024.09.11,10:30:50,`B,11) \n\nselect * from output1\n```\n\n| time                | sym | sumVolume |\n| ------------------- | --- | --------- |\n| 2024.09.10T13:30:00 | A   | 16        |\n| 2024.09.10T13:30:00 | B   | 9         |\n| 2024.09.10T13:30:00 | C   | 9         |\n| 2024.09.10T14:00:00 | A   | 11        |\n| 2024.09.10T14:00:00 | B   | 30        |\n| 2024.09.10T14:00:00 | C   | 13        |\n| 2024.09.10T14:30:00 | A   | 20        |\n| 2024.09.10T14:30:00 | B   | 20        |\n| 2024.09.10T14:30:00 | C   | 10        |\n| 2024.09.10T15:00:00 | A   | 30        |\n| 2024.09.10T15:00:00 | B   | 49        |\n| 2024.09.10T15:00:00 | C   |           |\n| 2024.09.11T10:00:00 | A   | 26        |\n| 2024.09.11T10:00:00 | B   | 14        |\n| 2024.09.11T10:00:00 | C   |           |\n| 2024.09.11T10:30:00 | A   |           |\n\n从上表的结果可以看出，2024.09.11 的数据中未包含 C 分组，但由于引擎未删除 2024.09.10 中的 C 分组，因此填充结果中仍然出现了 C 分组。\n\n例5. 将第二个 session 的时间调整为 13:00:00\\~15:00:30，并设置 *mergeLastWindow* 为 true。session 的起止时间将不进行规整，最后一个不完整的窗口 \\[15:00:00, 15:00:30) 的数据与前一个窗口 \\[14:59:00, 15:00:00)一同计算，合并为一个 \\[14:59:00,15:00:30) 窗口输出。\n\n```\ndropStreamEngine(\"engine1\")\nunsubscribeTable(tableName=\"trades\", actionName=\"engine1\")\nundef(`trades, SHARED)\nundef(`output1,SHARED)\n\nshare streamTable(1000:0, `date`second`sym`volume, [DATE, SECOND, SYMBOL, INT]) as trades\nshare keyedTable(`time`sym, 10000:0, `time`sym`sumVolume, [DATETIME, SYMBOL, INT]) as output1\nengine1 = createDailyTimeSeriesEngine(name=\"engine1\", windowSize=60, step=60, timeColumn=`date`second,\n  metrics=<[sum(volume)]>, dummyTable=trades, outputTable=output1,  \n  useSystemTime=false, keyColumn=`sym, garbageSize=50, \n  useWindowStartTime=false, sessionBegin=09:00:00 13:00:00, \n  sessionEnd=11:30:00 15:00:30, roundTime=false, mergeLastWindow=true)\nsubscribeTable(tableName=\"trades\", actionName=\"engine1\", offset=0, \n  handler=append!{engine1}, msgAsTable=true);\n\ninsert into trades values(2018.10.08,13:00:10,`A,16)\ninsert into trades values(2018.10.08,13:00:12,`B,9)\ninsert into trades values(2018.10.08,14:29:56,`A,20)\ninsert into trades values(2018.10.08,14:29:58,`B,20)\ninsert into trades values(2018.10.08,14:31:00,`A,10)\ninsert into trades values(2018.10.08,14:55:00,`B,29)\ninsert into trades values(2018.10.08,14:56:00,`B,29)\ninsert into trades values(2018.10.08,14:57:01,`A,29)\ninsert into trades values(2018.10.08,14:57:01,`B,29)\ninsert into trades values(2018.10.08,14:59:01,`B,29)\ninsert into trades values(2018.10.08,14:59:01,`A,29)\ninsert into trades values(2018.10.08,15:00:01,`B,29)\ninsert into trades values(2018.10.08,15:00:01,`A,29)\ninsert into trades values(2018.10.08,15:00:31,`B,29)\ninsert into trades values(2018.10.08,15:00:31,`A,29)\nsleep(2000)\nselect * from output1\n```\n\n| time                | sym | sumVolume |\n| ------------------- | --- | --------- |\n| 2018.10.08 13:01:00 | A   | 16        |\n| 2018.10.08 13:01:00 | B   | 9         |\n| 2018.10.08 14:30:00 | A   | 20        |\n| 2018.10.08 14:30:00 | B   | 20        |\n| 2018.10.08 14:56:00 | B   | 29        |\n| 2018.10.08 14:32:00 | A   | 10        |\n| 2018.10.08 14:57:00 | B   | 29        |\n| 2018.10.08 14:58:00 | A   | 29        |\n| 2018.10.08 14:58:00 | B   | 29        |\n| 2018.10.08 15:00:00 | A   | 58        |\n| 2018.10.08 15:00:00 | B   | 58        |\n\n**Related information**\n\n[createTimeSeriesEngine](https://docs.dolphindb.cn/zh/funcs/c/createTimeSeriesEngine.html)\n"
    },
    "createDataViewEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/createDataViewEngine.html",
        "signatures": [
            {
                "full": "createDataViewEngine(name, outputTable, keyColumns, timeColumn, [useSystemTime=true], [throttle],[includeOperationType=false])",
                "name": "createDataViewEngine",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "outputTable",
                        "name": "outputTable"
                    },
                    {
                        "full": "keyColumns",
                        "name": "keyColumns"
                    },
                    {
                        "full": "timeColumn",
                        "name": "timeColumn"
                    },
                    {
                        "full": "[useSystemTime=true]",
                        "name": "useSystemTime",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[throttle]",
                        "name": "throttle",
                        "optional": true
                    },
                    {
                        "full": "[includeOperationType=false]",
                        "name": "includeOperationType",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [createDataViewEngine](https://docs.dolphindb.cn/zh/funcs/c/createDataViewEngine.html)\n\n\n\n#### 语法\n\ncreateDataViewEngine(name, outputTable, keyColumns, timeColumn, \\[useSystemTime=true], \\[throttle],\\[includeOperationType=false])\n\n#### 详情\n\n该函数用于在 CEP 中创建一个 DataView 引擎。该引擎负责维护指定监控值的最新快照，并将其输出到目标表（通常为流表），供其他程序订阅。通过该函数，用户可以在 CEP 引擎运行过程中实时监控关键变量的变化趋势。\n\n#### 参数\n\n**name** 字符串，表示 DataView 引擎的名称，可包含字母，数字和下划线，但必须以字母开头。\n\n**outputTable** 一个表，可以是内存表或分布式表，用于存储 DataView 引擎中的数据。如果需要前端展示实时数据，或绘制数据变化趋势图，则 *outputTable* 必须指定为一个流表。\n\n**keyColumns** 字符串标量或向量，为 *outputTable* 中的列名。引擎将使用指定列中数据的唯一（组合）值作为引擎的键值，对于每个键值，引擎都只保留 1 条数据。\n\n**timeColumn** 一个字符串，表示指定 *outputTable* 中时间列的名称。\n\n**useSystemTime** 布尔值，表示是否使用数据注入引擎时的系统时间作为输出的时间列。\n\n* 若 *useSystemTime*=true，输出表中的时间列为系统时间，此时数据中不能包含时间列。\n* 若 *useSystemTime*=false，输出表中的时间列为数据中的时间，此时需要写入的数据中包含时间。\n\n**throttle** DURATION 类型，用于设置 DataView 引擎输出数据到 *outputTable* 的时间间隔。当指定该参数时，*includeOperationType* 必须为 false。\n\n**includeOperationType** 可选参数，布尔值，设置是否在输出结果中包含每条数据记录的变更类型。默认值为 false。当设置为 true 时，输出表第一列必须为 CHAR 类型，用于标识对应记录的操作类型：\n\n* 'A'：新增记录\n\n* 'U'：更新记录\n\n* 'D'：删除记录\n\n**Note:**\n\n默认情况下，数据被删除后，引擎不会输出对应记录；开启 *includeOperationType* 后，引擎会输出被删除的记录（操作类型为 'D'）。因此，开启或关闭 *includeOperationType* 时，输出的记录行数可能不同。\n\n#### 返回值\n\n一个键值表。该表记录了每个键值对应的最新记录。\n\n#### 例子\n\n例1. 下例演示如何使用 CEP（复杂事件处理）引擎来实时维护股票委托订单的最新状态，包含订单的新增和删除操作。\n\n```\nclass Orders{\n    market :: STRING\n    code :: STRING\n    price :: DOUBLE\n    qty :: INT\n    def Orders(m,c,p,q){\n        market = m\n        code = c\n        price = p\n        qty = q\n    }\n}\nclass DeleteOrder{\n \n    code :: STRING\n  \n    def DeleteOrder(c){\n        code = c\n    }\n}\n// 定义监视器\nclass MainMonitor:CEPMonitor {\n    def MainMonitor(){\n    }\n    // 删除引擎时自动调用：删除共享流表\n    def onunload(){ undef('orderDV', SHARED) }\n    def checkOrders(newOrder)\n    def deleteOrder(order)\n    // 创建 Data View Engine, 指定主键为 code 列，统计每个股票的最新的委托信息\n    def onload(){\n        addEventListener(checkOrders,'Orders',,'all') \n        orderDV = streamTable(array(CHAR, 0) as type, array(STRING, 0) as market, array(STRING, 0) as code, array(DOUBLE, 0) as price, array(INT, 0) as qty, array(TIMESTAMP, 0) as updateTime)\n        share(orderDV,'orderDV')\n        createDataViewEngine(name='orderDV', outputTable=objByName('orderDV'), keyColumns=`code, timeColumn=`updateTime, useSystemTime=true, includeOperationType=true)\n        addEventListener(deleteOrder,'DeleteOrder',,'all') \n    }\n    // 更新每个股票的最新的委托信息\n    def checkOrders(newOrder){\n        getDataViewEngine('orderDV').append!(table(newOrder.market as market, newOrder.code as code, newOrder.price as price, newOrder.qty as qty))\n    }\n    def deleteOrder(order){\n        deleteDataViewItems('orderDV',order.code )\n    }\n}\n// 创建 CEP 引擎\ndummy = table(array(STRING, 0) as eventType, array(BLOB, 0) as blobs)\ntry{dropStreamEngine('cep1')}catch(ex){print(ex)}\nengine = createCEPEngine(name='cep1', monitors=<MainMonitor()>, dummyTable=dummy, eventSchema=[Orders,DeleteOrder])\nengine.appendEvent(Orders(\"m1\", \"c1\", 10.0, 100))\nengine.appendEvent(Orders(\"m1\", \"c2\", 10.0, 100))\nengine.appendEvent(Orders(\"m1\", \"c2\", 9.5, 100))\nengine.appendEvent(DeleteOrder(\"c2\"))\n\n// 查看 orderDV 中的订单数据\nselect * from orderDV\n```\n\n| type | market | code | price | qty | updateTime              |\n| ---- | ------ | ---- | ----- | --- | ----------------------- |\n| A    | m1     | c1   | 10    | 100 | 2026.02.01 14:53:12.928 |\n| A    | m1     | c2   | 10    | 100 | 2026.02.01 14:53:12.928 |\n| U    | m1     | c2   | 9.5   | 100 | 2026.02.01 14:53:12.928 |\n| D    | m1     | c2   | 9.5   | 100 | 2026.02.01 14:53:12.928 |\n\n如果不需要输出订单更新操作列，则可以指定　*includeOperationType*=false，同时修改 orderDV 表结构。使用如下代码替换 `onload`：\n\n```\ndef onload(){\n    addEventListener(checkOrders,'Orders',,'all') \n    orderDV = streamTable(array(STRING, 0) as market, array(STRING, 0) as code, array(DOUBLE, 0) as price, array(INT, 0) as qty, array(TIMESTAMP, 0) as updateTime)\n    share(orderDV,'orderDV')\n    createDataViewEngine(name='orderDV', outputTable=objByName('orderDV'), keyColumns=`code, timeColumn=`updateTime, useSystemTime=true, includeOperationType=false)\n    addEventListener(deleteOrder,'DeleteOrder',,'all') \n}\n```\n\n此时查看表 orderDV 的结果如下。可以看出在 *includeOperationType*=false 时，引擎没有输出被删除数据的记录，因此和开启*includeOperationType* 时的输出记录行数不同。\n\n| market | code | price | qty | updateTime              |\n| ------ | ---- | ----- | --- | ----------------------- |\n| m1     | c1   | 10    | 100 | 2026.04.17 17:35:42.313 |\n| m1     | c2   | 10    | 100 | 2026.04.17 17:35:42.313 |\n| m1     | c2   | 9.5   | 100 | 2026.04.17 17:35:42.313 |\n\n例2. 本例介绍参数 *throttle* 的作用。在创建 Data view 引擎时指定 *throttle* 参数为30秒，则引擎每间隔30秒才会把数据数据到输出表。修改 `onload` 函数：\n\n```\ndef onload(){\n    addEventListener(checkOrders,'Orders',,'all') \n    orderDV = streamTable(array(STRING, 0) as market, array(STRING, 0) as code, array(DOUBLE, 0) as price, array(INT, 0) as qty, array(TIMESTAMP, 0) as updateTime)\n    share(orderDV,'orderDV')\n    createDataViewEngine(name='orderDV', outputTable=objByName('orderDV'), keyColumns=`code, timeColumn=`updateTime, useSystemTime=true, throttle=30s, includeOperationType=false)\n    addEventListener(deleteOrder,'DeleteOrder',,'all') \n}\n```\n\n在事件注入引擎30秒后查看表 orderDV，可以看到表中仅剩一条记录 c1。这是因为在引擎输出数据之前，已有一条 DeleteOrder 事件进入引擎，将 c2 这条数据删除了。\n\n**相关函数**：[createCEPEngine](https://docs.dolphindb.cn/zh/funcs/c/createCEPEngine.html), [deleteDataViewItems](https://docs.dolphindb.cn/zh/funcs/d/deleteDataViewItems.html), [dropDataViewEngine](https://docs.dolphindb.cn/zh/funcs/d/dropDataViewEngine.html), [getDataViewEngine](https://docs.dolphindb.cn/zh/funcs/g/getDataViewEngine.html)\n"
    },
    "createDeviceEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/createdeviceengine.html",
        "signatures": [
            {
                "full": "createDeviceEngine(name, metrics, dummyTable, outputTable, [keyColumn], [keepOrder])",
                "name": "createDeviceEngine",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "metrics",
                        "name": "metrics"
                    },
                    {
                        "full": "dummyTable",
                        "name": "dummyTable"
                    },
                    {
                        "full": "outputTable",
                        "name": "outputTable"
                    },
                    {
                        "full": "[keyColumn]",
                        "name": "keyColumn",
                        "optional": true
                    },
                    {
                        "full": "[keepOrder]",
                        "name": "keepOrder",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [createDeviceEngine](https://docs.dolphindb.cn/zh/funcs/c/createdeviceengine.html)\n\n#### 语法\n\ncreateDeviceEngine(name, metrics, dummyTable, outputTable, \\[keyColumn], \\[keepOrder])\n\n#### 详情\n\n创建一个设备引擎，该引擎会将注入输入表的数据，通过 GPU 加速完成 metrics 中定义的计算，将结果输出到输出表。\n\n注意：设备引擎不维护上一批数据的状态。即两批数据写入时，第二批数据的起始状态与第一批状态无关。\n\n#### 参数\n\n**name** 字符串标量，表示设备引擎的名称，作为其在一个数据节点/计算节点上的唯一标识。可包含字母，数字和下划线，但必须以字母开头。\n\n**metrics** 以元代码的形式表示计算公式，可以是一个或多个表达式、系统内置或用户自定义函数（不支持多返回值，for 循环不得嵌套，for 循环次数不能超过100），也可以是个常量标量/向量。当指定为常量向量时，对应的输出列应该设置为数组向量类型。有关元代码的详情可参考 [Metaprogramming](https://docs.dolphindb.cn/zh/progr/objs/meta_progr.html)。**metrics** 支持的函数包括：\n\n* 单目基础运算操作：not, neg, cast, log, log2, log10 ,log1p ,abs, sign, sqrt, sin, sinh, asin, asinh, cos, cosh, acos, acosh, tan, tanh, atan, atanh, reciprocal, cbrt, exp, exp2, expm1\n\n* 双目基础运算操作：add, sub, mul, div, ratio, pow, lt, gt, le, ge, eq, ne, and, or, or\\_\\_（即`||`运算符，需要注意关于 NULL 的处理依赖于配置项 `logicOrIgnoreNull` ）, max, min\n\n* 双目整型运算（其中 mod 支持 BOOL 类型，其他只支持数值类型)：mod, bitAnd, bitOr, bitXor, lshift, rshift\n\n* 三目运算：iif\n\n* 单目滑动窗口函数：mavg, msum, mcount, mprod, mvar, mvarp, mstd, mstdp, mskew, mkurtosis, mmin, mmax, mimin, mimax, sma, wma, mfirst, mlast, mrank, mmaxPositiveStreak, mmed, mpercentile, mmad（暂不支持参数 *useMedian*）\n\n* 双目滑动窗口函数：sma, ema, wma, dema, tema, trima, t3, wilder, gema, linearTimeTrend, ma, talib（仅支持所有 m 系列和 mTopN 函数，不支持其他函数）, kama\n\n* 其他滑动窗口函数：linearTimeTrend，mslr\n\n* 单目累计窗口函数：cumsum, cumprod, cummin, cummax, cumvar, cumvarp, cumstd, cumstdp, cumnunique, cumfirstNot, cumlastNot, cumavg, cumcount, cumPositiveStreak\n\n* 双目累计窗口函数：cumcorr, cumcovar, cumbeta, cumwsum, cumwavg\n\n* 序列相关函数：deltas, ratios, ffill, move, prev, next, percentChange, iterate, prevState, ewmMean, ewmVar, ewmStd, ewmCov, ewmCorr\n\n  注意：ewmVar, ewmStd, ewmCov, ewmCorr 均不支持设置 adjust=true，且不支持设置 bias=false。\n\n* row系列函数：rowMin, rowMax, rowAnd, rowOr, rowXor, rowProd, rowSum, rowSum2, rowSize, rowCount, rowAvg, rowVar, rowVarp, rowStd, rowStdp\n\n* tm系列函数：tmsum, tmsum2, tmavg, tmprod, tmcount, tmvar, tmvarp, tmstd, tmstdp, tmcovar, tmcorr, tmwavg, tmwsum, tmbeta, tmfirst, tmlast, tmmin, tmmax, tmskew, tmkurtosis, tmove\n\n* 其他函数：TrueRange，topRange，lowRange，stateMavg\n\n注意：自 3.00.1 版本起，当计算结果的绝对值小于 `DBL_EPSILON*10000`(约 2.22\\*10-12)时，所有滑动窗口系列函数和累积窗口系列函数均不会对结果进行约整，而是保留所有精度。\n\n**dummyTable** 一个表对象，注入数据的结构与其 schema 一致。可以含有数据，亦可为空表。\n\n**outputTable** 计算结果的输出表，可以是内存表或分布式表。使用 `createDeviceReactiveEngine`函数之前，需要将输出表预先设立为一个空表，并指定各列列名以及数据类型。`DeviceReactiveEngine`会将计算结果注入该表。\n\n**keyColumn** 可选参数，字符串标量或向量表示分组列名。计算将在各分组进行。\n\n**keepOrder**可选参数，表示输出表数据是否按照输入时的顺序排序。默认值为 false。设置 *keepOrder* = true，表示输出表按照输入时的顺序排序； *keepOrder* = false，表示输出表按照分组列排序。\n\n#### 返回值\n\n一个表对象。\n\n#### 例子\n\n```\n// 创建引擎\ndummyTb = table(1:0, `sym`id`value, [SYMBOL,INT,DOUBLE])\nshare table(100:0, `sym`id`flag`value`factor, [SYMBOL,INT,SYMBOL,DOUBLE,DOUBLE]) as result\nde = createDeviceEngine(name=\"myDe\", metrics=[<id>,<\"flag\"+\"_A\">,<value>,<mavg(value,5)>], dummyTable=dummyTb, outputTable=result, keyColumn=\"sym\")\n\n// 准备数据 \ndata1 = table(take(\"A\", 100) as sym, 1..100 as id, double(10+1..100) as value)\ndata2 = table(take(\"B\", 100) as sym, 1..100 as id, double(20+1..100) as value)\ndata3 = table(take(\"C\", 100) as sym, 1..100 as id, double(30+1..100) as value)\ndata = data1.unionAll(data2).unionAll(data3).sortBy!(`id)\n\n// 写入数据\nde.append!(data)\nselect top 10 * from result   \n```\n\n| sym | id | flag    | value | factor |\n| --- | -- | ------- | ----- | ------ |\n| A   | 1  | flag\\_A | 11    |        |\n| A   | 2  | flag\\_A | 12    |        |\n| A   | 3  | flag\\_A | 13    |        |\n| A   | 4  | flag\\_A | 14    |        |\n| A   | 5  | flag\\_A | 15    | 13     |\n| A   | 6  | flag\\_A | 16    | 14     |\n| A   | 7  | flag\\_A | 17    | 15     |\n| A   | 8  | flag\\_A | 18    | 16     |\n| A   | 9  | flag\\_A | 19    | 17     |\n| A   | 10 | flag\\_A | 20    | 18     |\n\n上例未设置 keepOrder 参数，结果显示输出表按照分组列进行排序。若在创建引擎时指定 *keepOrder*=true，则输出表中的数据将按照输入时的顺序排序，见下例。\n\n```\ndropStreamEngine(name=\"myDe\")\n// 创建引擎\ndummyTb = table(1:0, `sym`id`value, [SYMBOL,INT,DOUBLE])\nshare table(100:0, `sym`id`flag`value`factor, [SYMBOL,INT,SYMBOL,DOUBLE,DOUBLE]) as result\nde = createDeviceEngine(name=\"myDe\", metrics=[<id>,<\"flag\"+\"_A\">,<value>,<mavg(value,5)>], dummyTable=dummyTb, outputTable=result, keyColumn=\"sym\",keepOrder=true)\n\n// 准备数据 \ndata1 = table(take(\"A\", 100) as sym, 1..100 as id, double(10+1..100) as value)\ndata2 = table(take(\"B\", 100) as sym, 1..100 as id, double(20+1..100) as value)\ndata3 = table(take(\"C\", 100) as sym, 1..100 as id, double(30+1..100) as value)\ndata = data1.unionAll(data2).unionAll(data3).sortBy!(`id)\n\n// 写入数据\nde.append!(data)\nselect top 10 * from result   \n```\n\n| sym | id | flag    | value | factor |\n| --- | -- | ------- | ----- | ------ |\n| A   | 1  | flag\\_A | 11    |        |\n| B   | 1  | flag\\_A | 21    |        |\n| C   | 1  | flag\\_A | 31    |        |\n| A   | 2  | flag\\_A | 12    |        |\n| B   | 2  | flag\\_A | 22    |        |\n| C   | 2  | flag\\_A | 32    |        |\n| A   | 3  | flag\\_A | 13    |        |\n| B   | 3  | flag\\_A | 23    |        |\n| C   | 3  | flag\\_A | 33    |        |\n| A   | 4  | flag\\_A | 14    |        |\n\n"
    },
    "createDimensionTable": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/createdimensiontable.html",
        "signatures": [
            {
                "full": "createDimensionTable(dbHandle, table, tableName, [compressMethods], [sortColumns\\|primaryKey], [keepDuplicates=ALL], [softDelete=false], [indexes], [encryptMode='plaintext'])",
                "name": "createDimensionTable",
                "parameters": [
                    {
                        "full": "dbHandle",
                        "name": "dbHandle"
                    },
                    {
                        "full": "table",
                        "name": "table"
                    },
                    {
                        "full": "tableName",
                        "name": "tableName"
                    },
                    {
                        "full": "[compressMethods]",
                        "name": "compressMethods",
                        "optional": true
                    },
                    {
                        "full": "[sortColumns\\|primaryKey]",
                        "name": "[sortColumns\\|primaryKey]"
                    },
                    {
                        "full": "[keepDuplicates=ALL]",
                        "name": "keepDuplicates",
                        "optional": true,
                        "default": "ALL"
                    },
                    {
                        "full": "[softDelete=false]",
                        "name": "softDelete",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[indexes]",
                        "name": "indexes",
                        "optional": true
                    },
                    {
                        "full": "[encryptMode='plaintext']",
                        "name": "encryptMode",
                        "optional": true,
                        "default": "'plaintext'"
                    }
                ]
            }
        ],
        "markdown": "### [createDimensionTable](https://docs.dolphindb.cn/zh/funcs/c/createdimensiontable.html)\n\n\n\n#### 语法\n\ncreateDimensionTable(dbHandle, table, tableName, \\[compressMethods], \\[sortColumns\\\\|primaryKey], \\[keepDuplicates=ALL], \\[softDelete=false], \\[indexes], \\[encryptMode='plaintext'])\n\n别名：createTable\n\n#### 详情\n\n在分布式数据库中创建一个维度表。维度表是分布式数据库中没有进行分区的表，查询时会将表中所有数据加载到内存，适用于存储不频繁更新的小数据集。\n\n系统会定期检查内存的使用情况，当内存使用超过系统配置参数 *warningMemSize* 设定的阈值时，系统会尝试释放部分缓存。维度表如果长时间未被使用，其占用的内存根据 LRU（Least Recently Used）策略将被释放。用户也可以调用 *clearCachedDatabase* 手动释放维度表的缓存。\n\n维度表与分区表都是根据设置参数 *dfsReplicationFactor* 决定副本的数量。维度表的读写操作也支持事务。\n\n通过在配置项配置 *enableConcurrentDimensionalTableWrite* = true，可以支持对维度表进行并发的写入、修改或删除操作。\n\n#### 参数\n\n**dbHandle** 是 [database](https://docs.dolphindb.cn/zh/funcs/d/database.html) 函数返回的分布式数据库句柄。\n\n**table** 是一个表，系统将根据该表的结构在数据库中创建一个空的维度表。\n\n**tableName** 是一个字符串，表示维度表的名称。表名只能由中文或英文字母、数字或下划线（\\_）组成，且必须以中文或英文字母开头。\n\n**compressMethods** 一个字典，指定某些列使用 lz4, delta, zstd 或 chimp 压缩算法存储。key 为字段名，value 为压缩算法（\"lz4\", \"delta\", \"zstd\" 或 \"chimp\"）。若未指定，默认采用 lz4 压缩算法。有关 Delta 压缩算法，亦称为 delta-of-delta encoding，参考：[Delta Compression Techniques](http://engineering.nyu.edu/~suel/papers/delta-chap.pdf)。\n\n* 对于 DECIMAL,SHORT, INT, LONG 与时间或日期类型数据，建议采用 Delta 算法压缩。\n* 将字符串存储为 SYMBOL 类型数据，实现对字符串类型的压缩。\n* 对于小数部分长度在三位以内的 DOUBLE 类型的数据，可以考虑使用 chimp 算法压缩。\n\n**sortColumns** 字符串标量或向量，用于指定每一分区内的排序列，每次写入磁盘的数据在每一分区内将按 *sortColumns* 进行排序。系统默认 *sortColumns* （指定多列时） 除最后一列外的列字段作为排序的索引列，称作 sort key。每一分区内，同一个 sort key 组合值对应的数据将按最后一列的值顺序连续存放在一起。查询时，若查询条件包含索引列，可以快速定位数据所在的数据块位置，提高查询性能。\n\n* 仅当 dbHandle 指示的数据库采用 \"TSDB\" 引擎（engine=\"TSDB\"）时，本参数才生效。\n* *sortColumns* 只能是 INTEGER, TEMPORAL, LITERAL 类别（除 BLOB） 或 DECIMAL 类型。\n  * 若 *sortColumns* 指定为多列，则 *sortColumns* 的最后一列必须为时间类型或整型，其余列为索引列，且索引列不能为为 TIME, TIMESTAMP, NANOTIME, NANOTIMESTAMP 类型。\n  * 若 *sortColumns* 仅指定一列，则该列作为 sort key，其类型可以是除 TIME, TIMESTAMP, NANOTIME, NANOTIMESTAMP 之外的任意类型。若 *sortColumns* 为时间类型 （非分区列），且同时指定了 *sortKeyMappingFunction*，则查询的过滤条件中 *sortColumns* 只能与相同时间类型的值进行比较。\n* 频繁查询的字段适合设置为 *sortColumns*（建议不超过 4 列），且建议优先把查询频率高的字段作为 *sortColumns* 中位置靠前的列。\n* 为保证性能最优，建议每个分区内索引列的组合数（sort key）不超过 2000 个。\n* *sortColumns* 是每个分区内部 level file 内数据的排序依据，与其是否为分区字段无关。\n\n**primaryKey**字符串标量或向量，用于指定主键列。在数据写入操作中，如果主键相同，新的数据覆盖现有数据。\n\n* 仅当*dbHandle* 指示的数据库采用 “PKEY” 引擎（engine=”PKEY”）时，本参数才生效。\n\n* 主键列支持的类型包括：BOOL, CHAR, SHORT, INT, LONG, INT128, STRING, TIME, SECOND, MINUTE, DATE, MONTH, DATEHOUR, DATETIME, SYMBOL, TIMESTAMP, NANOTIME, NANOTIMESTAMP, UUID, COMPLEX, POINT, IPADDR, DECIMAL32, DECIMAL64, DECIMAL128。\n\n**keepDuplicates** 指定在每个分区内如何处理所有 *sortColumns* 之值皆相同的数据。提供以下选项：\n\n* ALL：保留所有数据，为默认值。\n* LAST：仅保留最新数据\n* FIRST：仅保留第一条数据\n\n**softDelete** 用于启用或禁用软删除功能。默认为 false，即禁用。该参数适于在行数多但删除量小的场景下使用。使用该参数需要同时满足以下条件：\n\n* 由TSDB 存储引擎创建的数据库内的表\n\n* *keepDuplicates* 已设置为 LAST\n\n**Note:** 参数 *sortColumns*, *keepDuplicates* 仅在 `database` 的 *engine* 参数指定为 TSDB 时才有效。\n\n**indexes** 为一个字典。当引擎为 PKEY 时，用于为表中的列指定索引。字典的键是 STRING 类型标量，表示列名；值是 STRING 类型标量，表示为该列指定的索引类型。目前支持设置 “bloomfilter” 索引类型：适用于对大基数列进行点查，且基数越大，索引效果越好，如身份证 ID、订单号、从业务上游同步的外键等数据列。目前支持的类型包括 BOOL, CHAR, SHORT, INT, LONG, BLOB, STRING, DECIMAL32, DECIMAL64, DECIMAL128。\n\n**Note:** 引擎会将所有主键列合并为组合主键，并为组合主键设置 bloomfilter 类型索引。\n\n**encryptMode** 可选参数，字符串标量，指定表的加密方式，默认为不加密（明文模式）。仅 Linux 系统支持该参数。目前支持以下可选值（大小写不区分）：plaintext, aes\\_128\\_ctr, aes\\_128\\_cbc, aes\\_128\\_ecb, aes\\_192\\_ctr, aes\\_192\\_cbc, aes\\_192\\_ecb, aes\\_256\\_ctr, aes\\_256\\_cbc, aes\\_256\\_ecb, sm4\\_128\\_cbc, sm4\\_128\\_ecb。\n\n#### 返回值\n\n一个表。\n\n#### 例子\n\n例1\n\n```\ndb=database(\"dfs://db1\",VALUE,1 2 3)\ntimestamp = [09:34:07,09:36:42,09:36:51,09:36:59,09:32:47,09:35:26,09:34:16,09:34:26,09:38:12]\nsym = `C`MS`MS`MS`IBM`IBM`C`C`C\nprice= 49.6 29.46 29.52 30.02 174.97 175.23 50.76 50.32 51.29\nqty = 2200 1900 2100 3200 6800 5400 1300 2500 8800\nt = table(timestamp, sym, qty, price);\n\ndt=db.createDimensionTable(t,`dt).append!(t);\nselect * from dt;\n```\n\n| timestamp | sym | qty  | price  |\n| --------- | --- | ---- | ------ |\n| 09:34:07  | C   | 2200 | 49.6   |\n| 09:36:42  | MS  | 1900 | 29.46  |\n| 09:36:51  | MS  | 2100 | 29.52  |\n| 09:36:59  | MS  | 3200 | 30.02  |\n| 09:32:47  | IBM | 6800 | 174.97 |\n| 09:35:26  | IBM | 5400 | 175.23 |\n| 09:34:16  | C   | 1300 | 50.76  |\n| 09:34:26  | C   | 2500 | 50.32  |\n| 09:38:12  | C   | 8800 | 51.29  |\n\n例2\n\n```\ndb = database(\"dfs://demodb\", VALUE, 1..10)\nt=table(take(1, 86400) as id, 2020.01.01T00:00:00 + 0..86399 as timestamp, rand(1..100, 86400) as val)\ndt = db.createDimensionTable(t, \"dt\", {timestamp:\"delta\", val:\"delta\"})\ndt.append!(t)\n```\n\n例3. TSDB 存储引擎下创建维度表\n\n```\nif(existsDatabase(\"dfs://dbctable_createDimensionTable\")){\n  dropDatabase(\"dfs://dbctable_createDimensionTable\")\n}\ndb = database(\"dfs://dbctable_createDimensionTable\", VALUE, 1..100, , \"TSDB\")\nt1 = table(1 100 100 300 300 400 500 as id, 1..7 as v)\ndb.createDimensionTable(t1, \"dt\", , \"id\").append!(t1)\ndt=loadTable(\"dfs://dbctable_createDimensionTable\",\"dt\")\n```\n\n例4. PKEY 存储引擎下创建维度表\n\n```\ndb = database(directory=\"dfs://PKDB\", partitionType=VALUE, partitionScheme=1..10, engine=\"PKEY\")\nschematb = table(1:0,`id1`id2`val1`val2`date1`time1,[INT,INT,INT,DECIMAL32(2),DATE,TIME])\npkt = createDimensionTable(dbHandle=db, table=schematb, tableName=\"pkt\", primaryKey=`id1`id2, indexes={\"val1\": \"bloomfilter\", \"val2\": \"bloomfilter\"})\n```\n\n**Related information**\n\n[createPartitionedTable](https://docs.dolphindb.cn/zh/funcs/c/createPartitionedTable.html)\n"
    },
    "createDistributedInMemoryTable": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/createDistributedInMemoryTable.html",
        "signatures": [
            {
                "full": "createDistributedInMemoryTable(tableName, colNames, colTypes, globalPartitionType, globalPartitionScheme, globalPartitionColumn, [localPartitionType], [localPartitionScheme], [localPartitionColumn])",
                "name": "createDistributedInMemoryTable",
                "parameters": [
                    {
                        "full": "tableName",
                        "name": "tableName"
                    },
                    {
                        "full": "colNames",
                        "name": "colNames"
                    },
                    {
                        "full": "colTypes",
                        "name": "colTypes"
                    },
                    {
                        "full": "globalPartitionType",
                        "name": "globalPartitionType"
                    },
                    {
                        "full": "globalPartitionScheme",
                        "name": "globalPartitionScheme"
                    },
                    {
                        "full": "globalPartitionColumn",
                        "name": "globalPartitionColumn"
                    },
                    {
                        "full": "[localPartitionType]",
                        "name": "localPartitionType",
                        "optional": true
                    },
                    {
                        "full": "[localPartitionScheme]",
                        "name": "localPartitionScheme",
                        "optional": true
                    },
                    {
                        "full": "[localPartitionColumn]",
                        "name": "localPartitionColumn",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [createDistributedInMemoryTable](https://docs.dolphindb.cn/zh/funcs/c/createDistributedInMemoryTable.html)\n\n\n\n#### 语法\n\ncreateDistributedInMemoryTable(tableName, colNames, colTypes, globalPartitionType, globalPartitionScheme, globalPartitionColumn, \\[localPartitionType], \\[localPartitionScheme], \\[localPartitionColumn])\n\n#### 详情\n\n创建一个分布式共享内存表，按指定分区方案，将数据存储在不同在节点上。该函数只能在数据节点/计算节点执行。\n\n按全局分区方案将分布式共享内存表的数据分散地存储在不同节点（数据节点/计算节点）的内存中。每个节点最多只能存放一个分区的数据。分布式共享内存表支持并行读写，因此，它适用于需要对内存表进行分布式计算的场景。\n\n分布式共享内存表的分区分为两级：\n\n* 第一级为全局分区。全局分区可以将内存表的数据按照分区存放在不同的节点上。\n* 第二级为局部分区（可选配置）。局部分区对存储在单个节点内的分区数据进行再分区。\n\n若同时配置了全局分区和局部分区，等同于对分布式共享内存表进行了组合分区。\n\n**Note:**\n\n* 仅支持在集群模式下创建分布式共享内存表。\n* 全局分区的数量必须不小于2，且不能超过数据节点和计算节点总数。\n* 其它节点访问分布式共享内存表前，需要执行 [loadDistributedInMemoryTable](https://docs.dolphindb.cn/zh/funcs/l/loadDistributedInMemoryTable.html) 函数加载表。\n* 通过命令 [dropDistributedInMemoryTable](https://docs.dolphindb.cn/zh/funcs/d/dropDistributedInMemoryTable.html) 删除分布式共享内存表。\n* 分布式共享内存表的操作暂不支持事务。\n\n#### 参数\n\n**tableName** 字符串标量，表示分布式共享内存表的名称。\n\n**colNames** 字符串向量，用于指定表的列名。\n\n**colTypes** 由数据类型组成的向量，用于指定 *colNames* 各列的类型。\n\n**globalPartitionType** 必选参数，表示集群全局的分区类型，仅支持范围分区（RANGE），哈希分区（HASH），数值分区（VALUE），列表分区（LIST）。\n\n**globalPartitionScheme** 必选参数，表示集群全局的分区方案。\n\n分区类型及对应的分区方案见下表：\n\n| 分区类型 | 分区符号  | 分区方案                           |\n| ---- | ----- | ------------------------------ |\n| 范围分区 | RANGE | 向量。向量的任意两个相邻元素定义分区的范围。         |\n| 哈希分区 | HASH  | 元组。第一个元素是分区列的数据类型，第二个元素是分区的数量。 |\n| 值分区  | VALUE | 向量。向量的每个元素定义了一个分区。             |\n| 列表分区 | LIST  | 向量。向量的每个元素定义了一个分区。             |\n\n**globalPartitionColumn** 必选参数，字符串标量，表示集群全局的分区列。\n\n以上参数对应整个集群的分区配置，分布式共享内存表将按照上述分区方案将数据分区后存储到各个节点。各个节点的数据可以通过以下参数，进行节点内部的二次分区。\n\n**localPartitionType** 可选参数，表示节点内部的分区类型，仅支持范围分区（RANGE），哈希分区（HASH），数值分区（VALUE），列表分区（LIST）。\n\n**localPartitionScheme** 可选参数，表示节点内部的分区方案。\n\n**localPartitionColumn** 可选参数，字符串标量，表示节点内部的分区列。\n\n#### 返回值\n\n一个表。\n\n#### 例子\n\n* 创建分布式共享内存表\n\n  本例的集群拥有两个数据节点 node1 和 node2，在 node1 上创建一个分布式共享内存表。因为分区的数量不能超过数据节点和计算节点数总和，建议进行 HASH 分区。\n\n  ```\n  pt = createDistributedInMemoryTable(`dt, `time`id`value, `DATETIME`INT`LONG, HASH, [INT, 2],`id)\n  ```\n\n* 加载分布式共享内存表\n\n  在 node2 上加载分布式共享内存表，并插入数据。\n\n  ```\n  time = take(2021.08.20 00:00:00..2021.08.30 00:00:00, 40);\n  id = 0..39;\n  value = rand(100, 40);\n  tmp = table(time, id, value);\n\n  pt = loadDistributedInMemoryTable(`dt)\n  pt.append!(tmp);\n\n  select * from pt;\n  ```\n\n* 查看分布式共享内存表是否存在。\n\n  ```\n  objs(true)\n  ```\n\n* 删除分布式共享内存表\n\n  ```\n  dropDistributedInMemoryTable(`dt)\n  ```\n"
    },
    "createDualOwnershipReactiveStateEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/createDualOwnershipReactiveStateEngine.html",
        "signatures": [
            {
                "full": "createDualOwnershipReactiveStateEngine(name, metrics1, metrics2, dummyTable, outputTable, keyColumn1, keyColumn2, [snapshotDir], [snapshotIntervalInMsgCount], [keyPurgeFilter1], [keyPurgeFilter2], [keyPurgeFreqInSecond=0], [raftGroup], [outputHandler], [msgAsTable=false])",
                "name": "createDualOwnershipReactiveStateEngine",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "metrics1",
                        "name": "metrics1"
                    },
                    {
                        "full": "metrics2",
                        "name": "metrics2"
                    },
                    {
                        "full": "dummyTable",
                        "name": "dummyTable"
                    },
                    {
                        "full": "outputTable",
                        "name": "outputTable"
                    },
                    {
                        "full": "keyColumn1",
                        "name": "keyColumn1"
                    },
                    {
                        "full": "keyColumn2",
                        "name": "keyColumn2"
                    },
                    {
                        "full": "[snapshotDir]",
                        "name": "snapshotDir",
                        "optional": true
                    },
                    {
                        "full": "[snapshotIntervalInMsgCount]",
                        "name": "snapshotIntervalInMsgCount",
                        "optional": true
                    },
                    {
                        "full": "[keyPurgeFilter1]",
                        "name": "keyPurgeFilter1",
                        "optional": true
                    },
                    {
                        "full": "[keyPurgeFilter2]",
                        "name": "keyPurgeFilter2",
                        "optional": true
                    },
                    {
                        "full": "[keyPurgeFreqInSecond=0]",
                        "name": "keyPurgeFreqInSecond",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[raftGroup]",
                        "name": "raftGroup",
                        "optional": true
                    },
                    {
                        "full": "[outputHandler]",
                        "name": "outputHandler",
                        "optional": true
                    },
                    {
                        "full": "[msgAsTable=false]",
                        "name": "msgAsTable",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [createDualOwnershipReactiveStateEngine](https://docs.dolphindb.cn/zh/funcs/c/createDualOwnershipReactiveStateEngine.html)\n\n\n\n#### 语法\n\ncreateDualOwnershipReactiveStateEngine(name, metrics1, metrics2, dummyTable, outputTable, keyColumn1, keyColumn2, \\[snapshotDir], \\[snapshotIntervalInMsgCount], \\[keyPurgeFilter1], \\[keyPurgeFilter2], \\[keyPurgeFreqInSecond=0], \\[raftGroup], \\[outputHandler], \\[msgAsTable=false])\n\n#### 详情\n\nDual Ownership Reactive State Engine 是对响应式状态引擎的扩展，支持对同一张流数据表指定两种不同的分组方式分别应用不同的指标进行并行计算。与响应式状态级联实现相比，该函数能极大地提升计算性能。\n\n**Note:**\n\n* 该引擎输出和输入顺序保持一致，即内部强制使 *keepOrder* = True。\n* 不支持乱序处理机制，用户需要自行保证输入的数据有序。\n\n#### 参数\n\n`createDualOwnershipReactiveStateEngine` 与 [createReactiveStateEngine](https://docs.dolphindb.cn/zh/funcs/c/createReactiveStateEngine.html) 参数基本一致，这里仅介绍有区别的参数：\n\n对 *keyColumn1* 分组后的数据按照 *metrics1* 进行计算，分组数据的清条件则由参数 *keyPurgeFilter1* 设置。\n\n对 *keyColumn2* 分组后的数据按照 *metrics2* 进行计算，分组数据的清条件则由参数 *keyPurgeFilter2* 设置。\n\n**outputTable** 结果的输出表，可以是内存表或者分布式表。使用 `createDualOwnershipReactiveStateEngine` 函数之前，需要将输出表预先设立为一个空表，并指定各列列名以及数据类型。\n\n输出表各列的顺序如下：\n\n1. 分组列。输出表的前几列为 *keyColumn1* 和 *keyColumn2* 的公共列，然后依次为 *keyColumn1* 的非公共列和 *keyColumn2* 的非公共列。\n2. 计算结果列。包含 *metrics1* 的计算结果列，*metrics2*的计算结果列。\n\n**outputHandler** 一元函数。设置此参数时，引擎计算结束后，不再将计算结果写到输出表，而是会调用此函数处理计算结果。\n\n**msgAsTable** 布尔标量，表示在设置了参数 outputHandler 时，将引擎的计算结果以表的结构调用函数。默认值为 false，此时将计算结果的每一列作为元素组成元组。\n\n#### 返回值\n\n一个表对象。\n\n#### 例子\n\n```\nshare streamTable(1:0, `date`time`sym`market`price`qty, [DATE, TIME, SYMBOL, CHAR, DOUBLE, INT]) as trades\nshare table(100:0, `date`sym`market`factor1`factor2, [DATE, SYMBOL, CHAR, DOUBLE, DOUBLE]) as outputTable\ndors = createDualOwnershipReactiveStateEngine(name=\"test\", metrics1=<mfirst(price, 3)>, metrics2=<mmax(price, 3)>, dummyTable=trades, outputTable=outputTable, keyColumn1=`date`sym, keyColumn2=`date`market)\ntmp = table(1:0, `date`time`sym`market`price`qty, [DATE, TIME, SYMBOL, CHAR, DOUBLE, INT])\nsubscribeTable(tableName=`trades, actionName=\"test\",msgAsTable=true, handler=tableInsert{dors})\ninsert into tmp values(2012.01.01, 09:00:00.030, `a, 'B', 10.65, 1500)\ninsert into tmp values(2012.01.01, 09:00:00.030, `a, 'B', 10.59, 2500)\ninsert into tmp values(2012.01.01, 09:00:00.031, `b, 'A', 10.59, 2500)\ninsert into tmp values(2012.01.01, 09:00:00.031, `a, 'B', 10.65, 1500)\ninsert into tmp values(2012.01.01, 09:00:00.031, `a, 'A', 10.59, 2500)\ninsert into tmp values(2012.01.01, 09:00:00.033, `b, 'B', 10.59, 2500)\ninsert into tmp values(2012.01.01, 09:00:00.033, `a, 'A', 10.59, 2500)\ninsert into tmp values(2012.01.01, 09:00:00.034, `b, 'A', 10.59, 2500)\ninsert into tmp values(2012.01.01, 09:00:00.034, `b, 'A', 10.22, 1200)\ninsert into tmp values(2012.01.01, 09:00:00.035, `a, 'A', 11.0, 2500)\ninsert into tmp values(2012.01.02, 09:00:00.031, `b, 'A', 10.22, 1200)\ninsert into tmp values(2012.01.02, 09:00:00.032, `a, 'B', 11.0, 2500)\ninsert into tmp values(2012.01.02, 09:00:00.032, `b, 'B', 15.6, 1300)\ninsert into tmp values(2012.01.02, 09:00:00.040, `c, 'B', 13.2, 2000)\ntrades.append!(tmp)\nselect * from outputTable\n```\n\n| date       | sym | market | factor1 | factor2 |\n| ---------- | --- | ------ | ------- | ------- |\n| 2012.01.01 | a   | 'B'    |         |         |\n| 2012.01.01 | a   | 'B'    |         |         |\n| 2012.01.01 | b   | 'A'    |         |         |\n| 2012.01.01 | a   | 'B'    | 10.65   | 10.65   |\n| 2012.01.01 | a   | 'A'    | 10.59   |         |\n| 2012.01.01 | b   | 'B'    |         | 10.65   |\n| 2012.01.01 | a   | 'A'    | 10.65   | 10.59   |\n| 2012.01.01 | b   | 'A'    | 10.59   | 10.59   |\n| 2012.01.01 | b   | 'A'    | 10.59   | 10.59   |\n| 2012.01.01 | a   | 'A'    | 10.59   | 11      |\n| 2012.01.02 | b   | 'A'    |         |         |\n| 2012.01.02 | a   | 'B'    |         |         |\n| 2012.01.02 | b   | 'B'    |         |         |\n| 2012.01.02 | c   | 'B'    |         | 15.6    |\n\n```\nunsubscribeTable(tableName=`trades, actionName=\"test\")\nundef(`trades,SHARED)\ndropStreamEngine(\"test\")\n```\n"
    },
    "createEqualJoinEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/createEqualJoinEngine.html",
        "signatures": [
            {
                "full": "createEquiJoinEngine(name, leftTable, rightTable, outputTable, metrics, matchingColumn, timeColumn, [garbageSize=5000], [maxDelayedTime], [snapshotDir], [snapshotIntervalInMsgCount])",
                "name": "createEquiJoinEngine",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "leftTable",
                        "name": "leftTable"
                    },
                    {
                        "full": "rightTable",
                        "name": "rightTable"
                    },
                    {
                        "full": "outputTable",
                        "name": "outputTable"
                    },
                    {
                        "full": "metrics",
                        "name": "metrics"
                    },
                    {
                        "full": "matchingColumn",
                        "name": "matchingColumn"
                    },
                    {
                        "full": "timeColumn",
                        "name": "timeColumn"
                    },
                    {
                        "full": "[garbageSize=5000]",
                        "name": "garbageSize",
                        "optional": true,
                        "default": "5000"
                    },
                    {
                        "full": "[maxDelayedTime]",
                        "name": "maxDelayedTime",
                        "optional": true
                    },
                    {
                        "full": "[snapshotDir]",
                        "name": "snapshotDir",
                        "optional": true
                    },
                    {
                        "full": "[snapshotIntervalInMsgCount]",
                        "name": "snapshotIntervalInMsgCount",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [createEqualJoinEngine](https://docs.dolphindb.cn/zh/funcs/c/createEqualJoinEngine.html)\n\n是 [createEquiJoinEngine](https://docs.dolphindb.cn/zh/funcs/c/createEquiJoinEngine.html) 的别名。\n\n\n以下是 `createEquiJoinEngine` 函数的文档：\n### [createEquiJoinEngine](https://docs.dolphindb.cn/zh/funcs/c/createEquiJoinEngine.html)\n\n\n\n#### 语法\n\ncreateEquiJoinEngine(name, leftTable, rightTable, outputTable, metrics, matchingColumn, timeColumn, \\[garbageSize=5000], \\[maxDelayedTime], \\[snapshotDir], \\[snapshotIntervalInMsgCount])\n\n别名：createEqualJoinEngine\n\n#### 详情\n\n创建流数据等值连接引擎。返回一个左、右两表 equi join 后的表对象。注入等值连接引擎的左、右两表将以 *matchingColumn* + *timeColumn* 作为连接列，返回两表中连接字段相等的行。\n\n流计算 equi join 引擎内部的左、右表基于连接列和时间列构建键值表，不保留全部历史记录，可能因匹配记录被清除而不输出结果，行为上不同于 SQL 的 equi join。\n\n更多流数据引擎的应用场景说明可以参考 [内置多数据源流式关联引擎](https://docs.dolphindb.cn/zh/stream/str_join_engine.html)。\n\n#### 计算规则\n\n* 每次数据注入引擎左表时，会在右表中查找与连接列字段相匹配的记录，若找到，则将两表匹配的记录 join 后，根据 *metrics* 给出的因子进行计算并输出。\n* 每次数据注入引擎右表时，亦会做同样操作。\n\n#### 参数\n\nequi join 引擎的部分参数和 asof join 引擎相同，请参照 [createAsofJoinEngine](https://docs.dolphindb.cn/zh/funcs/c/createAsofJoinEngine.html) 中参数介绍。下面介绍不同的参数：\n\n**name** 字符串标量，表示 equi join 引擎的名称，作为其在一个数据节点/计算节点上的唯一标识。可包含字母，数字和下划线，但必须以字母开头。\n\n**timeColumn** 字符串标量或向量。用于指定 *leftTable* 和 *rightTable* 中时间列的名称。两表的时间列名称可以不同，但数据类型需保持一致。当 *leftTable* 和 *rightTable* 时间列名称相同时，*timeColumn* 是字符串标量，否则，*timeColumn* 是长度为2的字符串向量。\n\n**garbageSize** 可选参数，正整数，默认值是 5,000（单位为行）。当内存中历史数据行数超过 *garbageSize* 时，会清理本次计算不需要的历史数据。\n\n满足以下条件的数据才会被清理：\n\n1. 历史数据中已经 join 并输出的数据；\n2. 历史数据未发生 join 的数据，但其时间戳与 *leftTable* 或 *rightTable* 收到的最新数据的时间戳的差值大于 *maxDelayedTime*。\n\n**maxDelayedTime** 可选参数，正整数，单位同 *timeColumn* 精度一致，默认值为 3 秒。该参数仅在达到 *garbageSize* 清理条件时才会起效，表示引擎内能够保留最新多长时间的数据。详情参考上述清理条件 2。不建议设置 *maxDelayedTime* 值设置过小，否则可能导致一些需关联却没及时关联的数据被清理。\n\n#### 返回值\n\n一个表对象。\n\n#### 例子\n\n```\nshare streamTable(1:0, `time`sym`price, [SECOND, SYMBOL, DOUBLE]) as leftTable\nshare streamTable(1:0, `time`sym`val, [SECOND, SYMBOL, DOUBLE]) as rightTable\nshare table(100:0, `time`sym`price`val`total, [SECOND, SYMBOL, DOUBLE, DOUBLE, DOUBLE]) as output\nejEngine=createEquiJoinEngine(\"test1\", leftTable, rightTable, output, [<price>, <val>, <price*val>], `sym, `time)\nsubscribeTable(tableName=\"leftTable\", actionName=\"joinLeft\", offset=0, handler=appendForJoin{ejEngine, true}, msgAsTable=true)\nsubscribeTable(tableName=\"rightTable\", actionName=\"joinRight\", offset=0, handler=appendForJoin{ejEngine, false}, msgAsTable=true)\n\ntmp1=table(13:30:10+1..20 as time, take(`AAPL, 10) join take(`IBM, 10) as sym, double(1..20) as price)\nleftTable.append!(tmp1)\ntmp2=table(13:30:10+1..20 as time, take(`AAPL, 10) join take(`IBM, 10) as sym, double(50..31) as val)\nrightTable.append!(tmp2)\n```\n\n下例中时间列类型为 TIMESTAMP，若不设置 *maxDelayedTime*，取默认值3000ms(3s)。\n\n```\nshare streamTable(5000000:0, `timestamp`sym`price, [TIMESTAMP, SYMBOL, DOUBLE]) as leftTable\nshare streamTable(5000000:0, `timestamp`sym`val, [TIMESTAMP, SYMBOL, DOUBLE]) as rightTable\nshare table(5000000:0, `timestamp`sym`price`val`total`diff`ratio, [TIMESTAMP, SYMBOL, DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE]) as output\nejEngine=createEquiJoinEngine(\"test1\", leftTable, rightTable, output, <[price, val, price+val, price-val, price/val]>, `sym, `timestamp, 5000)\ntopic1=subscribeTable(tableName=\"leftTable\", actionName=\"writeLeft\", offset=0, handler=appendForJoin{ejEngine, true}, batchSize=10000, throttle=1)\ntopic2=subscribeTable(tableName=\"rightTable\", actionName=\"writeRight\", offset=0, handler=appendForJoin{ejEngine, false}, batchSize=10000, throttle=1)\ndef writeLeftTable(mutable tb){\n   batch = 1000\n   for(i in 1..300){\n           tmp = table(batch:batch, `timestamp`sym`price, [TIMESTAMP, SYMBOL, DOUBLE])\n           tmp[`timestamp]=take(2012.01.01T00:00:00.000+i, batch)\n           tmp[`sym]=shuffle(\"A\"+string(1..batch))\n           tmp[`price]=rand(100.0, batch)\n           tb.append!(tmp)\n   }\n}\n\ndef writeRightTable(mutable tb){\n   batch = 500\n   for(i in 1..200){\n           tmp = table(batch:batch, `timestamp`sym`val, [TIMESTAMP, SYMBOL, DOUBLE])\n           tmp[`timestamp]=take(2012.01.01T00:00:00.000+i, batch)\n           tmp[`sym]=shuffle(\"A\"+string(1..batch))\n           tmp[`val]=rand(100.0, batch)\n           tb.append!(tmp)\n   }\n}\n\njob1 = submitJob(\"writeLeft\", \"\", writeLeftTable, leftTable)\njob2 = submitJob(\"writeRight\", \"\", writeRightTable, rightTable)\n\nselect count(*) from output order by sym, timestamp\n// output: 100000\n```\n"
    },
    "createEquiJoinEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/createEquiJoinEngine.html",
        "signatures": [
            {
                "full": "createEquiJoinEngine(name, leftTable, rightTable, outputTable, metrics, matchingColumn, timeColumn, [garbageSize=5000], [maxDelayedTime], [snapshotDir], [snapshotIntervalInMsgCount])",
                "name": "createEquiJoinEngine",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "leftTable",
                        "name": "leftTable"
                    },
                    {
                        "full": "rightTable",
                        "name": "rightTable"
                    },
                    {
                        "full": "outputTable",
                        "name": "outputTable"
                    },
                    {
                        "full": "metrics",
                        "name": "metrics"
                    },
                    {
                        "full": "matchingColumn",
                        "name": "matchingColumn"
                    },
                    {
                        "full": "timeColumn",
                        "name": "timeColumn"
                    },
                    {
                        "full": "[garbageSize=5000]",
                        "name": "garbageSize",
                        "optional": true,
                        "default": "5000"
                    },
                    {
                        "full": "[maxDelayedTime]",
                        "name": "maxDelayedTime",
                        "optional": true
                    },
                    {
                        "full": "[snapshotDir]",
                        "name": "snapshotDir",
                        "optional": true
                    },
                    {
                        "full": "[snapshotIntervalInMsgCount]",
                        "name": "snapshotIntervalInMsgCount",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [createEquiJoinEngine](https://docs.dolphindb.cn/zh/funcs/c/createEquiJoinEngine.html)\n\n\n\n#### 语法\n\ncreateEquiJoinEngine(name, leftTable, rightTable, outputTable, metrics, matchingColumn, timeColumn, \\[garbageSize=5000], \\[maxDelayedTime], \\[snapshotDir], \\[snapshotIntervalInMsgCount])\n\n别名：createEqualJoinEngine\n\n#### 详情\n\n创建流数据等值连接引擎。返回一个左、右两表 equi join 后的表对象。注入等值连接引擎的左、右两表将以 *matchingColumn* + *timeColumn* 作为连接列，返回两表中连接字段相等的行。\n\n流计算 equi join 引擎内部的左、右表基于连接列和时间列构建键值表，不保留全部历史记录，可能因匹配记录被清除而不输出结果，行为上不同于 SQL 的 equi join。\n\n更多流数据引擎的应用场景说明可以参考 [内置多数据源流式关联引擎](https://docs.dolphindb.cn/zh/stream/str_join_engine.html)。\n\n#### 计算规则\n\n* 每次数据注入引擎左表时，会在右表中查找与连接列字段相匹配的记录，若找到，则将两表匹配的记录 join 后，根据 *metrics* 给出的因子进行计算并输出。\n* 每次数据注入引擎右表时，亦会做同样操作。\n\n#### 参数\n\nequi join 引擎的部分参数和 asof join 引擎相同，请参照 [createAsofJoinEngine](https://docs.dolphindb.cn/zh/funcs/c/createAsofJoinEngine.html) 中参数介绍。下面介绍不同的参数：\n\n**name** 字符串标量，表示 equi join 引擎的名称，作为其在一个数据节点/计算节点上的唯一标识。可包含字母，数字和下划线，但必须以字母开头。\n\n**timeColumn** 字符串标量或向量。用于指定 *leftTable* 和 *rightTable* 中时间列的名称。两表的时间列名称可以不同，但数据类型需保持一致。当 *leftTable* 和 *rightTable* 时间列名称相同时，*timeColumn* 是字符串标量，否则，*timeColumn* 是长度为2的字符串向量。\n\n**garbageSize** 可选参数，正整数，默认值是 5,000（单位为行）。当内存中历史数据行数超过 *garbageSize* 时，会清理本次计算不需要的历史数据。\n\n满足以下条件的数据才会被清理：\n\n1. 历史数据中已经 join 并输出的数据；\n2. 历史数据未发生 join 的数据，但其时间戳与 *leftTable* 或 *rightTable* 收到的最新数据的时间戳的差值大于 *maxDelayedTime*。\n\n**maxDelayedTime** 可选参数，正整数，单位同 *timeColumn* 精度一致，默认值为 3 秒。该参数仅在达到 *garbageSize* 清理条件时才会起效，表示引擎内能够保留最新多长时间的数据。详情参考上述清理条件 2。不建议设置 *maxDelayedTime* 值设置过小，否则可能导致一些需关联却没及时关联的数据被清理。\n\n#### 返回值\n\n一个表对象。\n\n#### 例子\n\n```\nshare streamTable(1:0, `time`sym`price, [SECOND, SYMBOL, DOUBLE]) as leftTable\nshare streamTable(1:0, `time`sym`val, [SECOND, SYMBOL, DOUBLE]) as rightTable\nshare table(100:0, `time`sym`price`val`total, [SECOND, SYMBOL, DOUBLE, DOUBLE, DOUBLE]) as output\nejEngine=createEquiJoinEngine(\"test1\", leftTable, rightTable, output, [<price>, <val>, <price*val>], `sym, `time)\nsubscribeTable(tableName=\"leftTable\", actionName=\"joinLeft\", offset=0, handler=appendForJoin{ejEngine, true}, msgAsTable=true)\nsubscribeTable(tableName=\"rightTable\", actionName=\"joinRight\", offset=0, handler=appendForJoin{ejEngine, false}, msgAsTable=true)\n\ntmp1=table(13:30:10+1..20 as time, take(`AAPL, 10) join take(`IBM, 10) as sym, double(1..20) as price)\nleftTable.append!(tmp1)\ntmp2=table(13:30:10+1..20 as time, take(`AAPL, 10) join take(`IBM, 10) as sym, double(50..31) as val)\nrightTable.append!(tmp2)\n```\n\n下例中时间列类型为 TIMESTAMP，若不设置 *maxDelayedTime*，取默认值3000ms(3s)。\n\n```\nshare streamTable(5000000:0, `timestamp`sym`price, [TIMESTAMP, SYMBOL, DOUBLE]) as leftTable\nshare streamTable(5000000:0, `timestamp`sym`val, [TIMESTAMP, SYMBOL, DOUBLE]) as rightTable\nshare table(5000000:0, `timestamp`sym`price`val`total`diff`ratio, [TIMESTAMP, SYMBOL, DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE]) as output\nejEngine=createEquiJoinEngine(\"test1\", leftTable, rightTable, output, <[price, val, price+val, price-val, price/val]>, `sym, `timestamp, 5000)\ntopic1=subscribeTable(tableName=\"leftTable\", actionName=\"writeLeft\", offset=0, handler=appendForJoin{ejEngine, true}, batchSize=10000, throttle=1)\ntopic2=subscribeTable(tableName=\"rightTable\", actionName=\"writeRight\", offset=0, handler=appendForJoin{ejEngine, false}, batchSize=10000, throttle=1)\ndef writeLeftTable(mutable tb){\n   batch = 1000\n   for(i in 1..300){\n           tmp = table(batch:batch, `timestamp`sym`price, [TIMESTAMP, SYMBOL, DOUBLE])\n           tmp[`timestamp]=take(2012.01.01T00:00:00.000+i, batch)\n           tmp[`sym]=shuffle(\"A\"+string(1..batch))\n           tmp[`price]=rand(100.0, batch)\n           tb.append!(tmp)\n   }\n}\n\ndef writeRightTable(mutable tb){\n   batch = 500\n   for(i in 1..200){\n           tmp = table(batch:batch, `timestamp`sym`val, [TIMESTAMP, SYMBOL, DOUBLE])\n           tmp[`timestamp]=take(2012.01.01T00:00:00.000+i, batch)\n           tmp[`sym]=shuffle(\"A\"+string(1..batch))\n           tmp[`val]=rand(100.0, batch)\n           tb.append!(tmp)\n   }\n}\n\njob1 = submitJob(\"writeLeft\", \"\", writeLeftTable, leftTable)\njob2 = submitJob(\"writeRight\", \"\", writeRightTable, rightTable)\n\nselect count(*) from output order by sym, timestamp\n// output: 100000\n```\n"
    },
    "createGPLearnEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/creategplearnengine.html",
        "signatures": [
            {
                "full": "createGPLearnEngine(trainData, targetData,[groupCol=''], [populationSize=1000], [generations=20], [tournamentSize=20], [stoppingCriteria=0.0], [constRange], [windowRange], [initDepth], [initMethod='half'], [initProgram=''], [functionSet], [maxSamples=1.0], [fitnessFunc='mse'], [parsimonyCoefficient=0.001], [crossoverMutationProb=0.9], [subtreeMutationProb=0.01], [hoistMutationProb=0.01], [pointMutationProb=0.01], [eliteCount =0], [restrictDepth=false], [deviceId=0], [seed], [verbose=true], [minimize=true], [useAbsFit=true], [dimReduceCol=''])",
                "name": "createGPLearnEngine",
                "parameters": [
                    {
                        "full": "trainData",
                        "name": "trainData"
                    },
                    {
                        "full": "targetData",
                        "name": "targetData"
                    },
                    {
                        "full": "[groupCol='']",
                        "name": "groupCol",
                        "optional": true,
                        "default": "''"
                    },
                    {
                        "full": "[populationSize=1000]",
                        "name": "populationSize",
                        "optional": true,
                        "default": "1000"
                    },
                    {
                        "full": "[generations=20]",
                        "name": "generations",
                        "optional": true,
                        "default": "20"
                    },
                    {
                        "full": "[tournamentSize=20]",
                        "name": "tournamentSize",
                        "optional": true,
                        "default": "20"
                    },
                    {
                        "full": "[stoppingCriteria=0.0]",
                        "name": "stoppingCriteria",
                        "optional": true,
                        "default": "0.0"
                    },
                    {
                        "full": "[constRange]",
                        "name": "constRange",
                        "optional": true
                    },
                    {
                        "full": "[windowRange]",
                        "name": "windowRange",
                        "optional": true
                    },
                    {
                        "full": "[initDepth]",
                        "name": "initDepth",
                        "optional": true
                    },
                    {
                        "full": "[initMethod='half']",
                        "name": "initMethod",
                        "optional": true,
                        "default": "'half'"
                    },
                    {
                        "full": "[initProgram='']",
                        "name": "initProgram",
                        "optional": true,
                        "default": "''"
                    },
                    {
                        "full": "[functionSet]",
                        "name": "functionSet",
                        "optional": true
                    },
                    {
                        "full": "[maxSamples=1.0]",
                        "name": "maxSamples",
                        "optional": true,
                        "default": "1.0"
                    },
                    {
                        "full": "[fitnessFunc='mse']",
                        "name": "fitnessFunc",
                        "optional": true,
                        "default": "'mse'"
                    },
                    {
                        "full": "[parsimonyCoefficient=0.001]",
                        "name": "parsimonyCoefficient",
                        "optional": true,
                        "default": "0.001"
                    },
                    {
                        "full": "[crossoverMutationProb=0.9]",
                        "name": "crossoverMutationProb",
                        "optional": true,
                        "default": "0.9"
                    },
                    {
                        "full": "[subtreeMutationProb=0.01]",
                        "name": "subtreeMutationProb",
                        "optional": true,
                        "default": "0.01"
                    },
                    {
                        "full": "[hoistMutationProb=0.01]",
                        "name": "hoistMutationProb",
                        "optional": true,
                        "default": "0.01"
                    },
                    {
                        "full": "[pointMutationProb=0.01]",
                        "name": "pointMutationProb",
                        "optional": true,
                        "default": "0.01"
                    },
                    {
                        "full": "[eliteCount =0]",
                        "name": "[eliteCount =0]"
                    },
                    {
                        "full": "[restrictDepth=false]",
                        "name": "restrictDepth",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[deviceId=0]",
                        "name": "deviceId",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[seed]",
                        "name": "seed",
                        "optional": true
                    },
                    {
                        "full": "[verbose=true]",
                        "name": "verbose",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[minimize=true]",
                        "name": "minimize",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[useAbsFit=true]",
                        "name": "useAbsFit",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[dimReduceCol='']",
                        "name": "dimReduceCol",
                        "optional": true,
                        "default": "''"
                    }
                ]
            }
        ],
        "markdown": "### [createGPLearnEngine](https://docs.dolphindb.cn/zh/funcs/c/creategplearnengine.html)\n\n#### 语法\n\ncreateGPLearnEngine(trainData, targetData,\\[groupCol=''], \\[populationSize=1000], \\[generations=20], \\[tournamentSize=20], \\[stoppingCriteria=0.0], \\[constRange], \\[windowRange], \\[initDepth], \\[initMethod='half'], \\[initProgram=''], \\[functionSet], \\[maxSamples=1.0], \\[fitnessFunc='mse'], \\[parsimonyCoefficient=0.001], \\[crossoverMutationProb=0.9], \\[subtreeMutationProb=0.01], \\[hoistMutationProb=0.01], \\[pointMutationProb=0.01], \\[eliteCount =0], \\[restrictDepth=false], \\[deviceId=0], \\[seed], \\[verbose=true], \\[minimize=true], \\[useAbsFit=true], \\[dimReduceCol=''])\n\n**Note:**\n\n社区版 License 暂不支持该引擎，如需使用此功能，请联系技术支持。\n\n#### 详情\n\n创建一个 GPLearn 引擎用于训练和预测。\n\n#### 参数\n\n* **trainData** 是 FLOAT 或 DOUBLE 类型的表，表示用于训练的数据。\n\n* **targetData**是 FLOAT 或 DOUBLE 类型的向量，需要预测的数据。targetData 与 trainData 的数据类型必须一致。\n\n* **groupCol** 字符串标量或向量，表示分组列名，可将数据按照此参数指定的列进行分组后计算。默认为空，表示无分组列。\n\n  **Note:** 分组列本身不会参与计算。\n\n* **populationSize** 整型标量，表示每代公式的数量， 默认值为 1000。\n\n* **generations** 整型标量，表示进化的代数，默认为 20。\n\n* **tournamentSize** 整型标量，表示生成下一代公式时，参与竞争的公式数量，默认为 20。\n\n* **stoppingCriteria** 浮点型标量，表示终止迭代的适应度阈值。当适应度小于等于此阈值时，会提前结束进化。默认为 0，表示达到进化的代数之前不会停止。\n\n* **constRange** 可以是 0 或长度为 2 的浮点型向量，表示公式中包含的常量的范围，默认为 \\[-1.0, 1.0]。\n  * 为 0 时，公式中将不会包含常量。\n  * 为向量时，向量的两个元素代表闭区间边界。\n\n* **windowRange** 整型向量，表示滑动窗口函数的窗口大小取值范围，滑动窗口的大小是此向量中的随机值，默认为 \\[2, 3, 4, 5, 6, 7, 8, 9, 10, 15, 20, 30, 7, 14, 21, 48, 35, 42]。\n\n* **initDepth** 长度为 2 的整型向量，表示初始化公式树的深度范围，默认是 \\[2, 6]。\n\n* **initMethod** 字符串类型标量，用于指定初始化公式树的方法，默认为 half 。\n  * grow 公式树中的每一个节点，都是从函数、常量和变量中随机选取\n  * full 只有公式树的叶子节点可以是常量或变量\n  * half 公式树的子树，将会有50%/50%的概率通过 grow/full 生成\n\n* **initProgram**元代码或元代码的元组，默认为空。指定此参数，将会用指定的元代码初始化种群。例如 `<mavg(price, 10)>` ，其中 mavg 是 GPLearn 已经支持的函数， price 是 *trainData* 中的列。\n\n* **functionSet** 初始化公式树和进化时选择的算子，为字符串类型的向量。默认值为空，表示可以使用所有支持的算子。支持的算子列表详见附录。\n\n* **maxSamples** 浮点型标量，表示参与 fitnessFunc 计算的输入数据的比例，取值范围是 \\[0,1]，默认是 1.0 。\n\n* **fitnessFunc** 用户自定义的 FUNCTIONDEF 类型标量，或字符串标量，代表适应度函数。默认是 'mse'，字符串可选值为：\n  * 'mse'，均方误差。\n  * 'rmse'，均方根误差。\n  * 'pearson'，皮尔逊矩阵相关系数。\n  * 'spearmanr'，Spearmanr 排序相关系数。\n  * 'mae'，平均绝对误差。\n\n* **parsimonyCoefficient** 浮点型标量，表示节俭系数。随着进化次数的增加，公式会越来越膨胀，失去可解释性，节俭系数会惩罚过长的公式。默认为 0.0 。\n\n* **crossoverMutationProb** 浮点型标量，表示 crossover 的概率，默认是 0.9 。\n\n* **subtreeMutationProb** 浮点型标量，表示 subtree 变异的概率，默认是 0.01 。\n\n* **hoistMutationProb**浮点型标量，表示 hoist 变异的概率，默认是 0.01 。\n\n* **pointMutationProb**浮点型标量，表示 point 变异的概率，默认是 0.01 。\n\n**Note:** 所有变异概率之和必须小于等于 1\n\n* **eliteCount** INT 类型标量，代表精英数量，默认为 0。适应度最优的 eliteCount 个公式，会作为精英直接传递给下一代。\n* **restrictDepth**布尔类型标量，代表是否严格限制公式的长度，默认为 false。设置为 true 时，公式的深度不会超过 initDepth 的上限。\n* **deviceId** INT类型的标量或向量。当前机器拥有多卡时，可以指定使用的设备 ID，默认为 0 。\n* **seed** 整型标量，表示训练时使用的种子。\n* **verbose** BOOL 类型标量，设置是否输出训练时的信息，默认是 true。\n* **minimize** BOOL 类型标量，设置是否向适应度最小化的方向进化。默认是 true，则认为适应度越小，公式越优秀；反之则认为适应度越大，公式越优秀。\n* **useAbsFit**在计算适应度时是否取绝对值。可选参数，默认为 true，表示取绝对值。设置为 false 时，当 *fitnessFunc* 设置为 'pearson'，'spearmanr' 或 `corr`时，不取绝对值。\n* **dimReduceCol** 可选参数，STRING 类型标量或向量，表示分组列，计算将根据该参数指定的列进行分组聚合。指定此参数后，挖掘出的公式将包含降频算子。注意：若指定此参数，必须确保预测数据 *targetData* 与训练数据 *trainData* 按 *dimReduceCol* 分组聚合并按升序排序后的顺序一致。\n\n#### 返回值\n\n一个表对象。\n\n#### 例子\n\n参考：[Shark GPLearn 快速上手](https://docs.dolphindb.cn/zh/tutorials/gplearn.html)\n\n\n\n**Related information**\n\n[Shark GPLearn 快速上手](https://docs.dolphindb.cn/zh/tutorials/gplearn.html)\n"
    },
    "createGroup": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/createGroup.html",
        "signatures": [
            {
                "full": "createGroup(groupId, [userIds])",
                "name": "createGroup",
                "parameters": [
                    {
                        "full": "groupId",
                        "name": "groupId"
                    },
                    {
                        "full": "[userIds]",
                        "name": "userIds",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [createGroup](https://docs.dolphindb.cn/zh/funcs/c/createGroup.html)\n\n\n\n#### 语法\n\ncreateGroup(groupId, \\[userIds])\n\n#### 详情\n\n创建组。\n\n组中的用户必须是已经创建了的用户。\n\n**Note:** 该函数只能由管理员在控制节点、数据节点和计算节点运行。\n\n#### 参数\n\n**groupId** 是表示组名的字符串。只能包含字母、数字、下划线（\\_）、或短横线（-），且必须以字母开头，长度不得超过 30 个字符。\n\n**userId** 是表示组成员的字符串标量或向量。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n创建组 \"production\"，并且把用户 \"JohnSmith\" 添加到该组。\n\n```\ncreateGroup(`production, `JohnSmith);\n```\n"
    },
    "createIMOLTPTable": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/createIMOLTPTable.html",
        "signatures": [
            {
                "full": "createIMOLTPTable(dbHandle, table, tableName, primaryKey, [secondaryKey], [uniqueFlag])",
                "name": "createIMOLTPTable",
                "parameters": [
                    {
                        "full": "dbHandle",
                        "name": "dbHandle"
                    },
                    {
                        "full": "table",
                        "name": "table"
                    },
                    {
                        "full": "tableName",
                        "name": "tableName"
                    },
                    {
                        "full": "primaryKey",
                        "name": "primaryKey"
                    },
                    {
                        "full": "[secondaryKey]",
                        "name": "secondaryKey",
                        "optional": true
                    },
                    {
                        "full": "[uniqueFlag]",
                        "name": "uniqueFlag",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [createIMOLTPTable](https://docs.dolphindb.cn/zh/funcs/c/createIMOLTPTable.html)\n\n\n\n#### 语法\n\ncreateIMOLTPTable(dbHandle, table, tableName, primaryKey, \\[secondaryKey], \\[uniqueFlag])\n\n#### 详情\n\n在 IMOLTP 数据库中创建 IMOLTP 表。\n\n#### 参数\n\n**dbHandle**函数 [database](https://docs.dolphindb.cn/zh/funcs/d/database.html) 返回的 IMOLTP 数据库句柄。\n\n**table**一个表，系统将根据该表的结构在数据库中创建一个空的 IMOLTP 表。\n\n**tableName**字符串标量，表示 IMOLTP 表的名字。\n\n**primaryKey**字符串标量或向量，表示主键索引的键包含的字段（字段即为列名）。为标量时，表示只包含一个字段；为向量时，表示包含多个字段。\n\n**secondaryKey**可选参数，字符串标量或向量，表示每一个二级索引的键包含的字段。\n\n**uniqueFlag**可选参数，布尔类型标量或向量，表示每一个二级索引是否是唯一的：\n\n* uniqueFlag 为标量或 size 为 1 的向量，表示只有一个二级索引。此时 secondaryKey 可以为字符串标量（表示一个字段）或向量（表示多个字段）。\n* uniqueFlag 为长度大于 1 的向量，表示有多个二级索引。此时 secondaryKey 的长度必须与 uniqueFlag 相同，secondaryKey 的每一个元素表示一个键。\n\n#### 返回值\n\n一个表。\n\n#### 例子\n\n创建 IMOLTP 数据库\n\n```\ndbName = \"oltp://test_imoltp\"\ndb = database(directory=dbName, partitionType=VALUE, partitionScheme=1..100, engine=\"IMOLTP\")\n```\n\n创建表 test\\_table\\_1，以 id 为主键，没有二级索引\n\n```\npt1 = createIMOLTPTable(\n    dbHandle=db,\n    table=table(1:0, [\"id\", \"val1\", \"val2\", \"sym\"], [LONG, INT, LONG, STRING]),\n    tableName=\"test_table_1\",\n    primaryKey=`id\n)\n```\n\n创建表 test\\_table\\_2，以 id，sym 为主键，val2，sym 作为 unique 二级索引\n\n```\npt2 = createIMOLTPTable(\n    dbHandle=db,\n    table=table(1:0, [\"id\", \"val1\", \"val2\", \"sym\"], [LONG, INT, LONG, STRING]),\n    tableName=\"test_table_2\",\n    primaryKey=`id`sym,\n    secondaryKey=`val2`sym,\n    uniqueFlag=true\n)\n```\n\n创建表 test\\_table\\_3，以 id 为主键，有一个非 unique 二级索引：以 val1 为键；一个 unique 二级索引：以 sym 为键\n\n```\npt3 = createIMOLTPTable(\n    dbHandle=db,\n    table=table(1:0, [\"id\", \"val1\", \"val2\", \"sym\"], [LONG, INT, LONG, STRING]),\n    tableName=\"test_table_3\",\n    primaryKey=`id,\n    secondaryKey=[`val1, `sym],\n    uniqueFlag=[false, true]\n)\n```\n"
    },
    "createIPCInMemoryTable": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/createIPCInMemoryTable.html",
        "signatures": [
            {
                "full": "createIPCInMemoryTable(size, tableName, columnNames, columnTypes)",
                "name": "createIPCInMemoryTable",
                "parameters": [
                    {
                        "full": "size",
                        "name": "size"
                    },
                    {
                        "full": "tableName",
                        "name": "tableName"
                    },
                    {
                        "full": "columnNames",
                        "name": "columnNames"
                    },
                    {
                        "full": "columnTypes",
                        "name": "columnTypes"
                    }
                ]
            }
        ],
        "markdown": "### [createIPCInMemoryTable](https://docs.dolphindb.cn/zh/funcs/c/createIPCInMemoryTable.html)\n\n\n\n#### 语法\n\ncreateIPCInMemoryTable(size, tableName, columnNames, columnTypes)\n\n#### 详情\n\n创建一个跨进程共享内存表的句柄。跨进程共享内存表通常作为流计算的输出表。在对时延要求极高的场景下，用户进程通过插件直接访问共享内存获取数据，极大减小了 TCP 等网络传输的时延。\n\n跨进程共享内存表通过共享内存（由操作系统管理）进行跨进程通信。共享内存表仅支持在同一物理机内共享，不支持在集群不同物理节点间进行共享。\n\n跨进程共享内存表支持读写，但不支持对跨进程共享内存表的表结构进行修改。向跨进程共享内存表写数据的方法，与普通内存表一致。若一次性插入的数据量大于共享内存，系统会抛出异常。\n\n* 读写机制：将写入共享内存的进程作为生产者，从共享内存中读取数据的进程作为消费者。一次写入的数据将作为一个整体，供一次读取消费，且读进程依次按顺序对写入的数据进行消费。例如：第一写入 100 条数据，第二次写入 200 条数据，则第一次会读到 100 条数据，第二次会读到第二批写入的 200 条数据，以此类推。读取数据时，共享内存表中的所有数据均已被消费，则读进程会被阻塞，直到有新写入的可消费数据时，才能将数据读出。\n\nDolphinDB 支持多进程并发写入共享内存表，以及在写入的同时进行读操作。但注意，只能同时存在一个读进程。参考上述读写机制，读取是一次性的，若不同进程并发读取，将会得到不同阶段写入的数据。\n\n**Note:** 此函数仅适用于 Linux 系统。\n\n#### 参数\n\n**size** 整数，表示 table 能缓存的记录数。该值必须大于 1,000,000，否则系统自动取 1,000,000。\n\n**tableName** 字符串，表示跨进程共享内存表的名称。\n\n**columnNames** 字符串向量，用于指定表的列名。\n\n**columnTypes** 向量，表示每列的数据类型。可使用表示数据类型的系统保留字或相应的字符串。\n\n#### 返回值\n\n一个共享内存表句柄。\n\n#### 例子\n\n创建一个跨进程共享内存表，并作为流数据订阅的输出表。\n\n```\nshare streamTable(10000:0,`timestamp`temperature, [TIMESTAMP,DOUBLE]) as pubTable\nipc_t = createIPCInMemoryTable(1000000, \"ipc_table\", `timestamp`temperature, [TIMESTAMP, DOUBLE])\ndef shm_append(mutable table, msg) {\n   table.append!(msg)\n}\nsubscribeTable(tableName=\"pubTable\", actionName=\"act3\", offset=0, handler=shm_append{ipc_t}, msgAsTable=true)\n// 写入数据\n\nn = 200\ntimestamp = 2022.01.01T09:00:00.000 + 1..n\ntemp = 30 + rand(5.0,n)\n\ntableInsert(pubTable,timestamp,temp)\n```\n\n**Related information**\n\n[dropIPCInMemoryTable](https://docs.dolphindb.cn/zh/funcs/d/dropIPCInMemoryTable.html)\n\n[loadIPCInMemoryTable](https://docs.dolphindb.cn/zh/funcs/l/loadIPCInMemoryTable.html)\n"
    },
    "createLeftSemiJoinEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/createLeftSemiJoinEngine.html",
        "signatures": [
            {
                "full": "createLeftSemiJoinEngine(name, leftTable, rightTable, outputTable, metrics, matchingColumn, [garbageSize=5000], [updateRightTable=false], [snapshotDir], [snapshotIntervalInMsgCount])",
                "name": "createLeftSemiJoinEngine",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "leftTable",
                        "name": "leftTable"
                    },
                    {
                        "full": "rightTable",
                        "name": "rightTable"
                    },
                    {
                        "full": "outputTable",
                        "name": "outputTable"
                    },
                    {
                        "full": "metrics",
                        "name": "metrics"
                    },
                    {
                        "full": "matchingColumn",
                        "name": "matchingColumn"
                    },
                    {
                        "full": "[garbageSize=5000]",
                        "name": "garbageSize",
                        "optional": true,
                        "default": "5000"
                    },
                    {
                        "full": "[updateRightTable=false]",
                        "name": "updateRightTable",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[snapshotDir]",
                        "name": "snapshotDir",
                        "optional": true
                    },
                    {
                        "full": "[snapshotIntervalInMsgCount]",
                        "name": "snapshotIntervalInMsgCount",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [createLeftSemiJoinEngine](https://docs.dolphindb.cn/zh/funcs/c/createLeftSemiJoinEngine.html)\n\n\n\n#### 语法\n\ncreateLeftSemiJoinEngine(name, leftTable, rightTable, outputTable, metrics, matchingColumn, \\[garbageSize=5000], \\[updateRightTable=false], \\[snapshotDir], \\[snapshotIntervalInMsgCount])\n\n#### 详情\n\n创建流数据左半等值连接引擎，返回一个左、右表关联后的表对象。对于左表每一条数据，都去匹配右表相同 *matchingColumn* 的数据，若无匹配的右表记录，则不输出。若匹配多条右表记录，则由 *updateRightTable* 参数决定连接右表的第一条记录还是最新一条记录。\n\n**Note:** 右表根据 *updateRightTable* 指定的策略，同一 *matchingColumn* 只保留第一条或者最新一条数据，历史数据不再进行垃圾回收，因此用户需要控制 *matchingColumn* 的唯一值数量，否则可能会导致内存溢出。\n\n#### 参数\n\n**name** 表示流数据 left semi join 引擎的名称，作为其在一个数据节点/计算节点上的唯一标识。可包含字母，数字和下划线，但必须以字母开头。\n\n**leftTable** 表对象。可以不包含数据，但结构必须与输入的流数据表相同。自 2.00.11 版本开始，该参数支持 array vector。\n\n**rightTable** 表对象。可以不包含数据，但结构必须与输入的流数据表相同。自 2.00.11 版本开始，该参数支持 array vector。\n\n**outputTable** 为计算结果的输出表。在使用 `createLeftSemiJoinEngine` 函数之前，需要将输出表预先设立为一个空表，并指定各列列名以及数据类型。自 2.00.11 版本开始，引擎支持通过自定义聚合函数，将多个计算结果以 array vector 的形式输出，此时必须在该参数中指定对应列类型为 array vector。\n\n输出表的各列的顺序如下：\n\n1. 连接列。与 *matchingColumn* 中的列以及其顺序一致，可为多列。\n2. 计算结果列。可为多列。\n\n**metrics** 以元代码的格式表示计算指标，支持输入元组。有关元代码的更多信息可参考 [Metaprogramming](https://docs.dolphindb.cn/zh/progr/objs/meta_progr.html)。\n\n* 计算指标可以是一个或多个表达式、系统内置或用户自定义函数、一个常量标量/向量。当指定为常量向量时，对应的输出列必须设置为数组向量类型，例子参见 [createReactiveStateEngine](https://docs.dolphindb.cn/zh/funcs/c/createReactiveStateEngine.html) 中的例4。\n* **metrics** 内支持调用具有多个返回值的函数，且必须指定列名，例如 \\<func(price) as \\`col1\\`col2>。\n\n  若在 *metrics* 指定了 *leftTable* 和 *rightTable* 中具有相同名称的列，默认取左表的列，可以通过 \"tableName.colName\" 指定该列来自哪个表。\n\n  **Note:** *metrics* 中使用的列名大小写不敏感，不需要与输入表的列名大小写保持一致。\n\n**matchingColumn** 表示连接列的字符串标量/向量或字符串向量组成的 tuple，支持 Integral, Temporal 或 Literal(UUID 除外)类型。\n\n*matchingColumn* 指定规则：\n\n1. 只有一个连接列。当左表和右表的连接列名相同时，*matchingColumn* 是一个字符串标量，否则是一个长度为 2 的 tuple。例如：左表连接列名为 sym，右表连接列名为 sym1，则 *matchingColumn* = \\[\\[\\`sym],\\[\\`sym1]]。\n2. 有多个连接列。当左表和右表的连接列名相同时，*matchingColumn* 是一个字符串向量，否则是一个长度为 2 的 tuple。例如：左表连接列名为 timestamp, sym，右表连接列名为 timestamp, sym1，则 *matchingColumn* = \\[\\[\\`timestamp, \\`sym], \\[\\`timestamp,\\`sym1]]。\n\n**garbageSize** 可选参数，正整数，默认值是 5,000（单位为行）。和其他连接引擎不同，该函数的 *garbageSize* 参数只用于清理左表的历史数据。当左表发生过 join 的记录数超过 *garbageSize* 时，系统会触发清理。\n\n**updateRightTable** 可选参数，布尔值，默认为 false，表示右表存在多条相同 *matchingColumn* 的记录时，是保留第一条（false）还是最新一条记录（true）。\n\n若要开启快照机制 (snapshot)，必须指定 *snapshotDir* 与 *snapshotIntervalInMsgCount*。\n\n**snapshotDir** 可选参数，字符串，表示保存引擎快照的文件目录。\n\n* 指定的目录必须存在，否则系统会提示异常。\n* 创建流数据引擎时，如果指定了 *snapshotDir*，会检查该目录下是否存在快照。如果存在，会加载该快照，恢复引擎的状态。\n* 多个引擎可以指定同一个目录存储快照，用引擎的名称来区分快照文件。\n* 一个引擎的快照可能会使用三个文件名：\n* 临时存储快照信息：文件名为 \\<engineName>.tmp；\n* 快照生成并刷到磁盘：文件保存为 \\<engineName>.snapshot；\n* 存在同名快照：旧快照自动重命名为 \\<engineName>.old。\n\n**snapshotIntervalInMsgCount** 可选参数，为整数类型，表示每隔多少条数据保存一次流数据引擎快照。\n\n#### 返回值\n\n返回一个表对象。\n\n#### 例子\n\n```\nshare streamTable(1:0, `time`sym`price, [TIMESTAMP, SYMBOL, DOUBLE]) as leftTable\nshare streamTable(1:0, `time`sym1`vol, [TIMESTAMP, SYMBOL, INT]) as rightTable\n\nshare table(100:0, `time`sym`price`vol`total, [TIMESTAMP, SYMBOL, DOUBLE, INT, DOUBLE]) as output\nlsjEngine=createLeftSemiJoinEngine(name=\"test1\", leftTable=leftTable, rightTable=rightTable, outputTable=output,  metrics=<[price, vol,price*vol]>, matchingColumn=[[`time,`sym], [`time,`sym1]], updateRightTable=true)\n\nsubscribeTable(tableName=\"leftTable\", actionName=\"joinLeft\", offset=0, handler=appendForJoin{lsjEngine, true}, msgAsTable=true)\nsubscribeTable(tableName=\"rightTable\", actionName=\"joinRight\", offset=0, handler=appendForJoin{lsjEngine, false}, msgAsTable=true)\n\nv = [1, 5, 10, 15]\ntp1=table(2012.01.01T00:00:00.000+v as time, take(`AAPL, 4) as sym, rand(100,4) as price)\nleftTable.append!(tp1)\n\nv = [1, 1, 3, 4, 5, 5, 5, 15]\ntp2=table(2012.01.01T00:00:00.000+v as time, take(`AAPL, 8) as sym, rand(100,8) as vol)\nrightTable.append!(tp2)\n\nselect * from output\n```\n\n| time                    | sym  | price | vol | total |\n| ----------------------- | ---- | ----- | --- | ----- |\n| 2012.01.01T00:00:00.001 | AAPL | 44    | 76  | 3344  |\n| 2012.01.01T00:00:00.005 | AAPL | 15    | 64  | 960   |\n| 2012.01.01T00:00:00.015 | AAPL | 24    | 75  | 1800  |\n\n若要再次执行以上脚本，需要先删除引擎并取消订阅：\n\n```\ndropStreamEngine(\"test1\")\nlsjEngine=NULL\nunsubscribeTable(tableName=\"leftTable\", actionName=\"joinLeft\")\nunsubscribeTable(tableName=\"rightTable\", actionName=\"joinRight\")\n```\n\n**Related information**\n\n[流计算引擎](https://docs.dolphindb.cn/zh/funcs/themes/streamingEngine.html)\n"
    },
    "createLookupJoinEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/createLookupJoinEngine.html",
        "signatures": [
            {
                "full": "createLookupJoinEngine(name, leftTable, rightTable, outputTable, metrics, matchingColumn, [rightTimeColumn], [checkTimes], [outputElapsedMicroseconds=false], [keepDuplicates=false], [isInnerJoin], [snapshotDir], [snapshotIntervalInMsgCount])",
                "name": "createLookupJoinEngine",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "leftTable",
                        "name": "leftTable"
                    },
                    {
                        "full": "rightTable",
                        "name": "rightTable"
                    },
                    {
                        "full": "outputTable",
                        "name": "outputTable"
                    },
                    {
                        "full": "metrics",
                        "name": "metrics"
                    },
                    {
                        "full": "matchingColumn",
                        "name": "matchingColumn"
                    },
                    {
                        "full": "[rightTimeColumn]",
                        "name": "rightTimeColumn",
                        "optional": true
                    },
                    {
                        "full": "[checkTimes]",
                        "name": "checkTimes",
                        "optional": true
                    },
                    {
                        "full": "[outputElapsedMicroseconds=false]",
                        "name": "outputElapsedMicroseconds",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[keepDuplicates=false]",
                        "name": "keepDuplicates",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[isInnerJoin]",
                        "name": "isInnerJoin",
                        "optional": true
                    },
                    {
                        "full": "[snapshotDir]",
                        "name": "snapshotDir",
                        "optional": true
                    },
                    {
                        "full": "[snapshotIntervalInMsgCount]",
                        "name": "snapshotIntervalInMsgCount",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [createLookupJoinEngine](https://docs.dolphindb.cn/zh/funcs/c/createLookupJoinEngine.html)\n\n\n\n#### 语法\n\ncreateLookupJoinEngine(name, leftTable, rightTable, outputTable, metrics, matchingColumn, \\[rightTimeColumn], \\[checkTimes], \\[outputElapsedMicroseconds=false], \\[keepDuplicates=false], \\[isInnerJoin], \\[snapshotDir], \\[snapshotIntervalInMsgCount])\n\n#### 详情\n\n创建流数据表的 lookup join 引擎，该引擎以 *matchingColumn*作为连接列，将左表（必须为流数据表）与右表进行左连接或内连接。lookup join 引擎常用于右表更新不频繁的场景（如保存了日频指标的维度表）。若右表为非流数据表，则需设置定时刷新该表数据。\n\n##### 工作机制\n\n1. 仅当左表有新数据流入时才会触发计算。\n\n2. 当 *keepDuplicates* = false 时，引擎仅保留右表在基于 *matchingColumn* 分组后每组的最新一条数据。此时：\n\n   * 默认连接方式为左连接，即 *isInnerJoin* = false。每次数据注入左表时，无论右表中是否有匹配的记录，都会计算指标并输出（如果右表没有匹配记录，则输出空值）。\n   * 用户可以通过将 *isInnerJoin* 设置为 true 来将连接方式改为内连接。\n     当 *keepDuplicates* = true 时，引擎保留右表在基于 *matchingColumn* 分组后每组的所有数据。此时，连接方式只能是内连接，即每次数据注入左表时，系统会在右表中查找与连接列匹配的记录，只有匹配成功才会计算指标并输出，否则不进行计算和输出。\n\n3. 当右表是订阅的流数据表时，数据流入右表的同时会更新数据； 若右表为内存表、维度表或元代码，系统会根据 *checkTimes* 定时刷新右表数据。\n\nlookup join 引擎与 asof join, semi lookup join, snapshot join 引擎的比较：\n\n<table id=\"table_bpk_5s5_c2c\"><tbody><tr><td>\n\nasof join 引擎\n\n</td><td>\n\n* lookup join 引擎输出表的第一列可以不是时间列，而 asof join 引擎输出表第一列必须是时间列。\n* lookup join 引擎当左表有新数据流入便会触发连接计算，因此无需考虑数据延迟，也无需缓存左表数据。而 asof join 引擎，当指定 *timeColumn* 时，需要考虑左右表的数据延时。\n\n</td></tr><tr><td>\n\nleft semi join 引擎\n\n</td><td>\n\nlookup join 引擎和 left semi join 引擎都由左表的新记录触发连接计算，当引擎根据连接列匹配上右表中的记录时，引擎将输出结果。\n\nlookup join 引擎对于左表中未在右表中成功匹配的记录，根据参数设置或直接输出、或不输出结果；left semi join 引擎对于左表中未成功匹配的记录将进行缓存，等待与右表中更新的记录匹配后输出。\n\nleft semi join 引擎在缓存右表的记录时，对于相同连接列的数据总是只保留第一条或者最新一条，因此对于左表的每一条记录至多只会匹配一条右表记录并输出一条记录。在lookup join engine中，对于相同连接列的数据用户可选择保留全部记录，因此存在左表的每一条记录匹配到右表多条记录、输出多条记录的情况。\n\n</td></tr><tr><td>\n\nsnapshot join 引擎\n\n</td><td>\n\nlookup join 引擎只能由左表的新记录触发连接；而 snapshot join 引擎可以由左表或右表的新记录触发连接。\n\n</td></tr></tbody>\n</table>更多流数据引擎的应用场景说明可以参考 [流计算引擎](../themes/streamingEngine.md)。\n\n#### 参数\n\n**name** 必选参数，表示流数据 lookup join 引擎的名称，作为其在一个数据节点/计算节点上的唯一标识。可包含字母，数字和下划线，但必须以字母开头。\n\n**leftTable** 可选参数，表对象。可以不包含数据，但结构必须与输入的流数据表相同。\n\n**rightTable** 可选参数，表对象，可以是内存表、流数据表、维度表或 SQL 查询元代码（查询语句必须返回表 ）。请注意，如果 *rightTable* 没有被订阅，但 *rightTable* 会定期更新，则必须设置 *checkTimes* 来定时刷新右表数据。\n\n**outputTable** 必选参数，为计算结果的输出表。在使用 `createLookupJoinEngine` 函数之前，需要将输出表预先设立为一个空表，并指定各列列名以及数据类型。\n\n输出表的各列的顺序如下：\n\n1. 连接列。与 *matchingColumn* 中的列以及其顺序一致，可为多列。\n2. 计算结果列。可为多列。\n3. 耗时列。如果指定 *outputElapsedMicroseconds* = true，则指定一个 LONG 类型的列用于记录单次响应计算耗时（单位：微秒）。\n4. batchSize 列。如果指定 *outputElapsedMicroseconds* = true, 则指定一个INT类型的列，记录单次响应的数据条数。\n\n**metrics** 可选参数，以元代码的格式表示计算指标，支持输入元组。有关元代码的更多信息可参考 [Metaprogramming](https://docs.dolphindb.cn/zh/progr/objs/meta_progr.html)。\n\n* 计算指标可以是一个或多个表达式、系统内置或用户自定义函数、一个常量标量/向量，但不能是聚合函数。当指定为常量向量时，对应的输出列必须设置为数组向量类型，例子参见 [createReactiveStateEngine](https://docs.dolphindb.cn/zh/funcs/c/createReactiveStateEngine.html) 中的例4。\n* *metrics* 内支持调用具有多个返回值的函数，且必须指定列名，例如 \\<func(price) as \\`col1\\`col2>。\n* 若在 *metrics* 指定了 *leftTable* 和 *rightTable* 中具有相同名称的列，默认取左表的列，可以通过 \"tableName.colName\" 指定该列来自哪个表。\n\n  **Note:** *metrics* 中使用的列名大小写不敏感，不需要与输入表的列名大小写保持一致。\n\n**matchingColumn** 可选参数，表示连接列的字符串标量/向量或字符串向量组成的 tuple，支持 Integral, Temporal 或 Literal(UUID 除外)类型。*matchingColumn* 指定规则：\n\n1. 只有一个连接列。当左表和右表的连接列名相同时，*matchingColumn* 是一个字符串标量，否则是一个长度为 2 的 tuple。例如：左表连接列名为 sym，右表连接列名为 sym1，则 *matchingColumn* = \\[\\[\\`sym],\\[\\`sym1]]。\n2. 有多个连接列。当左表和右表的连接列名相同时，*matchingColumn* 是一个字符串向量，否则是一个长度为 2 的 tuple。例如：左表连接列名为 timestamp, sym，右表连接列名为 timestamp, sym1，则 *matchingColumn* = \\[\\[\\`timestamp, \\`sym], \\[\\`timestamp,\\`sym1]]。\n\n**rightTimeColumn** 可选参数，是字符串标量，表示右表的时间列名称。若设置该参数，右表会根据指定的时间列的时间戳保留最新的数据（若有多行，则取其中最后一行）。若不指定该参数，则根据数据注入系统的时间保留最新数据。\n\n**checkTimes** 可选参数，是一个时间类型向量或 DURATION 的标量。设置后，系统会定时更新 *rightTable* 的数据（只保留 *rightTable* 的最新数据），并将更新后的数据追加到引擎中。当无需更新 *rightTable* 时，则不用设置该参数，但需要在引擎创建后，手动将 *rightTable* 注入到引擎中。\n\n* *checkTimes* 是时间类型向量时，只能为SECOND、TIME 或 NANOTIME 类型。 lookup join 引擎每天根据向量内各元素指定的时间定时更新右表。\n* *checkTimes* 是 DURATION 标量时，表示更新右表的时间间隔。\n\n**outputElapsedMicroseconds** 可选参数，布尔值，表示是否输出单次响应计算的耗时（从触发计算的数据注入引擎到计算完成的耗时），默认为 false。指定参数 *outputElapsedMicroseconds* 后，在定义 outputTable 时需要在计算结果列后增加一个 LONG 类型的列和 INT 类型的列，详见 *outputTable* 参数说明。\n\n**keepDuplicates** 可选参数，布尔值，表示是否保留右表各分组内的所有数据。默认值为 false，即在关联时只取右表各分组内的最新一条数据。当设置为 true 时，在关联时则使用右表各分组内的所有数据，此时的连接类型为内连接，即只有左右两表匹配的记录被计算输出。\n\n**isInnerJoin** 布尔值，可选参数，表示是否进行内连接。该参数只在 *keepDuplicates*为 false 时可进行配置。该参数默认值为 false，即进行左连接，无论在右表中是否找到匹配的记录，都会输出结果（右表未匹配的记录输出空值）。设置为 true 时左右两表进行内连接。\n\n若要开启快照机制 (snapshot)，必须指定 *snapshotDir* 与 *snapshotIntervalInMsgCount*。\n\n**snapshotDir** 可选参数，字符串，表示保存引擎快照的文件目录。\n\n* 指定的目录必须存在，否则系统会提示异常。\n* 创建流数据引擎时，如果指定了 *snapshotDir*，会检查该目录下是否存在快照。如果存在，会加载该快照，恢复引擎的状态。\n* 多个引擎可以指定同一个目录存储快照，用引擎的名称来区分快照文件。\n* 一个引擎的快照可能会使用三个文件名：\n* 临时存储快照信息：文件名为 \\<engineName>.tmp；\n* 快照生成并刷到磁盘：文件保存为 \\<engineName>.snapshot；\n* 存在同名快照：旧快照自动重命名为 \\<engineName>.old。\n\n**snapshotIntervalInMsgCount** 可选参数，为整数类型，表示每隔多少条数据保存一次流数据引擎快照。\n\n#### 返回值\n\n返回一个表对象。\n\n#### 例子\n\n例1.\n\n```\nlogin(`admin, `123456)\nshare streamTable(1000:0, `timestamps`sym`price, [TIMESTAMP, SYMBOL, DOUBLE]) as trades\nshare streamTable(1000:0, `timestamps`sym`val`id, [TIMESTAMP, SYMBOL, DOUBLE, INT]) as prices\nshare table(100:0, `sym`factor1`factor2`factor3, [SYMBOL, DOUBLE, DOUBLE, DOUBLE]) as output\n\nLjEngine = createLookupJoinEngine(name=\"test1\", leftTable=trades, rightTable=prices, outputTable=output, metrics=<[price,val,price*val]>, matchingColumn=`sym)\nsubscribeTable(tableName=\"trades\", actionName=\"append_leftTable\", offset=0, handler=appendForJoin{LjEngine, true}, msgAsTable=true)\nsubscribeTable(tableName=\"prices\", actionName=\"append_rightTable\", offset=0, handler=appendForJoin{LjEngine, false}, msgAsTable=true)\n\nn = 15\ntem1 = 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)\nprices.append!(tem1)\nsleep(2000)\nn  = 10\ntem2 = 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)\ntrades.append!(tem2)\nsleep(100)\nselect * from output\n```\n\n| sym | factor1 | factor2 | factor3 |\n| --- | ------- | ------- | ------- |\n| A   | 10.1    | 13      | 131.3   |\n| B   | 11.1    | 14      | 155.4   |\n| C   | 12.1    | 15      | 181.5   |\n| A   | 13.1    | 13      | 170.3   |\n| B   | 14.1    | 14      | 197.4   |\n| C   | 15.1    | 15      | 226.5   |\n| A   | 16.1    | 13      | 209.3   |\n| B   | 17.1    | 14      | 239.4   |\n| C   | 8.1     | 15      | 271.5   |\n| A   | 19.1    | 13      | 248.3   |\n\n例2.\n\n```\nshare streamTable(1000:0, `timestamps`sym`price, [TIMESTAMP, SYMBOL, DOUBLE]) as trades\nshare streamTable(1000:0, `timestamps`sym`val`id, [TIMESTAMP, SYMBOL, DOUBLE, INT]) as prices\nshare table(100:0, `sym`factor1`factor2`factor3, [SYMBOL, DOUBLE, DOUBLE, DOUBLE]) as output\nLjEngine = createLookupJoinEngine(name=\"test1\", leftTable=trades, rightTable=prices, outputTable=output, metrics=<[price,val,price*val]>, matchingColumn=`sym, rightTimeColumn=`timestamps)\nsubscribeTable(tableName=\"trades\", actionName=\"append_leftTable\", offset=0, handler=appendForJoin{LjEngine, true}, msgAsTable=true)\nsubscribeTable(tableName=\"prices\", actionName=\"append_rightTable\", offset=0, handler=appendForJoin{LjEngine, false}, msgAsTable=true)\n\nn = 15\ntem1 = 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)\nprices.append!(tem1)\nsleep(2000)\nn  = 10\ntem2 = 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)\ntrades.append!(tem2)\nsleep(100)\nselect * from output\n```\n\n| sym | factor1 | factor2 | factor3 |\n| --- | ------- | ------- | ------- |\n| A   | 10.1    | 10      | 101     |\n| B   | 11.1    | 11      | 122.1   |\n| C   | 12.1    | 12      | 145.2   |\n| A   | 13.1    | 10      | 131     |\n| B   | 14.1    | 11      | 155.1   |\n| C   | 15.1    | 12      | 181.2   |\n| A   | 16.1    | 10      | 161     |\n| B   | 17.1    | 11      | 188.1   |\n| C   | 18.1    | 12      | 217.2   |\n| A   | 19.1    | 10      | 191     |\n\n例3. 右表是内存表，需设置 *checkTimes*\n\n```\nshare streamTable(1000:0, `timestamps`sym`price, [TIMESTAMP, SYMBOL, DOUBLE]) as trades\nshare table(100:0, `sym`factor1`factor2`factor3, [SYMBOL, DOUBLE, DOUBLE, DOUBLE]) as output\nshare table(1000:0, `timestamps`sym`val`id, [TIMESTAMP, SYMBOL, DOUBLE, INT]) as prices\nLjEngine = createLookupJoinEngine(name=\"test1\", leftTable=trades, rightTable=prices, outputTable=output, metrics=<[price,val,price*val]>, matchingColumn=`sym, rightTimeColumn=`timestamps, checkTimes=1s)\nsubscribeTable(tableName=\"trades\", actionName=\"append_leftTable\", offset=0, handler=appendForJoin{LjEngine, true}, msgAsTable=true)\n\nn = 15\ntem1 = 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)\nprices.append!(tem1)\nsleep(2000)\nn  = 10\ntem2 = 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)\ntrades.append!(tem2)\nsleep(100)\nselect * from output\n```\n\n| sym | factor1 | factor2 | factor3 |\n| --- | ------- | ------- | ------- |\n| A   | 10.1    | 10      | 101     |\n| B   | 11.1    | 11      | 122.1   |\n| C   | 12.1    | 12      | 145.2   |\n| A   | 13.1    | 10      | 131     |\n| B   | 14.1    | 11      | 155.1   |\n| C   | 15.1    | 12      | 181.2   |\n| A   | 16.1    | 10      | 161     |\n| B   | 17.1    | 11      | 188.1   |\n| C   | 18.1    | 12      | 217.2   |\n| A   | 19.1    | 10      | 191     |\n\n例4. 左表为一个实时的交易表与右表（相对稳定的维度表）做连接。\n\n```\nshare streamTable(1000:0, `time`volume`id, [TIMESTAMP, INT,INT]) as trades\ndbPath=\"dfs://testlj\"\nif(existsDatabase(dbPath)){\n   dropDatabase(dbPath)\n}\nrt=table(1000:0, `time`price`id, [TIMESTAMP, DOUBLE, INT])\ndb=database(dbPath, VALUE, `A`B`C)\nprices=db.createTable(rt,`rightTable)\nshare table(10000:0, `id`volume`price`prod, [INT,INT,DOUBLE,DOUBLE]) as outputTable\n\ntradesLookupJoin = createLookupJoinEngine(name=\"streamLookup1\", leftTable=trades, rightTable=prices, outputTable=outputTable, metrics=<[volume,price,volume*price]>, matchingColumn=`id, rightTimeColumn=`time,checkTimes=1s)\nsubscribeTable(tableName=\"trades\", actionName=\"append_trades\", offset=0, handler=appendForJoin{tradesLookupJoin, true}, msgAsTable=true)\n\ndef writeData(t,n){\n    timev = 2021.10.08T01:01:01.001 + timestamp(1..n)\n    volumev = take(1..n, n)\n    id = take(1 2 3, n)\n    insert into t values(timev, volumev, id)\n}\nwriteData(rt, 10)\nprices.append!(rt)\nsleep(2000)\nwriteData(trades, 6)\nsleep(2)\n\nselect * from outputTable\n```\n\n| id | volume | price | prod |\n| -- | ------ | ----- | ---- |\n| 1  | 1      | 10    | 10   |\n| 2  | 2      | 8     | 16   |\n| 3  | 3      | 9     | 27   |\n| 1  | 4      | 10    | 40   |\n| 2  | 5      | 8     | 40   |\n| 3  | 6      | 9     | 54   |\n\n例5. 通过 *rightTable* 可以对分布式分区表中的字段进行关联，此时 *rightTable* 是一个 SQL 查询元代码：\n\n```\nshare streamTable(1000:0, `time`volume`id, [TIMESTAMP, INT,INT]) as trades\ndbPath=\"dfs://lookupjoinDB\"\nif(existsDatabase(dbPath)){\n   dropDatabase(dbPath)\n}\nrt=table(1000:0, `time`price`id, [TIMESTAMP, DOUBLE, INT])\ndb=database(dbPath, HASH, [INT,5])\nprices=db.createPartitionedTable(rt,`rightTable, `id)\nshare table(10000:0, `id`volume`price`prod, [INT,INT,DOUBLE,DOUBLE]) as outputTable\n\ntradesLookupJoin = createLookupJoinEngine(name=\"streamLookup1\", leftTable=trades, rightTable=<select * from loadTable(dbPath, `rightTable)>, outputTable=outputTable, metrics=<[volume,price,volume*price]>, matchingColumn=`id, rightTimeColumn=`time,checkTimes=1s)\nsubscribeTable(tableName=\"trades\", actionName=\"append_trades\", offset=0, handler=appendForJoin{tradesLookupJoin, true}, msgAsTable=true)\n\ndef writeData(t,n){\n    timev = 2021.10.08T01:01:01.001 + timestamp(1..n)\n    volumev = take(1..n, n)\n    id = take(1 2 3, n)\n    insert into t values(timev, volumev, id)\n}\nwriteData(rt, 10)\nprices.append!(rt)\nsleep(2000)\nwriteData(trades, 6)\nsleep(2)\n\nselect * from outputTable\n```\n\n| id | volume | price | prod |\n| -- | ------ | ----- | ---- |\n| 1  | 1      | 10    | 10   |\n| 2  | 2      | 8     | 16   |\n| 3  | 3      | 9     | 27   |\n| 1  | 4      | 10    | 40   |\n| 2  | 5      | 8     | 40   |\n| 3  | 6      | 9     | 54   |\n\n例6. 设置 *isInnerJoin* 为 true，当在右表中没有匹配的记录时不输出结果。\n\n```\nlogin(`admin, `123456)\nshare streamTable(1000:0, `timestamps`sym`price, [TIMESTAMP, SYMBOL, DOUBLE]) as trades\nshare streamTable(1000:0, `timestamps`sym`val`id, [TIMESTAMP, SYMBOL, DOUBLE, INT]) as prices\nshare table(100:0, `sym`factor1`factor2`factor3, [SYMBOL, DOUBLE, DOUBLE, DOUBLE]) as output\n\nLjEngine = createLookupJoinEngine(name=\"test1\", leftTable=trades, rightTable=prices, outputTable=output, metrics=<[price,val,price*val]>, matchingColumn=`sym, isInnerJoin=true)\n\nn = 15\ntem1 = 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)\nappendForJoin(LjEngine, false,tem1)\nsleep(2000)\n\n// 左表中存在 2 条右表中无匹配的记录\nn  = 10\ntem2 = table( 2019.10.08T01:01:01.001 + 1..n as timestamps,take(`A`B`C`d, n) as sym,take(0.1+10..20,n) as price)\nappendForJoin(LjEngine, true,tem2)\nsleep(100)\nselect count(*) from output // 8\n```\n\n| sym | factor1 | factor2 | factor3 |\n| --- | ------- | ------- | ------- |\n| A   | 10.1    | 13      | 131.3   |\n| B   | 11.1    | 14      | 155.4   |\n| C   | 12.1    | 15      | 181.5   |\n| A   | 14.1    | 13      | 183.3   |\n| B   | 15.1    | 14      | 211.4   |\n| C   | 16.1    | 15      | 241.5   |\n| A   | 18.1    | 13      | 235.3   |\n| B   | 19.1    | 14      | 267.4   |\n"
    },
    "createMktDataEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/createMktDataEngine.html",
        "signatures": [
            {
                "full": "createMktDataEngine(name, referenceDate, mktDataConfig, [handler], [historicalData], [engineConfig])",
                "name": "createMktDataEngine",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "referenceDate",
                        "name": "referenceDate"
                    },
                    {
                        "full": "mktDataConfig",
                        "name": "mktDataConfig"
                    },
                    {
                        "full": "[handler]",
                        "name": "handler",
                        "optional": true
                    },
                    {
                        "full": "[historicalData]",
                        "name": "historicalData",
                        "optional": true
                    },
                    {
                        "full": "[engineConfig]",
                        "name": "engineConfig",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [createMktDataEngine](https://docs.dolphindb.cn/zh/funcs/c/createMktDataEngine.html)\n\n首发版本：3.00.5\n\n\n\n#### 语法\n\ncreateMktDataEngine(name, referenceDate, mktDataConfig, \\[handler], \\[historicalData], \\[engineConfig])\n\n#### 详情\n\n创建市场数据（曲线/曲面等）实时构建引擎。\n\n该引擎能够根据配置自动构建曲线和曲面等市场数据，支持历史数据回填和实时数据更新。\n\n#### 参数\n\n**name** 字符串标量，表示引擎名称。该参数是引擎在一个数据节点上的唯一标识，可包含字母，数字和下划线，但必须以字母开头。\n\n**referenceDate** DATE 类型标量，表示市场数据的参考日期。\n\n**mktDataConfig** 字典或由字典组成的元组，表示市场数据构建配置。关于配置格式，请参考[下文](https://docs.dolphindb.cn/zh/funcs/c/createMktDataEngine.html#例子)。\n\n**handler** 可选参数，用于处理市场数据构建结果，可为自定义函数、共享内存表或定价引擎。其参数形式或表结构由 `engineConfig.outputTime` 决定：\n\n* `engineConfig.outputTime=false`：自定义函数的参数为 (kind, date, name, data)；共享内存表包含 kind(STRING)、date(DATE)、name(STRING)、data(MKTDATA) 四列。\n\n* `engineConfig.outputTime=true`：自定义函数的参数为 (eventTime, kind, date, name, data)；共享内存表包含 eventTime(NANOTIMESTAMP)、kind(STRING)、date(DATE)、name(STRING)、data(MKTDATA) 五列。\n\n**historicalData** 可选参数，历史市场数据，当构建过程中无法从引擎缓存或实时流中获取所需市场数据时，将从该历史数据中获取。可以是：\n\n* 字典或向量：数据格式参考 [instrumentPricer](https://docs.dolphindb.cn/zh/funcs/i/instrumentPricer.html) 函数中的 *marketData* 参数。\n\n* 自定义函数：参数是 (kind，date，name)。\n\n**engineConfig** 可选参数，一个字典，用于设置引擎运行配置。字典包含如下键值对：\n\n* numThreads：可选，整型标量，表示工作线程数，默认 8。\n\n* maxQueueDepth：可选，整型标量，表示最大队列深度，默认 10,000,000。\n\n* useSystemTime：可选，布尔标量，表示是否使用系统时间作为事件时间。默认为 true，使用系统时间作为事件时间。\n\n* timeColumn：可选，字符串标量，指定时间列（NANOTIMESTAMP）作为事件时间。指定该列后，输入数据中需要包含该列。\n\n* outputTime：可选，布尔标量，表示是否输出事件时间。默认为 false。\n\n#### 返回值\n\n返回一个市场数据引擎句柄。\n\n#### mktDataConfig 配置及数据写入示例\n\n##### 外汇即期汇率\n\n生成外汇即期汇率曲线需要配置的 *mktDataConfig* 字段包括：\n\n* **name**：必填，字符串标量，汇率表示的货币对。可选值为\"EURUSD\", \"USDCNY\", \"EURCNY\", \"GBPCNY\", \"JPYCNY\", \"HKDCNY\"。货币对的表示也可由 `.` 或 `/` 分隔，例如 \"EURUSD\" 也可写为 \"EUR.USD\" 或 \"EUR/USD\"。\n\n* **type**：必填，字符串标量，必须填 \"FxSpotRate\"。\n\n**配置示例：**\n\n```\nconfig = {\n    \"name\": \"USDCNY\",\n    \"type\": \"FxSpotRate\"\n}\n```\n\n**说明：**\n\n在相关曲线或曲面构建过程中自动包含外汇即期汇率曲线，例如跨币种利率互换收益率曲线或外汇波动率曲面，因此无需要单独配置。仅当需要单独输出外汇即期汇率曲线时，才需要显式配置该类市场数据。\n\n**插入数据格式：**\n\n| 列名    | 类型     | 说明                                      |\n| ----- | ------ | --------------------------------------- |\n| type  | STRING | 固定为 \"FxSpotRate\"                        |\n| name  | STRING | 货币对，例如 “USDCNY”（货币对的表示可由 `.` 或 `/` 分隔）。 |\n| price | DOUBLE | 当前报价                                    |\n\n注：插入数据时，列名和类型必须符合以上表格定义，列顺序不作要求。\n\n**完整示例：**\n\n```\nreferenceDate = 2025.01.01\n\nconfig1 = {\n    \"name\": \"USDCNY\",\n    \"type\": \"FxSpotRate\"\n}\nconfig2 = {\n    \"name\": \"EURUSD\",\n    \"type\": \"FxSpotRate\"\n}\nconfig3 = {\n    \"name\": \"EURCNY\",\n    \"type\": \"FxSpotRate\"\n}\n\nengine = createMktDataEngine(\"MKTDATA_ENGINE\", referenceDate, [config1, config2, config3])\n\ntypeCol = [\"FxSpot\", \"FxSpot\", \"FxSpot\"]\nnameCol = [\"USDCNY\", \"USDCNY\", \"EURUSD\"]\npriceCol = [7.12, 7.13, 1.10]\n\ndata = table(typeCol as type, nameCol as name, priceCol as price)\n\nengine.append!(data)\nsleep(100)\n```\n\n* 本例中创建了三个构建目标，分别用于表示美元兑人民币（USDCNY）、欧元兑美元（EURUSD）和欧元兑人民币（EURCNY）这三种汇率报价。\n\n* 写入的数据中仅覆盖两个构建目标，共包含三条数据：其中 USDCNY 两条，EURUSD 一条。\n\n* 数据写入采用异步模式，因此需要预留一定的等待时间，以确保所有数据均被完整处理。\n\n可以使用 `getMktData` 接口获取已构建好的市场数据。\n\n```\nre = getMktData(engine, \"Price\", referenceDate, \"USDCNY\")\nprint(re)\n\nre = getMktData(engine, \"Price\", referenceDate, \"EURUSD\")\nprint(re)\n\nre = getMktData(engine, \"Price\", referenceDate, \"EURCNY\")\nprint(re)\n```\n\n结果将显示 USDCNY 和 EURUSD 的最新市场数据；由于未写入 EURCNY 数据，调用 `getMktData` 将报错。\n\n##### 债券收益率曲线\n\n生成债券收益率曲线需要配置的 *mktDataConfig* 字段包括：\n\n* **name**：必填，曲线名称\n\n* **type**：必填，必须是 \"BondYieldCurve\"\n\n* **bonds**：必填，构建使用的基准债券\n\n* **currency**：必填，货币单位\n\n* **dayCountConvention**：必填，日期计数惯例\n\n* **compounding**：选填，复利类型\n\n* **frequency**：选填，计息频率\n\n* **interpMethod**：选填，内插方法\n\n* **extrapMethod**：选填，外插方法\n\n* **method**：选填，曲线构建方法\n\n上述字段要求与 [bondYieldCurveBuilder](https://docs.dolphindb.cn/zh/funcs/b/bondYieldCurveBuilder.html) 的参数保持一致。\n\n**配置示例：**\n\n```\nbonds = array(ANY, 5)\nfor (i in 0..4) {\n    bond_template = {\n        \"productType\": \"Cash\",\n        \"assetType\": \"Bond\",\n        \"bondType\": \"FixedRateBond\",\n        \"instrumentId\": \"88\" + lpad(string(i), 4, \"0\") + \".IB\",\n        \"start\": 2024.06.01,\n        \"maturity\": 2024.06.01 + (i + 1) * 365,\n        \"issuePrice\": 100,\n        \"coupon\": 0.02,\n        \"dayCountConvention\": \"Actual365\",\n        \"frequency\": \"Annual\"\n    };\n    bonds[i] = parseInstrument(bond_template);\n}\n\nconfig = {\n    \"name\": \"CNY_TREASURY_BOND\",\n    \"type\": \"BondYieldCurve\",\n    \"bonds\": bonds,\n    \"currency\": \"CNY\",\n    \"dayCountConvention\": \"Actual365\"\n}\n```\n\n**说明：**\n\n构建名称为 “CNY\\_TREASURY\\_BOND” 的债券收益率曲线。参考债券为五支随机生成的债券（Instrument 数据）。其他参数的使用方式可参考 `bondYieldCurveBuilder` 函数。构建过程中，引擎将基于参考债券的信息，和引擎参数中的 *referenceDate*，计算出每支债券的剩余到期时间，并按到期顺序重新排列。\n\n**插入数据格式：**\n\n| 列名    | 类型     | 说明         |\n| ----- | ------ | ---------- |\n| type  | STRING | 固定为 \"Bond\" |\n| name  | STRING | 债券名称       |\n| price | DOUBLE | 报价         |\n\n**插入数据示例：**\n\n```\ntypeCol = [\"Bond\", \"Bond\", \"Bond\", \"Bond\", \"Bond\"]\nnameCol = [\"880000.IB\", \"880001.IB\", \"880002.IB\", \"880003.IB\", \"880004.IB\"]\npriceCol = [0.015, 0.016, 0.017, 0.018, 0.019]  // YTM\n\ndata = table(typeCol as type, nameCol as name, priceCol as price)\n```\n\n**完整示例：**\n\n```\ntry{dropStreamEngine(\"MKTDATA_ENGINE\")}catch(ex){}\nreferenceDate = 2025.01.01\nbonds = array(ANY, 5)\nfor (i in 0..4) {\n    bond_template = {\n        \"productType\": \"Cash\",\n        \"assetType\": \"Bond\",\n        \"bondType\": \"FixedRateBond\",\n        \"instrumentId\": \"88\" + lpad(string(i), 4, \"0\") + \".IB\",\n        \"start\": 2024.06.01,\n        \"maturity\": 2024.06.01 + (i + 1) * 365,\n        \"issuePrice\": 100,\n        \"coupon\": 0.02,\n        \"dayCountConvention\": \"Actual365\",\n        \"frequency\": \"Annual\"\n    };\n    bonds[i] = parseInstrument(bond_template);\n}\n\nconfig = {\n    \"name\": \"CNY_TREASURY_BOND\",\n    \"type\": \"BondYieldCurve\",\n    \"bonds\": bonds,\n    \"currency\": \"CNY\",\n    \"dayCountConvention\": \"Actual365\"\n}\n\nengine = createMktDataEngine(\"MKTDATA_ENGINE\", referenceDate, [config])\n\ntypeCol = [\"Bond\", \"Bond\", \"Bond\", \"Bond\", \"Bond\"]\nnameCol = [\"880000.IB\", \"880001.IB\", \"880002.IB\", \"880003.IB\", \"880004.IB\"]\npriceCol = [0.015, 0.016, 0.017, 0.018, 0.019]  // YTM\n\ndata = table(typeCol as type, nameCol as name, priceCol as price)\nengine.append!(data)\nsleep(100)\n\nre = getMktData(engine, \"Curve\", referenceDate, \"CNY_TREASURY_BOND\")\nprint(re)\n```\n\n##### 单货币利率互换曲线\n\n生成单货币利率互换曲线需要配置的 *mktDataConfig* 字段包括：\n\n* **name**：必填，曲线名称\n\n* **type**：必填，必须是 \"IrSingleCurrencyCurve\"\n\n* **insts**：必填，一个 Any Vector，每个元素是一个包含三个元素的元组：\\[instName, instType, term]。其中，\n\n  * instName, instType 是 STRING 标量\n\n  * term 是 STRING 或者 DURATION 标量\n\n* **currency**：必填，货币单位\n\n* **dayCountConvention**：必填，日期计数惯例\n\n* **discountCurve**：选填，贴现曲线\n\n* **compounding**：选填，复利类型\n\n* **frequency**：选填，计息频率\n\n除 insts 外，其它字段要求与 [irSingleCurrencyCurveBuilder](https://docs.dolphindb.cn/zh/funcs/i/irSingleCurrencyCurveBuilder.html) 参数保持一致。\n\n**配置示例：**\n\n```\nconfig = {\n    \"name\": \"CNY_FR_007\",\n    \"type\": \"IrSingleCurrencyCurve\",\n    \"insts\": [\n        [\"FR_007\", \"Deposit\", 7d],\n        [\"CNY_FR_007\", \"IrVanillaSwap\", 1M],\n        [\"CNY_FR_007\", \"IrVanillaSwap\", 3M],\n        [\"CNY_FR_007\", \"IrVanillaSwap\", 6M],\n        [\"CNY_FR_007\", \"IrVanillaSwap\", 9M],\n        [\"CNY_FR_007\", \"IrVanillaSwap\", 1y],\n        [\"CNY_FR_007\", \"IrVanillaSwap\", 2y],\n        [\"CNY_FR_007\", \"IrVanillaSwap\", 3y],\n        [\"CNY_FR_007\", \"IrVanillaSwap\", 4y],\n        [\"CNY_FR_007\", \"IrVanillaSwap\", 5y],\n        [\"CNY_FR_007\", \"IrVanillaSwap\", 7y],\n        [\"CNY_FR_007\", \"IrVanillaSwap\", 10y]\n    ],\n    \"currency\": \"CNY\",\n    \"dayCountConvention\": \"Actual365\"\n}\n```\n\n**说明：**\n\n本例中，构建目标是名称为 CNY\\_FR\\_007 的 IrSingleCurrencyCurve，报价信息参考 [irSingleCurrencyCurveBuilder](https://docs.dolphindb.cn/zh/funcs/i/irSingleCurrencyCurveBuilder.html) 例2。\n\n**插入数据格式：**\n\n| 列名    | 类型              | 说明                                   |\n| ----- | --------------- | ------------------------------------ |\n| type  | STRING          | 构建目标类型，目前仅支持 Deposit 或 IrVanillaSwap |\n| name  | STRING          | 金融工具名称                               |\n| term  | STRING/DURATION | 合约剩余期限，例如 \"1M\"。                      |\n| price | DOUBLE          | 报价数据                                 |\n\n**插入数据示例：**\n\n```\ntypeCol = [\n    \"Deposit\", \"IrVanillaSwap\", \"IrVanillaSwap\", \"IrVanillaSwap\",\n    \"IrVanillaSwap\", \"IrVanillaSwap\", \"IrVanillaSwap\", \"IrVanillaSwap\",\n    \"IrVanillaSwap\", \"IrVanillaSwap\", \"IrVanillaSwap\", \"IrVanillaSwap\"\n]\n\nnameCol = [\n    \"FR_007\", \"CNY_FR_007\", \"CNY_FR_007\", \"CNY_FR_007\",\n    \"CNY_FR_007\", \"CNY_FR_007\", \"CNY_FR_007\", \"CNY_FR_007\",\n    \"CNY_FR_007\", \"CNY_FR_007\", \"CNY_FR_007\", \"CNY_FR_007\"\n]\n\ntermCol = [\n    7d, 1M, 3M, 6M,\n    9M, 1y, 2y, 3y,\n    4y, 5y, 7y, 10y\n]\n\npriceCol = [\n    2.3500, 2.3396, 2.3125, 2.3613,\n    2.4075, 2.4513, 2.5750, 2.6763,\n    2.7650, 2.8463, 2.9841, 3.1350\n] \\ 100\n\ndata = table(typeCol as type, nameCol as name, termCol as term, priceCol as price)\n```\n\n**完整示例：**\n\n```\ntry{dropStreamEngine(\"MKTDATA_ENGINE\")}catch(ex){}\nreferenceDate = 2021.05.26\n\nconfig = {\n    \"name\": \"CNY_FR_007\",\n    \"type\": \"IrSingleCurrencyCurve\",\n    \"insts\": [\n        [\"FR_007\", \"Deposit\", 7d],\n        [\"CNY_FR_007\", \"IrVanillaSwap\", 1M],\n        [\"CNY_FR_007\", \"IrVanillaSwap\", 3M],\n        [\"CNY_FR_007\", \"IrVanillaSwap\", 6M],\n        [\"CNY_FR_007\", \"IrVanillaSwap\", 9M],\n        [\"CNY_FR_007\", \"IrVanillaSwap\", 1y],\n        [\"CNY_FR_007\", \"IrVanillaSwap\", 2y],\n        [\"CNY_FR_007\", \"IrVanillaSwap\", 3y],\n        [\"CNY_FR_007\", \"IrVanillaSwap\", 4y],\n        [\"CNY_FR_007\", \"IrVanillaSwap\", 5y],\n        [\"CNY_FR_007\", \"IrVanillaSwap\", 7y],\n        [\"CNY_FR_007\", \"IrVanillaSwap\", 10y]\n    ],\n    \"currency\": \"CNY\",\n    \"dayCountConvention\": \"Actual365\"\n}\n\nengine = createMktDataEngine(\"MKTDATA_ENGINE\", referenceDate, [config])\n\ntypeCol = [\n    \"Deposit\", \"IrVanillaSwap\", \"IrVanillaSwap\", \"IrVanillaSwap\",\n    \"IrVanillaSwap\", \"IrVanillaSwap\", \"IrVanillaSwap\", \"IrVanillaSwap\",\n    \"IrVanillaSwap\", \"IrVanillaSwap\", \"IrVanillaSwap\", \"IrVanillaSwap\"\n]\n\nnameCol = [\n    \"FR_007\", \"CNY_FR_007\", \"CNY_FR_007\", \"CNY_FR_007\",\n    \"CNY_FR_007\", \"CNY_FR_007\", \"CNY_FR_007\", \"CNY_FR_007\",\n    \"CNY_FR_007\", \"CNY_FR_007\", \"CNY_FR_007\", \"CNY_FR_007\"\n]\n\ntermCol = [\n    7d, 1M, 3M, 6M,\n    9M, 1y, 2y, 3y,\n    4y, 5y, 7y, 10y\n]\n\npriceCol = [\n    2.3500, 2.3396, 2.3125, 2.3613,\n    2.4075, 2.4513, 2.5750, 2.6763,\n    2.7650, 2.8463, 2.9841, 3.1350\n] \\ 100\n\ndata = table(typeCol as type, nameCol as name, termCol as term, priceCol as price)\n\nengine.append!(data)\nsleep(100)\n\nre = getMktData(engine, \"Curve\", referenceDate, \"CNY_FR_007\")\nprint(re)\n```\n\n##### 跨币种利率互换收益率曲线\n\n生成跨币种利率互换收益率曲线需要配置的 *mktDataConfig* 字段包括：\n\n* **name**：必填，曲线名称\n\n* **type**：必填，必须是 \"IrCrossCurrencyCurve\"\n\n* **insts**：必填，一个 Any Vector，每个元素是一个包含三个元素的元组：\\[instName, instType, term]。其中，\n\n  * instName, instType 是 STRING 标量\n\n  * term 是 STRING 或者 DURATION 标量\n\n* **currency**：必填，货币单位\n\n* **currencyPair**：必填，货币对\n\n* **dayCountConvention**：必填，日期计数惯例\n\n* **discountCurve**：必填，贴现曲线\n\n* **compounding**：选填，复利类型\n\n* **frequency**：选填，计息频率\n\n除 insts 外，其它字段要求与 [irCrossCurrencyCurveBuilder](https://docs.dolphindb.cn/zh/funcs/i/irCrossCurrencyCurveBuilder.html) 参数保持一致。\n\n**配置示例：**\n\n```\nconfig = {\n    \"name\": \"USD_USDCNY_FX\",\n    \"type\": \"IrCrossCurrencyCurve\",\n    \"insts\": [\n        (\"USDCNY\", \"FxSwap\", \"1d\"),\n        (\"USDCNY\", \"FxSwap\", \"1w\"),\n        (\"USDCNY\", \"FxSwap\", \"2w\"),\n        (\"USDCNY\", \"FxSwap\", \"3w\"),\n        (\"USDCNY\", \"FxSwap\", \"1M\"),\n        (\"USDCNY\", \"FxSwap\", \"2M\"),\n        (\"USDCNY\", \"FxSwap\", \"3M\"),\n        (\"USDCNY\", \"FxSwap\", \"6M\"),\n        (\"USDCNY\", \"FxSwap\", \"9M\"),\n        (\"USDCNY\", \"FxSwap\", \"1y\"),\n        (\"USDCNY\", \"FxSwap\", \"18M\"),\n        (\"USDCNY\", \"FxSwap\", \"2y\"),\n        (\"USDCNY\", \"FxSwap\", \"3y\")\n    ],\n    \"currency\": \"USD\",\n    \"currencyPair\": \"USDCNY\",\n    \"dayCountConvention\": \"Actual365\",\n    \"discountCurve\": \"CNY_SHIBOR_3M\"\n}\n```\n\n**说明：**\n\n本例中构建目标为名称是 “USD\\_USDCNY\\_FX” 的跨币种利率互换收益率曲线。使用外汇掉期作为定价所使用的金融工具，指定构建时使用的贴现曲线为 “CNY\\_SHIBOR\\_3M”。因为跨币种利率互换收益率曲线中已经包含货币对信息，因此不需要再额外定义 FxSpot 作为构建目标。具体参数要求请参考：[irCrossCurrencyCurveBuilder](https://docs.dolphindb.cn/zh/funcs/i/irCrossCurrencyCurveBuilder.html)\n\n**插入数据格式：**\n\n| 列名    | 类型                | 说明             |\n| ----- | ----------------- | -------------- |\n| type  | STRING            | 目前仅支持 “FxSwap” |\n| name  | STRING            | FxSwap: 对应的货币对 |\n| term  | STRING / DURATION | 期限             |\n| price | DOUBLE            | 报价数据           |\n\n**插入数据示例：**\n\n```\ntypeCol = [\n    \"FxSwap\", \"FxSwap\", \"FxSwap\", \"FxSwap\",\n    \"FxSwap\", \"FxSwap\", \"FxSwap\", \"FxSwap\",\n    \"FxSwap\", \"FxSwap\", \"FxSwap\", \"FxSwap\",\n    \"FxSwap\"\n]\nnameCol = [\n    \"USDCNY\", \"USDCNY\", \"USDCNY\", \"USDCNY\",\n    \"USDCNY\", \"USDCNY\", \"USDCNY\", \"USDCNY\",\n    \"USDCNY\", \"USDCNY\", \"USDCNY\", \"USDCNY\",\n    \"USDCNY\"\n]\ntermCol = [\n    \"1d\", \"1w\", \"2w\", \"3w\",\n    \"1M\", \"2M\", \"3M\", \"6M\",\n    \"9M\", \"1y\", \"18M\", \"2y\",\n    \"3y\"\n]\npriceCol = [\n    -5.54, -39.00, -75.40, -113.20,\n    -177.00, -317.00, -466.00, -898.50,\n    -1284.99, -1676.00, -2320.00, -2870.00,\n    -3962.50\n] \\ 10000\n\ndata = table(typeCol as type, nameCol as name, termCol as term, priceCol as price)\ninsert into data values(\"FxSpot\", \"USDCNY\", \"0d\", 7.1627)\n```\n\n**完整示例：**\n\n利用市场数据引擎从 USDCNY 外汇掉期报价和人民币 CNY\\_FR\\_007 曲线，自动构建出美元的隐含收益率曲线（USD\\_USDCNY\\_FX）。\n\n```\ntry{dropStreamEngine(\"MKTDATA_ENGINE\")}catch(ex){}\nreferenceDate = 2025.08.18\n\nconfig = {\n    \"name\": \"USD_USDCNY_FX\",\n    \"type\": \"IrCrossCurrencyCurve\",\n    \"insts\": [\n        (\"USDCNY\", \"FxSwap\", \"1d\"),\n        (\"USDCNY\", \"FxSwap\", \"1w\"),\n        (\"USDCNY\", \"FxSwap\", \"2w\"),\n        (\"USDCNY\", \"FxSwap\", \"3w\"),\n        (\"USDCNY\", \"FxSwap\", \"1M\"),\n        (\"USDCNY\", \"FxSwap\", \"2M\"),\n        (\"USDCNY\", \"FxSwap\", \"3M\"),\n        (\"USDCNY\", \"FxSwap\", \"6M\"),\n        (\"USDCNY\", \"FxSwap\", \"9M\"),\n        (\"USDCNY\", \"FxSwap\", \"1y\"),\n        (\"USDCNY\", \"FxSwap\", \"18M\"),\n        (\"USDCNY\", \"FxSwap\", \"2y\"),\n        (\"USDCNY\", \"FxSwap\", \"3y\")\n    ],\n    \"currency\": \"USD\",\n    \"currencyPair\": \"USDCNY\",\n    \"dayCountConvention\": \"Actual365\",\n    \"discountCurve\": \"CNY_SHIBOR_3M\"\n}\n\n\ntypeCol = [\n    \"FxSwap\", \"FxSwap\", \"FxSwap\", \"FxSwap\",\n    \"FxSwap\", \"FxSwap\", \"FxSwap\", \"FxSwap\",\n    \"FxSwap\", \"FxSwap\", \"FxSwap\", \"FxSwap\",\n    \"FxSwap\"\n]\nnameCol = [\n    \"USDCNY\", \"USDCNY\", \"USDCNY\", \"USDCNY\",\n    \"USDCNY\", \"USDCNY\", \"USDCNY\", \"USDCNY\",\n    \"USDCNY\", \"USDCNY\", \"USDCNY\", \"USDCNY\",\n    \"USDCNY\"\n]\ntermCol = [\n    \"1d\", \"1w\", \"2w\", \"3w\",\n    \"1M\", \"2M\", \"3M\", \"6M\",\n    \"9M\", \"1y\", \"18M\", \"2y\",\n    \"3y\"\n]\npriceCol = [\n    -5.54, -39.00, -75.40, -113.20,\n    -177.00, -317.00, -466.00, -898.50,\n    -1284.99, -1676.00, -2320.00, -2870.00,\n    -3962.50\n] \\ 10000\n\ndata = table(typeCol as type, nameCol as name, termCol as term, priceCol as price)\ninsert into data values(\"FxSpot\", \"USDCNY\", \"0d\", 7.1627)\n\n\ncnyShibor3mDict = {\n    \"mktDataType\": \"Curve\",\n    \"curveType\": \"IrYieldCurve\",\n    \"curveName\": \"CNY_SHIBOR_3M\",\n    \"referenceDate\": referenceDate,\n    \"currency\": \"CNY\",\n    \"dayCountConvention\": \"Actual365\",\n    \"compounding\": \"Continuous\",\n    \"interpMethod\": \"Linear\",\n    \"extrapMethod\": \"Flat\",\n    \"dates\": [\n        2025.08.21, 2025.08.27, 2025.09.03, 2025.09.10,\n        2025.09.22, 2025.10.20, 2025.11.20, 2026.02.20,\n        2026.05.20, 2026.08.20, 2027.02.22, 2027.08.20,\n        2028.08.21\n    ],\n    \"values\": [\n        1.5113, 1.5402, 1.5660, 1.5574,\n        1.5556, 1.5655, 1.5703, 1.5934,\n        1.6040, 1.6020, 1.5928, 1.5842,\n        1.6068\n    ] \\ 100\n}\n\ncnyShibor3m = parseMktData(cnyShibor3mDict)\n\nengine = createMktDataEngine(\"MKTDATA_ENGINE\", referenceDate, [config], historicalData=[cnyShibor3m])\n\nengine.append!(data)\nsleep(100)\n\nre = getMktData(engine, \"Curve\", referenceDate, \"USD_USDCNY_FX\")\nprint(re)\n```\n\n1. 因为构建目标中自动包含了外汇即期汇率，因此写入数据中也需要包含相应的报价数据，否则无法构建成功。\n\n2. 本例中将 CNY\\_SHIBOR\\_3M 作为历史数据传入引擎，而非实时构建，因此需要提前准备一条对应曲线。\n\n##### 外汇波动率曲面\n\n生成外汇波动率曲面需要配置的 *mktDataConfig* 字段包括：\n\n* **name**：必填，曲面名称\n\n* **type**：必填，必须是 \"FxVolatilitySurface\"\n\n* **names**：必填，为 \\[\"ATM\", \"D25\\_RR\", \"D25\\_BF\", \"D10\\_RR\", \"D10\\_BF\"] 的一组排列，表示报价名称\n\n* **terms**：必填，市场报价的对应期限\n\n* **currencyPair**：必填，货币对\n\n* **domesticCurve**：必填，本币折现曲线\n\n* **foreignCurve**：必填，外币折现曲线\n\n* **model**：选填。构建波动率曲面所用模型\n\n上述字段要求与 [fxVolatilitySurfaceBuilder](https://docs.dolphindb.cn/zh/funcs/f/fxVolatilitySurfaceBuilder.html) 参数保持一致。\n\n**配置示例：**\n\n```\nconfig = {\n    \"name\": \"USDCNY\",\n    \"type\": \"FxVolatilitySurface\",\n    \"names\": [\"ATM\", \"D25_RR\", \"D25_BF\", \"D10_RR\", \"D10_BF\"],\n    \"terms\": [\"1d\", \"1w\", \"2w\", \"3w\", \"1M\", \"2M\", \"3M\", \"6M\", \"9M\", \"1y\", \"18M\", \"2y\", \"3y\"],\n    \"currencyPair\": \"USDCNY\",\n    \"domesticCurve\": \"CNY_FR_007\",\n    \"foreignCurve\": \"USD_USDCNY_FX\",\n    \"model\": \"SVI\"\n}\n```\n\n**说明：**\n\n本例中构建目标是名为 USDCNY 的外汇波动率曲面。使用 CNY\\_FR\\_007 作为本币的折现曲线，USD\\_USDCNY\\_FX 作为外币的折现曲线，并且使用模型 SVI 进行曲面构建。\n\n**插入数据格式：**\n\n| 列名      | 类型                | 说明                                                    |\n| ------- | ----------------- | ----------------------------------------------------- |\n| type    | STRING            | 固定为 FxOption                                          |\n| name    | STRING            | 货币对                                                   |\n| subType | STRING            | “ATM” / “D25\\_RR” / “D25\\_BF” / “D10\\_RR” / “D10\\_BF” |\n| term    | STRING / DURATION | 期限                                                    |\n| price   | DOUBLE            | 报价数据                                                  |\n\n**插入数据示例：**\n\n```\ntypeCol = take(\"FxOption\", 65)\nnameCol = take(\"USDCNY\", 65)\nsubTypeCol = take([\"ATM\"], 13)\n    .append!(take([\"D25_RR\"], 13))\n    .append!(take([\"D25_BF\"], 13))\n    .append!(take([\"D10_RR\"], 13))\n    .append!(take([\"D10_BF\"], 13))\ntermCol = take([\n    \"1d\", \"1w\", \"2w\", \"3w\", \"1M\", \"2M\", \"3M\", \"6M\", \"9M\", \"1y\", \"18M\", \"2y\", \"3y\"\n], 65)\npriceCol = [\n    0.030000, -0.007500, 0.003500, -0.010000, 0.005500, \n    0.020833, -0.004500, 0.002000, -0.006000, 0.003800, \n    0.022000, -0.003500, 0.002000, -0.004500, 0.004100, \n    0.022350, -0.003500, 0.002000, -0.004500, 0.004150, \n    0.024178, -0.003000, 0.002200, -0.004750, 0.005500, \n    0.027484, -0.002650, 0.002220, -0.004000, 0.005650, \n    0.030479, -0.002500, 0.002400, -0.003500, 0.005750, \n    0.035752, -0.000500, 0.002750,  0.000000, 0.006950, \n    0.038108,  0.001000, 0.002800,  0.003000, 0.007550, \n    0.039492,  0.002250, 0.002950,  0.005000, 0.007550, \n    0.040500,  0.004000, 0.003100,  0.007000, 0.007850, \n    0.041750,  0.005250, 0.003350,  0.008000, 0.008400, \n    0.044750,  0.006250, 0.003400,  0.009000, 0.008550\n].reshape(5:13).transpose().flatten()\n\ndata = table(typeCol as type, nameCol as name, subTypeCol as subType, termCol as term, priceCol as price)\ninsert into data values(\"FxSpot\", \"USDCNY\", \"\", \"0d\", 7.1627)\n```\n\n**完整示例：**\n\n本例说明如何使用 DolphinDB 的市场数据引擎（`createMktDataEngine`）来构建和管理 USDCNY 外汇波动率曲面。包含如下步骤：\n\n1. 构造波动率报价数据、即期汇率、收益率曲线数据。\n\n2. 使用 `parseMktData` 将字典格式的曲线数据解析为 MKTDATA 类型对象。\n\n3. 创建名为 \"MKTDATA\\_ENGINE\" 的市场数据引擎，配置 USDCNY 波动率曲面的构建参数（使用 SVI 模型）。然后将 CNY\\_FR\\_007 和 USD\\_USDCNY\\_FX 作为历史数据传入引擎。\n\n4. 通过 `getMktData` 从引擎中获取构建完成的 USDCNY 外汇波动率曲面，该曲面可用于后续的外汇期权定价。\n\n```\ntry{dropStreamEngine(\"MKTDATA_ENGINE\")}catch(ex){}\nreferenceDate = 2025.08.18\n\nconfig = {\n    \"name\": \"USDCNY\",\n    \"type\": \"FxVolatilitySurface\",\n    \"names\": [\"ATM\", \"D25_RR\", \"D25_BF\", \"D10_RR\", \"D10_BF\"],\n    \"terms\": [\"1d\", \"1w\", \"2w\", \"3w\", \"1M\", \"2M\", \"3M\", \"6M\", \"9M\", \"1y\", \"18M\", \"2y\", \"3y\"],\n    \"currencyPair\": \"USDCNY\",\n    \"domesticCurve\": \"CNY_FR_007\",\n    \"foreignCurve\": \"USD_USDCNY_FX\",\n    \"model\": \"SVI\"\n}\n\ntypeCol = take(\"FxOption\", 65)\nnameCol = take(\"USDCNY\", 65)\nsubTypeCol = take([\"ATM\"], 13)\n    .append!(take([\"D25_RR\"], 13))\n    .append!(take([\"D25_BF\"], 13))\n    .append!(take([\"D10_RR\"], 13))\n    .append!(take([\"D10_BF\"], 13))\ntermCol = take([\n    \"1d\", \"1w\", \"2w\", \"3w\", \"1M\", \"2M\", \"3M\", \"6M\", \"9M\", \"1y\", \"18M\", \"2y\", \"3y\"\n], 65)\npriceCol = [\n    0.030000, -0.007500, 0.003500, -0.010000, 0.005500, \n    0.020833, -0.004500, 0.002000, -0.006000, 0.003800, \n    0.022000, -0.003500, 0.002000, -0.004500, 0.004100, \n    0.022350, -0.003500, 0.002000, -0.004500, 0.004150, \n    0.024178, -0.003000, 0.002200, -0.004750, 0.005500, \n    0.027484, -0.002650, 0.002220, -0.004000, 0.005650, \n    0.030479, -0.002500, 0.002400, -0.003500, 0.005750, \n    0.035752, -0.000500, 0.002750,  0.000000, 0.006950, \n    0.038108,  0.001000, 0.002800,  0.003000, 0.007550, \n    0.039492,  0.002250, 0.002950,  0.005000, 0.007550, \n    0.040500,  0.004000, 0.003100,  0.007000, 0.007850, \n    0.041750,  0.005250, 0.003350,  0.008000, 0.008400, \n    0.044750,  0.006250, 0.003400,  0.009000, 0.008550\n].reshape(5:13).transpose().flatten()\n\ndata = table(typeCol as type, nameCol as name, subTypeCol as subType, termCol as term, priceCol as price)\ninsert into data values(\"FxSpot\", \"USDCNY\", \"\", \"0d\", 7.1627)\n\ndomesticCurveDict = {\n    \"mktDataType\": \"Curve\",\n    \"curveName\": \"CNY_FR_007\",\n    \"curveType\": \"IrYieldCurve\",\n    \"referenceDate\": referenceDate,\n    \"currency\": \"CNY\",\n    \"dayCountConvention\": \"Actual365\",\n    \"compounding\": \"Continuous\",  \n    \"interpMethod\": \"Linear\",\n    \"extrapMethod\": \"Flat\",\n    \"frequency\": \"Annual\",\n    \"dates\": [\n        2025.08.21, 2025.08.27, 2025.09.03, 2025.09.10, 2025.09.22,\n        2025.10.20, 2025.11.20, 2026.02.24, 2026.05.20, 2026.08.20,\n        2027.02.22, 2027.08.20, 2028.08.21\n    ],\n    \"values\": [\n        1.5113, 1.5402, 1.5660, 1.5574, 1.5556,\n        1.5655, 1.5703, 1.5934, 1.6040, 1.6020, \n        1.5928, 1.5842, 1.6068\n    ] \\ 100\n}\ndomesticCurve = parseMktData(domesticCurveDict)\n\nforeignCurveDict = {\n    \"mktDataType\": \"Curve\",\n    \"curveName\": \"USD_USDCNY_FX\",\n    \"curveType\": \"IrYieldCurve\",\n    \"referenceDate\": referenceDate,\n    \"currency\": \"USD\",\n    \"dayCountConvention\": \"Actual365\",\n    \"compounding\": \"Continuous\",  \n    \"interpMethod\": \"Linear\",\n    \"extrapMethod\": \"Flat\",\n    \"frequency\": \"Annual\",\n    \"dates\": [\n        2025.08.21, 2025.08.27, 2025.09.03, 2025.09.10, 2025.09.22,\n        2025.10.20, 2025.11.20, 2026.02.24, 2026.05.20, 2026.08.20,\n        2027.02.22, 2027.08.20, 2028.08.21\n    ],\n    \"values\": [\n        4.3345, 4.3801, 4.3119, 4.3065, 4.2922, \n        4.2196, 4.1599, 4.0443, 4.0244, 3.9698, \n        3.7740, 3.6289, 3.5003\n    ] \\ 100\n}\nforeignCurve = parseMktData(foreignCurveDict)\n\nengine = createMktDataEngine(\"MKTDATA_ENGINE\", referenceDate, [config], historicalData=[domesticCurve, foreignCurve])\n\nengine.append!(data)\nsleep(100)\n\nre = getMktData(engine, \"Surface\", referenceDate, \"USDCNY\")\nprint(re)\n```\n\n1. 因为构建目标中自动包含了外汇即期汇率曲线，因此写入数据中也需要包含相应的报价数据，否则无法构建成功。\n\n2. 本例中将 CNY\\_FR\\_007 和 USD\\_USDCNY\\_FX 作为历史数据传入引擎，而非实时构建，因此需要提前准备对应曲线。\n\n#### *handler* 参数示例\n\n**指定为自定义函数**\n\n以构建外汇即期汇率曲线为例，定义一个自定义函数，打印构建出来的市场数据。\n\n```\ndef myHandler(kind, date, name, data) {\n    print(data)\n}\n\ntry{dropStreamEngine(\"MKTDATA_ENGINE\")}catch(ex){}\nreferenceDate = 2025.01.01\n\nconfig1 = {\n    \"name\": \"USDCNY\",\n    \"type\": \"FxSpotRate\"\n}\nconfig2 = {\n    \"name\": \"EURUSD\",\n    \"type\": \"FxSpotRate\"\n}\nconfig3 = {\n    \"name\": \"EURCNY\",\n    \"type\": \"FxSpotRate\"\n}\n\nengine = createMktDataEngine(\"MKTDATA_ENGINE\", referenceDate, [config1, config2, config3], handler=myHandler)\n\ntypeCol = [\"FxSpot\", \"FxSpot\", \"FxSpot\"]\nnameCol = [\"USDCNY\", \"EURCNY\", \"EURUSD\"]\npriceCol = [7.12, 7.88, 1.10]\n\ndata = table(typeCol as type, nameCol as name, priceCol as price)\n\nengine.append!(data)\nsleep(100)\n```\n\n**指定为共享内存表**\n\n定义一个结构如下的共享表（需保证列顺序一致）。\n\n| 列名   | 类型      |\n| ---- | ------- |\n| kind | STRING  |\n| date | DATE    |\n| name | STRING  |\n| data | MKTDATA |\n\n**完整示例**\n\n```\nshare streamTable(1:0, `kind`date`name`data, [STRING, DATE, STRING, MKTDATA]) as st\n\ntry{dropStreamEngine(\"MKTDATA_ENGINE\")}catch(ex){}\nreferenceDate = 2025.01.01\n\nconfig1 = {\n    \"name\": \"USDCNY\",\n    \"type\": \"FxSpotRate\"\n}\nconfig2 = {\n    \"name\": \"EURUSD\",\n    \"type\": \"FxSpotRate\"\n}\nconfig3 = {\n    \"name\": \"EURCNY\",\n    \"type\": \"FxSpotRate\"\n}\n\nengine = createMktDataEngine(\"MKTDATA_ENGINE\", referenceDate, [config1, config2, config3], handler=st)\n\ntypeCol = [\"FxSpot\", \"FxSpot\", \"FxSpot\"]\nnameCol = [\"USDCNY\", \"EURCNY\", \"EURUSD\"]\npriceCol = [7.12, 7.88, 1.10]\n\ndata = table(typeCol as type, nameCol as name, priceCol as price)\n\nengine.append!(data)\nsleep(100)\n\nprint(select * from st)\n```\n\n**指定为定价引擎**\n\n创建一个定价引擎，并传入 *handler* 参数。\n\n**完整示例**\n\n```\ntry{dropStreamEngine(\"MKTDATA_ENGINE\")}catch(ex){}\ntry{dropStreamEngine(\"PRICING_ENGINE\")}catch(ex){}\nreferenceDate = 2025.01.01\n\nbonds = array(ANY, 5)\nfor (i in 0..4) {\n    bond_template = {\n        \"productType\": \"Cash\",\n        \"assetType\": \"Bond\",\n        \"bondType\": \"FixedRateBond\",\n        \"instrumentId\": \"88\" + lpad(string(i), 4, \"0\") + \".IB\",\n        \"start\": 2024.06.01,\n        \"maturity\": 2024.06.01 + (i + 1) * 365,\n        \"issuePrice\": 100,\n        \"coupon\": 0.02,\n        \"dayCountConvention\": \"Actual365\",\n        \"frequency\": \"Annual\"\n    };\n    bonds[i] = parseInstrument(bond_template);\n}\n\nconfig = {\n    \"name\": \"CNY_TREASURY_BOND\",\n    \"type\": \"BondYieldCurve\",\n    \"bonds\": bonds,\n    \"currency\": \"CNY\",\n    \"dayCountConvention\": \"Actual365\"\n}\n\nbondDict = {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Bond\",\n    \"bondType\": \"FixedRateBond\",\n    \"instrumentId\": \"880010.IB\",\n    \"start\": 2028.05.01,\n    \"maturity\": 2038.05.01,\n    \"issuePrice\": 100,\n    \"coupon\": 0.02,\n    \"dayCountConvention\": \"Actual365\",\n    \"frequency\": \"Annual\",\n    \"discountCurve\": \"CNY_TREASURY_BOND\"\n}\nbond = parseInstrument(bondDict)\n\nshare streamTable(1:0, `name`date`price, [STRING, DATE, DOUBLE]) as priceSt\n\npricingEngine = createPricingEngine(\"PRICING_ENGINE\", [bond], tableInsert{priceSt})\n\nmktdataEngine = createMktDataEngine(\"MKTDATA_ENGINE\", referenceDate, [config], handler=pricingEngine)\n\ntypeCol = [\"Bond\", \"Bond\", \"Bond\", \"Bond\", \"Bond\"]\nnameCol = [\"880000.IB\", \"880001.IB\", \"880002.IB\", \"880003.IB\", \"880004.IB\"]\npriceCol = [0.015, 0.016, 0.017, 0.018, 0.019]  // YTM\n\ndata = table(typeCol as type, nameCol as name, priceCol as price)\n\nmktdataEngine.append!(data)\nsleep(100)\n\nre = getMktData(mktdataEngine, \"Curve\", referenceDate, \"CNY_TREASURY_BOND\")\nprint(re)\n\nprint(select * from priceSt)\n```\n\n本例中使用 880000.IB \\~ 880004.IB作为基准债券构建曲线 CNY\\_TREASURY\\_BOND，并将该曲线作为定价引擎的输入曲线，对 880010.IB 定价。最后输出定价结果到 priceSt 表中。\n\n**相关函数**：[appendMktData](https://docs.dolphindb.cn/zh/funcs/a/appendMktData.html), [append!](https://docs.dolphindb.cn/zh/funcs/a/append!.html), [getMktData](https://docs.dolphindb.cn/zh/funcs/g/getMktData.html), [createPricingEngine](https://docs.dolphindb.cn/zh/funcs/c/createpricingengine.html)\n"
    },
    "createNarrowReactiveStateEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/createnarrowreactivestateengine.html",
        "signatures": [
            {
                "full": "createNarrowReactiveStateEngine(name, metrics, metricNames, dummyTable, outputTable, keyColumn, [filter], [snapshotDir], [snapshotIntervalInMsgCount], [keepOrder], [keyPurgeFilter], [keyPurgeFreqInSecond=0], [raftGroup], [outputElapsedMicroseconds=false], [keyCapacity=1024], [parallelism=1])",
                "name": "createNarrowReactiveStateEngine",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "metrics",
                        "name": "metrics"
                    },
                    {
                        "full": "metricNames",
                        "name": "metricNames"
                    },
                    {
                        "full": "dummyTable",
                        "name": "dummyTable"
                    },
                    {
                        "full": "outputTable",
                        "name": "outputTable"
                    },
                    {
                        "full": "keyColumn",
                        "name": "keyColumn"
                    },
                    {
                        "full": "[filter]",
                        "name": "filter",
                        "optional": true
                    },
                    {
                        "full": "[snapshotDir]",
                        "name": "snapshotDir",
                        "optional": true
                    },
                    {
                        "full": "[snapshotIntervalInMsgCount]",
                        "name": "snapshotIntervalInMsgCount",
                        "optional": true
                    },
                    {
                        "full": "[keepOrder]",
                        "name": "keepOrder",
                        "optional": true
                    },
                    {
                        "full": "[keyPurgeFilter]",
                        "name": "keyPurgeFilter",
                        "optional": true
                    },
                    {
                        "full": "[keyPurgeFreqInSecond=0]",
                        "name": "keyPurgeFreqInSecond",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[raftGroup]",
                        "name": "raftGroup",
                        "optional": true
                    },
                    {
                        "full": "[outputElapsedMicroseconds=false]",
                        "name": "outputElapsedMicroseconds",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[keyCapacity=1024]",
                        "name": "keyCapacity",
                        "optional": true,
                        "default": "1024"
                    },
                    {
                        "full": "[parallelism=1]",
                        "name": "parallelism",
                        "optional": true,
                        "default": "1"
                    }
                ]
            }
        ],
        "markdown": "### [createNarrowReactiveStateEngine](https://docs.dolphindb.cn/zh/funcs/c/createnarrowreactivestateengine.html)\n\n\n\n#### 语法\n\ncreateNarrowReactiveStateEngine(name, metrics, metricNames, dummyTable, outputTable, keyColumn, \\[filter], \\[snapshotDir], \\[snapshotIntervalInMsgCount], \\[keepOrder], \\[keyPurgeFilter], \\[keyPurgeFreqInSecond=0], \\[raftGroup], \\[outputElapsedMicroseconds=false], \\[keyCapacity=1024], \\[parallelism=1])\n\n#### 详情\n\n创建生成窄表的响应式状态引擎。其计算规则和计算方式与 createReactiveStateEngine 一致，输出形式不同。createReactiveStateEngine 将每次计算的指标输出为一行的不同列，而该引擎则把通过 metricNames 指定指标的计算以窄表的形式输出，即计算结果输出到不同行的相同列。\n\n**Note:** 不支持乱序处理机制，用户需要自行保证输入的数据有序。\n\n#### 参数\n\n该引擎的的大部分参数和 createReactiveStateEngine 的参数相同，可以参考 createReactiveStateEngine 中的参数说明。这里仅对有区别的参数进行说明。\n\n**metrics** 以元代码的格式表示计算指标，支持输入元组，表示需要输出到 outputTable 中的除 keyColumn 外的输入表中的列或计算指标。注意：这里不要求必须指定除 keyColumn 外的列，但必须指定计算指标，且计算指标必须与 *metricNames* 指定的名称一一对应。\n\n**metricNames** 字符串标量或向量，表示输出到 *outputTable*中的指标的名称。\n\n**outputTable** 计算结果的输出表，可以是内存表或分布式表。使用 `createNarrowReactiveStateEngine` 函数之前，需要预先设立一个输出表，引擎会将计算结果注入该表。\n\n输出表的各列的顺序如下：\n\n(1) 分组列。根据 *keyColumn* 的设置，输出表的前几列必须和 *keyColumn* 设置的列及其顺序保持一致。\n\n(2) 耗时列。指定 *outputElapsedMicroseconds* = true 时才有。此时需要增加一个 LONG 类型和一个 INT 类型的列，分别用于存储引擎内部每个 batch 的数据耗时（单位：微秒）和记录数。\n\n(3) *metrics*中指定的除 *metricNames*指定的计算指标外的列。\n\n(4) *metricNames*列，仅1列。\n\n(5) 计算结果列，仅1列。\n\n**Note:**\n\n暂不支持指定参数 *raftGroup。*\n\n若要开启快照机制 (snapshot)，必须指定 *snapshotDir* 与 *snapshotIntervalInMsgCount*。\n\n**snapshotDir** 可选参数，字符串，表示保存引擎快照的文件目录。\n\n* 指定的目录必须存在，否则系统会提示异常。\n\n* 创建流数据引擎时，如果指定了 *snapshotDir*，会检查该目录下是否存在快照。如果存在，会加载该快照，恢复引擎的状态。\n\n* 多个引擎可以指定同一个目录存储快照，用引擎的名称来区分快照文件。\n\n* 一个引擎的快照可能会使用三个文件名：\n\n  * 临时存储快照信息：文件名为 *\\<engineName>.tmp*；\n\n  * 快照生成并刷到磁盘：文件保存为 *\\<engineName>.snapshot*；\n\n  * 存在同名快照：旧快照自动重命名为 *\\<engineName>.old*。\n\n**snapshotIntervalInMsgCount** 可选参数，为整数类型，表示每隔多少条数据保存一次流数据引擎快照。\n\n#### 返回值\n\n一个表对象。\n\n#### 例子\n\n下例通过 `createNarrowReactiveStateEngine` 计算累计成交量和移动平均最新价，并将计算结果输出到窄表中，即两个指标的结果输出到同一列。\n\n```\ndummy = streamTable(1:0, [\"securityID1\",\"securityID2\",\"securityID3\",\"createTime\",\"updateTime\",\"upToDatePrice\",\"qty\",\"value\"], [STRING,STRING,STRING,TIMESTAMP,TIMESTAMP,DOUBLE,DOUBLE,INT]) \noutputTable = streamTable(1:0,[\"securityID1\",\"securityID2\",\"securityID3\",\"createTime\",\"updateTime\",\"metricNames\",\"factorValue\"], [STRING,STRING,STRING, TIMESTAMP,TIMESTAMP,STRING,DOUBLE])\n//这里定义计算指标，本例中定义了累计成交量和移动平均最新价两个指标。用户可根据实际需要修改指标。\nfactor = [<createTime>, <updateTime>,<cumsum(qty)>,<cumavg(upToDatePrice)>]\nNarrowtest = createNarrowReactiveStateEngine(name=\"narrowtest1\",metrics=factor,metricNames=[\"factor1\",\"factor2\"],dummyTable=dummy,outputTable=outputTable,keyColumn=[\"securityID1\",\"securityID2\",\"securityID3\"])\n\nnum = 5\ntmp = table(take(\"A\" + lpad(string(1..4),4,\"0\"),num) as securityID1,take(\"CC.HH\" + lpad(string(21..34),4,\"0\"),num) as securityID2,take(\"FFICE\" + lpad(string(13..34),4,\"0\"),num) as securityID3, 2023.09.01 00:00:00+(1..num) as createTime, 2023.09.01 00:00:00+take(1..num, num).sort() as updateTime,take(rand(100.0,num) join take(int(),30),num) as upToDatePrice,take(take(100.0,num) join take(int(),30),num)+30 as qty,take(1..20 join take(int(),5),num) as value)\nNarrowtest.append!(tmp)\n\nselect * from outputTable\n```\n\n| securityID1 | securityID2 | securityID3 | createTime              | updateTime              | metricNames | factorValue |\n| ----------- | ----------- | ----------- | ----------------------- | ----------------------- | ----------- | ----------- |\n| A0001       | CC.HH0021   | FFICE0013   | 2023.09.01T00:00:01.000 | 2023.09.01T00:00:01.000 | factor1     | 131         |\n| A0001       | CC.HH0021   | FFICE0013   | 2023.09.01T00:00:01.000 | 2023.09.01T00:00:01.000 | factor2     | 101         |\n| A0002       | CC.HH0022   | FFICE0014   | 2023.09.01T00:00:02000  | 2023.09.01T00:00:02.000 | factor1     | 132         |\n| A0002       | CC.HH0022   | FFICE0014   | 2023.09.01T00:00:02.000 | 2023.09.01T00:00:02.000 | factor2     | 102         |\n| A0003       | CC.HH0023   | FFICE0015   | 2023.09.01T00:00:03.000 | 2023.09.01T00:00:03.000 | factor1     | 133         |\n| A0003       | CC.HH0023   | FFICE0015   | 2023.09.01T00:00:03.000 | 2023.09.01T00:00:03.000 | factor2     | 103         |\n| A0004       | CC.HH0024   | FFICE0016   | 2023.09.01T00:00:04.000 | 2023.09.01T00:00:04.000 | factor1     | 134         |\n| A0004       | CC.HH0024   | FFICE0016   | 2023.09.01T00:00:04.000 | 2023.09.01T00:00:04.000 | factor2     | 105         |\n| A0001       | CC.HH0025   | FFICE0017   | 2023.09.01T00:00:05.000 | 2023.09.01T00:00:05.000 | factor1     | 135         |\n| A0001       | CC.HH0025   | FFICE0017   | 2023.09.01T00:00:05.000 | 2023.09.01T00:00:05.000 | factor2     | 105         |\n\n**Related information**\n\n[addReactiveMetrics](https://docs.dolphindb.cn/zh/funcs/a/addreactivemetrics.html)\n\n[getReactiveMetrics](https://docs.dolphindb.cn/zh/funcs/g/getreactivemetrics.html)\n"
    },
    "createNearestJoinEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/createNearestJoinEngine.html",
        "signatures": [
            {
                "full": "createNearestJoinEngine(name, leftTable, rightTable, outputTable, kNearest, metrics, matchingColumn, [timeColumn], [useSystemTime=false], [garbageSize = 5000], [maxDelayedTime], [nullFill], [cachedTableCapacity=1024], [snapshotDir], [snapshotIntervalInMsgCount])",
                "name": "createNearestJoinEngine",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "leftTable",
                        "name": "leftTable"
                    },
                    {
                        "full": "rightTable",
                        "name": "rightTable"
                    },
                    {
                        "full": "outputTable",
                        "name": "outputTable"
                    },
                    {
                        "full": "kNearest",
                        "name": "kNearest"
                    },
                    {
                        "full": "metrics",
                        "name": "metrics"
                    },
                    {
                        "full": "matchingColumn",
                        "name": "matchingColumn"
                    },
                    {
                        "full": "[timeColumn]",
                        "name": "timeColumn",
                        "optional": true
                    },
                    {
                        "full": "[useSystemTime=false]",
                        "name": "useSystemTime",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[garbageSize = 5000]",
                        "name": "[garbageSize = 5000]"
                    },
                    {
                        "full": "[maxDelayedTime]",
                        "name": "maxDelayedTime",
                        "optional": true
                    },
                    {
                        "full": "[nullFill]",
                        "name": "nullFill",
                        "optional": true
                    },
                    {
                        "full": "[cachedTableCapacity=1024]",
                        "name": "cachedTableCapacity",
                        "optional": true,
                        "default": "1024"
                    },
                    {
                        "full": "[snapshotDir]",
                        "name": "snapshotDir",
                        "optional": true
                    },
                    {
                        "full": "[snapshotIntervalInMsgCount]",
                        "name": "snapshotIntervalInMsgCount",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [createNearestJoinEngine](https://docs.dolphindb.cn/zh/funcs/c/createNearestJoinEngine.html)\n\n首发版本：3.00.4，3.00.3.1\n\n\n\n#### 语法\n\ncreateNearestJoinEngine(name, leftTable, rightTable, outputTable, kNearest, metrics, matchingColumn, \\[timeColumn], \\[useSystemTime=false], \\[garbageSize = 5000], \\[maxDelayedTime], \\[nullFill], \\[cachedTableCapacity=1024], \\[snapshotDir], \\[snapshotIntervalInMsgCount])\n\n#### 详情\n\n创建流计算最近邻关联引擎。引擎接收的左表和右表以 *matchingColumn* 指定的连接列分组，并在每个组内进行匹配。对于每个分组中每条左表数据，实时关联右表中时间戳不晚于该记录的最近 k 条记录，并基于这些记录计算并输出结果。\n\n**Note:** 不支持乱序处理机制，用户需要自行保证输入的数据有序。\n\n#### 参数\n\n**name** 表示引擎的名称，作为其在一个数据节点/计算节点上的唯一标识。可包含字母，数字和下划线，但必须以字母开头。\n\n**leftTable** 表对象。可以不包含数据，但结构必须与输入的流数据表相同。\n\n**rightTable** 表对象。可以不包含数据，但结构必须与输入的流数据表相同。\n\n**outputTable** 计算结果的输出表。引擎会将计算结果注入该表。输出表的各列的顺序如下：\n\n1. 时间列。其中：\n\n   * 若 *useSystemTime* = true，为 TIMESTAMP 类型；\n\n   * 若 *useSystemTime* = false，数据类型与 *timeColumn* 列一致。\n\n2. 连接列。与 *matchingColumn* 中的列以及其顺序一致，可为多列。\n\n3. 计算结果列。可为多列。\n\n**kNearest**一个正整数，表示记录的条数。对于每条左表记录，关联右表中时间戳不大于该记录时间戳的最近 k 条记录。\n\n**metrics** 以元代码的格式表示计算指标，支持输入元组。有关元代码的更多信息可参考 [元编程](https://docs.dolphindb.cn/zh/progr/objs/meta_progr.html)。\n\n* 计算指标可以是一个或多个表达式、系统内置或用户自定义函数。\n\n* *metrics* 内支持调用具有多个返回值的函数，且必须指定列名，例如 \\<func(price) as \\`col1\\`col2>。\n\n  若在 *metrics* 指定了 *leftTable* 和 *rightTable* 中具有相同名称的列，默认取左表的列，可以通过 \"tableName.colName\" 指定该列来自哪个表。\n\n* 在需要输出 array vector 类型结果时，需要显式指定`toArray`函数转换类型，例如：`<toArray(price)>`，其中 price 为右表中的普通列。\n\n* 支持使用 `toColumnarTuple` 函数，将非聚合计算结果转换为列式元组（columnar tuple）。\n\n**注意：**\n\n* *metrics* 中使用的列名大小写不敏感，不要求与输入表的列名大小写保持一致。\n\n* 当以下函数只计算 *rightTable* 中的数据列时，最近邻关联引擎对它们进行了优化：sum, sum2, avg, std, var, corr, covar, wavg, wsum, beta, max, min, last, first, med, percentile。\n\n**matchingColumn** 表示连接列的字符串标量/向量/tuple，支持 Integral, Temporal 或 Literal（UUID 除外）类型。*matchingColumn* 指定规则为：\n\n1. 只有一个连接列：当左表和右表的连接列名相同时，*matchingColumn* 是一个字符串标量，否则是一个长度为 2 的 tuple，例如：左表连接列名为 sym，右表连接列名为 sym1，则 *matchingColumn* = \\[\\[\\`sym],\\[\\`sym1]]。\n2. 有多个连接列：当左表和右表的连接列名相同时，*matchingColumn* 是一个字符串向量，否则是一个长度为 2 的 tuple，例如：左表连接列名为 timestamp, sym，右表连接列名为 timestamp, sym1，则 *matchingColumn* = \\[\\[\\`timestamp, \\`sym], \\[\\`timestamp,\\`sym1]]。\n\n**timeColumn** 可选参数，当 *useSystemTime* = false 时，指定要连接的两个表中时间列的名称。*leftTable* 和 *rightTable* 时间列名称可以不同，但数据类型需保持一致。当 *leftTable* 和 *rightTable* 时间列名称不同时，*timeColumn* 为一个长度为2的字符串向量。\n\n**useSystemTime** 可选参数，表示 *outputTable* 中第一列（时间列）为系统当前时间（*useSystemTime* = true）或左表的时间列（*useSystemTime* = false）。\n\n**garbageSize** 可选参数，是正整数，默认值是5,000（单位为行）。随着订阅的流数据不断积累进入 window join 引擎，存放在内存中的数据会越来越多，这时需要清理不再需要的历史数据。当左/右两表各个分组内的数据行数超过 *garbageSize* 值时，系统会清理本次计算不需要的历史数据。\n\n**maxDelayedTime** 可选参数，是正整数，用于触发引擎中长时间未输出的分组数据进行计算。 具体来说，若`(某个分组中的左表数据时间戳) + (maxDelayedTime) < (右表最新收到的任意一个分组数据的时间戳)`，则这条数据会触发关联计算。\n\n**Note:**\n\n指定该参数时，必须同时指定 *timeColumn*，且两者的单位需一致。默认值为3秒，根据 *timeColumn* 的精度换算。例如，若 *timeColumn* 的精度是毫秒，则默认值为3000毫秒。\n\n**Note:** 请合理设置 *maxDelayedTime* 参数。当左表数据较少而右表数据频率较高时，若 *maxDelayedTime* 设置过小，系统可能在未触发某些分组计算之前，就清理掉右表中过早的数据。\n\n**nullFill** 和输出表列字段等长且类型一一对应的元组，用于填充以下列中的空值：输出表中包含的左表列、右表列、右表列被聚合计算后的计算结果列。\n\n**cachedTableCapacity**可选参数，为正整数，表示引擎为每个不同的分组分别创建的左缓存表和右缓存表的初始容量（以数据条数计）。默认值为 1024。\n\n**snapshotDir** 可选参数，字符串，表示保存引擎快照的文件目录。\n\n* 指定的目录必须存在，否则系统会提示异常。\n\n* 创建流数据引擎时，如果指定了 *snapshotDir*，会检查该目录下是否存在快照。如果存在，会加载该快照，恢复引擎的状态。\n\n* 多个引擎可以指定同一个目录存储快照，用引擎的名称来区分快照文件。\n\n* 一个引擎的快照可能会使用三个文件名：\n\n* 临时存储快照信息：文件名为 \\<engineName>.tmp；\n\n* 快照生成并刷到磁盘：文件保存为 \\<engineName>.snapshot；\n\n* 存在同名快照：旧快照自动重命名为 \\<engineName>.old。\n\n**snapshotIntervalInMsgCount** 可选参数，正整数，表示每隔多少条数据保存一次流数据引擎快照。\n\n#### 返回值\n\n一个表。\n\n#### 例子\n\n```\nshare streamTable(1:0, `time`sym`price, [TIMESTAMP, SYMBOL, DOUBLE]) as leftTable\nshare streamTable(1:0, `time`sym`val, [TIMESTAMP, SYMBOL, DOUBLE]) as rightTable\nshare table(100:0, `time`sym`factor1`factor2`factor3, [TIMESTAMP, SYMBOL, DOUBLE, DOUBLE[], DOUBLE]) as output\n\nnullFill= [2012.01.01T00:00:00.000, `NONE, 0.0, [], 0.0]\n\nnjEngine=createNearestJoinEngine(name=\"test1\", leftTable=leftTable, rightTable=rightTable, outputTable=output,  kNearest=8, metrics=<[price,toArray(val),sum(val)]>, matchingColumn=`sym, timeColumn=`time, useSystemTime=false,nullFill=nullFill)\n\nsubscribeTable(tableName=\"leftTable\", actionName=\"joinLeft\", offset=0, handler=appendForJoin{njEngine, true}, msgAsTable=true)\nsubscribeTable(tableName=\"rightTable\", actionName=\"joinRight\", offset=0, handler=appendForJoin{njEngine, false}, msgAsTable=true)\n\n\nn=10\n\ntp2=table(take(2012.01.01T00:00:00.000+0..10, 2*n) as time, take(`A, n) join take(`B, n) as sym, take(double(1..n),2*n) as val)\ntp2.sortBy!(`time)\nrightTable.append!(tp2)\n\n\ntp1=table(take(2012.01.01T00:00:00.003+0..10, 2*n) as time, take(`A, n) join take(`B, n) as sym, take(NULL join rand(10.0, n-1),2*n) as price)\ntp1.sortBy!(`time)\nleftTable.append!(tp1)\n\n\ntp2=table(take(2012.01.01T00:00:00.010+0..10, 2*n) as time, take(`A, n) join take(`B, n) as sym, take(double(1..n),2*n) as val)\ntp2.sortBy!(`time)\nrightTable.append!(tp2)\n\nselect * from output\n```\n\n| time                    | sym | factor1             | factor2                    | factor3 |\n| ----------------------- | --- | ------------------- | -------------------------- | ------- |\n| 2012.01.01 00:00:00.003 | A   | 0                   | \\[1, 2, 3, 4]              | 10      |\n| 2012.01.01 00:00:00.004 | A   | 8.049739237951693   | \\[1, 2, 3, 4, 5]           | 15      |\n| 2012.01.01 00:00:00.005 | A   | 6.31845193685475    | \\[1, 2, 3, 4, 5, 6]        | 21      |\n| 2012.01.01 00:00:00.006 | A   | 0.01247286192106635 | \\[1, 2, 3, 4, 5, 6, 7]     | 28      |\n| 2012.01.01 00:00:00.007 | A   | 8.373015887228414   | \\[1, 2, 3, 4, 5, 6, 7, 8]  | 36      |\n| 2012.01.01 00:00:00.008 | A   | 4.636610761119452   | \\[2, 3, 4, 5, 6, 7, 8, 9]  | 44      |\n| 2012.01.01 00:00:00.003 | B   | 8.049739237951693   | \\[2, 3, 4, 5]              | 14      |\n| 2012.01.01 00:00:00.004 | B   | 6.31845193685475    | \\[2, 3, 4, 5, 6]           | 20      |\n| 2012.01.01 00:00:00.005 | B   | 0.01247286192106635 | \\[2, 3, 4, 5, 6, 7]        | 27      |\n| 2012.01.01 00:00:00.006 | B   | 8.373015887228414   | \\[2, 3, 4, 5, 6, 7, 8]     | 35      |\n| 2012.01.01 00:00:00.007 | B   | 4.636610761119452   | \\[2, 3, 4, 5, 6, 7, 8, 9]  | 44      |\n| 2012.01.01 00:00:00.008 | B   | 7.700075873220435   | \\[3, 4, 5, 6, 7, 8, 9, 10] | 52      |\n| 2012.01.01 00:00:00.009 | B   | 0.5831421500989946  | \\[3, 4, 5, 6, 7, 8, 9, 10] | 52      |\n| 2012.01.01 00:00:00.009 | A   | 7.700075873220435   | \\[3, 4, 5, 6, 7, 8, 9, 10] | 52      |\n| 2012.01.01 00:00:00.010 | A   | 0.5831421500989946  | \\[4, 5, 6, 7, 8, 9, 10, 1] | 50      |\n| 2012.01.01 00:00:00.011 | A   | 5.117162734418752   | \\[5, 6, 7, 8, 9, 10, 1, 2] | 48      |\n| 2012.01.01 00:00:00.012 | A   | 8.823084861596655   | \\[6, 7, 8, 9, 10, 1, 2, 3] | 46      |\n| 2012.01.01 00:00:00.010 | B   | 5.117162734418752   | \\[5, 6, 7, 8, 9, 10, 1, 2] | 48      |\n| 2012.01.01 00:00:00.011 | B   | 8.823084861596655   | \\[6, 7, 8, 9, 10, 1, 2, 3] | 46      |\n| 2012.01.01 00:00:00.013 | B   | 0                   | \\[8, 9, 10, 1, 2, 3, 4, 5] | 42      |\n"
    },
    "createOrcaHaKeyedStreamTable": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/createOrcaHaKeyedStreamTable.html",
        "signatures": [
            {
                "full": "createOrcaHaKeyedStreamTable(name, keyColumn, colNames, colTypes, raftGroup, cacheLimit, [retentionMinutes=1440])",
                "name": "createOrcaHaKeyedStreamTable",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "keyColumn",
                        "name": "keyColumn"
                    },
                    {
                        "full": "colNames",
                        "name": "colNames"
                    },
                    {
                        "full": "colTypes",
                        "name": "colTypes"
                    },
                    {
                        "full": "raftGroup",
                        "name": "raftGroup"
                    },
                    {
                        "full": "cacheLimit",
                        "name": "cacheLimit"
                    },
                    {
                        "full": "[retentionMinutes=1440]",
                        "name": "retentionMinutes",
                        "optional": true,
                        "default": "1440"
                    }
                ]
            }
        ],
        "markdown": "### [createOrcaHaKeyedStreamTable](https://docs.dolphindb.cn/zh/funcs/c/createOrcaHaKeyedStreamTable.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\ncreateOrcaHaKeyedStreamTable(name, keyColumn, colNames, colTypes, raftGroup, cacheLimit, \\[retentionMinutes=1440])\n\n#### 详情\n\n创建一个高可用键值流数据表。\n\n与 `StreamGraph::haKeyedSource` 的区别在于，`createOrcaHaKeyedStreamTable` 无需依赖流图。\n\n#### 参数\n\n**name** 表示流表的名称。字符串标量，可以传入完整的流表全限定名（如 \"trading.orca\\_table.trades\"）；也可以仅提供流表名（如 \"trades\"），系统会根据当前的 catalog 设置自动补全为对应的全限定名。\n\n**keyColumn** 是一个字符串或向量，表示主键。主键的数据类型必须属于以下类别：INTEGRAL, TEMPORAL, LITERAL 或 FLOATING。\n\n**colNames** 是一个向量，表示列名。\n\n**colTypes** 是一个向量，表示每列的数据类型，支持数组向量类型和元组（ANY）类型。可使用表示数据类型的系统保留字或相应的字符串。\n\n**raftGroup** 是一个大于1的整数，或者字符串。\n\n* 当为整数时，表示 Raft 组的 ID。\n* 当为字符串时，表示 Raft 组的别名（需事先通过 *streamingRaftGroupAliases* 配置 ）。\n\n**cacheSize** 是一个正整数，用于指定高可用流数据表在内存中最多保留多少行。如果 *cacheSize* 是小于1000的正整数，它会被自动调整为1000。\n\n**retentionMinutes** 可选参数，整数，用于指定保留大小超过 1GB 的 log 文件的时间（从文件的最后修改时间开始计算），单位是分钟。默认值是1440，即一天。\n\n#### 返回值\n\n返回一个表。\n\n#### 例子\n\n```\nif(!existsCatalog(\"demo\")){\n    createCatalog(\"demo\")\n}\ngo\nuse catalog demo\n\ncreateOrcaHaKeyedStreamTable(\"ha_keyedTable\",`symbol, `time`symbol`price`volume, [DATETIME,SYMBOL,DOUBLE,LONG], 3, 50000)\n```\n"
    },
    "createOrcaHaStreamTable": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/createOrcaHaStreamTable.html",
        "signatures": [
            {
                "full": "createOrcaHaStreamTable(name, colNames, colTypes, raftGroup, cacheLimit, [retentionMinutes=1440])",
                "name": "createOrcaHaStreamTable",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "colNames",
                        "name": "colNames"
                    },
                    {
                        "full": "colTypes",
                        "name": "colTypes"
                    },
                    {
                        "full": "raftGroup",
                        "name": "raftGroup"
                    },
                    {
                        "full": "cacheLimit",
                        "name": "cacheLimit"
                    },
                    {
                        "full": "[retentionMinutes=1440]",
                        "name": "retentionMinutes",
                        "optional": true,
                        "default": "1440"
                    }
                ]
            }
        ],
        "markdown": "### [createOrcaHaStreamTable](https://docs.dolphindb.cn/zh/funcs/c/createOrcaHaStreamTable.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\ncreateOrcaHaStreamTable(name, colNames, colTypes, raftGroup, cacheLimit, \\[retentionMinutes=1440])\n\n#### 详情\n\n创建一个高可用流数据表。参考 [haStreamTable](https://docs.dolphindb.cn/zh/funcs/h/haStreamTable.html)。\n\n与 `StreamGraph::haSource` 的区别在于，`createOrcaHaStreamTable` 无需依赖流图。\n\n#### 参数\n\n**name** 表示流表的名称。字符串标量，可以传入完整的流表全限定名（如 \"trading.orca\\_table.trades\"）；也可以仅提供流表名（如 \"trades\"），系统会根据当前的 catalog 设置自动补全为对应的全限定名。\n\n**colNames** 是一个向量，表示列名。\n\n**colTypes** 是一个向量，表示每列的数据类型，支持数组向量类型和元组（ANY）类型。可使用表示数据类型的系统保留字或相应的字符串。\n\n**raftGroup** 是一个大于1的整数，或者字符串。\n\n* 当为整数时，表示 Raft 组的 ID。\n* 当为字符串时，表示 Raft 组的别名（需事先通过 *streamingRaftGroupAliases* 配置 ）。\n\n**cacheSize** 是一个正整数，用于指定高可用流数据表在内存中最多保留多少行。如果 *cacheSize* 是小于1000的正整数，它会被自动调整为1000。\n\n**retentionMinutes** 可选参数，整数，用于指定保留大小超过 1GB 的 log 文件的时间（从文件的最后修改时间开始计算），单位是分钟。默认值是1440，即一天。\n\n#### 返回值\n\n返回一个表。\n\n#### 例子\n\n```\nif(!existsCatalog(\"demo\")){\n    createCatalog(\"demo\")\n}\ngo\nuse catalog demo\n\ncreateOrcaHaStreamTable(\"ha_table\",`time`symbol`price`volume, [DATETIME,SYMBOL,DOUBLE,LONG], 3, 50000)\n```\n"
    },
    "createOrcaKeyedStreamTable": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/createOrcaKeyedStreamTable.html",
        "signatures": [
            {
                "full": "createOrcaKeyedStreamTable(name, keyColumn, colNames, colTypes, [asyncWrite=true], [compress=true], [cacheSize], [retentionMinutes=1440], [flushMode=0], [preCache], [cachePurgeTimeColumn], [cachePurgeInterval], [cacheRetentionTime])",
                "name": "createOrcaKeyedStreamTable",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "keyColumn",
                        "name": "keyColumn"
                    },
                    {
                        "full": "colNames",
                        "name": "colNames"
                    },
                    {
                        "full": "colTypes",
                        "name": "colTypes"
                    },
                    {
                        "full": "[asyncWrite=true]",
                        "name": "asyncWrite",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[compress=true]",
                        "name": "compress",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[cacheSize]",
                        "name": "cacheSize",
                        "optional": true
                    },
                    {
                        "full": "[retentionMinutes=1440]",
                        "name": "retentionMinutes",
                        "optional": true,
                        "default": "1440"
                    },
                    {
                        "full": "[flushMode=0]",
                        "name": "flushMode",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[preCache]",
                        "name": "preCache",
                        "optional": true
                    },
                    {
                        "full": "[cachePurgeTimeColumn]",
                        "name": "cachePurgeTimeColumn",
                        "optional": true
                    },
                    {
                        "full": "[cachePurgeInterval]",
                        "name": "cachePurgeInterval",
                        "optional": true
                    },
                    {
                        "full": "[cacheRetentionTime]",
                        "name": "cacheRetentionTime",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [createOrcaKeyedStreamTable](https://docs.dolphindb.cn/zh/funcs/c/createOrcaKeyedStreamTable.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\ncreateOrcaKeyedStreamTable(name, keyColumn, colNames, colTypes, \\[asyncWrite=true], \\[compress=true], \\[cacheSize], \\[retentionMinutes=1440], \\[flushMode=0], \\[preCache], \\[cachePurgeTimeColumn], \\[cachePurgeInterval], \\[cacheRetentionTime])\n\n#### 详情\n\n创建一个持久化键值流数据表。参考 [keyedStreamTable](https://docs.dolphindb.cn/zh/funcs/k/keyedStreamTable.html) 和 [enableTableShareAndPersistence](https://docs.dolphindb.cn/zh/funcs/e/enableTableShareAndPersistence.html)。\n\n与 `StreamGraph::keyedSource` 的区别在于，`createOrcaKeyedStreamTable` 无需依赖流图。\n\n#### 参数\n\n**name** 表示流表的名称。字符串标量，可以传入完整的流表全限定名（如 \"trading.orca\\_table.trades\"）；也可以仅提供流表名（如 \"trades\"），系统会根据当前的 catalog 设置自动补全为对应的全限定名。\n\n**keyColumn** 是一个字符串或向量，表示主键。主键的数据类型必须属于以下类别：INTEGRAL, TEMPORAL, LITERAL 或 FLOATING。\n\n**colNames** 是一个向量，表示列名。\n\n**colTypes** 是一个向量，表示每列的数据类型，支持数组向量类型和元组（ANY）类型。可使用表示数据类型的系统保留字或相应的字符串。\n\n**asyncWrite** 可选参数，是一个布尔值，表示是否异步持久化数据到磁盘。默认值为 true，流数据写入内存即为写入成功，持久化到磁盘的操作将会由另一个线程执行。\n\n**Note:**\n\n持久化数据到磁盘包含两个步骤：\n\n* 写内存数据到操作系统缓存\n\n* 写缓存数据到磁盘（是否开启同步刷盘由参数 *flushMode* 决定）\n\n**compress** 可选参数，是一个布尔值，表示是否以压缩模式模式保存至磁盘。默认值为 true。\n\n**cacheSize** 可选参数，整数，表示流数据表在内存中最多保留多少行。如果未指定该参数，则所有记录行都会保存在内存中。如果 *cacheSize* 小于 1000，它会被自动调整为 1000。\n\n**retentionMinutes** 可选参数，是一个整数，表示文件大小超过 1GB的 log 文件的保留时间(从文件的最后修改时间开始计算)，单位是分钟。默认值是 1440，即一天。如果 log 文件未达 1GB，则会一直保留至大小达到 1GB。\n\n**flushMode** 可选参数，是一个整数，表示是否开启同步刷盘，取值只能为 0 或 1。默认值是 0，表示异步刷盘，内存中的流数据写入操作系统缓存即为写入成功，并进行下一批数据的写入。 若为 1，则表示同步刷盘，当前批次的流数据必须落盘完成，才会进行下一批数据的写入。\n\n**preCache** 可选参数，是一个整数，表示从磁盘加载到内存的记录条数。如果没有指定该参数，重启后实际加载到内存的数据量受 *cacheSize* 限制。\n\n**cachePurgeTimeColumn** 可选参数，字符串标量，需要指定为持久化流表中的时间列名称。\n\n**cachePurgeInterval** 可选参数，DURATION 类型标量，表示触发清理内存中数据的时间间隔。\n\n**cacheRetentionTime** 可选参数，DURATION 类型标量，表示内存中数据的最长保留期限。\n\n#### 返回值\n\n返回一个表。\n\n#### 例子\n\n```\nif(!existsCatalog(\"demo\")){\n    createCatalog(\"demo\")\n}\ngo\nuse catalog demo\n\ncreateOrcaKeyedStreamTable(\"trade\", `symbol, `time`symbol`price`volume, [DATETIME,SYMBOL,DOUBLE,LONG])\n```\n"
    },
    "createOrcaLatestKeyedStreamTable": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/createOrcaLatestKeyedStreamTable.html",
        "signatures": [
            {
                "full": "createOrcaLatestKeyedStreamTable(name, keyColumn, timeColumn, colNames, colTypes, [asyncWrite=true], [compress=true], [cacheSize], [retentionMinutes=1440], [flushMode=0], [preCache], [cachePurgeTimeColumn], [cachePurgeInterval], [cacheRetentionTime])",
                "name": "createOrcaLatestKeyedStreamTable",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "keyColumn",
                        "name": "keyColumn"
                    },
                    {
                        "full": "timeColumn",
                        "name": "timeColumn"
                    },
                    {
                        "full": "colNames",
                        "name": "colNames"
                    },
                    {
                        "full": "colTypes",
                        "name": "colTypes"
                    },
                    {
                        "full": "[asyncWrite=true]",
                        "name": "asyncWrite",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[compress=true]",
                        "name": "compress",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[cacheSize]",
                        "name": "cacheSize",
                        "optional": true
                    },
                    {
                        "full": "[retentionMinutes=1440]",
                        "name": "retentionMinutes",
                        "optional": true,
                        "default": "1440"
                    },
                    {
                        "full": "[flushMode=0]",
                        "name": "flushMode",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[preCache]",
                        "name": "preCache",
                        "optional": true
                    },
                    {
                        "full": "[cachePurgeTimeColumn]",
                        "name": "cachePurgeTimeColumn",
                        "optional": true
                    },
                    {
                        "full": "[cachePurgeInterval]",
                        "name": "cachePurgeInterval",
                        "optional": true
                    },
                    {
                        "full": "[cacheRetentionTime]",
                        "name": "cacheRetentionTime",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [createOrcaLatestKeyedStreamTable](https://docs.dolphindb.cn/zh/funcs/c/createOrcaLatestKeyedStreamTable.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\ncreateOrcaLatestKeyedStreamTable(name, keyColumn, timeColumn, colNames, colTypes, \\[asyncWrite=true], \\[compress=true], \\[cacheSize], \\[retentionMinutes=1440], \\[flushMode=0], \\[preCache], \\[cachePurgeTimeColumn], \\[cachePurgeInterval], \\[cacheRetentionTime])\n\n#### 详情\n\n创建一个最新值键值流数据表，并将它持久化到磁盘上。参考 [latestKeyedStreamTable](https://docs.dolphindb.cn/zh/funcs/l/latestkeyedstreamtable.html) 和 [enableTableShareAndPersistence](https://docs.dolphindb.cn/zh/funcs/e/enableTableShareAndPersistence.html)。\n\n与 `StreamGraph::latestKeyedSource` 的区别在于，`createOrcaLatestKeyedStreamTable` 无需依赖流图。\n\n#### 参数\n\n**name** 表示流表的名称。字符串标量，可以传入完整的流表全限定名（如 \"trading.orca\\_table.trades\"）；也可以仅提供流表名（如 \"trades\"），系统会根据当前的 catalog 设置自动补全为对应的全限定名。\n\n**timeColumn** 字符串标量或长度为 2 的向量，分别用于指定 1 个或 2 个时间列。当仅指定 1 个时间列时，该列可以为整型或时间类型；当指定 2 个时间列时，第 1 列必须是 DATE 类型，第 2 列则是 TIME, SECOND 或 NANOTIME 类型。通过这两列，可以共同确定唯一的时间值。\n\n**colNames** 是一个向量，表示列名。\n\n**colTypes** 是一个向量，表示每列的数据类型，支持数组向量类型和元组（ANY）类型。可使用表示数据类型的系统保留字或相应的字符串。\n\n**asyncWrite** 可选参数，是一个布尔值，表示是否异步持久化数据到磁盘。默认值为 true，流数据写入内存即为写入成功，持久化到磁盘的操作将会由另一个线程执行。\n\n**Note:**\n\n持久化数据到磁盘包含两个步骤：\n\n* 写内存数据到操作系统缓存\n\n* 写缓存数据到磁盘（是否开启同步刷盘由参数 *flushMode* 决定）\n\n**compress** 可选参数，是一个布尔值，表示是否以压缩模式模式保存至磁盘。默认值为 true。\n\n**cacheSize** 可选参数，整数，表示流数据表在内存中最多保留多少行。如果未指定该参数，则所有记录行都会保存在内存中。如果 *cacheSize* 小于 1000，它会被自动调整为 1000。\n\n**retentionMinutes** 可选参数，是一个整数，表示文件大小超过 1GB的 log 文件的保留时间(从文件的最后修改时间开始计算)，单位是分钟。默认值是 1440，即一天。如果 log 文件未达 1GB，则会一直保留至大小达到 1GB。\n\n**flushMode** 可选参数，是一个整数，表示是否开启同步刷盘，取值只能为 0 或 1。默认值是 0，表示异步刷盘，内存中的流数据写入操作系统缓存即为写入成功，并进行下一批数据的写入。 若为 1，则表示同步刷盘，当前批次的流数据必须落盘完成，才会进行下一批数据的写入。\n\n**preCache** 可选参数，是一个整数，表示从磁盘加载到内存的记录条数。如果没有指定该参数，重启后实际加载到内存的数据量受 *cacheSize* 限制。\n\n**cachePurgeTimeColumn** 可选参数，字符串标量，需要指定为持久化流表中的时间列名称。\n\n**cachePurgeInterval** 可选参数，DURATION 类型标量，表示触发清理内存中数据的时间间隔。\n\n**cacheRetentionTime** 可选参数，DURATION 类型标量，表示内存中数据的最长保留期限。\n\n#### 返回值\n\n返回一个表。\n\n#### 例子\n\n```\nif(!existsCatalog(\"demo\")){\n    createCatalog(\"demo\")\n}\ngo\nuse catalog demo\n\ncreateOrcaLatestKeyedStreamTable(\"trade\", `symbol, `time, `time`symbol`price`volume, [DATETIME,SYMBOL,DOUBLE,LONG])\n```\n"
    },
    "createOrcaStreamTable": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/createOrcaStreamTable.html",
        "signatures": [
            {
                "full": "createOrcaStreamTable(name, colNames, colTypes, [asyncWrite=true], [compress=true], [cacheSize], [retentionMinutes=1440], [flushMode=0], [preCache], [cachePurgeTimeColumn], [cachePurgeInterval], [cacheRetentionTime])",
                "name": "createOrcaStreamTable",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "colNames",
                        "name": "colNames"
                    },
                    {
                        "full": "colTypes",
                        "name": "colTypes"
                    },
                    {
                        "full": "[asyncWrite=true]",
                        "name": "asyncWrite",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[compress=true]",
                        "name": "compress",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[cacheSize]",
                        "name": "cacheSize",
                        "optional": true
                    },
                    {
                        "full": "[retentionMinutes=1440]",
                        "name": "retentionMinutes",
                        "optional": true,
                        "default": "1440"
                    },
                    {
                        "full": "[flushMode=0]",
                        "name": "flushMode",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[preCache]",
                        "name": "preCache",
                        "optional": true
                    },
                    {
                        "full": "[cachePurgeTimeColumn]",
                        "name": "cachePurgeTimeColumn",
                        "optional": true
                    },
                    {
                        "full": "[cachePurgeInterval]",
                        "name": "cachePurgeInterval",
                        "optional": true
                    },
                    {
                        "full": "[cacheRetentionTime]",
                        "name": "cacheRetentionTime",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [createOrcaStreamTable](https://docs.dolphindb.cn/zh/funcs/c/createOrcaStreamTable.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\ncreateOrcaStreamTable(name, colNames, colTypes, \\[asyncWrite=true], \\[compress=true], \\[cacheSize], \\[retentionMinutes=1440], \\[flushMode=0], \\[preCache], \\[cachePurgeTimeColumn], \\[cachePurgeInterval], \\[cacheRetentionTime])\n\n#### 详情\n\n创建一个持久化共享流数据表。详情参考 [enableTableShareAndPersistence](https://docs.dolphindb.cn/zh/funcs/e/enableTableShareAndPersistence.html)。\n\n与 `StreamGraph::source` 的区别在于，`createOrcaStreamTable` 无需依赖流图。\n\n**Note:**\n\n* 调用该函数前，必须先启用 Orca 功能，即在配置文件 cluster.cfg 或 controller.cfg 中配置 `enableORCA=true`。\n* 在集群环境下，该函数只能在计算组中的计算节点上运行。\n\n#### 参数\n\n**name** 表示流表的名称。字符串标量，可以传入完整的流表全限定名（如 \"trading.orca\\_table.trades\"）；也可以仅提供流表名（如 \"trades\"），系统会根据当前的 catalog 设置自动补全为对应的全限定名。\n\n**colNames** 是一个向量，表示列名。\n\n**colTypes** 是一个向量，表示每列的数据类型，支持数组向量类型和元组（ANY）类型。可使用表示数据类型的系统保留字或相应的字符串。\n\n**asyncWrite** 可选参数，是一个布尔值，表示是否异步持久化数据到磁盘。默认值为 true，流数据写入内存即为写入成功，持久化到磁盘的操作将会由另一个线程执行。\n\n**Note:**\n\n持久化数据到磁盘包含两个步骤：\n\n* 写内存数据到操作系统缓存\n\n* 写缓存数据到磁盘（是否开启同步刷盘由参数 *flushMode* 决定）\n\n**compress** 可选参数，是一个布尔值，表示是否以压缩模式模式保存至磁盘。默认值为 true。\n\n**cacheSize** 可选参数，整数，表示流数据表在内存中最多保留多少行。如果未指定该参数，则所有记录行都会保存在内存中。如果 *cacheSize* 小于 1000，它会被自动调整为 1000。\n\n**retentionMinutes** 可选参数，是一个整数，表示文件大小超过 1GB的 log 文件的保留时间(从文件的最后修改时间开始计算)，单位是分钟。默认值是 1440，即一天。如果 log 文件未达 1GB，则会一直保留至大小达到 1GB。\n\n**flushMode** 可选参数，是一个整数，表示是否开启同步刷盘，取值只能为 0 或 1。默认值是 0，表示异步刷盘，内存中的流数据写入操作系统缓存即为写入成功，并进行下一批数据的写入。 若为 1，则表示同步刷盘，当前批次的流数据必须落盘完成，才会进行下一批数据的写入。\n\n**preCache** 可选参数，是一个整数，表示从磁盘加载到内存的记录条数。如果没有指定该参数，重启后实际加载到内存的数据量受 *cacheSize* 限制。\n\n**cachePurgeTimeColumn** 可选参数，字符串标量，需要指定为持久化流表中的时间列名称。\n\n**cachePurgeInterval** 可选参数，DURATION 类型标量，表示触发清理内存中数据的时间间隔。\n\n**cacheRetentionTime** 可选参数，DURATION 类型标量，表示内存中数据的最长保留期限。\n\n#### 返回值\n\n返回一个表。\n\n#### 例子\n\n```\nif(!existsCatalog(\"demo\")){\n    createCatalog(\"demo\")\n}\ngo\nuse catalog demo\n\ncreateOrcaStreamTable(\"trade\", `time`symbol`price`volume, [DATETIME,SYMBOL,DOUBLE,LONG])\n```\n"
    },
    "createOrderBookSnapshotEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/createorderbooksnapshotengine.html",
        "signatures": [
            {
                "full": "createOrderBookSnapshotEngine(name, exchange, orderbookDepth, intervalInMilli, date, startTime, prevClose, dummyTable, outputTable, inputColMap, [outputColMap], [outputCodeMap], [snapshotDir], [snapshotIntervalInMsgCount], [raftGroup], [outputIntervalOffsetMap], [checkRestrict], [maxPrice], [minPrice], [userDefinedMetrics], [priceNullFill], [triggerType], [forceTriggerTime], [precision], [orderBySeq], [skipCrossedMarket=true], [orderBookDetailDepth=0], [orderBookAsArray=false],[useSystemTime=false],[independentForceTriggerTime],[includeImmediateExecution=false], [securitySubType='ConvertibleBond'], [priceScale=10000], [endTime])",
                "name": "createOrderBookSnapshotEngine",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "exchange",
                        "name": "exchange"
                    },
                    {
                        "full": "orderbookDepth",
                        "name": "orderbookDepth"
                    },
                    {
                        "full": "intervalInMilli",
                        "name": "intervalInMilli"
                    },
                    {
                        "full": "date",
                        "name": "date"
                    },
                    {
                        "full": "startTime",
                        "name": "startTime"
                    },
                    {
                        "full": "prevClose",
                        "name": "prevClose"
                    },
                    {
                        "full": "dummyTable",
                        "name": "dummyTable"
                    },
                    {
                        "full": "outputTable",
                        "name": "outputTable"
                    },
                    {
                        "full": "inputColMap",
                        "name": "inputColMap"
                    },
                    {
                        "full": "[outputColMap]",
                        "name": "outputColMap",
                        "optional": true
                    },
                    {
                        "full": "[outputCodeMap]",
                        "name": "outputCodeMap",
                        "optional": true
                    },
                    {
                        "full": "[snapshotDir]",
                        "name": "snapshotDir",
                        "optional": true
                    },
                    {
                        "full": "[snapshotIntervalInMsgCount]",
                        "name": "snapshotIntervalInMsgCount",
                        "optional": true
                    },
                    {
                        "full": "[raftGroup]",
                        "name": "raftGroup",
                        "optional": true
                    },
                    {
                        "full": "[outputIntervalOffsetMap]",
                        "name": "outputIntervalOffsetMap",
                        "optional": true
                    },
                    {
                        "full": "[checkRestrict]",
                        "name": "checkRestrict",
                        "optional": true
                    },
                    {
                        "full": "[maxPrice]",
                        "name": "maxPrice",
                        "optional": true
                    },
                    {
                        "full": "[minPrice]",
                        "name": "minPrice",
                        "optional": true
                    },
                    {
                        "full": "[userDefinedMetrics]",
                        "name": "userDefinedMetrics",
                        "optional": true
                    },
                    {
                        "full": "[priceNullFill]",
                        "name": "priceNullFill",
                        "optional": true
                    },
                    {
                        "full": "[triggerType]",
                        "name": "triggerType",
                        "optional": true
                    },
                    {
                        "full": "[forceTriggerTime]",
                        "name": "forceTriggerTime",
                        "optional": true
                    },
                    {
                        "full": "[precision]",
                        "name": "precision",
                        "optional": true
                    },
                    {
                        "full": "[orderBySeq]",
                        "name": "orderBySeq",
                        "optional": true
                    },
                    {
                        "full": "[skipCrossedMarket=true]",
                        "name": "skipCrossedMarket",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[orderBookDetailDepth=0]",
                        "name": "orderBookDetailDepth",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[orderBookAsArray=false]",
                        "name": "orderBookAsArray",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[useSystemTime=false]",
                        "name": "useSystemTime",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[independentForceTriggerTime]",
                        "name": "independentForceTriggerTime",
                        "optional": true
                    },
                    {
                        "full": "[includeImmediateExecution=false]",
                        "name": "includeImmediateExecution",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[securitySubType='ConvertibleBond']",
                        "name": "securitySubType",
                        "optional": true,
                        "default": "'ConvertibleBond'"
                    },
                    {
                        "full": "[priceScale=10000]",
                        "name": "priceScale",
                        "optional": true,
                        "default": "10000"
                    },
                    {
                        "full": "[endTime]",
                        "name": "endTime",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [createOrderBookSnapshotEngine](https://docs.dolphindb.cn/zh/funcs/c/createorderbooksnapshotengine.html)\n\n\n\n#### 语法\n\ncreateOrderBookSnapshotEngine(name, exchange, orderbookDepth, intervalInMilli, date, startTime, prevClose, dummyTable, outputTable, inputColMap, \\[outputColMap], \\[outputCodeMap], \\[snapshotDir], \\[snapshotIntervalInMsgCount], \\[raftGroup], \\[outputIntervalOffsetMap], \\[checkRestrict], \\[maxPrice], \\[minPrice], \\[userDefinedMetrics], \\[priceNullFill], \\[triggerType], \\[forceTriggerTime], \\[precision], \\[orderBySeq], \\[skipCrossedMarket=true], \\[orderBookDetailDepth=0], \\[orderBookAsArray=false],\\[useSystemTime=false],\\[independentForceTriggerTime],\\[includeImmediateExecution=false], \\[securitySubType='ConvertibleBond'], \\[priceScale=10000], \\[endTime])\n\n**Note:**\n\n社区版 License 暂不支持该引擎，如需使用此功能，请联系技术支持。\n\n#### 详情\n\n`createOrderBookSnapshotEngine` 用于创建一个订单簿快照引擎（OrderBook Snapshot Engine）。该引擎根据逐笔委托和逐笔成交数据实时合成指定频率（如 1 秒、100ms、30ms 等）的订单簿快照数据。\n\n输出内容包括：\n\n* 全档位盘口信息（order book）\n\n* 窗口统计指标\n\n* 全天累计统计指标\n\n该引擎既支持实时流式数据，也支持历史逐笔数据回放。\n\n如果输入数据后，引擎一直没有输出或者输出的结果很少，请参考 [Orderbook 引擎教程 7.5 小节](https://docs.dolphindb.cn/zh/tutorials/orderBookSnapshotEngine.md#)排查问题。\n\n##### 支持的市场类型\n\n目前支持合成深交所股票、深交所债券、深交所基金、上交所股票、上交所债券、上交所基金的订单薄数据。\n\n**Note:** 债券撮合规则遵循2022年8月之后发布的新规定。\n\n##### 窗口计算规则\n\n当未指定 *outputIntervalOffsetMap* 时，窗口计算规则如下：\n\n由参数 *intervalInMilli*指定窗口的长度（以时间衡量），输出表中时间戳为窗口的右边界。最后一个窗口区间为左开右开，其余窗口区间全部左开右闭。\n\n最后一个窗口的右边界上限为：\n\n* 若指定 *endTime*，则最后一个窗口的右边界上限为 *endTime*。\n\n* 若未指定 *endTime*：\n\n  * 当*exchange* = “XSHGBOND” 时，最后一个窗口的右边界上限为 15:00:00.000。\n\n  * 当*exchange* 是其它值时，最后一个窗口的右边界上限为 14:57:00.000。\n\n当指定 *outputIntervalOffsetMap* 时，窗口长度及边界将根据 *outputIntervalOffsetMap* 中配置的偏移量（*offset*）进行调整。\n\n* **第一个窗口**：区间为 \\[*startTime, startTime + intervalInMilli + offset*]。\n* **后续中间窗口**：区间为上个窗口右边界至当前右边界，长度固定为 *intervalInMilli*。\n* **最后一个窗口**：长度为*intervalInMilli - offset*。\n\n例如：*intervalInMilli* = 500ms，*offset*= 50ms。\n\n* 第一个窗口：09:30:00.000 - 09:30:00.550（长度 550ms）\n* 第二个窗口：09:30:00.550 - 09:30:01.050（长度 500ms）\n* ...\n* 最后一个窗口（假设 *endTime* 为 14:57:00）：14:56:59.550 - 14:57:00.000（长度 450ms）\n\n##### 触发规则\n\n第一条输出记录由输入表中第一条时间戳大于 startTime + intervalInMilli 的记录触发，此时输出表的时间戳为 startTime + intervalInMilli。之后根据参数 *triggerType*的配置值，决定新收到任意一条逐笔数据，当其时间戳大于窗口右边界时，触发输出单个或所有标的的快照。\n\n**Note:**\n\n* 一个引擎至多只能输入一个交易日、一个通道的全部标的数据。\n* 必须保证注入引擎的数据表内的数据按照交易所的逐笔序号排序。\n\n#### 参数\n\n**Note:** 传参时必须指定参数名。\n\n**name** 字符串标量，表示 orderbook 快照引擎的名称，可包含字母，数字和下划线，但必须以字母开头。\n\n**exchange** 字符串标量，用于指定交易所及标的类别。可选参数：\n\n* \"XSHE\" 或 \"XSHESTOCK\"：深交所股票\n* \"XSHEBOND\"：深交所债券\n* \"XSHEFUND\"：深交所基金\n* \"XSHG\" 或 \"XSHGSTOCK\"：上交所股票\n* \"XSHGBOND\"：上交所债券\n* \"XSHGFUND\"：上交所基金\n\n**orderbookDepth** 正整数，表示 orderbook 中最多能够显示的买卖报价的档位。\n\n**intervalInMilli** 正整数，表示触发输出数据的时间间隔，即合成快照的时间频率，单位为毫秒。\n\n**date** DATE 类型标量，表示交易日期。该参数和窗口右边界组合成输出表的 TIMESTAMP 列。\n\n**startTime** TIME 类型标量，表示触发输出数据的起始时刻。引擎只会输出该参数指定时刻（规整后）之后的数据。\n\n**prevClose** 字典，其 key 为字符串标量或向量，表示股票代码；其 value 为数值类型，表示对应于股票代码的上一个交易日的收盘价格。注意：若 value 为浮点型，则认为是真实价格，引擎处理过程中会乘以 *priceScale*，以匹配输入表中 priceColumn 字段的精度。若为整型，则视为已和 priceColumn 具备相同精度，不再进行缩放。\n\n**dummyTable** 一个表对象，和输入的流数据表的 schema 一致，可以含有数据，亦可为空表。\n\n**outputTable** 一个表对象。若指定 *userDefinedMetrics*，*outputTable* 根据 `genOutputColumnsForOBSnapshotEngine` 函数指定的 *basic*、*depth* 以及用户自定义的指标来确定表结构。否则，*outputTable* 根据 *outputColMap*的设置来确定表结构。\n\n**Note:** tradeDetail（成交明细）中的 tradeBuyOrderTypeList 和 tradeSellOrderTypeList。如需要输出上述字段，请在 *outputColMap* 中手动添加。\n\n**inputColMap** 字典，将输入表中列字段的名称映射为引擎计算所需要的列。其中：\n\n* key 为字符串类型，表示引擎所需要的固定的输入字段。具体字段名和含义见下表。注意，这些 key 区分大小写，必须全部指定，但顺序可以不固定。\n* value 为字符串类型，表示输入表中对应的列名称。\n\n<table id=\"inputTable\"><thead><tr><th>\n\nkey\n\n</th><th>\n\nvalue 对应的字段类型\n\n</th><th>\n\n含义\n\n</th></tr></thead><tbody><tr><td>\n\n\"codeColumn\"\n\n</td><td>\n\nSYMBOL\n\n</td><td>\n\n标的代码（如300010.SZ）\n\n</td></tr><tr><td>\n\n\"timeColumn\"\n\n</td><td>\n\nTIME\n\n</td><td>\n\n交易时间\n\n</td></tr><tr><td>\n\n\"typeColumn\"\n\n</td><td>\n\nINT\n\n</td><td>\n\n交易类型：-   如果是逐笔委托单，则：1 表示市价；2 表示限价；3 表示本方最优；10 表示撤单（仅上交所）；11 市场状态（仅上交所）\n\n* 如果是逐笔成交单，则：0 表示成交；1 表示撤单（仅深交所）\n\n</td></tr><tr><td>\n\n\"priceColumn\"\n\n</td><td>\n\nLONG\n\n</td><td>\n\n价格，由 *priceScale* 决定，默认是真实价格\\*10000\n\n</td></tr><tr><td>\n\n\"qtyColumn\"\n\n</td><td>\n\nLONG\n\n</td><td>\n\n数量（股数）\n\n</td></tr><tr><td>\n\n\"buyOrderColumn\"\n\n</td><td>\n\nLONG\n\n</td><td>\n\n* 逐笔成交：对应其原始成交中的买方委托序号。\n* 逐笔委托：\n  * 上交所：填充原始委托中的原始订单号，即上交所在新增、删除订单时用以标识订单的唯一编号（OrderNo 字段）\n  * 深交所：填充 0。此字段为深交所为了补全上交所数据格式而增加的冗余列\n\n</td></tr><tr><td>\n\n\"sellOrderColumn\"\n\n</td><td>\n\nLONG\n\n</td><td>\n\n* 逐笔成交：对应其原始成交中的卖方委托序号。\n* 逐笔委托：\n  * 上交所：填充原始委托中的原始订单号，即上交所在新增、删除订单时用以标识订单的唯一编号（OrderNo 字段）\n  * 深交所：填充 0。此字段深交所为了补全上交所数据格式而增加的冗余列\n\n</td></tr><tr><td>\n\n\"sideColumn\"\n\n</td><td>\n\nINT\n\n</td><td>\n\n买卖方向：1 表示买单；2 表示卖单说明：\n\n* 委托单的 BSFlag，必填\n* 撤单的 BSFlag 由原始委托单决定买卖方向，必填\n* 成交单的 BSFlag，不影响结果，非必填\n\n</td></tr><tr><td>\n\n\"msgTypeColumn\"\n\n</td><td>\n\nINT\n\n</td><td>\n\n数据类型：-   0 表示逐笔委托；\n\n* 1 表示逐笔成交；\n* -1 表示产品状态。\n\n</td></tr><tr><td>\n\n\"seqColumn\"\n\n</td><td>\n\nLONG\n\n</td><td>\n\n一个通道内从 1 开始递增的逐笔数据序号。深交所为 appseqlnum 字段，若深交所数据中包含 index 字段，也可以使用 index；上交所为 bizIndex 字段。\n\n</td></tr><tr><td>\n\n\"receiveTime\"\n\n</td><td>\n\nNANOTIMESTAMP\n\n</td><td>\n\n逐笔数据的接收时间\n\n</td></tr></tbody>\n</table>**Note:** 引擎规范了枚举类型中各枚举值的具体含义。输入表对应的枚举值必须遵守这个规范。比如枚举类型字段 sideColumn 所对应的输入表中的字段必须使用 1 代表买方向，2 代表卖方向。\n\n**outputColMap** 可选参数，字符串向量，用于指定需要输出的字段名称，不区分大小写。为方便指定 *outputColMap*，用户可通过 `genOutputColumnsForOBSnapshotEngine` 函数生成需要输出的字段名称，将返回值的第一个元素赋值给 *outputColMap* 即可。\n\n**Note:** `genOutputColumnsForOBSnapshotEngine`函数生成的字段列表中不包含以下字段：\n\n* tradeDetail（成交明细）中的 tradeBuyOrderTypeList 和 tradeSellOrderTypeList。\n\n* withdrawDetail（撤单明细）中的 withdrawBuyOrderNoList和withdrawSellOrderNoList。\n\n* residualDetail（剩余委托明细）中的 ResidualBidOrderNoList 和 ResidualAskOrderNoList。\n\n如需要输出上述字段，请在 *outputColMap* 中手动添加。\n\n**outputCodeMap** 可选参数，字符串向量，表示股票代码，例如：\"000803.SZ\"。指定该参数后，将只输出指定股票对应的数据。\n\n**outputIntervalOffsetMap** 可选参数，向量或字典，用于指定输出表中股票被触发计算的时间偏移量（单位：毫秒）。\n\n* **计算逻辑**：引擎会根据偏移量重新定义各股票的快照边界。第一个窗口会自动包含从 *startTime* 到 *startTime + intervalInMilli + offset* 之间的所有逐笔数据，从而确保偏移期间产生的数据被纳入当条快照计算。\n* **向量形式**：引擎将根据输入的股票数量自动将这些股票均匀分配到这些偏移量上。例如，`outputIntervalOffsetMap = [400, 500]`，表示引擎将自动将输入的股票均匀分成两部分，经过 intervalInMilli + 400(ms) 后触发其中一部分股票的数据输出；经过 intervalInMilli + 500(ms) 后触发另一部分股票的数据输出。\n* **字典形式**： key 为字符串类型，表示股票代码；其 value 为整型，表示时间偏移量。例如：`outputIntervalOffsetMap =dict([\"127053.sz\",\"123082.SZ\"],[400, 500])`，表示经过 intervalInMilli + 400(ms) 后触发 127053.sz 股票的数据输出；经过 intervalInMilli + 500(ms) 后触发 123082.SZ 股票的数据输出。\n\n**checkRestrict** 可选参数，布尔值，默认值为 true，表示开启价格笼子机制；若设置为 false，则关闭笼子机制，此时会取消对股票交易的限制，创业板合成出的快照可能不正确。\n\n**Note:** 深交所对创业板标的（标的代码以 3 开头）设定了价格笼子。在 *checkRestrict*=true 时，引擎只会将标的代码的首字符是否为 3 作为是否执行价格笼子的判断标准。因此，在向引擎输入创业板数据时，标的代码必须以 3 开头。\n\n**maxPrice** 可选参数，字典。其 key 为字符串类型，表示标的代码；其 value 为 DOUBLE 或 INT 类型，表示涨停价格。注意：若 *maxPrice* 为浮点型，则认为是真实价格，引擎处理过程中会乘以 *priceScale*，以匹配输入表中 priceColumn 字段的精度。若为整型，则视为已和 priceColumn 具备相同精度，不再进行缩放。\n\n**minPrice** 可选参数，字典。其 key 为字符串类型，表示标的代码；其 value 为 DOUBLE 或 INT 类型，表示跌停价格。注意：若 *minPrice* 为浮点型，则认为是真实价格，引擎处理过程中会乘以 *priceScale*，以匹配输入表中 priceColumn 字段的精度。若为整型，则视为已和 priceColumn 具备相同精度，不再进行缩放。\n\n**userDefinedMetrics** 可选参数，一元函数。\n\n* 函数的入参是一个表，表的每一行是一个标的，每一列是标的对应的快照。若指定 *outputColMap*，则表中数据为 *outputColMap*设置的字段；否则表中数据为基础字段和报价/询价的价格和数量。\n\n* 函数的返回值是一个元组，元组的每一个元素是一个常规向量，代表每个标的经对应指标计算后的结果。\n\n**priceNullFill** 一个数字。该参数值用于填充输出表中多档买/卖价格中缺失档位的价格。例如涨停后卖单的价格都为 NULL，此时如有指定卖单价格为 0 的需求，可以设置 priceNullFill=0。\n\n**triggerType** 可选参数，字符串标量，表示触发方式。可选值为：\n\n* \"mutual\"（默认值）：新收到任意一条逐笔数据，当其时间戳大于窗口右边界时，就会触发所有股票未计算的快照合成输出。触发计算的数据并不会参与该次计算。\n* \"independent\"：新收到任意一条逐笔数据，当其时间戳大于窗口右边界时，只触发该条数据对应股票未计算的快照合成输出。触发计算的数据并不会参与该次计算。\n* \"perRow\"：每收到一行逐笔数据都会触发该条数据对应股票计算并输出，触发计算的数据并参与该次计算。\n\n**forceTriggerTime** 可选参数，是非负整数，单位为毫秒。除了正常触发合成快照外，有时会出现一些数据因乱序不能触发合成快照，而是被缓存在引擎中。在这种情况下，可通过该参数设置强制触发引擎中长时间未处理的逐笔数据合成快照。触发规则为：\n\n1. 最新收到的逐笔数据的时间戳（t ）减去最后一条已经处理的交易数据的时间戳（t0 ）大于或等于 *forceTriggerTime*，则触发未处理的数据中序号最小的那条数据合成快照，并更新已经处理的交易数据的时间戳（t1）。\n2. 重复上述操作，若判断 t-t1 >= *forceTriggerTime*，则触发未处理的数据中序号最小的那条数据合成快照，并更新已经处理的交易数据的时间戳（t2）；直到两个时间戳的差值小于 *forceTriggerTime*时，停止触发快照合成。\n\n**precision** 可选参数，整数，表示小数位数，取值范围为\\[-1,4]。\n\n* 当 *precision*=-1 时，引擎输出的价格相关字段为整型。注意：输出表中相应的字段可以是整型或非整型。\n* 当 *precision* 取 \\[0, 4] 中的值时，表示小数位数。输出表中所有的价格将按照指定的位数进行四舍五入。否则，按照原始结果输出。\n\n**orderBySeq** 可选参数，布尔值或元组。\n\n* 指定该参数值为布尔值时，表示是否按照逐笔数据中的 seqColumn 列中值的大小顺序处理数据。当 *exchange*=\"XSHG\" 或 \"XSHGFUND\" 时，默认值为 true；在其他情况下，默认值为 false。\n  * 当 *orderBySeq*=true 时，会根据逐笔数据的序号有序处理数据，并计算输出。例如引擎先后收到序号为1，3的数据，因为缺少序号为2的数据，引擎先将1和3的数据缓存，待收到序号2的数据时，再进行计算输出。此时也可以指定 *forceTriggerTime*强制触发计算输出。\n  * 当 *orderBySeq*=false 时，每接收到一条数据都会立即进行计算并输出，此时不可设置 *forceTriggerTime*。\n* 指定该参数值为元组时，以（BOOL, INTEGER, \\[STRING]）的形式表示，其中：\n  * 第一个元素为布尔值，表示是否按照逐笔数据的序号有序输出结果的布尔值，作用同上。\n  * 第二个元素为正整数，表示记录缓存输入数据量的时间间隔，单位为毫秒（ms）。\n  * 第三个元素为指定输出日志级别的字符串标量，可选参数，其可用值为 DEBUG （默认值）和 INFO，分别对应 Debug 和 Info 级别的日志输出。\n\n**skipCrossedMarket**可选参数， 布尔值，表示是否输出买一卖一价交叉的计算结果。\n\n* 当 *skipCrossedMarket*=true（默认值）时，若设置 *useSystemTime* = false，若出现买一卖一价交叉，即卖一价<=买一价，则不输出该条结果；若设置 *useSystemTime* = true，则出现买一卖一交叉时，暂时不输出该条快照，若接下来收到的数据不再有交叉，则立即触发该条快照输出。\n* 当 *skipCrossedMarket*=false 时，若出现买一卖一价交叉，仍然输出该条结果。\n\n**orderBookDetailDepth** 可选参数，整型标量，表示 orderbook 明细的深度。默认值为0，表示不输出。该参数必须和 *outputColMap* 中 orderBookDetailDepth 字段的值保持一致。\n\n**orderBookAsArray** 可选参数，布尔值，表示是否以数组向量形式输出报价/询价的价格和数量。默认值为 false，价格和数量将以多列形式输出。\n\n注意，若指定 *userDefinedMetrics*，价格和数量的输出形式由 *orderBookAsArray* 确定。否则，价格和数量的输出形式由 *outputColMap* 确定，该参数失效。\n\n**useSystemTime** 可选参数，布尔值，表示是否使用系统时间来触发快照输出。\n\n* 当 *useSystemTime* = true 时，交易时段内，引擎将基于当前的系统时间，按照 *intervalInMilli* 设置的时间间隔触发快照输出。此时，休盘时段（(11:30:00.000，13:00:00.000]）不输出数据，下午盘第一个输出窗口时间戳为 13:00:00.000+*intervalInMilli*。注意，若设置 *useSystemTime* = true，则不能指定 *forceTriggerTime*；可以不指定 *triggerType*，或者指定为 *triggerType*=\"mutual\"\n* 当 *useSystemTime* = false（缺省值）时，引擎根据事件时间来触发快照输出。\n\n**independentForceTriggerTime** 可选参数，非负整数，单位为毫秒。该参数用于设置在长时间未触发快照输出的分组中，强制输出快照的时间间隔。仅当设置 *triggerType*=\"independent\" 时，该参数才会生效。\n\n举例说明：假设在当前已处理的数据中，最新一条数据的时间为 t。各个分组内已处理的应被触发输出的快照时间为 ti。如果满足 t-ti>*independentForceTriggerTime*，则会触发输出相应分组的快照。\n\n**includeImmediateExecution** 可选参数，布尔值，默认值为 false，表示是否将即时成交的信息统计到委托明细（orderDetail）中。此设置仅在合成上交所订单簿时有效，且适用于股票和基金数据（*exchange* 指定为 \"XSHG\", \"XSHGSTOCK\" 或 \"XSHGFUND\"）。\n\n**Note:** 注意：若该配置项设置为 true，则 **inputColMap** 必须保证输入数据中的 OrderNo 全局有序。同时，确保即时成交记录中的未被记录的 orderNo 大于等于当前最新记录的 OrderNo。\n\n**securitySubType** 字符串标量（不区分大小写），用于指定生成订单簿的标的子类型，仅适用于*exchange* 为 \"XSHEBOND\" 或 \"XSHGBOND\" 的情况。可选值为：\n\n* \"ConvertibleBond\"（默认）：对于 \"XSHEBOND\" 订单簿仅包含代码前缀为 \"123\"，\"127\"，\"128\" 的债券；对于 “XSHGBOND” 订单簿仅包含代码前缀为 \"110\"，\"111\"，\"113\"，\"118\" 的债券。\n* \"All\"：包含所有债券，无前缀限制。\n\n**priceScale** 一个正整数，表示输入表中 priceColumn 列的缩放比例，默认值为 10000。引擎输出时会将计算结果除以 *priceScale*。\n\n**endTime**可选参数，TIME 类型标量，指定快照输出的最后一个窗口的的右边界上限。即，仅当窗口右边界时间戳小于*endTime*时，才会输出该窗口对应的快照数据。\n\n仅在 *triggerType* = \"mutual\" 时支持设置该参数。若不设置，当 *exchange* = “XSHGBOND” 时，*endTime* 默认值为 15:00:00.000；当 *exchange* 是其它值时，*endTime* 默认值为14:57:00.000。\n\n若要开启快照机制 (snapshot)，必须指定 *snapshotDir* 与 *snapshotIntervalInMsgCount*。\n\n**snapshotDir** 可选参数，字符串，表示保存引擎快照的文件目录。\n\n* 指定的目录必须存在，否则系统会提示异常。\n\n* 创建流数据引擎时，如果指定了 *snapshotDir*，会检查该目录下是否存在快照。如果存在，会加载该快照，恢复引擎的状态。\n\n* 多个引擎可以指定同一个目录存储快照，用引擎的名称来区分快照文件。\n\n* 一个引擎的快照可能会使用三个文件名：\n\n  * 临时存储快照信息：文件名为 *\\<engineName>.tmp*；\n\n  * 快照生成并刷到磁盘：文件保存为 *\\<engineName>.snapshot*；\n\n  * 存在同名快照：旧快照自动重命名为 *\\<engineName>.old*。\n\n**snapshotIntervalInMsgCount** 可选参数，为整数类型，表示每隔多少条数据保存一次流数据引擎快照。\n\n#### 返回值\n\n返回一个表。\n\n#### 例子\n\n运行代码前，先下载 [../data/orderbookDemoInput.zip](https://docs.dolphindb.cn/zh/funcs/data/orderbookDemoInput.zip) 文件。\n\n例 1. 本例展示 `createOrderBookSnapshotEngine` 函数的基础应用：将历史逐笔数据合成高频订单簿。本例创建引擎时设置了每1秒计算输出深交所股票10档买卖盘口，展示了完整的数据处理流程，包括数据加载、引擎创建、数据注入和结果验证。\n\n```\n// 登录\nlogin(\"admin\", \"123456\")\n\n// 释放已有的引擎\ntry { dropStreamEngine(\"demo\") } catch(ex) { print(ex) }\n\n// 创建引擎参数 outputTable，即指定输出表\nsuffix = string(1..10)\ncolNames = `SecurityID`timestamp`lastAppSeqNum`tradingPhaseCode`modified`turnover`volume`tradeNum`totalTurnover`totalVolume`totalTradeNum`lastPx`highPx`lowPx`ask`bid`askVol`bidVol`preClosePx`invalid  join (\"bids\" + suffix) join (\"bidVolumes\" + suffix) join (\"bidOrderNums\" + suffix) join (\"asks\" + suffix)  join (\"askVolumes\" + suffix) join (\"askOrderNums\" + suffix) \ncolTypes = [SYMBOL,TIMESTAMP,LONG,INT,BOOL,DOUBLE,LONG,INT,DOUBLE,LONG,INT,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,LONG,LONG,DOUBLE,BOOL] join take(DOUBLE, 10) join take(LONG, 10) join take(INT, 10) join take(DOUBLE, 10) join take(LONG, 10) join take(INT, 10) \nshare table(10000000:0, colNames, colTypes) as outTable\n\n// 创建引擎参数 dummyTable，即指定输入表的表结构\ncolNames = `SecurityID`Date`Time`SecurityIDSource`SecurityType`Index`SourceType`Type`Price`Qty`BSFlag`BuyNo`SellNo`ApplSeqNum`ChannelNo\ncolTypes = [SYMBOL, DATE, TIME, SYMBOL, SYMBOL, LONG, INT, INT, LONG, LONG, INT, LONG, LONG, LONG, INT]\ndummyOrderStream = table(1:0, colNames, colTypes)\n\n// 创建引擎参数 inputColMap，即指定输入表各字段的含义\ninputColMap = dict(`codeColumn`timeColumn`typeColumn`priceColumn`qtyColumn`buyOrderColumn`sellOrderColumn`sideColumn`msgTypeColumn`seqColumn, `SecurityID`Time`Type`Price`Qty`BuyNo`SellNo`BSFlag`SourceType`ApplSeqNum)\n\n// 创建引擎参数 prevClose，即昨日收盘价，prevClose 不影响最终的输出结果中除昨日收盘价以外的其他字段\nprevClose = dict(`000587.SZ`002694.SZ`002822.SZ`000683.SZ`301063.SZ`300459.SZ`300057.SZ`300593.SZ`301035.SZ`300765.SZ, [1.66, 6.56, 6.10, 8.47, 38.10, 5.34, 9.14, 48.81, 60.04, 16.52])\n\n// 定义引擎，每1s计算输出深交所股票10档买卖盘口\nengine = createOrderBookSnapshotEngine(name=\"demo\", exchange=\"XSHE\", orderbookDepth=10, intervalInMilli = 1000, date=2022.01.10, startTime=09:15:00.000, prevClose=prevClose, dummyTable=dummyOrderStream, outputTable=outTable, inputColMap=inputColMap)\n\nfilePath = \"./orderbookDemoInput.csv\"\ncolNames = `SecurityID`Date`Time`SecurityIDSource`SecurityType`Index`SourceType`Type`Price`Qty`BSFlag`BuyNo`SellNo`ApplSeqNum`ChannelNo\ncolTypes = [SYMBOL, DATE, TIME, SYMBOL, SYMBOL, LONG, INT, INT, LONG, LONG, INT, LONG, LONG, LONG, INT]\norderTrade = table(1:0, colNames, colTypes)\norderTrade.append!(select * from loadText(filePath) order by Time)\n\n// 10支股票的逐笔数据批量注入快照合成引擎\nengine.append!(orderTrade)\nselect count(*) from outTable where SecurityID=\"300593.SZ\", timestamp between 2022.01.10T13:15:01.000 and 2022.01.10T13:15:10.000\n\n//output: 10\n```\n\n例 2. 本例将展示价格控制与输出过滤功能，关键参数设置如下：\n\n* 通过 *maxPrice* 和 *minPrice*设置涨跌停价格\n* *priceNullFill*=0 设置缺失价格的填充为 0\n* *priceScale* 和 *precision* 分别设置价格缩放比例，和输出价格的小数位数\n* 设置 *skipCrossedMarket*=false，允许输出买卖价交叉的结果\n\n```\ntry { dropStreamEngine(\"demo\") } catch(ex) { print(ex) }  \n  \nfilePath = \"./orderbookDemoInput.csv\"  \n  \n// 创建引擎参数 dummyTable  \ncolNames = `SecurityID`Date`Time`SecurityIDSource`SecurityType`Index`SourceType`Type`Price`Qty`BSFlag`BuyNo`SellNo`ApplSeqNum`ChannelNo  \ncolTypes = [SYMBOL, DATE, TIME, SYMBOL, SYMBOL, LONG, INT, INT, LONG, LONG, INT, LONG, LONG, LONG, INT]  \nshare table(1:0, colNames, colTypes) as dummyOrderStream  \n  \n// 创建引擎参数 inputColMap  \ninputColMap = dict(`codeColumn`timeColumn`typeColumn`priceColumn`qtyColumn`buyOrderColumn`sellOrderColumn`sideColumn`msgTypeColumn`seqColumn, `SecurityID`Time`Type`Price`Qty`BuyNo`SellNo`BSFlag`SourceType`ApplSeqNum)  \n  \n// 创建引擎参数 prevClose  \nprevClose = dict(`000587.SZ`002694.SZ`002822.SZ`000683.SZ`301063.SZ`300459.SZ`300057.SZ`300593.SZ`301035.SZ`300765.SZ, [1.66, 6.56, 6.10, 8.47, 38.10, 5.34, 9.14, 48.81, 60.04, 16.52])  \n  \n// 设置涨停价和跌停价（真实价格，引擎会自动乘以 priceScale）  \nmaxPrice = dict(`000587.SZ`002694.SZ`002822.SZ, [1.83, 7.22, 6.71])  \nminPrice = dict(`000587.SZ`002694.SZ`002822.SZ, [1.49, 5.90, 5.49])  \n  \n// 指定只输出特定股票的代码  \noutputCodeMap = `000587.SZ`002694.SZ`002822.SZ  \n  \n// 创建输出表结构  \noutputColMap, outputTableSch = genOutputColumnsForOBSnapshotEngine(basic=true, time=false, depth=(10, true), tradeDetail=true, orderDetail=false, withdrawDetail=false, orderBookDetailDepth=0, prevDetail=false)  \n  \n// 创建引擎，设置价格相关参数和输出过滤  \nengine = createOrderBookSnapshotEngine(  \n    name=\"demo\",   \n    exchange=\"XSHE\",   \n    orderbookDepth=10,   \n    intervalInMilli = 1000,   \n    date=2022.01.10,   \n    startTime=09:15:00.000,   \n    prevClose=prevClose,   \n    dummyTable=dummyOrderStream,   \n    outputTable=outputTableSch,   \n    inputColMap=inputColMap,   \n    outputColMap=outputColMap,  \n    outputCodeMap=outputCodeMap,  // 只输出指定股票  \n    maxPrice=maxPrice,          // 设置涨停价  \n    minPrice=minPrice,          // 设置跌停价  \n    priceNullFill=0,            // 缺失价格填充为0  \n    priceScale=10000,           // 价格缩放比例  \n    precision=2,                // 价格保留2位小数  \n    skipCrossedMarket=false     // 允许输出买卖价交叉的结果  \n)  \n  \n// 注入数据  \nengine.append!(select * from loadText(filePath) order by Time)  \nselect top 10 * from outputTableSch where code in outputCodeMap, timestamp between 2022.01.10T13:15:01.000 and 2022.01.10T13:15:10.000\n```\n\n例 3. 本例将展示引擎触发机制和时间控制功能，关键参数设置：\n\n* *triggerType*=\"independent\" 设置为独立触发模式\n* *forceTriggerTime* 设置强制触发时间间隔\n* *orderBySeq*=true 确保按序号顺序处理数据\n* *independentForceTriggerTime* 为独立触发模式设置分组强制触发时间\n\n```\ntry { dropStreamEngine(\"demo\") } catch(ex) { print(ex) }  \n  \nfilePath = \"./orderbookDemoInput.csv\"  \n  \n// 创建引擎参数 dummyTable  \ncolNames = `SecurityID`Date`Time`SecurityIDSource`SecurityType`Index`SourceType`Type`Price`Qty`BSFlag`BuyNo`SellNo`ApplSeqNum`ChannelNo  \ncolTypes = [SYMBOL, DATE, TIME, SYMBOL, SYMBOL, LONG, INT, INT, LONG, LONG, INT, LONG, LONG, LONG, INT]  \nshare table(1:0, colNames, colTypes) as dummyOrderStream  \n  \n// 创建引擎参数 inputColMap  \ninputColMap = dict(`codeColumn`timeColumn`typeColumn`priceColumn`qtyColumn`buyOrderColumn`sellOrderColumn`sideColumn`msgTypeColumn`seqColumn, `SecurityID`Time`Type`Price`Qty`BuyNo`SellNo`BSFlag`SourceType`ApplSeqNum)  \n  \n// 创建引擎参数 prevClose  \nprevClose = dict(`000587.SZ`002694.SZ`002822.SZ`000683.SZ`301063.SZ`300459.SZ`300057.SZ`300593.SZ`301035.SZ`300765.SZ, [1.66, 6.56, 6.10, 8.47, 38.10, 5.34, 9.14, 48.81, 60.04, 16.52])  \n    \n// 创建输出表结构  \noutputColMap, outputTableSch = genOutputColumnsForOBSnapshotEngine(basic=true, time=false, depth=(10, true), tradeDetail=true, orderDetail=false, withdrawDetail=false, orderBookDetailDepth=0, prevDetail=false)  \n  \n// 创建引擎，设置触发机制和时间控制  \nengine = createOrderBookSnapshotEngine(  \n    name=\"demo\",   \n    exchange=\"XSHE\",   \n    orderbookDepth=10,   \n    intervalInMilli = 1000,   \n    date=2022.01.10,   \n    startTime=09:15:00.000,   \n    prevClose=prevClose,   \n    dummyTable=dummyOrderStream,   \n    outputTable=outputTableSch,   \n    inputColMap=inputColMap,   \n    outputColMap=outputColMap,  \n    triggerType=\"independent\",                      // 独立触发模式  \n    forceTriggerTime=5000,                          // 5秒后强制触发  \n    orderBySeq=true,                                // 按序号顺序处理  \n    independentForceTriggerTime=3000                // 独立分组的强制触发时间  \n)  \n\n// 注入数据  \nengine.append!(select * from loadText(filePath) order by Time)  \nselect top 10 * from outputTableSch where timestamp between 2022.01.10T13:15:01.000 and 2022.01.10T13:15:10.000\n```\n\n例 4. 本例通过 *outputIntervalOffsetMap* 参数为特定股票指定不同的时间偏移量。因 *outputIntervalOffsetMap* 不能与 *triggerType*=\"independent\" 或 *triggerType*=\"perRow\" 同时使用，本例中设置 *triggerType*=\"mutual\"（默认值）。\n\n```\ntry { dropStreamEngine(\"demo\") } catch(ex) { print(ex) }  \n  \nfilePath = \"./orderbookDemoInput.csv\"  \n  \n// 创建引擎参数 dummyTable  \ncolNames = `SecurityID`Date`Time`SecurityIDSource`SecurityType`Index`SourceType`Type`Price`Qty`BSFlag`BuyNo`SellNo`ApplSeqNum`ChannelNo  \ncolTypes = [SYMBOL, DATE, TIME, SYMBOL, SYMBOL, LONG, INT, INT, LONG, LONG, INT, LONG, LONG, LONG, INT]  \nshare table(1:0, colNames, colTypes) as dummyOrderStream  \n  \n// 创建引擎参数 inputColMap  \ninputColMap = dict(`codeColumn`timeColumn`typeColumn`priceColumn`qtyColumn`buyOrderColumn`sellOrderColumn`sideColumn`msgTypeColumn`seqColumn, `SecurityID`Time`Type`Price`Qty`BuyNo`SellNo`BSFlag`SourceType`ApplSeqNum)  \n  \n// 创建引擎参数 prevClose  \nprevClose = dict(`000587.SZ`002694.SZ`002822.SZ`000683.SZ`301063.SZ`300459.SZ`300057.SZ`300593.SZ`301035.SZ`300765.SZ, [1.66, 6.56, 6.10, 8.47, 38.10, 5.34, 9.14, 48.81, 60.04, 16.52])  \n  \n// 设置输出时间偏移（字典形式）- 为不同股票设置不同的输出时间偏移  \noutputIntervalOffsetMap = dict(`000587.SZ`002694.SZ`002822.SZ, [100, 200, 300])  // 不同股票有100ms、200ms、300ms的偏移  \n  \n// 创建输出表结构  \noutputColMap, outputTableSch = genOutputColumnsForOBSnapshotEngine(basic=true, time=false, depth=(10, true), tradeDetail=true, orderDetail=false, withdrawDetail=false, orderBookDetailDepth=0, prevDetail=false)  \n  \n// 创建引擎，使用默认的 triggerType=\"mutual\" 来配合 outputIntervalOffsetMap  \nengine = createOrderBookSnapshotEngine(  \n    name=\"demo\",   \n    exchange=\"XSHE\",   \n    orderbookDepth=10,   \n    intervalInMilli = 1000,   \n    date=2022.01.10,   \n    startTime=09:15:00.000,   \n    prevClose=prevClose,   \n    dummyTable=dummyOrderStream,   \n    outputTable=outputTableSch,   \n    inputColMap=inputColMap,   \n    outputColMap=outputColMap,  \n    outputIntervalOffsetMap=outputIntervalOffsetMap  // 设置时间偏移  \n)  \n  \n// 注入数据  \nengine.append!(select * from loadText(filePath) order by Time)  \n  \n// 查看不同股票的输出时间戳差异  \nselect * from outputTableSch where code in `000587.SZ`002694.SZ`002822.SZ, timestamp between 2022.01.10T13:15:00.000 and 2022.01.10T13:15:02.000 order by code, timestamp\n```\n\n部分结果展示如下：\n\n![](https://docs.dolphindb.cn/zh/images/orderBook3.png)\n\n例 5. 通过 *outputColMap*指定需要输出的字段。`genOutputColumnsForOBSnapshotEngine` 函数返回值的第一个元素即为 *outputColMap*，返回值的第二个元素可以确定 *outputTable* 的 schema。\n\n```\ntry { dropStreamEngine(\"demo\") } catch(ex) { print(ex) }\n\nfilePath = \"./orderbookDemoInput.csv\"\n\n// 创建引擎参数 dummyTable，即指定输入表的表结构\ncolNames = `SecurityID`Date`Time`SecurityIDSource`SecurityType`Index`SourceType`Type`Price`Qty`BSFlag`BuyNo`SellNo`ApplSeqNum`ChannelNo\ncolTypes = [SYMBOL, DATE, TIME, SYMBOL, SYMBOL, LONG, INT, INT, LONG, LONG, INT, LONG, LONG, LONG, INT]\nshare table(1:0, colNames, colTypes) as dummyOrderStream\n\n// 创建引擎参数 inputColMap，即指定输入表各字段的含义\ninputColMap = dict(`codeColumn`timeColumn`typeColumn`priceColumn`qtyColumn`buyOrderColumn`sellOrderColumn`sideColumn`msgTypeColumn`seqColumn, `SecurityID`Time`Type`Price`Qty`BuyNo`SellNo`BSFlag`SourceType`ApplSeqNum)\n\n// 创建引擎参数 prevClose，即昨日收盘价，prevClose 不影响最终的输出结果中除昨日收盘价以外的其他字段\nprevClose = dict(`000587.SZ`002694.SZ`002822.SZ`000683.SZ`301063.SZ`300459.SZ`300057.SZ`300593.SZ`301035.SZ`300765.SZ, [1.66, 6.56, 6.10, 8.47, 38.10, 5.34, 9.14, 48.81, 60.04, 16.52])\n\n//创建使用 outputColMap 和 outputTableSch 接收 genOutputColumnsForOBSnapshotEngine 的返回值。它们分别用于确定 outputColMap 和 outputTable\noutputColMap, outputTableSch = genOutputColumnsForOBSnapshotEngine(basic=true, time=false, depth=(10, true), tradeDetail=true, orderDetail=false, withdrawDetail=false, orderBookDetailDepth=0, prevDetail=false)\n\nengine = createOrderBookSnapshotEngine(name=\"demo\", exchange=\"XSHE\", orderbookDepth=10, intervalInMilli = 1000, date=2022.01.10, startTime=09:15:00.000, prevClose=prevClose, dummyTable=dummyOrderStream, outputTable=outputTableSch, inputColMap=inputColMap, outputColMap=outputColMap, orderBookAsArray=true)\n\n// 10支股票的逐笔数据批量注入快照合成引擎\nengine.append!(select * from loadText(filePath) order by Time)\nselect top 10 * from outputTableSch where code=\"300593.SZ\", timestamp between 2022.01.10T13:15:01.000 and 2022.01.10T13:15:10.000\n```\n\n部分结果展示如下：\n\n![](https://docs.dolphindb.cn/zh/images/orderBook1.png)\n\n可结合 `genOutputColumnsForOBSnapshotEngine`，输出部分需要的字段。假如我们只需要输出示例中 `tradeDetail` 的部分字段（如排除最后 4 列），可对 `genOutputColumnsForOBSnapshotEngine` 的返回值进行如下处理：\n\n```\noutputColMap = outputColMap[0 : (size(outputColMap) - 4)]\noutputTableSch = outputTableSch[, 0 : (outputTableSch.columns() - 4)]\nengine = createOrderBookSnapshotEngine(name=\"demo\", exchange=\"XSHE\", orderbookDepth=10, intervalInMilli = 1000, date=2022.01.10, startTime=09:15:00.000, prevClose=prevClose, dummyTable=dummyOrderStream, outputTable=outputTableSch, inputColMap=inputColMap, outputColMap=outputColMap, orderBookAsArray=true)\n```\n\n例 6. 本例通过 *userDefinedMetrics* 参数为引擎添加自定义量化指标计算功能，实现除标准订单簿数据外的自定义指标输出。\n\n```\ntry { dropStreamEngine(\"demo\") } catch(ex) { print(ex) }\n\nfilePath = \"./orderbookDemoInput.csv\"\n\n// 创建引擎参数 dummyTable，即指定输入表的表结构\ncolNames = `SecurityID`Date`Time`SecurityIDSource`SecurityType`Index`SourceType`Type`Price`Qty`BSFlag`BuyNo`SellNo`ApplSeqNum`ChannelNo`ReceiveTime\ncolTypes = [SYMBOL, DATE, TIME, SYMBOL, SYMBOL, LONG, INT, INT, LONG, LONG, INT, LONG, LONG, LONG, INT, NANOTIMESTAMP]\nshare table(1:0, colNames, colTypes) as dummyOrderStream\n\n// 创建引擎参数 inputColMap，即指定输入表各字段的含义\ninputColMap = dict(`codeColumn`timeColumn`typeColumn`priceColumn`qtyColumn`buyOrderColumn`sellOrderColumn`sideColumn`msgTypeColumn`seqColumn`receiveTime, `SecurityID`Time`Type`Price`Qty`BuyNo`SellNo`BSFlag`SourceType`ApplSeqNum`ReceiveTime)\n\n// 创建引擎参数 prevClose，即昨日收盘价，prevClose 不影响最终的输出结果中除昨日收盘价以外的其他字段\nprevClose = dict(`000587.SZ`002694.SZ`002822.SZ`000683.SZ`301063.SZ`300459.SZ`300057.SZ`300593.SZ`301035.SZ`300765.SZ, [1.66, 6.56, 6.10, 8.47, 38.10, 5.34, 9.14, 48.81, 60.04, 16.52])\n\n//此处只定义 outputColMap 接收 genOutputColumnsForOBSnapshotEngine 的第一个返回值。因 userDefinedMetrics 定义的指标中需要使用委托明细和回撤明细，因此 genOutputColumnsForOBSnapshotEngine  需要指定 orderDetail=false, withdrawDetail=true\noutputColMap = genOutputColumnsForOBSnapshotEngine(basic=true, time=false, depth=(10, true), tradeDetail=true, orderDetail=false, withdrawDetail=true, orderBookDetailDepth=0, prevDetail=false)[0]\n\n\n//// 定义用户自定义因子\ndef userDefinedFunc(t){\n        AvgBuyDuration = rowAvg(t.TradeMDTimeList-t.TradeOrderBuyNoTimeList).int()\n        AvgSellDuration = rowAvg(t.TradeMDTimeList-t.TradeOrderSellNoTimeList).int()        \n        BuyWithdrawQty = rowSum(t.WithdrawBuyQtyList)\n        SellWithdrawQty = rowSum(t.WithdrawSellQtyList)\n        return (AvgBuyDuration, AvgSellDuration, BuyWithdrawQty, SellWithdrawQty)\n}\n\n// 定义 orderbook 引擎的输出表，需要包含基础字段（basic），报价/询价的多档价格和数量（depth），userDefinedMetrics 自定义指标的输出结果\noutputTableSch = genOutputColumnsForOBSnapshotEngine(basic=true, time=false, depth=(10, true), tradeDetail=false, orderDetail=false, withdrawDetail=false, orderBookDetailDepth=0, prevDetail=false)[1]\ncolNames = outputTableSch.schema().colDefs.name join (`AvgBuyDuration`AvgSellDuration`BuyWithdrawQty`SellWithdrawQty)\ncolTypes = outputTableSch.schema().colDefs.typeString join (`INT`INT`INT`INT) \noutputTable = table(1:0, colNames, colTypes)\n\n// 创建引擎，每1s计算输出深交所股票10档 orderbook \n\nengine = createOrderBookSnapshotEngine(name=\"demo\", exchange=\"XSHE\", orderbookDepth=10, intervalInMilli = 1000, date=2022.01.10, startTime=09:30:00.000, prevClose=prevClose, dummyTable=dummyOrderStream, outputTable=outputTable, inputColMap=inputColMap, outputColMap=outputColMap, orderBookAsArray=true, userDefinedMetrics=userDefinedFunc)\n\nt = select * from loadText(filePath) order by Time\nupdate t set ReceiveTime = now(true) // 构造接收时间列\n\ngetStreamEngine(\"demo\").append!(t)\n\nselect top 10 * from outputTable where code=\"300593.SZ\", timestamp between 2022.01.10T13:15:01.000 and 2022.01.10T13:15:10.000\n```\n\n部分结果展示如下：\n\n![](https://docs.dolphindb.cn/zh/images/orderBook2.png)\n\n相关函数：[genOutputColumnsForOBSnapshotEngine](https://docs.dolphindb.cn/zh/funcs/g/genoutputcolumnsforobsnapshotengine.html)\n\n相关教程：[基于逐笔数据合成高频 Orderbook：DolphinDB Orderbook 引擎](https://docs.dolphindb.cn/zh/tutorials/orderBookSnapshotEngine.html)\n\n#### 附录\n\n**basic（基础字段）**\n\n不指定 *outputColMap* 和 *userDefinedMetrics* 时，输出除 openPrice，maxPrice，minPrice 外的字段。\n\n<table id=\"table1\"><thead><tr><th>\n\n字段名\n\n</th><th>\n\n类型\n\n</th><th>\n\n说明\n\n</th></tr></thead><tbody><tr><td>\n\ncode\n\n</td><td>\n\nSYMBOL\n\n</td><td>\n\n标的代码\n\n</td></tr><tr><td>\n\ntimestamp\n\n</td><td>\n\nTIMESTAMP\n\n</td><td>\n\n快照时间戳，如以1s间隔合成快照：2022.08.01T09:20:00.000，2022.08.01T09:20:01.000\n\n</td></tr><tr><td>\n\nlastSeq\n\n</td><td>\n\nLONG\n\n</td><td>\n\n最后一条逐笔数据的序号（lastAppSeqNum）\n\n</td></tr><tr><td>\n\ntradingPhaseCode\n\n</td><td>\n\nINT\n\n</td><td>\n\n交易阶段代码（tradingPhaseCode）。枚举值：0（开盘前，启动）、1（开盘集合竞价）、2（开盘集合竞价阶段结束至连续竞价阶段开始之前）、3（连续竞价）、4（中午午休）、5（收盘集合竞价）\n\n</td></tr><tr><td>\n\nmodified\n\n</td><td>\n\nBOOL\n\n</td><td>\n\n各标的代码当前周期无输入数据，则对应输出表中的该字段显示为 false，否则显示为 true。\n\n</td></tr><tr><td>\n\nturnover\n\n</td><td>\n\nDOUBLE\n\n</td><td>\n\n当前周期内的成交金额\n\n</td></tr><tr><td>\n\nvolume\n\n</td><td>\n\nLONG\n\n</td><td>\n\n当前周期内的成交量\n\n</td></tr><tr><td>\n\ntradeNum\n\n</td><td>\n\nINT\n\n</td><td>\n\n当前周期内的成交笔数\n\n</td></tr><tr><td>\n\nttlTurnover\n\n</td><td>\n\nDOUBLE\n\n</td><td>\n\n（totalTurnover）开盘到现在的成交金额\n\n</td></tr><tr><td>\n\nttlVolume\n\n</td><td>\n\nLONG\n\n</td><td>\n\n（totalVolume）开盘到现在的成交量\n\n</td></tr><tr><td>\n\nttlTradeNum\n\n</td><td>\n\nINT\n\n</td><td>\n\n（totalTradeNum）开盘到现在的成交笔数\n\n</td></tr><tr><td>\n\nlastPrice\n\n</td><td>\n\nDOUBLE\n\n</td><td>\n\n（lastPx）最近成交价\n\n</td></tr><tr><td>\n\nhighPrice\n\n</td><td>\n\nDOUBLE\n\n</td><td>\n\n（highPx）开盘到现在的最高价\n\n</td></tr><tr><td>\n\nlowPrice\n\n</td><td>\n\nDOUBLE\n\n</td><td>\n\n（lowPx）开盘到现在的最低价\n\n</td></tr><tr><td>\n\nopenPrice\n\n</td><td>\n\nDOUBLE\n\n</td><td>\n\n（openPx）开盘价\n\n</td></tr><tr><td>\n\navgAskPrice\n\n</td><td>\n\nDOUBLE\n\n</td><td>\n\n（ask）卖出加权平均价 = 卖单的每一档价格\\*量 / 卖单的总量\n\n</td></tr><tr><td>\n\navgBidPrice\n\n</td><td>\n\nDOUBLE\n\n</td><td>\n\n（bid）买入加权平均价 = 买单的每一档价格\\*量 / 买单的总量\n\n</td></tr><tr><td>\n\naskQty\n\n</td><td>\n\nLONG\n\n</td><td>\n\n（askVol）当前卖盘挂单量\n\n</td></tr><tr><td>\n\nbidQty\n\n</td><td>\n\nLONG\n\n</td><td>\n\n（bidVol）当前买盘挂单量\n\n</td></tr><tr><td>\n\npreClosePrice\n\n</td><td>\n\nDOUBLE/INT\n\n</td><td>\n\n（preClosePx）昨收价。\n\n引擎外部定义昨收价，并以字典的方式传入引擎。\n\n</td></tr><tr><td>\n\nabnormal\n\n</td><td>\n\nBOOL\n\n</td><td>\n\n（invalid）输入数据是否异常：\n\n* true 表示输入数据异常，或在设置了*forceTriggerTime* 后对不连续的数据进行了强制合成得到的第一批订单簿快照数据及其后续数据；其中，数据异常是指收到了逐笔成交或者撤单，却找不到对应的委托单。\n\n* false 表示输入数据正常。\n\n</td></tr><tr><td>\n\nmaxPrice\n\n</td><td>\n\nDOUBLE/INT\n\n</td><td>\n\n涨停价。\n\n引擎外部定义涨停价，并以字典的方式传入引擎。\n\n</td></tr><tr><td>\n\nminPrice\n\n</td><td>\n\nDOUBLE/INT\n\n</td><td>\n\n跌停价。\n\n引擎外部定义跌停价，并以字典的方式传入引擎。\n\n</td></tr></tbody>\n</table>**time（时间字段）**\n\n<table id=\"table2\"><thead><tr><th>\n\n字段名\n\n</th><th>\n\n类型\n\n</th><th>\n\n说明\n\n</th></tr></thead><tbody><tr><td>\n\nmdTime\n\n</td><td>\n\nTIME\n\n</td><td>\n\n快照时间戳，如以1s间隔合成快照：09:20:00.000，09:20:01.000\n\n</td></tr><tr><td>\n\nmdDate\n\n</td><td>\n\nDATE\n\n</td><td>\n\n快照日期。\n\n引擎外部定义快照日期，通过 date 参数传入引擎。\n\n</td></tr><tr><td>\n\nUpdateTime1\n\n</td><td>\n\nNANOTIMESTAMP\n\n</td><td>\n\n触发窗口关闭的那条输入数据的 receiveTime\n\n</td></tr><tr><td>\n\nUpdateTime2\n\n</td><td>\n\nNANOTIMESTAMP\n\n</td><td>\n\n触发窗口关闭后计算完成的系统时刻，即输出计算结果时的系统时间。\n\n</td></tr></tbody>\n</table>**depth（报价/询价档位）**\n\n不指定 *outputColMap* 和 *userDefinedMetrics* 时，会输出 depth 中的所有字段。提供两种方式存储 depth 数据。两种方式只能选其一：\n\n* 每个档位输出一列。比如 bidsPrice 有10个档位，则会输出10个 bidsPrice 字段：bidsPrice1、bidsPrice2、…、bidsPrice10。\n\n| 字段名       | 类型          | 说明                                             |\n| --------- | ----------- | ---------------------------------------------- |\n| bidsPrice | DOUBLE (多个) | （bids）多个字段，分别存放多档买入价格，档位由 *depth*确定            |\n| bidsQty   | LONG (多个)   | （bidVolumes）多个字段，分别存放多档买入数量，档位由 *depth* 确定     |\n| bidsCount | INT (多个)    | （bidOrderNums）多个字段，分别存放多档买入委托笔数，档位由 *depth* 确定 |\n| asksPrice | DOUBLE (多个) | （asks）多个字段，分别存放多档卖出价格，档位由 *depth* 确定           |\n| asksQty   | LONG (多个)   | （askVolumes）多个字段，分别存放多档卖出数量，档位由 *depth* 确定     |\n| asksCount | INT (多个)    | （askOrderNums）多个字段，分别存放多档卖出委托笔数，档位由 *depth* 确定 |\n\n* 多个档位输出到一个列字段，该列的类型为数组向量。比如 bidsPrice 有10个档位，则会将这10个档位以数组向量的形式输出到一个字段：bidsPriceList。\n\n| 字段名           | 类型        | 说明                             |\n| ------------- | --------- | ------------------------------ |\n| bidsPriceList | DOUBLE\\[] | 数组向量，存放多档买入价格，档位由 *depth* 确定   |\n| bidsQtyList   | LONG\\[]   | 数组向量，存放多档买入数量，档位由 *depth* 确定   |\n| bidsCountList | INT\\[]    | 数组向量，存放多档买入委托笔数，档位由 *depth* 确定 |\n| asksPriceList | DOUBLE\\[] | 数组向量，存放多档卖出价格，档位由 *depth* 确定   |\n| asksQtyList   | LONG\\[]   | 数组向量，存放多档卖出数量，档位由 *depth* 确定   |\n| asksCountList | INT\\[]    | 数组向量，存放多档卖出委托笔数，档位由 *depth* 确定 |\n\n**tradeDetail（成交明细）**\n\n**Note:**\n\n* 对于上交所订单簿，若指定参数 *includeImmediateExecution* = true，则委托明细中将会统计即时成交的订单。此时，系统将 trade 记录的成交时间作为 order 的下单时间，并在 tradeOrderBuyNoTimeList/tradeOrderSellNoTimeList 字段中显示。\n* 在调用 `genOutputColumnsForOBSnapshotEngine` 函数时，当 *tradeDetail*=true 时，默认不会输出 tradeBuyOrderTypeList 和 tradeSellOrderTypeList 两个字段。\n\n| 基础衍生字段                   | 类型        | 含义                                        |\n| ------------------------ | --------- | ----------------------------------------- |\n| buyQty                   | LONG      | 当前周期内的买入总量 = sum(BSFlag=1 的成交量)，单位与原始数据一致 |\n| sellQty                  | LONG      | 当前周期内的卖出总量 = sum(BSFlag=2 的成交量)，单位与原始数据一致 |\n| buyMoney                 | DOUBLE    | 当前周期内的买入总金额 = sum( BSFlag=1 的成交量\\*价格）     |\n| sellMoney                | DOUBLE    | 当前周期内的卖出总金额 = sum( BSFlag=2 的成交量\\*价格）     |\n| tradePriceList           | DOUBLE\\[] | 当前周期内成交价格列表                               |\n| tradeQtyList             | LONG\\[]   | 当前周期内成交量列表，单位与原始数据一致                      |\n| tradeTypeList            | INT\\[]    | 当前周期内成交类型列表                               |\n| tradeBSFlagList          | INT\\[]    | 当前周期内成交方向列表                               |\n| tradeMDTimeList          | TIME\\[]   | 当前周期内成交时间列表                               |\n| tradeBuyNoList           | LONG\\[]   | 当前周期内买方委托序号列表                             |\n| tradeSellNoList          | LONG\\[]   | 当前周期内卖方委托序号列表                             |\n| tradeOrderBuyNoTimeList  | TIME\\[]   | 当前周期内的有效成交对应的委托的买单下单时间                    |\n| tradeOrderSellNoTimeList | TIME\\[]   | 当前周期内的有效成交对应的委托的卖单下单时间                    |\n| tradeBuyOrderTypeList    | INT\\[]    | 当前周期内的有效成交对应的委托的买单类型                      |\n| tradeSellOrderTypeList   | INT\\[]    | 当前周期内的有效成交对应的委托的卖单类型                      |\n\n**orderDetail （委托明细）**\n\n注意：对于上交所订单簿，若指定参数 *includeImmediateExecution* = true，则委托明细中将会统计即时成交的订单。\n\n| 基础衍生字段          | 类型        | 含义                   |\n| --------------- | --------- | -------------------- |\n| orderPriceList  | DOUBLE\\[] | 当前周期内委托价格列表          |\n| orderQtyList    | LONG\\[]   | 当前周期内委托量列表，单位与原始数据一致 |\n| orderTypeList   | INT\\[]    | 当前周期内委托类型列表          |\n| orderBSFlagList | INT\\[]    | 当前周期内委托方向列表          |\n| orderMDTimeList | TIME\\[]   | 当前周期内委托时间列表          |\n| orderNoList     | LONG\\[]   | 当前周期内委托序号列表          |\n\n**withdrawDetail（撤单明细）**\n\n**Note:**\n\n* 对于上交所订单簿，若指定参数 *includeImmediateExecution* = true，则委托明细中将会统计即时成交的订单。此时，withdrawBuyOrderQtyList/WithdrawSellOrderQtyList 字段中将包括即时成交的数量。\n* 在调用 `genOutputColumnsForOBSnapshotEngine` 函数时，当 *withdrawDetail*=true 时，默认不会输出 withdrawBuyOrderNoList 和 withdrawSellOrderNoList 两个字段。\n\n| 基础衍生字段                      | 类型        | 含义                                |\n| --------------------------- | --------- | --------------------------------- |\n| withdrawBuyPriceList        | DOUBLE\\[] | 当前周期内买方撤单的委托价格                    |\n| withdrawBuyQtyList          | LONG\\[]   | 当前周期内买方撤单的委托量，单位与原始数据一致           |\n| withdrawBuyOrderTypeList    | INT\\[]    | 当前周期内买方撤单的委托的订单类型                 |\n| withdrawBuyMDTimeList       | TIME\\[]   | 当前周期内买方撤单的订单时间                    |\n| withdrawBuyOrderMDTimeList  | TIME\\[]   | 当前周期内买方撤单对应的委托下单时间                |\n| WithdrawBuyOrderQtyList     | LONG\\[]   | 当前周期内买方撤单对应的原始委托数据中的委托量，单位与原始数据一致 |\n| withdrawSellPriceList       | DOUBLE\\[] | 当前周期内卖方撤单的委托价格                    |\n| withdrawSellQtyList         | LONG\\[]   | 当前周期内卖方撤单的委托量，单位与原始数据一致           |\n| withdrawSellOrderTypeList   | INT\\[]    | 当前周期内卖方撤单的委托的订单类型                 |\n| withdrawSellMDTimeList      | TIME\\[]   | 当前周期内卖方撤单的订单时间                    |\n| withdrawSellOrderMDTimeList | TIME\\[]   | 当前周期内卖方撤单对应的委托下单时间                |\n| WithdrawSellOrderQtyList    | LONG\\[]   | 当前周期内卖方撤单对应的原始委托数据中的委托量，单位与原始数据一致 |\n| withdrawBuyOrderNoList      | LONG\\[]   | 当前周期内买方撤单对应的原始委托数据中的订单号           |\n| withdrawSellOrderNoList     | LONG\\[]   | 当前周期内卖方撤单对应的原始委托数据中的订单号           |\n\n**prevDetail（上一笔交易明细）**\n\n**Note:** 对于上交所订单簿，若指定参数 *includeImmediateExecution* = true，则委托明细中将会统计即时成交的订单。此时，当即时成交的价格和上一笔快照的价格（BuyPrice1/SellPrice1）相同，则 prevBuyAddQtyList1/prevSellAddQtyList1 字段中将包括即时成交的申购明细。\n\n| 基础衍生字段                   | 类型      | 含义                                         |\n| ------------------------ | ------- | ------------------------------------------ |\n| prevBuyPrice1            | DOUBLE  | 上一笔快照的 BuyPrice1 价格                        |\n| prevSellPrice1           | DOUBLE  | 上一笔快照的 SellPrice1 价格                       |\n| prevBuyAddQtyList1       | LONG\\[] | 价格为上一笔快照的 BuyPrice1，在当前周期内的申购明细，单位与原始数据一致  |\n| prevSellAddQtyList1      | LONG\\[] | 价格为上一笔快照的 SellPrice1，在当前周期内的申购明细，单位与原始数据一致 |\n| prevBuyWithdrawQtyList1  | LONG\\[] | 价格为上一笔快照的 BuyPrice1，在当前周期内的撤单明细，单位与原始数据一致  |\n| prevSellWithdrawQtyList1 | LONG\\[] | 价格为上一笔快照的 SellPrice1，在当前周期内的撤单明细，单位与原始数据一致 |\n\n**orderBookDetailDepth（ orderbook 明细档位）**\n\n每个档位输出一列，该列的类型是数组向量。比如 buyQtyList 有20个档位，则会输出20个 buyQtyList 字段：buyQtyList1、buyQtyList2、…、buyQtyList20。buyValueList，sellQtyList 和 sellValueList 同理。\n\n| 基础衍生字段        | 类型            | 含义                   |\n| ------------- | ------------- | -------------------- |\n| buyQtyList    | LONG\\[]（多个）   | 当前最新盘口各档位买入的每一笔委托的数量 |\n| buyValueList  | DOUBLE\\[]（多个） | 当前最新盘口各档位买入的每一笔委托的金额 |\n| sellQtyList   | LONG\\[]（多个）   | 当前最新盘口各档位卖出的每一笔委托的数量 |\n| sellValueList | DOUBLE\\[]（多个） | 当前最新盘口各档位卖出的每一笔委托的金额 |\n\n**seqDetail（sequence 明细）**\n\n**Note:** 对于上交所订单簿，若指定参数 *includeImmediateExecution* = true，则委托明细中将会统计即时成交的订单。此时，orderSeqList 字段中将会包含即时成交的委托记录。\n\n| 基础衍生字段              | 类型      | 含义             |\n| ------------------- | ------- | -------------- |\n| tradeSeqList        | LONG\\[] | 当前周期内的成交序号列表   |\n| orderSeqList        | LONG\\[] | 当前周期内的委托序号列表   |\n| withdrawBuySeqList  | LONG\\[] | 当前周期内的买方撤单序号列表 |\n| withdrawSellSeqList | LONG\\[] | 当前周期内的卖方撤单序号列表 |\n\n**residualDetail（剩余委托明细）**\n\n注意：\n\n* 卖方字段（ResidualAskPriceList, ResidualAskQtyList, ResidualAskTimeList, ResidualAskApplSeqNumList）中每个档位的信息按照价格和交易时间升序排序。若价格和交易时间相同，则按数据进入引擎的时间升序排序。\n\n* 买方字段（ResidualBidPriceList, ResidualBidQtyList, ResidualBidTimeList, ResidualBidApplSeqNumList）中每个档位的信息按价格降序和交易时间升序排序，若价格和交易时间相同，则按数据进入引擎的时间升序排序。\n\n* 在调用 `genOutputColumnsForOBSnapshotEngine` 函数时，当 *residualDetail*=true 时，默认不会输出 ResidualBidOrderNoList 和 ResidualAskOrderNoList 两个字段。\n\n| 字段名                       | 类型        | 说明                    |\n| ------------------------- | --------- | --------------------- |\n| ResidualAskPriceList      | DOUBLE\\[] | 卖方剩余委托价格列表            |\n| ResidualAskQtyList        | LONG\\[]   | 卖方剩余委托量列表             |\n| ResidualAskTimeList       | TIME\\[]   | 卖方剩余委托时间列表            |\n| ResidualAskApplSeqNumList | LONG\\[]   | 卖方剩余委托单 ApplSeqNum 列表 |\n| ResidualBidPriceList      | DOUBLE\\[] | 买方剩余委托价格列表            |\n| ResidualBidQtyList        | LONG\\[]   | 买方剩余委托量列表             |\n| ResidualBidTimeList       | TIME\\[]   | 买方剩余委托时间列表            |\n| ResidualBidApplSeqNumList | LONG\\[]   | 买方剩余委托单 ApplSeqNum 列表 |\n| ResidualBidOrderNoList    | LONG\\[]   | 买方剩余委托的订单号            |\n| ResidualAskOrderNoList    | LONG\\[]   | 卖方剩余委托的订单号            |\n"
    },
    "createPartitionedTable": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/createPartitionedTable.html",
        "signatures": [
            {
                "full": "createPartitionedTable(dbHandle, table, tableName, partitionColumns, [compressMethods], [sortColumns|primaryKey], [keepDuplicates=ALL], [sortKeyMappingFunction], [softDelete=false], [indexes], [latestKeyCache=false], [compressHashSortKey=true], [encryptMode='plaintext'])",
                "name": "createPartitionedTable",
                "parameters": [
                    {
                        "full": "dbHandle",
                        "name": "dbHandle"
                    },
                    {
                        "full": "table",
                        "name": "table"
                    },
                    {
                        "full": "tableName",
                        "name": "tableName"
                    },
                    {
                        "full": "partitionColumns",
                        "name": "partitionColumns"
                    },
                    {
                        "full": "[compressMethods]",
                        "name": "compressMethods",
                        "optional": true
                    },
                    {
                        "full": "[sortColumns|primaryKey]",
                        "name": "[sortColumns|primaryKey]"
                    },
                    {
                        "full": "[keepDuplicates=ALL]",
                        "name": "keepDuplicates",
                        "optional": true,
                        "default": "ALL"
                    },
                    {
                        "full": "[sortKeyMappingFunction]",
                        "name": "sortKeyMappingFunction",
                        "optional": true
                    },
                    {
                        "full": "[softDelete=false]",
                        "name": "softDelete",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[indexes]",
                        "name": "indexes",
                        "optional": true
                    },
                    {
                        "full": "[latestKeyCache=false]",
                        "name": "latestKeyCache",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[compressHashSortKey=true]",
                        "name": "compressHashSortKey",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[encryptMode='plaintext']",
                        "name": "encryptMode",
                        "optional": true,
                        "default": "'plaintext'"
                    }
                ]
            }
        ],
        "markdown": "### [createPartitionedTable](https://docs.dolphindb.cn/zh/funcs/c/createPartitionedTable.html)\n\n\n\n#### 语法\n\ncreatePartitionedTable(dbHandle, table, tableName, partitionColumns, \\[compressMethods], \\[sortColumns|primaryKey], \\[keepDuplicates=ALL], \\[sortKeyMappingFunction], \\[softDelete=false], \\[indexes], \\[latestKeyCache=false], \\[compressHashSortKey=true], \\[encryptMode='plaintext'])\n\n#### 详情\n\n根据 *table* 的结构创建一个空的分区表。\n\n* 对于分布式数据库和本地磁盘数据库，*table* 参数只能是一个表。\n* 对于内存数据库，*table* 参数可以是一个表或包含多个表的元组。如果 *table* 是一个元组，每个 *table* 表示一个分区。\n\n如果参数 *table* 是一个表，则根据该表的结构创建一个分区表。通过 `append!`或 `tableInsert`给新创建的分区表插入数据。它不能用于创建顺序分区的分区表。\n\n如果参数 *table* 是一系列表，则创建一个分区的内存表。参数 *table* 中表的数量与数据库中分区的数量相同。\n\n**Note:**\n\n* 创建分区表时只会使用参数 *table* 的结构，并不会把 *table* 中的数据插入到新的分区表中。\n* OLAP 引擎允许集群每个节点创建的不同的分布式分区表句柄（包含临时句柄）上限为 8192；TSDB 引擎没有上限。临时句柄的说明请参考注释。\n* 调用函数 createPartitionedTable 创建分布式分区表时，若用户没有创建一个句柄变量来接收函数的返回值，则每个数据库会创建一个临时句柄。若在同一数据库下多次创表，则该数据库的临时句柄会被覆盖。\n\n#### 参数\n\n**Note:** 参数 *sortColumns*, *keepDuplicates* 及 *sortKeyMappingFunction* 仅在 `database` 的 *engine* 参数指定为 TSDB 时才有效。\n\n**dbHandle** [database](https://docs.dolphindb.cn/zh/funcs/d/database.html) 函数返回的数据库句柄。它可以是本地磁盘数据库，也可以是分布式数据库。*dbHandle* 为空字符串或没有指定时，表示内存数据库的句柄。\n\n**table** 一个表或包含多个表的元组。系统将会根据该表的结构创建新的分区表。\n\n**tableName** 一个字符串，表示分区表的名称。表名只能由中文或英文字母、数字或下划线（\\_）组成，且必须以中文或英文字母开头。\n\n**partitionColumns** 一个字符串或字符串向量，表示分区列或者应用于分区列的函数调用（例如：\"partitionFunc(id)\"）。对于组合分区，*partitionColumns* 是一个字符串向量。对非顺序分区，此参数为必选参数。若指定该参数为函数调用，则必须有且仅有一个参数是分区列，且其它参数是常量标量。此时，系统在创建分布式表时，会根据函数调用返回的数据进行分区。然而，在 SQL 查询中，对于基于分区列（例如partitionFunc(id) 中的 id 列）的查询优化行为受到一些限制：\n\n* 当 WHERE 条件中对分区列进行非等值比较（例如 >，<）时，不会进行分区剪枝。\n* 无法根据分区列或分区路径进行其它查询优化。\n\n**compressMethods** 一个字典，指定某些列使用 lz4, delta, zstd 或 chimp 压缩算法存储。key 为字段名，value 为压缩算法（\"lz4\", \"delta\", \"zstd\" 或 \"chimp\"）。若未指定，默认采用 lz4 压缩算法。有关 Delta 压缩算法，亦称为 delta-of-delta encoding，参考：[Delta Compression Techniques](http://engineering.nyu.edu/~suel/papers/delta-chap.pdf)。\n\n* 对于 DECIMAL,SHORT, INT, LONG 与时间或日期类型数据，建议采用 Delta 算法压缩。\n* 将字符串存储为 SYMBOL 类型数据，实现对字符串类型的压缩。\n* 对于小数部分长度在三位以内的 DOUBLE 类型的数据，可以考虑使用 chimp 算法压缩。\n\n**sortColumns** 字符串标量或向量，用于指定每一分区内的排序列，每次写入磁盘的数据在每一分区内将按 *sortColumns* 进行排序。系统默认 *sortColumns* （指定多列时） 除最后一列外的列字段作为排序的索引列，称作 sort key。每一分区内，同一个 sort key 组合值对应的数据将按最后一列的值顺序连续存放在一起。查询时，若查询条件包含索引列，可以快速定位数据所在的数据块位置，提高查询性能。\n\n* 仅当 dbHandle 指示的数据库采用 \"TSDB\" 引擎（engine=\"TSDB\"）时，本参数才生效。\n* *sortColumns* 只能是 INTEGER, TEMPORAL, LITERAL 类别（除 BLOB） 或 DECIMAL 类型。\n  * 若 *sortColumns* 指定为多列，则 *sortColumns* 的最后一列必须为时间类型或整型，其余列为索引列，且索引列不能为为 TIME, TIMESTAMP, NANOTIME, NANOTIMESTAMP 类型。\n  * 若 *sortColumns* 仅指定一列，则该列作为 sort key，其类型可以是除 TIME, TIMESTAMP, NANOTIME, NANOTIMESTAMP 之外的任意类型。若 *sortColumns* 为时间类型 （非分区列），且同时指定了 *sortKeyMappingFunction*，则查询的过滤条件中 *sortColumns* 只能与相同时间类型的值进行比较。\n* 频繁查询的字段适合设置为 *sortColumns*（建议不超过 4 列），且建议优先把查询频率高的字段作为 *sortColumns* 中位置靠前的列。\n* 为保证性能最优，建议每个分区内索引列的组合数（sort key）不超过 2000 个。\n* *sortColumns* 是每个分区内部 level file 内数据的排序依据，与其是否为分区字段无关。\n\n**primaryKey**字符串标量或向量，用于指定主键列。在数据写入操作中，如果主键相同，新的数据覆盖现有数据。\n\n* 仅当*dbHandlei* 指示的数据库采用 \"PKEY\" 引擎（engine=\"PKEY\"）时，本参数才生效。\n* 主键列必须包含所有的分区列。\n* 主键列支持的类型包括：BOOL, CHAR, SHORT, INT, LONG, INT128, STRING, TIME, SECOND, MINUTE, DATE, MONTH, DATEHOUR, DATETIME, SYMBOL, TIMESTAMP, NANOTIME, NANOTIMESTAMP, UUID, COMPLEX, POINT, IPADDR, DECIMAL32, DECIMAL64, DECIMAL128。\n\n**keepDuplicates** 指定在每个分区内如何处理所有 *sortColumns* 之值皆相同的数据。提供以下选项：\n\n* ALL：保留所有数据，为默认值。\n* LAST：仅保留最新数据\n* FIRST：仅保留第一条数据\n\n在 TSDB 引擎单个分区 sort key 组合数过多，但每个 sort key 组合值对应的记录数较少的场景下，建议配置 *sortKeyMappingFunction* 参数以对 sort key 组合数进行降维。降维后单个 TSDB level File 内的数据块可以存储更多的数据，查询时既减少了读数据块的次数（降低了 I/O 开销），又提升了数据的压缩率。\n\n**sortKeyMappingFunction** 由一元函数对象组成的向量，其长度与 sort key 一致。若只指定一个映射函数 mapfunc，必须写为 *sortKeyMappingFunction*=\\[mapfunc]。用于指定应用在索引列中各列的映射函数，以减少 sort key 的组合数，该过程称为 sort key 降维。\n\n索引列中的各列被对应的映射函数降维后，原本的多个 sort key 组合值会被重新映射到一个新的 sort key 组合值上。而每个新 sort key 组合值对应的数据仍将根据 *sortColumns* 的最后一列进行排序。降维在写入磁盘时进行，因此指定该参数一定程度上将影响写入性能。\n\n**Note:**\n\n* *sortKeyMappingFunction* 指定的函数对象与索引列中的各列一一对应，若其中某列无需降维，则函数对象置为空。\n* 当 *sortKeyMappingFunction* 中的函数对象为 `hashBucket`，且需要对采用 Hash 分区的分区字段进行降维时，应确保 Hash 分区的数量和 `hashBucket` 中的 *buckets* 之间不存在整除关系（*buckets*=1 除外），否则会导致同一分区内的所有 Hash 值得到的 key 都相同。\n\n**softDelete** 用于启用或禁用软删除功能。默认为 false，即禁用。该参数适于在行数多但删除量小的场景下使用。使用该参数需要同时满足以下条件：\n\n* 由TSDB 存储引擎创建的数据库内的表\n* *keepDuplicates* 已设置为 LAST\n\n**indexes** 为一个字典，用于为表中的列指定索引。仅当 *dbHandle* 指示的数据库采用 “TSDB” （engine=”TSDB” 且 keepDuplicates=ALL）或 “PKEY” 引擎（engine=”PKEY”）时，本参数才生效。\n\n* 设置布隆过滤器，适用于 PKEY 数据库。\n\n  为 PKEY 数据库表中的列指定索引。字典的键是 STRING 类型标量，表示列名；值是 STRING 类型标量，表示为该列指定的索引类型。目前支持设置 “bloomfilter” 索引类型：适用于对大基数列进行点查，且基数越大，索引效果越好，如身份证 ID、订单号、从业务上游同步的外键等数据列。目前支持的类型包括 BOOL, CHAR, SHORT, INT, LONG, TEMPORAL, BLOB, STRING, BINARY, COMPLEX, DECIMAL32, DECIMAL64, DECIMAL128。\n\n  **Note:** 引擎会将所有主键列合并为组合主键，并为组合主键设置 bloomfilter 类型索引。\n\n* 设置文本索引，适用于 PKEY 数据库。\n\n  为某一列设置文本索引，以便在查询时对该列进行高效的文本查询。每个表支持为 STRING 或 BLOB 类型的非主键列设置文本索引。字典的 key 为 STRING 类型，表示列名，且该列类型必须是 STRING 或 BLOB；字典的 value 为 STRING 类型，其形式为 `textindex(parser=english,full=false,lowercase=true,stem=true)`，其中：\n\n  * parser：指定分词器。没有默认值，必须显式指定。可选值为 none, english, chinese, mixed：\n\n    * none：不分词。\n\n    * english：英文分词器，按照空格和标点进行分词，适合于英文为主要内容的场景。\n\n    * chinese：中文分词器。按照中文词库、空格和标点进行分词。适合于中文较多，仅有少量英文或对英文要求不高的场景。\n\n    * mixed：混合分词器。英文按单词分词，中文按 Bigram 分词（以两个连续字符为单位进行分词，且会重叠。如 '武汉市长江大桥' 会被分词为 '武汉' '汉市' '市长' '长江' '江大' '大桥'）。适合于中英文交替，且对英文要求较高的场景。\n\n  * full：设置中文分词时的分词模式。该属性仅在 parser=chinese 时有效。默认值为 false。\n\n    * false：默认模式。词语之间不会重叠和包含。比如 '武汉市长江大桥' 会分成 '武汉市' 和 '长江大桥'。\n\n    * true：全分词模式。该模式会尽可能多的分析句子中包含的词语。比如 '武汉市长江大桥' 会分成 '武汉', '武汉市', '市长', '长江', '长江大桥', '大桥'。\n\n  * lowercase：是否忽略大小写。该属性在 *parser* 为 english, chinese, mixed 时有效。默认值为true。\n\n    * true：适用于需要忽略英文大小写的场景。\n\n    * false：适用于需要大小写敏感的场景。\n\n  * stem：是否将英文单词作为词干匹配。该属性仅在 parser=english 且 lowercase=true 时生效。默认值为 false。\n\n    * true：将英文单词作为词干。此时可能会匹配到相应的派生词，例如查询单词'dark'，可能会搜到含 'darkness' 的结果。\n\n    * false：只能精确查询结果。\n\n* 设置向量索引，适用于 TSDB 和 PKEY 数据库。\n\n  为某一列设置向量索引，以便在查询时对该列进行高效的欧氏距离计算。目前，每个表仅支持为单个列设置向量索引。字典的键为 STRING 类型，表示列名，且该列的类型必须为 FLOAT\\[] 或 DOUBLE\\[]；字典的 value 为 STRING 类型，其形式为 `\"vectorindex(type=flat, dim=128)\"`，其中：\n\n  type 可选值为 flat, pq, ivf, ivfpq, hnsw：\n\n  * flat 适用于数据规模在数百至数万级别的向量数据，或需要最高精度的场景。\n  * pq 适用于数据规模在数十万至数千万级别的向量数据，且对搜索精度要求不高的场景。常见应用场景如大型数据库、视频库等。\n  * ivf 适用于数据规模在数万至数百万级别的向量数据，常见应用场景如图片检索、文本检索等。\n  * ivfpq 适用于数据规模在数百万至数千万级别的向量数据，需要在检索速度和精度之间找到最佳平衡的场景。常见应用场景如大型推荐系统、社交网络中的用户匹配。\n  * hnsw 适用于数据规模在数亿至数十亿级别的向量数据，并对检索速度，精度和动态更新有高要求的场景，常见应用场景如实时推荐系统、在线搜索、RAG 等。\n    dim 为正整数，表示向量的维度。若 *type* 指定为 pq 或 ivfpq，则要求 *dim* 为 4 的倍数。 后续插入的向量维度必须为 *dim*，否则会插入失败。\n\n  如果已为某一列设置了向量索引，在查询语句中，若同时满足以下条件，则会应用向量索引提升查询性能：\n\n  * 不包含 join 语句\n\n  * 包含 order by 子句且其中只包含对该列应用 rowEuclidean 函数并按升序排序\n\n  * 包含 limit 子句\n\n  * 若引擎为 TSDB，where 子句中不包含 sort key\n\n  **Note:** 当引擎为 PKEY，在满足上述查询条件时，查询会先根据 order by 子句和 limit 子句对索引列进行过滤，再将所得结果根据 where 条件进行过滤，由此得到的结果可能会比 limit 的结果少。\n\n**latestKeyCache** 可选参数，布尔标量，用于设置 IOTDB 是否开启最新值缓存功能。默认值为 false，即关闭。注意：该参数为 true 时，参数 *sortColumns* 至少需要包含两列。一般为 ID 列、各种 tag 列和时间列。\n\n**compressHashSortKey** 可选参数，布尔标量，用于设置是否开启 sortColumns 列压缩功能。当引擎为 IOTDB 时，默认值为 true。当 *sortKeyMappingFunction* 设置为 `hashBucket` 函数时，该功能默认开启。\n\n注意：建立点位管理表时，\n\n* 须保证当前数据库使用 IOTDB 引擎。\n\n* 暂不支持通过 `createPartitionedTable` 函数创建 IOTANY 列，只能通过 [create](https://docs.dolphindb.cn/zh/progr/sql/create.html) 语句创建。\n\n* 暂不支持 softDelete 等利用 cid 特性的功能。故建立时须设置 softDelete=false。\n\n* 不支持 sortColumns 中包含 DECIMAL 类型。\n\n**encryptMode** 可选参数，字符串标量，指定表的加密方式，默认为不加密（明文模式）。仅 Linux 系统支持该参数。目前支持以下可选值（大小写不区分）：plaintext, aes\\_128\\_ctr, aes\\_128\\_cbc, aes\\_128\\_ecb, aes\\_192\\_ctr, aes\\_192\\_cbc, aes\\_192\\_ecb, aes\\_256\\_ctr, aes\\_256\\_cbc, aes\\_256\\_ecb, sm4\\_128\\_cbc, sm4\\_128\\_ecb。\n\n#### 返回值\n\n返回一个表。\n\n#### 例子\n\n例1. 在分布式数据库中创建一个分区表\n\n例1.1 创建一张 OLAP 引擎下的分区表。\n\n```\nn=1000000;\nt=table(2020.01.01T00:00:00 + 0..(n-1) as timestamp, rand(`IBM`MS`APPL`AMZN,n) as symbol, rand(10.0, n) as value)\ndb = database(\"dfs://rangedb_tradedata\", RANGE, `A`F`M`S`ZZZZ)\nTrades = db.createPartitionedTable(table=t, tableName=\"Trades\", partitionColumns=\"symbol\", compressMethods={timestamp:\"delta\"});\n```\n\n`createPartitionedTable` 只是建立一张空的表格 Trades，该表复制了表 t 的字段。接着用 `append!` 函数将数据追加到 Trades 表里。\n\n```\nTrades.append!(t);\n```\n\n查询分区表：\n\n```\nTrades=loadTable(db,`Trades);\nselect min(value) from Trades;\n\n0\n```\n\n在分布式数据库中，初次创建表后，可以跳过 [loadTable](https://docs.dolphindb.cn/zh/funcs/l/loadTable.html) 把表载入内存的步骤，因为分布式文件系统会动态刷新表的内容。系统重启后，需要再次执行 `loadTable` 函数加载表。\n\n例1.2 创建一张 TSDB 引擎下的分区表。\n\n```\nn = 10000\nSecurityID = rand(`st0001`st0002`st0003`st0004`st0005, n)\nsym = rand(`A`B, n)\nTradeDate = 2022.01.01 + rand(100,n)\nTotalVolumeTrade = rand(1000..3000, n)\nTotalValueTrade = rand(100.0, n)\nschemaTable_snap = table(SecurityID, TradeDate, TotalVolumeTrade, TotalValueTrade).sortBy!(`SecurityID`TradeDate)\n\ndbPath = \"dfs://TSDB_STOCK\"\nif(existsDatabase(dbPath)){dropDatabase(dbPath)}\ndb_snap = database(dbPath, VALUE, 2022.01.01..2022.01.05, engine='TSDB')\nsnap=createPartitionedTable(dbHandle=db_snap, table=schemaTable_snap, tableName=\"snap\", \n    partitionColumns=`TradeDate, sortColumns=`SecurityID`TradeDate, keepDuplicates=ALL, \n    sortKeyMappingFunction=[hashBucket{,5}])\nsnap.append!(schemaTable_snap)\nflushTSDBCache()\nsnap = loadTable(dbPath, `snap)\nselect * from snap\n```\n\n例2. 在内存数据库中创建一个分区表\n\n例2.1 创建分区常规内存表\n\n```\nn = 200000\ncolNames = `time`sym`qty`price\ncolTypes = [TIME,SYMBOL,INT,DOUBLE]\nt = table(n:0, colNames, colTypes)\ndb = database(, RANGE, `A`D`F)\npt = db.createPartitionedTable(table=t, tableName=`pt, partitionColumns=`sym)\n\ninsert into pt values(09:30:00.001,`AAPL,100,56.5)\ninsert into pt values(09:30:01.001,`DELL,100,15.5)\n```\n\n例2.2 创建分区键值内存表\n\n```\nn = 200000\ncolNames = `time`sym`qty`price\ncolTypes = [TIME,SYMBOL,INT,DOUBLE]\nt = keyedTable(`time`sym, n:0, colNames, colTypes)\ndb = database(, RANGE, `A`D`F)\npt = db.createPartitionedTable(table=t, tableName=`pt, partitionColumns=`sym)\n\ninsert into pt values(09:30:00.001,`AAPL,100,56.5)\ninsert into pt values(09:30:01.001,`DELL,100,15.5)\n```\n\n例2.3 创建分区流数据表\n\n注意，创建分区流数据表时 `createPartitionedTable` 的第二个参数必须是元组，并且其长度必须与分区数量相等，每个表对应一个分区。下例中，trades\\_stream1 和 trades\\_stream2 组成一个分区流数据表 trades。写入数据时，只能分别往 trades\\_stream1 和 trades\\_stream2 写入，不能直接写入到 trades。查询 trades 可以获取到两个表的数据。\n\n```\nn=200000\ncolNames = `time`sym`qty`price\ncolTypes = [TIME,SYMBOL,INT,DOUBLE]\ntrades_stream1 = streamTable(n:0, colNames, colTypes)\ntrades_stream2 = streamTable(n:0, colNames, colTypes)\ndb=database(, RANGE, `A`D`F)\ntrades = createPartitionedTable(db,table=[trades_stream1, trades_stream2], tableName=\"\", partitionColumns=`sym)\n\ninsert into trades_stream1 values(09:30:00.001,`AAPL,100,56.5)\ninsert into trades_stream2 values(09:30:01.001,`DELL,100,15.5)\n\nselect * from trades;\n```\n\n| time         | sym  | qty | price |\n| ------------ | ---- | --- | ----- |\n| 09:30:00.001 | AAPL | 100 | 56.5  |\n| 09:30:01.001 | DELL | 100 | 15.5  |\n\n例2.4 创建分区 MVCC 内存表\n\n创建分区 MVCC 内存表的方式与创建分区流数据表的方式相同。\n\n```\nn=200000\ncolNames = `time`sym`qty`price\ncolTypes = [TIME,SYMBOL,INT,DOUBLE]\ntrades_mvcc1 = mvccTable(n:0, colNames, colTypes)\ntrades_mvcc2 = mvccTable(n:0, colNames, colTypes)\ndb=database(, RANGE, `A`D`F)\ntrades = createPartitionedTable(db,table=[trades_mvcc1, trades_mvcc2], tableName=\"\", partitionColumns=`sym)\n\ninsert into trades_mvcc1 values(09:30:00.001,`AAPL,100,56.5)\ninsert into trades_mvcc2 values(09:30:01.001,`DELL,100,15.5)\n\nselect * from trades;\n```\n\n| time         | sym  | qty | price |\n| ------------ | ---- | --- | ----- |\n| 09:30:00.001 | AAPL | 100 | 56.5  |\n| 09:30:01.001 | DELL | 100 | 15.5  |\n\n例3. 创建 TSDB 分区表时设置向量索引，提高查询性能。\n\n```\ndb = database(directory=\"dfs://indexesTest\", partitionType=VALUE, partitionScheme=1..10, engine=\"TSDB\")\nschematb = table(1:0,`col0`col1`col2`col3,[INT,INT,TIMESTAMP,FLOAT[]])\npt = createPartitionedTable(dbHandle=db, table=schematb, tableName=`pt, partitionColumns=`col0, sortColumns=`col1`col2, indexes={\"col3\":\"vectorindex(type=flat, dim=5)\"})\n\ntmp = cj(table(1..10 as col0),cj(table(1..10 as col1),table(now()+1..10 as col2))) join table(arrayVector(1..1000*5,1..5000) as col3)\n\npt.tableInsert(tmp)\n\nselect * from pt where col2<now() order by rowEuclidean(col3,[1339,252,105,105,829]) limit 10\n```\n\n| col0 | col1 | col2                    | col3                       |\n| ---- | ---- | ----------------------- | -------------------------- |\n| 2    | 1    | 2024.06.27 16:56:38.950 | \\[526, 527, 528, 529, 530] |\n| 2    | 1    | 2024.06.27 16:56:38.949 | \\[521, 522, 523, 524, 525] |\n| 2    | 1    | 2024.06.27 16:56:38.951 | \\[531, 532, 533, 534, 535] |\n| 2    | 1    | 2024.06.27 16:56:38.948 | \\[516, 517, 518, 519, 520] |\n| 2    | 1    | 2024.06.27 16:56:38.952 | \\[536, 537, 538, 539, 540] |\n| 2    | 1    | 2024.06.27 16:56:38.947 | \\[511, 512, 513, 514, 515] |\n| 2    | 1    | 2024.06.27 16:56:38.953 | \\[541, 542, 543, 544, 545] |\n| 2    | 1    | 2024.06.27 16:56:38.946 | \\[506, 507, 508, 509, 510] |\n| 2    | 1    | 2024.06.27 16:56:38.954 | \\[546, 547, 548, 549, 550] |\n| 2    | 1    | 2024.06.27 16:56:38.945 | \\[501, 502, 503, 504, 505] |\n\n例4. 创建主键引擎的分区表\n\n```\ndb = database(directory=\"dfs://PKDB\", partitionType=VALUE, partitionScheme=1..10, engine=\"PKEY\")\nschematb = table(1:0,`id1`id2`val1`val2`date1`time1,[INT,INT,INT,DECIMAL32(2),DATE,TIME])\npkt = createPartitionedTable(dbHandle=db, table=schematb, tableName=\"pkt\", partitionColumns=\"id1\", primaryKey=`id1`id2, indexes={\"val1\": \"bloomfilter\", \"val2\": \"bloomfilter\"})\n```\n\n例5. 创建点位管理表\n\n本例中，我们通过复合分区方案按 id 和 ts 分区，创建了一个名为 pt 的点位管理表。该表使用 ticket 和 id2 作为唯一识别一个点位的两列；启用最新值缓存和 hashSortKey 压缩。\n\n```\ndb1 = database(, partitionType=HASH, partitionScheme=[INT, 10])\ndb2 = database(, partitionType=VALUE, partitionScheme=2017.08.07..2017.08.11)\ndb = database(dbName, COMPO, [db1, db2], engine='IOTDB')\nschematb = table(1:0,`id`ticket`id2`ts,[INT,SYMBOL,LONG,TIMESTAMP])\npt = createPartitionedTable(dbHandle=db, table=schematb, tableName=\"pt\", partitionColumns=`id`ts, sortColumns=`ticket`id2`ts, sortKeyMappingFunction = [hashBucket{, 50}, hashBucket{, 50}], latestKeyCache = true )\n```\n"
    },
    "createPricingEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/createpricingengine.html",
        "signatures": [
            {
                "full": "createPricingEngine(name, instrument, [handler], [engineConfig])",
                "name": "createPricingEngine",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "instrument",
                        "name": "instrument"
                    },
                    {
                        "full": "[handler]",
                        "name": "handler",
                        "optional": true
                    },
                    {
                        "full": "[engineConfig]",
                        "name": "engineConfig",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [createPricingEngine](https://docs.dolphindb.cn/zh/funcs/c/createpricingengine.html)\n\n首发版本：3.00.5\n\n\n\n#### 语法\n\ncreatePricingEngine(name, instrument, \\[handler], \\[engineConfig])\n\n#### 详情\n\n创建实时估值定价引擎。该引擎支持调用 DolphinDB 内置估值定价函数，也支持用户传入自定义函数。\n\n#### 参数\n\n**name** 字符串标量，表示引擎名称。该参数是引擎在一个数据节点上的唯一标识，可包含字母，数字和下划线，但必须以字母开头。\n\n**instrument**INSTRUMENT 类型标量或向量，表示待定价的金融工具。定价过程中，市场数据匹配规则遵循 [instrumentPricer](https://docs.dolphindb.cn/zh/funcs/i/instrumentPricer.html) 的规范。\n\n**handler** 可选参数，一个自定义函数，用于处理定价完成后的结果输出。\n\n* 若 *engineConfig* 中设置 `outputTime = true`，函数签名为 `def(eventTime, name, date, npv)`；\n* 若 *engineConfig* 中设置 `outputTime = false`（默认值），函数签名为 `def(name, date, npv)`。\n\n参数说明如下：\n\n* eventTime：NANOTIMESTAMP，触发事件的时间。\n* name：STRING，定价对象的 instrumentId。\n* date：DATE，定价日期。\n* npv：DOUBLE，定价结果的净值。\n\n**engineConfig** 可选参数，一个字典，用于设置引擎运行配置。字典包含如下键值对：\n\n* numThreads：可选，整型标量，表示工作线程数，默认 8。设为 0 表示同步执行。\n\n* maxQueueDepth：可选，整型标量，表示最大队列深度，默认 10,000,000。\n\n* useSystemTime：可选，布尔标量，表示是否使用系统时间作为事件时间。默认为 true，使用系统时间作为事件时间。\n\n* timeColumn：可选，字符串标量，指定时间列作为事件时间。若指定该参数，必须将 useSystemTime 设置为 false。\n\n* outputTime：可选，布尔标量，表示是否输出事件时间列。默认值为 false。\n\n#### 返回值\n\n返回一个定价引擎句柄。\n\n#### 例子\n\n本例中定义待定价金融工具 240025.IB，根据 `instrumentPricer` 的默认规则，该工具将使用名为 CNY\\_TREASURY\\_BOND 的市场数据。通过调用 `appendMktData` 接口将相关市场数据写入定价引擎。\n\n```\ntry{dropStreamEngine(\"PRICING_ENGINE\")}catch(ex){}\n\nbondDict  = {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Bond\",\n    \"bondType\": \"FixedRateBond\",\n    \"instrumentId\": \"240025.IB\",\n    \"start\": 2024.12.25,\n    \"maturity\": 2031.12.25,\n    \"issuePrice\": 100.0,\n    \"coupon\": 0.0149,\n    \"frequency\": \"Annual\",\n    \"dayCountConvention\": \"ActualActualISDA\"\n}\ninstrument = parseInstrument(bondDict)\n\npricingDate = 2025.08.18\n\ncurveDict = {\n    \"mktDataType\": \"Curve\",\n    \"curveType\": \"IrYieldCurve\",\n    \"referenceDate\": pricingDate,\n    \"currency\": \"CNY\",\n    \"curveName\": \"CNY_TREASURY_BOND\",\n    \"dayCountConvention\": \"ActualActualISDA\",\n    \"compounding\": \"Compounded\",\n    \"interpMethod\": \"Linear\",\n    \"extrapMethod\": \"Flat\",\n    \"frequency\": \"Annual\",\n    \"dates\": [\n        2025.09.18, 2025.11.18, 2026.02.18, 2026.08.18, 2027.08.18,\n        2028.08.18, 2030.08.18, 2032.08.18, 2035.08.18, 2040.08.18,\n        2045.08.18, 2055.08.18, 2065.08.18, 2075.08.18\n    ],\n    \"values\": [\n        1.3000, 1.3700, 1.3898, 1.3865, 1.4299,\n        1.4471, 1.6401, 1.7654, 1.7966, 1.9930,\n        2.1834, 2.1397, 2.1987, 2.2225\n    ] \\ 100.0\n}\n\ndiscountCurve = parseMktData(curveDict)\n\nshare streamTable(1:0, `name`date`price, [STRING, DATE, DOUBLE]) as st\n\ndef myHandler(name, date, price) {\n    tableInsert(st, name, date, price)\n}\n\nengine = createPricingEngine(\"PRICING_ENGINE\", [instrument], myHandler)\n\nappendMktData(engine, discountCurve)\n\nselect * from st\n```\n\n| name      | date       | price |\n| --------- | ---------- | ----- |\n| 240025.IB | 2025.08.18 | 99.60 |\n\n**相关函数**：[appendMktData](https://docs.dolphindb.cn/zh/funcs/a/appendMktData.html)\n"
    },
    "createReactiveStateEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/createReactiveStateEngine.html",
        "signatures": [
            {
                "full": "createReactiveStateEngine(name, metrics, dummyTable, outputTable, [keyColumn], [filter],\n        [snapshotDir], [snapshotIntervalInMsgCount], [keepOrder], [keyPurgeFilter],\n        [keyPurgeFreqInSecond=0], [raftGroup], [outputElapsedMicroseconds=false],\n        [keyCapacity=1024], [parallelism=1], [outputHandler], [msgAsTable=false])",
                "name": "createReactiveStateEngine",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "metrics",
                        "name": "metrics"
                    },
                    {
                        "full": "dummyTable",
                        "name": "dummyTable"
                    },
                    {
                        "full": "outputTable",
                        "name": "outputTable"
                    },
                    {
                        "full": "[keyColumn]",
                        "name": "keyColumn",
                        "optional": true
                    },
                    {
                        "full": "[filter]",
                        "name": "filter",
                        "optional": true
                    },
                    {
                        "full": "[snapshotDir]",
                        "name": "snapshotDir",
                        "optional": true
                    },
                    {
                        "full": "[snapshotIntervalInMsgCount]",
                        "name": "snapshotIntervalInMsgCount",
                        "optional": true
                    },
                    {
                        "full": "[keepOrder]",
                        "name": "keepOrder",
                        "optional": true
                    },
                    {
                        "full": "[keyPurgeFilter]",
                        "name": "keyPurgeFilter",
                        "optional": true
                    },
                    {
                        "full": "[keyPurgeFreqInSecond=0]",
                        "name": "keyPurgeFreqInSecond",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[raftGroup]",
                        "name": "raftGroup",
                        "optional": true
                    },
                    {
                        "full": "[outputElapsedMicroseconds=false]",
                        "name": "outputElapsedMicroseconds",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[keyCapacity=1024]",
                        "name": "keyCapacity",
                        "optional": true,
                        "default": "1024"
                    },
                    {
                        "full": "[parallelism=1]",
                        "name": "parallelism",
                        "optional": true,
                        "default": "1"
                    },
                    {
                        "full": "[outputHandler]",
                        "name": "outputHandler",
                        "optional": true
                    },
                    {
                        "full": "[msgAsTable=false]",
                        "name": "msgAsTable",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [createReactiveStateEngine](https://docs.dolphindb.cn/zh/funcs/c/createReactiveStateEngine.html)\n\n\n\n#### 语法\n\n```\ncreateReactiveStateEngine(name, metrics, dummyTable, outputTable, [keyColumn], [filter],\n        [snapshotDir], [snapshotIntervalInMsgCount], [keepOrder], [keyPurgeFilter],\n        [keyPurgeFreqInSecond=0], [raftGroup], [outputElapsedMicroseconds=false],\n        [keyCapacity=1024], [parallelism=1], [outputHandler], [msgAsTable=false])\n```\n\n#### 详情\n\n创建响应式状态引擎。返回一个表对象，向该表写入数据意味着这些数据进入响应式状态引擎进行计算。\n\n**Note:** 不支持乱序处理机制，用户需要自行保证输入的数据有序。\n\n下列状态函数在 DolphinDB 的响应式状态引擎中的实现均得到了优化。需要注意的是，状态引擎不允许使用未经优化的内置状态函数，且需避免使用聚合函数。\n\n* 累计窗口函数：[cumavg](https://docs.dolphindb.cn/zh/funcs/c/cumavg.html), [cumsum](https://docs.dolphindb.cn/zh/funcs/c/cumsum.html), [cumprod](https://docs.dolphindb.cn/zh/funcs/c/cumprod.html), [cumcount](https://docs.dolphindb.cn/zh/funcs/c/cumcount.html), [cummin](https://docs.dolphindb.cn/zh/funcs/c/cummin.html), [cummax](https://docs.dolphindb.cn/zh/funcs/c/cummax.html), [cumvar](https://docs.dolphindb.cn/zh/funcs/c/cumvar.html), [cumvarp](https://docs.dolphindb.cn/zh/funcs/c/cumvarp.html), [cumstd](https://docs.dolphindb.cn/zh/funcs/c/cumstd.html), [cumstdp](https://docs.dolphindb.cn/zh/funcs/c/cumstdp.html), [cumcorr](https://docs.dolphindb.cn/zh/funcs/c/cumcorr.html), [cumcovar](https://docs.dolphindb.cn/zh/funcs/c/cumcovar.html), [cumbeta](https://docs.dolphindb.cn/zh/funcs/c/cumbeta.html), [cumwsum](https://docs.dolphindb.cn/zh/funcs/c/cumwsum.html), [cumwavg](https://docs.dolphindb.cn/zh/funcs/c/cumwavg.html), [cumfirstNot](https://docs.dolphindb.cn/zh/funcs/c/cumfirstNot.html), [cumlastNot](https://docs.dolphindb.cn/zh/funcs/c/cumlastNot.html), [cummed](https://docs.dolphindb.cn/zh/funcs/c/cummed.html), [cumpercentile](https://docs.dolphindb.cn/zh/funcs/c/cumpercentile.html), [cumnunique](https://docs.dolphindb.cn/zh/funcs/c/cumnunique.html), [cumPositiveStreak](https://docs.dolphindb.cn/zh/funcs/c/cumPositiveStreak.html), [cummdd](https://docs.dolphindb.cn/zh/funcs/c/cummdd.html), [cumcovarp](https://docs.dolphindb.cn/zh/funcs/c/cumcovarp.html)\n* 滑动窗口函数：[ema](https://docs.dolphindb.cn/zh/funcs/e/ema.html), [mavg](https://docs.dolphindb.cn/zh/funcs/m/mavg.html), [msum](https://docs.dolphindb.cn/zh/funcs/m/msum.html), [mcount](https://docs.dolphindb.cn/zh/funcs/m/mcount.html), [mprod](https://docs.dolphindb.cn/zh/funcs/m/mprod.html), [mvar](https://docs.dolphindb.cn/zh/funcs/m/mvar.html), [mvarp](https://docs.dolphindb.cn/zh/funcs/m/mvarp.html), [mstd](https://docs.dolphindb.cn/zh/funcs/m/mstd.html), [mstdp](https://docs.dolphindb.cn/zh/funcs/m/mstdp.html), [mskew](https://docs.dolphindb.cn/zh/funcs/m/mskew.html), [mkurtosis](https://docs.dolphindb.cn/zh/funcs/m/mkurtosis.html), [mmin](https://docs.dolphindb.cn/zh/funcs/m/mmin.html), [mmax](https://docs.dolphindb.cn/zh/funcs/m/mmax.html), [mimin](https://docs.dolphindb.cn/zh/funcs/m/mimin.html), [mimax](https://docs.dolphindb.cn/zh/funcs/m/mimax.html), [mimaxLast](https://docs.dolphindb.cn/zh/funcs/m/mimaxlast.html), [miminLast](https://docs.dolphindb.cn/zh/funcs/m/miminlast.html), [mmed](https://docs.dolphindb.cn/zh/funcs/m/mmed.html), [mpercentile](https://docs.dolphindb.cn/zh/funcs/m/mpercentile.html), [mrank](https://docs.dolphindb.cn/zh/funcs/m/mrank.html), [mcorr](https://docs.dolphindb.cn/zh/funcs/m/mcorr.html), [mcovar](https://docs.dolphindb.cn/zh/funcs/m/mcovar.html), [mbeta](https://docs.dolphindb.cn/zh/funcs/m/mbeta.html), [mwsum](https://docs.dolphindb.cn/zh/funcs/m/mwsum.html), [mwavg](https://docs.dolphindb.cn/zh/funcs/m/mwavg.html), [mmad](https://docs.dolphindb.cn/zh/funcs/m/mmad.html), [mfirst](https://docs.dolphindb.cn/zh/funcs/m/mfirst.html), [mlast](https://docs.dolphindb.cn/zh/funcs/m/mlast.html), [mslr](https://docs.dolphindb.cn/zh/funcs/m/mslr.html), [tmove](https://docs.dolphindb.cn/zh/funcs/t/tmove.html), [tmfirst](https://docs.dolphindb.cn/zh/funcs/t/tmfirst.html), [tmlast](https://docs.dolphindb.cn/zh/funcs/t/tmlast.html), [tmsum](https://docs.dolphindb.cn/zh/funcs/t/tmsum.html), [tmsum2](https://docs.dolphindb.cn/zh/funcs/t/tmsum2.html), [tmavg](https://docs.dolphindb.cn/zh/funcs/t/tmavg.html), [tmcount](https://docs.dolphindb.cn/zh/funcs/t/tmcount.html), [tmvar](https://docs.dolphindb.cn/zh/funcs/t/tmvar.html), [tmvarp](https://docs.dolphindb.cn/zh/funcs/t/tmvarp.html), [tmstd](https://docs.dolphindb.cn/zh/funcs/t/tmstd.html), [tmstdp](https://docs.dolphindb.cn/zh/funcs/t/tmstdp.html), [tmprod](https://docs.dolphindb.cn/zh/funcs/t/tmprod.html), [tmskew](https://docs.dolphindb.cn/zh/funcs/t/tmskew.html), [tmkurtosis](https://docs.dolphindb.cn/zh/funcs/t/tmkurtosis.html), [tmmin](https://docs.dolphindb.cn/zh/funcs/t/tmmin.html), [tmmax](https://docs.dolphindb.cn/zh/funcs/t/tmmax.html), [tmmed](https://docs.dolphindb.cn/zh/funcs/t/tmmed.html), [tmpercentile](https://docs.dolphindb.cn/zh/funcs/t/tmpercentile.html), [tmrank](https://docs.dolphindb.cn/zh/funcs/t/tmrank.html), [tmcovar](https://docs.dolphindb.cn/zh/funcs/t/tmcovar.html), [tmbeta](https://docs.dolphindb.cn/zh/funcs/t/tmbeta.html), [tmcorr](https://docs.dolphindb.cn/zh/funcs/t/tmcorr.html), [tmwavg](https://docs.dolphindb.cn/zh/funcs/t/tmwavg.html), [tmwsum](https://docs.dolphindb.cn/zh/funcs/t/tmwsum.html), [tmoving](https://docs.dolphindb.cn/zh/funcs/ho_funcs/tmoving.html), [moving](https://docs.dolphindb.cn/zh/funcs/ho_funcs/moving.html), [sma](https://docs.dolphindb.cn/zh/funcs/s/sma.html), [wma](https://docs.dolphindb.cn/zh/funcs/w/wma.html), [dema](https://docs.dolphindb.cn/zh/funcs/d/dema.html), [tema](https://docs.dolphindb.cn/zh/funcs/t/tema.html), [trima](https://docs.dolphindb.cn/zh/funcs/t/trima.html), [linearTimeTrend](https://docs.dolphindb.cn/zh/funcs/l/linearTimeTrend.html), [talib](https://docs.dolphindb.cn/zh/funcs/ho_funcs/talib.html), [t3](https://docs.dolphindb.cn/zh/funcs/t/t3.html), [ma](https://docs.dolphindb.cn/zh/funcs/m/ma.html), [gema](https://docs.dolphindb.cn/zh/funcs/g/gema.html), [wilder](https://docs.dolphindb.cn/zh/funcs/w/wilder.html), [mmaxPositiveStreak](https://docs.dolphindb.cn/zh/funcs/m/mmaxPositiveStreak.html), [movingWindowData](https://docs.dolphindb.cn/zh/funcs/m/movingWindowData.html), [tmovingWindowData](https://docs.dolphindb.cn/zh/funcs/t/tmovingWindowData.html), [mcovarp](https://docs.dolphindb.cn/zh/funcs/m/mcovarp.html), [tmcovarp](https://docs.dolphindb.cn/zh/funcs/t/tmcovarp.html)\n* 序列相关函数：[deltas](https://docs.dolphindb.cn/zh/funcs/d/deltas.html), [ratios](https://docs.dolphindb.cn/zh/funcs/r/ratios.html), [ffill](https://docs.dolphindb.cn/zh/funcs/f/ffill.html), [move](https://docs.dolphindb.cn/zh/funcs/m/move.html), [prev](https://docs.dolphindb.cn/zh/funcs/p/prev.html), [iterate](https://docs.dolphindb.cn/zh/funcs/i/iterate.html), [ewmMean](https://docs.dolphindb.cn/zh/funcs/e/ewmMean.html), [ewmVar](https://docs.dolphindb.cn/zh/funcs/e/ewmVar.html), [ewmStd](https://docs.dolphindb.cn/zh/funcs/e/ewmStd.html), [ewmCov](https://docs.dolphindb.cn/zh/funcs/e/ewmCov.html), [ewmCorr](https://docs.dolphindb.cn/zh/funcs/e/ewmCorr.html), [prevState](https://docs.dolphindb.cn/zh/funcs/p/prevState.html), [percentChange](https://docs.dolphindb.cn/zh/funcs/p/percentChange.html)\n* topN 相关函数：[msumTopN](https://docs.dolphindb.cn/zh/funcs/m/msumTopN.html), [mavgTopN](https://docs.dolphindb.cn/zh/funcs/m/mavgTopN.html), [mstdpTopN](https://docs.dolphindb.cn/zh/funcs/m/mstdpTopN.html), [mstdTopN](https://docs.dolphindb.cn/zh/funcs/m/mstdTopN.html), [mvarpTopN](https://docs.dolphindb.cn/zh/funcs/m/mvarpTopN.html), [mvarTopN](https://docs.dolphindb.cn/zh/funcs/m/mvarTopN.html), [mcorrTopN](https://docs.dolphindb.cn/zh/funcs/m/mcorrTopN.html), [mbetaTopN](https://docs.dolphindb.cn/zh/funcs/m/mbetaTopN.html), [mcovarTopN](https://docs.dolphindb.cn/zh/funcs/m/mcovarTopN.html), [mwsumTopN](https://docs.dolphindb.cn/zh/funcs/m/mwsumTopN.html), [cumsumTopN](https://docs.dolphindb.cn/zh/funcs/c/cumsumTopN.html),[cumwsumTopN](https://docs.dolphindb.cn/zh/funcs/c/cumwsumTopN.html), [cumvarTopN](https://docs.dolphindb.cn/zh/funcs/c/cumvarTopN.html), [cumvarpTopN](https://docs.dolphindb.cn/zh/funcs/c/cumvarpTopN.html), [cumstdTopN](https://docs.dolphindb.cn/zh/funcs/c/cumstdTopN.html), [cumstdpTopN](https://docs.dolphindb.cn/zh/funcs/c/cumstdpTopN.html), [cumcorrTopN](https://docs.dolphindb.cn/zh/funcs/c/cumcorrTopN.html), [cumbetaTopN](https://docs.dolphindb.cn/zh/funcs/c/cumbetaTopN.html), [cumavgTopN](https://docs.dolphindb.cn/zh/funcs/m/mstdpTopN.html), [cumskewTopN](https://docs.dolphindb.cn/zh/funcs/c/cumskewTopN.html), [cumkurtosisTopN](https://docs.dolphindb.cn/zh/funcs/c/cumkurtosisTopN.html), [mskewTopN](https://docs.dolphindb.cn/zh/funcs/m/mskewTopN.html), [mkurtosisTopN](https://docs.dolphindb.cn/zh/funcs/m/mkurtosisTopN.html),[tmsumTopN](https://docs.dolphindb.cn/zh/funcs/t/tmsumTopN.html), [tmavgTopN](https://docs.dolphindb.cn/zh/funcs/t/tmavgTopN.html), [tmstdTopN](https://docs.dolphindb.cn/zh/funcs/t/tmstdTopN.html), [tmstdpTopN](https://docs.dolphindb.cn/zh/funcs/t/tmstdpTopN.html), [tmvarTopN](https://docs.dolphindb.cn/zh/funcs/t/tmvarTopN.html), [tmvarpTopN](https://docs.dolphindb.cn/zh/funcs/t/tmvarpTopN.html), [tmskewTopN](https://docs.dolphindb.cn/zh/funcs/t/tmskewTopN.html), [tmkurtosisTopN](https://docs.dolphindb.cn/zh/funcs/t/tmkurtosisTopN.html), [tmbetaTopN](https://docs.dolphindb.cn/zh/funcs/t/tmbetaTopN.html), [tmcorrTopN](https://docs.dolphindb.cn/zh/funcs/t/tmcorrTopN.html), [tmcovarTopN](https://docs.dolphindb.cn/zh/funcs/t/tmcovarTopN.html), [tmwsumTopN](https://docs.dolphindb.cn/zh/funcs/t/tmwsumTopN.html), [mcovarpTopN](https://docs.dolphindb.cn/zh/funcs/m/mcovarpTopN.html), [tmcovarpTopN](https://docs.dolphindb.cn/zh/funcs/t/tmcovarpTopN.html), [cumcovarpTopN](https://docs.dolphindb.cn/zh/funcs/c/cumcovarpTopN.html)\n* 高阶函数：[segmentby](https://docs.dolphindb.cn/zh/funcs/ho_funcs/segmentby.html) (参数 *func* 暂支持 cumsum, cummax, cummin, cumcount, cumavg, cumstd, cumvar, cumstdp, cumvarp), [moving](https://docs.dolphindb.cn/zh/funcs/ho_funcs/moving.html), [byColumn](https://docs.dolphindb.cn/zh/funcs/ho_funcs/byColumn.html), [accumulate](https://docs.dolphindb.cn/zh/funcs/ho_funcs/accumulate.html), [window](https://docs.dolphindb.cn/zh/funcs/ho_funcs/window.html)\n* 其他函数：[talibNull](https://docs.dolphindb.cn/zh/funcs/t/talibNull.html), [dynamicGroupCumsum](https://docs.dolphindb.cn/zh/funcs/d/dynamicGroupCumsum.html), [dynamicGroupCumcount](https://docs.dolphindb.cn/zh/funcs/d/dynamicGroupCumcount.html), [topRange](https://docs.dolphindb.cn/zh/funcs/t/topRange.html), [lowRange](https://docs.dolphindb.cn/zh/funcs/l/lowRange.html), [trueRange](https://docs.dolphindb.cn/zh/funcs/t/trueRange.html), [sumbars](https://docs.dolphindb.cn/zh/funcs/s/sumbars.html)\n* 特殊函数（仅支持在引擎内使用）：[stateIterate](https://docs.dolphindb.cn/zh/funcs/s/stateIterate.html), [conditionalIterate](https://docs.dolphindb.cn/zh/funcs/c/conditionalIterate.html), [genericStateIterate](https://docs.dolphindb.cn/zh/funcs/g/genericStateIterate.html), [genericTStateIterate](https://docs.dolphindb.cn/zh/funcs/g/genericTStateIterate.html)\n\n**Note:** [talib](https://docs.dolphindb.cn/zh/funcs/ho_funcs/talib.html) 作为状态函数时，第一个参数 *func* 只能是响应式状态引擎支持的状态函数。\n\n有关更多流数据引擎的应用场景说明，参考：[流计算引擎](https://docs.dolphindb.cn/zh/funcs/themes/streamingEngine.html)。\n\n#### 计算规则\n\n每注入一条数据都会计算并产生一条结果。用户可以通过设置参数 *filter* 过滤计算结果后输出。 若指定了 *keyColumn* 进行分组，则计算将在组内进行。\n\n**Note:** 状态引擎的输出结果可能和输入顺序不一致，建议配置参数 *keepOrder* = true，保持输出结果的有序性。\n\n#### 引擎的其它功能\n\n* 支持数据/状态清理：状态引擎内部的状态数据是按分组保存的，为避免分组过多，导致引擎内部内存开销过大，可以将历史分组数据进行清理。用户可以通过配置参数 *keyPurgeFilter* 设置清理条件，配置 *keyPurgeFreqInSecond* 设置清理时间间隔。\n* 快照机制：启用快照机制之后，系统若出现异常，可及时将流数据引擎恢复到最新的快照状态。（详情请参考 *snapshotDir* 和 *snapshotIntervalInMsgCount* 的参数说明）\n\n#### 参数\n\n**name** 字符串标量，表示响应式状态引擎的名称，作为其在一个数据节点/计算节点上的唯一标识。可包含字母，数字和下划线，但必须以字母开头。\n\n**metrics** 以元代码的形式表示计算公式，可以是一个或多个表达式、系统内置或用户自定义函数、一个常量标量/向量。当指定为常量向量时，对应的输出列应该设置为数组向量类型。有关元代码的详情可参考 [Metaprogramming](https://docs.dolphindb.cn/zh/progr/objs/meta_progr.html)。若需使用用户自定义函数，请注意以下事项：\n\n1. 需在定义前添加声明 \"@state\"。状态函数只能包含赋值语句和 return 语句。\n\n   自 2.00.9 版本起，支持使用 if-else 条件语句，且条件只能是标量。\n\n   自2.00.11 版本起，支持使用 for 循环（包含 break, continue 语句），请注意不支持嵌套 for 循环，且循环次数须小于 100 次。\n\n2. 状态引擎中可以使用无状态函数或者状态函数。但不允许在无状态函数中嵌套使用状态函数。\n\n3. 若赋值语句的右值是一个多返回值的函数（内置函数或自定义函数），则需要将多个返回值同时赋予多个变量。例如：两个返回值的函数 linearTimeTrend 应用于自定义状态函数中，正确写法为：\n\n   ```\n   @state\n   def forcast2(S, N){\n         linearregIntercept, linearregSlope = linearTimeTrend(S, N)\n         return (N - 1) * linearregSlope + linearregIntercept\n   }\n   ```\n\n4. 在响应式状态引擎中，自定义状态函数不允许包含自赋值语句，如 `a=a+b`。以下示例中，当条件为 false 时，`iif` 表达式会返回 out，从而导致自赋值（`out = out`）并报错。\n\n   ```\n   out = iif((p1 > 0) and (p2 == 0), p1, out)\n   // An assignment statement in state function 'xxx' can't use self reference\n   ```\n\n**dummyTable** 一个表对象，和输入的流数据表的 schema 一致，可以含有数据，亦可为空表。\n\n**outputTable** 计算结果的输出表，可以是内存表或分布式表。使用 `createReactiveStateEngine` 函数之前，需要将输出表预先设立为一个空表，并指定各列列名以及数据类型。响应式状态引擎会将计算结果注入该表。输出表的各列的顺序如下：\n\n1. 分组列。若指定 *keyColumn*，则根据 *keyColumn* 的设置，输出表的前几列必须和 *keyColumn* 设置的列及其顺序保持一致。\n2. 耗时列和记录数。若指定 *outputElapsedMicroseconds* = true，则需要指定一个 LONG 类型和一个 INT 类型的列，分别用于存储引擎内部每个 batch 的数据耗时（单位：微秒）和记录数。\n3. 计算结果列。可为多列。\n\n**keyColumn** 可选参数，字符串标量或向量表示分组列名。若指定该参数，计算将在各分组进行。\n\n**filter** 可选参数，以元代码的形式表示过滤条件。过滤条件只能是一个表达式，并且只能包含 *dummyTable*中的列。设置多个条件时，用逻辑运算符（and, or）连接。引擎会先计算指标，然后根据 *filter*指定的过滤条件，输出满足条件的输入数据对应的计算结果。\n\n若要开启快照机制（snapshot），必须指定 *snapshotDir* 与 *snapshotIntervalInMsgCount*。\n\n**snapshotDir** 可选参数，字符串，表示保存引擎快照的文件目录。\n\n* 指定的目录必须存在，否则系统会提示异常。\n* 创建流数据引擎时，如果指定了 *snapshotDir*，会检查该目录下是否存在快照。如果存在，会加载该快照，恢复引擎的状态。\n* 多个引擎可以指定同一个目录存储快照，用引擎的名称来区分快照文件。\n* 一个引擎的快照可能会使用三个文件名：\n  * 临时存储快照信息：文件名为 *\\<engineName>.tmp*；\n  * 快照生成并刷到磁盘：文件保存为 *\\<engineName>.snapshot*；\n  * 存在同名快照：旧快照自动重命名为 *\\<engineName>.old*。\n\n**snapshotIntervalInMsgCount** 可选参数，为整数类型，表示每隔多少条数据保存一次流数据引擎快照。\n\n**keepOrder** 可选参数，表示输出表数据是否按照输入时的顺序排序。设置 *keepOrder* = true，表示输出表按照输入时的顺序排序。当 *keyColumn* 包含有时间列时，*keepOrder* 默认值为 true，否则默认值为 false。\n\n**keyPurgeFilter** 可选参数，是一个由布尔表达式组成的元代码，表示清理条件。各表达式只能引用 *outputTable* 中的字段。必须指定 *keyColumn* 才能使用该参数。\n\n**keyPurgeFreqInSecond** 正整数，表示触发数据清理需要满足的时间间隔（以秒为单位）。必须指定 *keyColumn* 才能使用该参数。\n\n响应式状态引擎提供了 *keyPurgeFilter*, *keyPurgeFreqInSecond* 两个参数，用来清理不再需要的分组数据。每次数据注入时，系统会依次根据以下条件决定是否触发数据清理：\n\n1. 检测本次数据注入与上一次数据注入的时间间隔是否大于等于 *keyPurgeFreqInSecond* （第一次数据注入时，检测注入时间和引擎创建时间的间隔）；\n2. 若满足上述条件，系统将根据 *keyPurgeFilter* 指定的条件，过滤出待清理的数据；\n3. 若待清理的数据所属的分组数大于等于所有分组数的 10%，则触发清理。\n\n若需要查看清理前后的状态，可以通过调用 [getStreamEngineStat](https://docs.dolphindb.cn/zh/funcs/g/getStreamEngineStat.html) 函数查看 ReactiveStreamEngine 引擎状态的 numGroups 列，来对比响应式状态引擎清理前后分组数的变化。\n\n**raftGroup** 是流数据高可用订阅端 raft 组的 ID (大于1的整数，由流数据高可用相关的配置项 *streamingRaftGroups* 指定)。设置该参数表示开启计算引擎高可用。在 leader 节点创建流数据引擎后，会同步在 follower 节点创建该引擎。每次保存的 snapshot 也会同步到 follower。当 raft 组的 leader 节点宕机时，会自动切换新 leader 节点重新订阅流数据表。请注意，若要指定 *raftGroup*，必须同时指定 *snapshotDir*。 若同时有一批数据注入响应式状态引擎，则引擎内部数据是分批进行计算的，每个批次的数据称为一个 batch，每个 batch 包含记录数由系统决定。\n\n注意，自 3.00.5 版本起，流计算引擎暂不支持高可用功能，*raftGroup* 参数将不生效。\n\n**outputElapsedMicroseconds** 布尔值，可选参数，表示是否输出每个 batch 中数据从注入引擎到计算输出的总耗时，以及每个 batch 包含的总记录数，默认为 false。指定参数 *outputElapsedMicroseconds* 后，在定义 *outputTable* 时需要指定耗时列和记录数两列，详见 *outputTable* 参数说明。\n\n**keyCapacity** 正整数，可选参数，表示建表时系统为该表预分配的 key 分组数量，用于调整状态表中 key 的函数。通过该参数的合理设置，能够降低在 key 分组较多时可能出现的延迟。\n\n**parallelism** 不超过63的正整数，可选参数，表示并行计算的工作线程数，默认值为 1。在计算量较大时，合理地调整该参数能够有效利用计算资源，降低计算耗时。\n\n**Note:** *parallelism* 不能超过 min(许可核数, 逻辑核数)-1。\n\n**outputHandler** 一元函数。设置此参数时，引擎计算结束后，不再将计算结果写到输出表，而是会调用此函数处理计算结果。\n\n**msgAsTable** 布尔标量，表示在设置了参数 outputHandler 时，将引擎的计算结果以表的结构调用函数。默认值为 false，此时将计算结果的每一列作为元素组成元组。\n\n#### 返回值\n\n返回一个表对象。\n\n#### 例子\n\n例1.\n\n```\ndef sum_diff(x, y){\n return (x-y)/(x+y)\n}\nfactor1 = <ema(1000 * sum_diff(ema(price, 20), ema(price, 40)),10) -  ema(1000 * sum_diff(ema(price, 20), ema(price, 40)), 20)>\nshare streamTable(1:0, `sym`time`price, [STRING,DATETIME,DOUBLE]) as tickStream\nshare table(1000:0, `sym`time`factor1, [STRING,DATETIME,DOUBLE]) as result\nrse = createReactiveStateEngine(name=\"reactiveDemo\", metrics =[<time>, factor1], dummyTable=tickStream, outputTable=result, keyColumn=\"sym\", filter=<sym in [\"000001.SH\", \"000002.SH\"]>)\nsubscribeTable(tableName=`tickStream, actionName=\"factors\", handler=tableInsert{rse})\n\ndata1 = table(take(\"000001.SH\", 100) as sym, 2021.02.08T09:30:00 + 1..100 *3 as time, 10+cumsum(rand(0.1, 100)-0.05) as price)\ndata2 = table(take(\"000002.SH\", 100) as sym, 2021.02.08T09:30:00 + 1..100 *3 as time, 20+cumsum(rand(0.2, 100)-0.1) as price)\ndata3 = table(take(\"000003.SH\", 100) as sym, 2021.02.08T09:30:00 + 1..100 *3 as time, 30+cumsum(rand(0.3, 100)-0.15) as price)\ndata = data1.unionAll(data2).unionAll(data3).sortBy!(`time)\n\nreplay(inputTables=data, outputTables=tickStream, timeColumn=`time)\n```\n\n查看结果表 *result*，可见只有过滤条件中的 \"000001.SH\" 与 \"000002.SH\" 这两只股票的计算结果被输出。\n\n若要重复调试以上代码，需要先执行以下代码。\n\n```\nunsubscribeTable(tableName=`tickStream, actionName=\"factors\")\ndropStreamEngine(`reactiveDemo)\nundef(`tickStream, SHARED)\n```\n\n例2. *keyColumn* 设置以股票和日期进行分组计算，并设置输出时间在 \"2012.01.01\" 和\"2012.01.03\" 之间的计算结果。\n\n```\nshare streamTable(1:0, `date`time`sym`market`price`qty, [DATE, TIME, SYMBOL, CHAR, DOUBLE, INT]) as trades\nshare table(100:0, `date`sym`factor1, [DATE, STRING, DOUBLE]) as outputTable\nengine = createReactiveStateEngine(name=\"test\", metrics=<mavg(price, 3)>, dummyTable=trades, outputTable=outputTable, keyColumn=[\"date\",\"sym\"], filter=<date between 2012.01.01 : 2012.01.03>, keepOrder=true)\nsubscribeTable(tableName=`trades, actionName=\"test\", msgAsTable=true, handler=tableInsert{engine})\n\nn=100\ntmp = table(rand(2012.01.01..2012.01.10, n) as date, rand(09:00:00.000..15:59:59.999, n) as time, rand(\"A\"+string(1..10), n) as sym, rand(['B', 'S'], n) as market, rand(100.0, n) as price, rand(1000..2000, n) as qty)\ntrades.append!(tmp)\nselect * from outputTable\n\n//若要重复调试以上代码，需要先执行以下代码\nunsubscribeTable(tableName=`trades, actionName=\"test\")\ndropStreamEngine(`test)\nundef(`trades, SHARED)\n```\n\n例3. 2.00.9 版本后，支持在响应式状态引擎中调用 `moving` 高阶函数计算 array vector。\n\n```\ndefg myFactor(x){\n   return avg(var(x));\n}\nshare streamTable(1:0, `DateTime`SecurityID`Trade, [TIMESTAMP, SYMBOL, DOUBLE[]]) as tickStream\nshare table(1000:0, `SecurityID`DateTime`result, [SYMBOL, DATETIME, DOUBLE]) as result\nrse = createReactiveStateEngine(name=\"reactiveDemo\", metrics =<[DateTime, moving(myFactor, Trade, 3, 1)]>, dummyTable=tickStream, outputTable=result, keyColumn=\"SecurityID\")\nDateTime = 2022.09.15T09:00:00.000+1..12\nSecurityID = take(`600021, 12)\nTrade = [[10.06, 10.06], [10.04], [10.05, 10.06, 10.05, 10.08],[10.02,10.01], [10.06, 10.06, 10.05, 10.05], [10.04], [10.05,10.08, 10.09],[10.02,10.01],[10.06, 10.06, 10.05], [10.04, 10.03], [10.05, 10.06, 10.05, 10.08, 10.09],[10.02]]\nt = table(1:0, `DateTime`SecurityID`Trade, [TIMESTAMP, SYMBOL, DOUBLE[]])\ntableInsert(t, DateTime, SecurityID, Trade)\nrse.append!(t)\nselect * from result\ndropStreamEngine(\"reactiveDemo\")\n```\n\n例4. 本例对例3进行改造，在指标中指定一个常数，表示因子名称。此时，输出表中会包含一个因子名称列。\n\n```\ndefg myFactor(x){\n   return avg(var(x));\n}\nshare streamTable(1:0, `DateTime`SecurityID`Trade, [TIMESTAMP, SYMBOL, DOUBLE[]]) as tickStream\nshare table(1000:0, `SecurityID`DateTime`factorName`result, [SYMBOL, DATETIME, STRING, DOUBLE]) as result\nrse = createReactiveStateEngine(name=\"reactiveDemo\", metrics =<[DateTime,\"factor1\", moving(myFactor, Trade, 3, 1)]>, dummyTable=tickStream, outputTable=result, keyColumn=\"SecurityID\")\nDateTime = 2022.09.15T09:00:00.000+1..12\nSecurityID = take(`600021, 12)\nTrade = [[10.06, 10.06], [10.04], [10.05, 10.06, 10.05, 10.08],[10.02,10.01], [10.06, 10.06, 10.05, 10.05], [10.04], [10.05,10.08, 10.09],[10.02,10.01],[10.06, 10.06, 10.05], [10.04, 10.03], [10.05, 10.06, 10.05, 10.08, 10.09],[10.02]]\nt = table(1:0, `DateTime`SecurityID`Trade, [TIMESTAMP, SYMBOL, DOUBLE[]])\ntableInsert(t, DateTime, SecurityID, Trade)\nrse.append!(t)\nselect * from result\n```\n\n| SecurityID | DateTime            | factorName | result |\n| ---------- | ------------------- | ---------- | ------ |\n| 600021     | 2022.09.15 09:00:00 | factor1    | 0      |\n| 600021     | 2022.09.15 09:00:00 | factor1    | 0.0001 |\n| 600021     | 2022.09.15 09:00:00 | factor1    | 0.0002 |\n| 600021     | 2022.09.15 09:00:00 | factor1    | 0.0006 |\n| 600021     | 2022.09.15 09:00:00 | factor1    | 0.0004 |\n| 600021     | 2022.09.15 09:00:00 | factor1    | 0.0004 |\n| 600021     | 2022.09.15 09:00:00 | factor1    | 0.0003 |\n| 600021     | 2022.09.15 09:00:00 | factor1    | 0.001  |\n| 600021     | 2022.09.15 09:00:00 | factor1    | 0.0007 |\n| 600021     | 2022.09.15 09:00:00 | factor1    | 0.0004 |\n\n例5. 3.00.5 版本后，支持在响应式状态引擎中调用 `movingWindowData` 函数计算 array vector。\n\n```\nx = array(INT[], 0, 1000).append!([[1,2,3], [4,5], [6], [], [7,8,9]])\nt = table([1,1,1,2,2] as id, \"a\" +string(1..5) as sym, x as bids)\noutput = table(1:0, `id`f1`f2, [INT, ANY, ANY])\ntry {dropStreamEngine(\"testRSE\") } catch(ex) { print(ex) }\nengine = createReactiveStateEngine(name=\"testRSE\", metrics=[<movingWindowData(bids, 3)>, <movingWindowData(bids, 3, true)>], dummyTable=t, outputTable=output, keyColumn=`id)\nengine.append!(t)\n\nselect * from output \n```\n\n输出结果：\n\n| id | f1                     | f2                     |\n| -- | ---------------------- | ---------------------- |\n| 1  | (\\[1,2,3])             | (,,\\[1,2,3])           |\n| 1  | (\\[1,2,3],\\[4,5])      | (,\\[1,2,3],\\[4,5])     |\n| 1  | (\\[1,2,3],\\[4,5],\\[6]) | (\\[1,2,3],\\[4,5],\\[6]) |\n| 2  | (\\[00i])               | (,,)                   |\n| 2  | (,\\[7,8,9])            | (,,\\[7,8,9])           |\n\n例6. 本例实时计算累计成交数量与累计成交金额，通过设置 *outputElapsedMicroseconds*=true 额外输出当前 batch 的计算耗时和记录数。\n\n```\nshare streamTable(1:0, `execTime`symbol`execQty`execPrice, [TIMESTAMP, SYMBOL, INT, DOUBLE]) as trades\nshare table(100:0, `symbol`elapsedUs`batchRows`execTime`cumQty`cumAmount, [SYMBOL, LONG, INT, TIMESTAMP, INT, DOUBLE]) as outputTable\n\nrseElapsedDemo = createReactiveStateEngine(\n   name=\"rseElapsedDemo\",\n   metrics=[<execTime>, <cumsum(execQty)>, <cumsum(execQty * execPrice)>],\n   dummyTable=trades,\n   outputTable=outputTable,\n   keyColumn=\"symbol\",\n   keepOrder=true,\n   outputElapsedMicroseconds=true\n)\n\nsubscribeTable(tableName=\"trades\", actionName=\"rseElapsedDemo\", offset=0, handler=append!{rseElapsedDemo}, msgAsTable=true)\n\ninsert into trades values(2024.06.03T09:30:00.000, `600519, 200, 1478.5)\ninsert into trades values(2024.06.03T09:30:00.500, `600519, 150, 1479.2)\ninsert into trades values(2024.06.03T09:30:01.200, `000001, 500, 12.36)\n\nsleep(500)\n\nselect * from outputTable\n```\n\n输出结果可能如下：\n\n| symbol | elapsedUs | batchRows | execTime                | cumQty | cumAmount |\n| ------ | --------- | --------- | ----------------------- | ------ | --------- |\n| 600519 | 492       | 1         | 2024.06.03 09:30:00.000 | 200    | 295,700   |\n| 600519 | 983       | 2         | 2024.06.03 09:30:00.500 | 350    | 517,580   |\n| 000001 | 983       | 2         | 2024.06.03 09:30:01.200 | 500    | 6,180     |\n\n* 设置 *outputElapsedMicroseconds*=true 后，*outputTable* 中必须在分组列后增加一个 LONG 列和一个 INT 列，分别记录 batch 耗时和 batch 记录数。\n\n* 本例中 *keyColumn*=\"symbol\"，因此 cumQty 和 cumAmount 都在股票代码分组内独立累计。\n\n* elapsedUs 列的值与机器配置、负载和 batch 切分情况有关，因此不同环境下会不同。\n\n例7. 本例模拟账户成交处理。设置 *outputHandler* 后，引擎计算结果不再写入 outputTable，而是调用定义的一元函数处理计算结果。*msgAsTable* 用于控制回调参数的结构：\n\n* *msgAsTable*=false：回调参数是由各列组成的元组；\n\n* *msgAsTable*=true：回调参数是一个表。\n\n```\nshare streamTable(1:0, `execTime`accountId`symbol`filledQty, [TIMESTAMP, SYMBOL, SYMBOL, INT]) as fills\nshare table(100:0, `accountId`execTime`cumFilledQty, [SYMBOL, TIMESTAMP, INT]) as ignoredTuple\nshare table(100:0, `accountId`execTime`cumFilledQty, [SYMBOL, TIMESTAMP, INT]) as ignoredTable\nshare table(100:0, `accountId`execTime`cumFilledQty, [SYMBOL, TIMESTAMP, INT]) as tupleResult\nshare table(100:0, `accountId`execTime`cumFilledQty, [SYMBOL, TIMESTAMP, INT]) as tableResult\n\ndef handleTuple(msg){\n   tupleResult.tableInsert(msg[0], msg[1], msg[2])\n}\n\ndef handleTable(msg){\n   tableResult.append!(msg)\n}\n\nengineTuple = createReactiveStateEngine(\n   name=\"rseTupleHandler\",\n   metrics=[<execTime>, <cumsum(filledQty)>],\n   dummyTable=fills,\n   outputTable=ignoredTuple,\n   keyColumn=\"accountId\",\n   keepOrder=true,\n   outputHandler=handleTuple,\n   msgAsTable=false\n)\n\nengineTable = createReactiveStateEngine(\n   name=\"rseTableHandler\",\n   metrics=[<execTime>, <cumsum(filledQty)>],\n   dummyTable=fills,\n   outputTable=ignoredTable,\n   keyColumn=\"accountId\",\n   keepOrder=true,\n   outputHandler=handleTable,\n   msgAsTable=true\n)\n\nsubscribeTable(tableName=\"fills\", actionName=\"engineTuple\", offset=0, handler=append!{engineTuple}, msgAsTable=true)\nsubscribeTable(tableName=\"fills\", actionName=\"engineTable\", offset=0, handler=append!{engineTable}, msgAsTable=true)\n\n\ninsert into fills values(2024.06.03T09:35:00.000, `ACC1001, `600519, 300)\ninsert into fills values(2024.06.03T09:35:02.000, `ACC1001, `600519, 120)\ninsert into fills values(2024.06.03T09:35:05.000, `ACC2003, `000001, 180)\n\n```\n\n分别执行 `select * from tupleResult` 和 `select * from tableResult`。\n\ntupleResult 和 tableResult 的结果都为：\n\n| accountId | execTime                | cumFilledQty |\n| --------- | ----------------------- | ------------ |\n| ACC1001   | 2024.06.03 09:35:00.000 | 300          |\n| ACC1001   | 2024.06.03 09:35:02.000 | 420          |\n| ACC2003   | 2024.06.03 09:35:05.000 | 180          |\n\n* engineTuple 中，`handleTuple` 接收到的是列元组，一元函数中使用 `tableInsert` 将 `msg[0]`、`msg[1]`、`msg[2]` 插入到目标表。\n\n* engineTable 中，`handleTable` 接收到的是结果表，一元函数中使用 `append!` 将结果表插入到目标表。\n\n分别执行 `select * from ignoredTuple` 和 `select * from ignoredTable`，输出结果均为空。这是因为设置了 *outputHandler*，计算结果不会写入 ignoredTuple 和 ignoredTable。\n"
    },
    "createReactiveStatelessEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/createReactiveStatelessEngine.html",
        "signatures": [
            {
                "full": "createReactiveStatelessEngine(name, metrics, outputTable, [snapshotDir], [snapshotIntervalInMsgCount], [filter], [dummyTable], [keyColumn], [timeColumn])",
                "name": "createReactiveStatelessEngine",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "metrics",
                        "name": "metrics"
                    },
                    {
                        "full": "outputTable",
                        "name": "outputTable"
                    },
                    {
                        "full": "[snapshotDir]",
                        "name": "snapshotDir",
                        "optional": true
                    },
                    {
                        "full": "[snapshotIntervalInMsgCount]",
                        "name": "snapshotIntervalInMsgCount",
                        "optional": true
                    },
                    {
                        "full": "[filter]",
                        "name": "filter",
                        "optional": true
                    },
                    {
                        "full": "[dummyTable]",
                        "name": "dummyTable",
                        "optional": true
                    },
                    {
                        "full": "[keyColumn]",
                        "name": "keyColumn",
                        "optional": true
                    },
                    {
                        "full": "[timeColumn]",
                        "name": "timeColumn",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [createReactiveStatelessEngine](https://docs.dolphindb.cn/zh/funcs/c/createReactiveStatelessEngine.html)\n\n\n\n#### 语法\n\ncreateReactiveStatelessEngine(name, metrics, outputTable, \\[snapshotDir], \\[snapshotIntervalInMsgCount], \\[filter], \\[dummyTable], \\[keyColumn], \\[timeColumn])\n\n#### 详情\n\n创建一个响应式无状态引擎，基于当前最新值与其他指标结果进行组合计算，支持对不同数据设置独立的触发规则和计算逻辑。\n\n**Note:** 不支持乱序处理机制，用户需要自行保证输入的数据有序。\n\n#### 计算规则\n\n引擎每有一批数据注入，会根据参数 metrics 中定义的依赖关系，将任何直接依赖或间接依赖这批数据的数据输出，每次输出的条数等于直接或间接依赖这批数据的变量个数。即使这个变量的值没有改变，也会输出。\n\n#### 参数\n\n**name**字符串标量，表示引擎的名称，作为其在一个数据节点/计算节点上的唯一标识。可包含字母，数字和下划线，但必须以字母开头。\n\n**metrics** 可以是表或字典数组，表示规则集合。\n\n* 当 *metrics* 为表时：必须以下四列：\n\n  * formula：STRING 类型，表示计算逻辑。其中的变量采用 *keyColumn* 指定的列中的值标识，*keyColumn* 如不止一列，则使用 `:` 连接各值。\n\n  * outputMetricKey：STRING 类型，为该计算指定指标名。\n\n  * triggerOn：STRING 类型，表示触发该计算的数据标识，即 *keyColumn* 指定的列为该值时触发计算，*keyColumn* 如不止一列，则使用 `:` 连接各值 。\n\n  * filter：一个数据对，表示计算结果的限定范围，属于该范围的结果才会被输出。\n\n* 当 *metrics* 为字典数组时：每个字典表示一条规则，包含键值 *outputName*，formula 以及可选键值 triggerOn，filter。\n\n**outputTable**输出表，包含以下列：\n\n* 若干特定数据标识列，与 *keyColumn* 指定的列名和顺序一致。\n\n* 若干时间列，与 *timeColumn* 指定的列名和顺序一致。\n\n* DOUBLE 类型列的计算结果列 outputValue。\n\n**snapshotDir** 可选参数，字符串，表示保存引擎快照的文件目录。\n\n* 指定的目录必须存在，否则系统会提示异常。\n\n* 创建流数据引擎时，如果指定了 *snapshotDir*，会检查该目录下是否存在快照。如果存在，会加载该快照，恢复引擎的状态。\n\n* 多个引擎可以指定同一个目录存储快照，用引擎的名称来区分快照文件。\n\n* 一个引擎的快照可能会使用三个文件名：\n\n  * 临时存储快照信息：文件名为 \\<engineName>.tmp；\n\n  * 快照生成并刷到磁盘：文件保存为 \\<engineName>.snapshot；\n\n  * 存在同名快照：旧快照自动重命名为 \\<engineName>.old。\n\n**snapshotIntervalInMsgCount** 可选参数，为整数类型，表示每隔多少条数据保存一次流数据引擎快照。\n\n**filter** 可选参数，一个数据对，表示引擎级整体输出过滤范围。仅当 *metrics* 中没有设置为空时才使用该整体过滤。\n\n**dummyTable** 可选参数，是一个表，表示用于初始化引擎的样例表，其 schema 必须与订阅的流数据表一致。当指定 *keyColumn* 或 *timeColumn* 时，*dummyTable* 为必填参数。\n\n**keyColumn** 可选参数，字符串标量或向量，表示输入表中用于标识数据的列名。\n\n**timeColumn** 可选参数，字符串标量或向量，表示输入表的时间戳列名。配置后输出表包含对应时间列，其值为触发本次计算的数据时间；若多个计算触发同时触发，取最大时间。\n\n#### 返回值\n\n返回一个流数据引擎对象句柄，向该句柄写入数据，即为将数据注入引擎。\n\n#### 例子\n\n例1. 现有一个窄表，表中信息如下\n\n| productName | metricName | value |\n| ----------- | ---------- | ----- |\n| product\\_A  | factor1    | 1     |\n| product\\_A  | factor2    | 2     |\n| product\\_B  | factor1    | 1     |\n| product\\_B  | value      | 4     |\n| product\\_C  | factor1    | 2     |\n| product\\_C  | value      | 8     |\n\n上表中，product\\_A:factor1, product\\_A:factor2, product\\_B:factor1, product\\_C:factor1 完全由外部输入决定；一些数据依赖其他数据的值 product\\_B:value=product\\_A:factor1+product\\_A:factor2+product\\_B:factor1，product\\_C:value=product\\_B:value\\*product\\_C:factor1\n\n根据以上信息，通过以下脚本创建引擎\n\n```\n// 创建输出表\nnames = `product`metric`value\ntypes = [STRING, STRING, DOUBLE]\noutputTable = table(1:0, names, types)\n\n// 创建 metrics 描述数据间的依赖关系\nmetrics = array(ANY, 0, 0)\nmetric1 = dict(STRING,ANY)\n// 依赖关系 product_B:value=product_A:factor1+product_A:factor2+product_B:factor1\nmetric1[\"outputName\"] = `product_B:`value\nmetric1[\"formula\"] = <A+B+C>\nmetric1[\"A\"] = `product_A:`factor1\nmetric1[\"B\"] = `product_A:`factor2\nmetric1[\"C\"] = `product_B:`factor1\nmetrics.append!(metric1)\n// 依赖关系 product_C:value=product_B:value*product_C:factor1\nmetric2 = dict(STRING, ANY)\nmetric2[\"outputName\"] =`product_C:`value\nmetric2[\"formula\"] = <A*B>\nmetric2[\"A\"] = `product_B:`value \nmetric2[\"B\"] = `product_C:`factor1\nmetrics.append!(metric2)\n\n// 创建引擎\nengine1 = createReactiveStatelessEngine(\"engine1\", metrics, outputTable)\n```\n\n每次插入数据，无论插入的数据量有多大，都只会返回一次。\n\n第一次插入2条数据，此时，两个依赖关系所需的数据尚不完整，无法计算得到需要的结果，所以输出表中对应值为空。\n\n```\ninsert into engine1 values([\"product_A\",\"product_A\"],[\"factor1\",\"factor2\"],[1,2])\noutputTable\n```\n\n| product    | metric | value |\n| ---------- | ------ | ----- |\n| product\\_B | value  |       |\n| product\\_C | value  |       |\n\n第二次插入1条数据，此时，第一个依赖关系所需数据已经完整，故得到结果，第二个依赖关系所需数据仍不完整，对应值为空。\n\n```\ninsert into engine1 values(\"product_B\",\"factor1\",1)\noutputTable\n```\n\n| product    | metric | value |\n| ---------- | ------ | ----- |\n| product\\_B | value  |       |\n| product\\_C | value  |       |\n| product\\_B | value  | 4     |\n| product\\_C | value  |       |\n\n第三次插入1条数据，此时，第二个依赖关系所需数据完整，输出对应结果。\n\n```\ninsert into engine1 values(\"product_C\",\"factor1\",2)\noutputTable\n```\n\n| product    | metric | value |\n| ---------- | ------ | ----- |\n| product\\_B | value  |       |\n| product\\_C | value  |       |\n| product\\_B | value  | 4     |\n| product\\_C | value  |       |\n| product\\_C | value  | 8     |\n\n第四次插入1条数据，此时，由于数据被修改，依赖此数据的相关数据均会受到影响，并将更新后的结果输出。\n\n```\ninsert into engine1 values(\"product_C\",\"factor1\",3)\noutputTable\n```\n\n| product    | metric | value |\n| ---------- | ------ | ----- |\n| product\\_B | value  |       |\n| product\\_C | value  |       |\n| product\\_B | value  | 4     |\n| product\\_C | value  |       |\n| product\\_C | value  | 8     |\n| product\\_C | value  | 12    |\n\n注意，数据更新后，即使依赖此数据的相关数据的值最终没有变化，也会将最新结果输出\n\n```\ninsert into engine1 values([\"product_A\",\"product_A\"],[\"factor1\",\"factor2\"],[2,1])\noutputTable\n```\n\n| product    | metric | value |\n| ---------- | ------ | ----- |\n| product\\_B | value  |       |\n| product\\_C | value  |       |\n| product\\_B | value  | 4     |\n| product\\_C | value  |       |\n| product\\_C | value  | 8     |\n| product\\_C | value  | 12    |\n| product\\_B | value  | 4     |\n| product\\_C | value  | 12    |\n\n如果只想获得变量的最新状态，可以创建键值表作为输出表\n\n```\nkt = keyedTable(`product`metric, 1:0, `product`metric`value, [STRING, STRING, DOUBLE])\n```\n\n例2. 一个表中实时记录有 factor1，factor2，factor3，factor4 的数据。要求每当 factor3 的数据来到时，计算 factor1+factor2+factor3 的结果 value1，以及 value1\\*factor3 的结果 value2，且仅当 value2 属于 \\[10,40] 时才输出。\n\n```\nmetricsTable = table(\n    // 指标计算公式列表\n    [\n        '\"factor1\" + \"factor2\" + \"factor3\"',  // 对应 eventA 的计算逻辑\n        '\"value1\"*\"factor3\"'                  // 模拟计算逻辑\n    ] as formula,\n    // 对应每个公式的输出指标名称\n    [\"value1\", \"value2\"] as outputMetricKey,\n    // 触发条件，仅当对应字段更新时计算公式\n    [\"factor3\", \"\"] as triggerOn,\n    // 输出过滤器，仅当结果值满足条件时输出\n    [NULL,2.0:100.0] as filter  // 仅对 R134_A 生效，第二条为空\n)\n\n// 创建输入数据表和输出表\nshare streamTable(1000:0, `MetricKey`timestamp`value,[STRING, TIMESTAMP,DOUBLE]) as inputTable\nshare streamTable(1000:0, `MetricKey`timestamp`value,[STRING, TIMESTAMP,DOUBLE]) as outputTable\n\n// 创建引擎\nengine1 = createReactiveStatelessEngine(\"engine1\", metricsTable, outputTable, dummyTable=inputTable, keyColumn=`MetricKey, timeColumn=`timestamp)\nsubscribeTable(tableName=\"inputTable\", actionName=\"statelessEngine\", handler=tableInsert{engine1})\n\n// 插入数据\ninsert into inputTable values([\"factor1\",\"factor2\"],[2025.10.11T09:00:00.000,2025.10.11T09:00:00.000], [1,2])\ninsert into inputTable values([\"factor3\"],[2025.10.11T09:00:01.000],[3])\ninsert into inputTable values([\"factor4\"],[2025.10.11T09:00:02.000],[3])\ninsert into inputTable values([\"factor3\"],2025.10.11T09:00:03.000,[4])\ninsert into inputTable values([\"factor3\"],2025.10.11T09:00:04.000,[6])\n\n// 查看输出表\noutputTable\n```\n\n| MetricKey | timestamp               | value |\n| --------- | ----------------------- | ----- |\n| value1    | 2025.10.11 09:00:01.000 | 6     |\n| value2    | 2025.10.11 09:00:01.000 | 18    |\n| value1    | 2025.10.11 09:00:03.000 | 7     |\n| value2    | 2025.10.11 09:00:03.000 | 28    |\n| value1    | 2025.10.11 09:00:04.000 | 9     |\n\n上述结果中可以看到， 09:00:01.000 时 factor3 的数据触发了 value1 和 value2 的计算。09:00:02.000 时 factor4 的数据并不会触发计算。09:00:03.000 和 09:00:04.000 时 factor3 的数据都触发了 value1 和 value2 的计算，但因09:00:04.000 时计算结果中 value2 大于 40，所以不会输出。\n"
    },
    "createRuleEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/createRuleEngine.html",
        "signatures": [
            {
                "full": "createRuleEngine(name, ruleSets, dummyTable, outputColumns, outputTable, [policy], [ruleSetColumn], [callback], [snapshotDir], [snapshotIntervalInMsgCount])",
                "name": "createRuleEngine",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "ruleSets",
                        "name": "ruleSets"
                    },
                    {
                        "full": "dummyTable",
                        "name": "dummyTable"
                    },
                    {
                        "full": "outputColumns",
                        "name": "outputColumns"
                    },
                    {
                        "full": "outputTable",
                        "name": "outputTable"
                    },
                    {
                        "full": "[policy]",
                        "name": "policy",
                        "optional": true
                    },
                    {
                        "full": "[ruleSetColumn]",
                        "name": "ruleSetColumn",
                        "optional": true
                    },
                    {
                        "full": "[callback]",
                        "name": "callback",
                        "optional": true
                    },
                    {
                        "full": "[snapshotDir]",
                        "name": "snapshotDir",
                        "optional": true
                    },
                    {
                        "full": "[snapshotIntervalInMsgCount]",
                        "name": "snapshotIntervalInMsgCount",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [createRuleEngine](https://docs.dolphindb.cn/zh/funcs/c/createRuleEngine.html)\n\n\n\n#### 语法\n\ncreateRuleEngine(name, ruleSets, dummyTable, outputColumns, outputTable, \\[policy], \\[ruleSetColumn], \\[callback], \\[snapshotDir], \\[snapshotIntervalInMsgCount])\n\n#### 详情\n\n`createRuleEngine` 用于创建一个规则引擎。\n\n**Note:** 不支持乱序处理机制，用户需要自行保证输入的数据有序。\n\n该引擎适用于对流数据逐条执行规则判断的场景。可以预先为不同类型的数据定义不同规则，例如按设备编号、证券代码、业务类别等将数据路由到对应规则集，再基于字段值、字段间运算结果或多个条件组合，对每条数据进行实时检查。\n\n引擎主要可以完成以下工作：\n\n* 按字段值匹配不同规则集，对不同类别的数据应用不同检查逻辑。\n\n* 对单条数据执行一条或多条规则判断，例如阈值判断、区间判断，以及 `value*price > 10` 这类基于表达式的计算判断。\n\n* 输出规则检查结果；既可以返回首个未通过规则的下标，也可以返回全部规则的布尔检查结果。\n\n* 在输出结果后通过回调函数继续处理，例如触发告警、筛选异常数据、写入下游表。\n\n因此，可以将规则引擎理解为一个面向实时数据的“条件检查与结果分发”组件：它负责根据数据内容选取规则、完成判断，并将结果输出给下游消费。\n\n**应用场景**\n\n规则引擎支持毫秒级实时响应、精准处理大规模时序数据以及动态规则调整，可应用于如下场景：\n\n* 物联网：设备监测，例如监测设备的温度、湿度；电力监控，例如监控电压、用电量。\n\n* 金融：风控场景，例如过滤订单、监控股票成交量、设置超量预警信号等。\n\n**与[异常检测引擎](https://docs.dolphindb.cn/zh/funcs/c/createAnomalyDetectionEngine.html)的异同**\n\n* 规则引擎是无状态引擎；异常检测引擎是有状态的。\n\n* 规则引擎可以对不同数据，采用不同的检查规则；异常检测引擎会对所有数据以相同的规则进行检测。\n\n* 规则引擎可以动态调整检测规则，包括增加、删除和修改；异常检测引擎创建后无法修改。\n\n* 规则引擎支持设置回调函数，用户可根据检测结果进行相应处理；异常检测引擎不支持设置回调函数。\n\n#### 参数\n\n**name** 是一个字符串，表示引擎名。\n\n**ruleSets** 是一个字典，表示规则集。字典的 key 是 STRING 或 INT 类型，value 是一个包含元代码的元组。如果 key 为NULL，表示此条为默认规则。如果未指定 *ruleSetColumn*，或数据未命中任何规则，将采用默认规则检查数据。一个规则集必须包含默认规则。\n\n**dummyTable** 一个表对象，和输入的流数据表的 schema 一致，可以含有数据，亦可为空表。\n\n**outputColumns** 一个 STRING 类型向量，表示输入表中需要保留到输出表的列。\n\n**outputTable** 是一个表对象，表示输出表，可以是内存表或者分布式表，包含 ***outputColumns*** 指示的列，以及一列规则检查的结果列。当参数 *policy* 设置为 \"shortcut\" 时，最后一列为 INT 类型的标量；否则，为 BOOL 类型的向量。\n\n**policy** 是一个字符串标量，表示规则检查策略。可取以下值：\n\n* \"shortcut\" 是默认值，代表短路逻辑。当检查到任一规则不符合（计算结果为 false）时，规则引擎立即停止检查并返回该规则的 index（从 0 开始）；如果所有规则都符合，则返回 NULL。比如数据匹配到如下规则，当 age 字段的值小于 18 时，计算结果为 false，规则引擎停止检查并返回 0 （规则的 index）到输出表中。\n\n  ```\n  (< age > 18 >,< income > 5000 >,< debtRatio < 0.5 >)\n  ```\n\n* \"all\" 代表检查全部规则，返回规则集的检查结果，布尔类型。比如数据匹配到如下规则，当 `voltage=220`、`current=37.11`、`temperature=39`，检查结果为 `[false, false, false]`。\n\n  ```\n  (< voltage > 221.86 >,< current > 39.96 >,< temperature > 44.43 >)\n  ```\n\n**ruleSetColumn** 是一个 STRING 类型标量，为输入表的某一列名，如果没有定义或者输入数据中的该列数据没有命中任何一个规则集，则使用默认规则，即规则集中 key 为 NULL 时所指示的规则。\n\n**callback** 是一个函数，其参数为一个元组，是引擎输出的一行。若设置此参数，引擎每处理一行，在将引擎处理结果输出到输出表的同时，会将该结果作为入参调用此函数。\n\n**snapshotDir** 与 **snapshotIntervalInMsgCount** 可选参数，无需配置，实际不生效，仅用于兼容 ORCA 框架。\n\n#### 返回值\n\n返回一个表对象。\n\n#### 例子\n\n##### 实现步骤\n\n1. 创建分布式表，存放回调函数输出的数据。\n\n2. 定义规则集，用于检查输入的数据。\n\n3. 定义回调函数，根据检查结果进一步处理数据。\n\n4. 创建规则引擎。\n\n5. 向规则引擎输入数据。\n\n##### 示例代码\n\n**创建分布式表**\n\n```\n// 创建分布式表，存放回调函数输出的数据\ndb = database(\"dfs://temp\", VALUE, 1..3)\nt1 = table(1:0, `sym`value`price, [INT,DOUBLE,DOUBLE])\npt = db.createPartitionedTable(t1,`pt,`sym)\n```\n\n**定义规则集**\n\n如下规则集包含三组规则，规则的 key 分别为 1、2、NULL，其中 NULL 代表默认规则。\n\n```\nx = [1, 2, NULL]\ny = [ [ < value > 1 > ], [ < price < 2 >, < price > 6 > ], [ < value*price > 10 > ] ]\nruleSets = dict(x, y)\n/* 输出：\n->(< (value * price) > 10 >)\n2->(< price < 2 >,< price > 6 >)\n1->(< value > 1 >)\n*/\n```\n\n**定义回调函数**\n\n如下回调函数用于判断引擎每一行的检查结果中首个值是否为 `false`，如是，则将对应数据插入分布式表。\n\n```\ndef writeBack(result){\n    if(result.rule[0]==false){\n        temp = select sym,value,price from result\n        loadTable(\"dfs://temp\",`pt).append!(temp)\n    }\n}\n```\n\n**创建规则引擎**\n\n```\nnames = `sym`value`price`quantity\ntypes = [INT, DOUBLE, DOUBLE, DOUBLE]\ndummy = table(1:0, names, types)\noutputNames = `sym`value`price`rule\noutputTypes = [INT, DOUBLE, DOUBLE, BOOL[]]\noutputTable = table(10:0, outputNames, outputTypes)\ntest = createRuleEngine(\n        name=\"ruleEngineTest\",\n        ruleSets=ruleSets,\n        dummyTable=dummy,\n        outputColumns=[\"sym\",\"value\",\"price\"],\n        outputTable=outputTable,\n        policy=\"all\",\n        ruleSetColumn=\"sym\",\n        callback=writeBack)\n```\n\n**向规则引擎输入数据**\n\n插入两条 `sym=1` 的数据，此时会根据规则集 *ruleSets* 中 `key=1` 对应的规则，即 `value >1` 来检查这两条数据。\n\n```\ntest.append!(table(1 as sym, 0 as value, 2 as price, 3 as quantity))\ntest.append!(table(1 as sym, 2 as value, 2 as price, 3 as quantity))\n```\n\n插入三条 `sym=2` 的数据，此时会根据规则集 *ruleSets* 中 `key=2` 对应的规则，即 `price < 2` 和 `price > 6` 来检查这三条数据。\n\n```\ntest.append!(table(2 as sym, 2 as value, 0 as price, 3 as quantity))\ntest.append!(table(2 as sym, 2 as value, 4 as price, 3 as quantity))\ntest.append!(table(2 as sym, 2 as value, 8 as price, 3 as quantity))\n```\n\n插入两条 `sym=3` 的数据，由于规则集 *ruleSets* 只设置了键值为 1 和 2 的规则，此时会根据规则集中 `key=NULL` 对应的规则，即 `value*price > 10` 来检查这两条数据。\n\n```\ntest.append!(table(3 as sym, 2 as value, 3 as price, 3 as quantity))\ntest.append!(table(3 as sym, 2 as value, 6 as price, 3 as quantity))\n```\n\n查看输出表 outputTable 的内容。\n\n```\nselect * from outputTable\n```\n\n| sym | value | price |      rule      |\n| :-: | :---: | :---: | :------------: |\n|  1  |   0   |   2   |    \\[false]    |\n|  1  |   2   |   2   |     \\[true]    |\n|  2  |   2   |   0   |  \\[true,false] |\n|  2  |   2   |   4   | \\[false,false] |\n|  2  |   2   |   8   |  \\[false,true] |\n|  3  |   2   |   3   |    \\[false]    |\n|  3  |   2   |   6   |     \\[true]    |\n\n回调函数处理后，所有检查结果中首个值为`false`的行均被写入了分布式表 dfs\\://temp/pt。\n\n```\nselect * from loadTable(\"dfs://temp\",\"pt\")\n```\n\n| sym | value | price |\n| :-: | :---: | :---: |\n|  1  |   0   |   2   |\n|  2  |   2   |   4   |\n|  2  |   2   |   8   |\n|  3  |   2   |   3   |\n\n相关函数：[updateRule](https://docs.dolphindb.cn/zh/funcs/u/updateRule.html)、[deleteRule](https://docs.dolphindb.cn/zh/funcs/d/deleteRule.html)、[getRules](https://docs.dolphindb.cn/zh/funcs/g/getrules.html)\n"
    },
    "createSchema": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/createSchema.html",
        "signatures": [
            {
                "full": "createSchema(catalog, dbUrl, schema)",
                "name": "createSchema",
                "parameters": [
                    {
                        "full": "catalog",
                        "name": "catalog"
                    },
                    {
                        "full": "dbUrl",
                        "name": "dbUrl"
                    },
                    {
                        "full": "schema",
                        "name": "schema"
                    }
                ]
            }
        ],
        "markdown": "### [createSchema](https://docs.dolphindb.cn/zh/funcs/c/createSchema.html)\n\n\n\n#### 语法\n\ncreateSchema(catalog, dbUrl, schema)\n\n#### 详情\n\n把指定数据库添加到指定的 catalog 中。\n\n由于数据库的 dbUrl 是全局唯一的，但不同 catalog 中的 schema 可以重名。因此需要先将数据库和 dbUrl 进行解耦。然后在将指定数据库添加到指定 catalog 时，需要为该数据库指定一个 schema 名称（类似该数据库的别名）。在后续 catalog 的相关操作中，都将使用该数据库的 schema 名称而非 dbUrl。\n\n注意：不支持将数据库同时加到两个 catalog 中。\n\n#### 参数\n\n**catalog** 字符串标量，表示 catalog 的名称。\n\n**dbUrl** 字符串标量，表示数据库的路径。\n\n**schema** 字符串标量，表示数据库对应的 schema 名称。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\ncreateSchema(\"catalog1\", \"dfs://db1\", \"schema1\")\n```\n"
    },
    "createSessionWindowEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/createSessionWindowEngine.html",
        "signatures": [
            {
                "full": "createSessionWindowEngine(name, sessionGap, metrics, dummyTable, outputTable, [timeColumn], [useSystemTime=false], [keyColumn], [updateTime], [useSessionStartTime=true], [snapshotDir], [snapshotIntervalInMsgCount], [raftGroup], [forceTriggerTime])",
                "name": "createSessionWindowEngine",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "sessionGap",
                        "name": "sessionGap"
                    },
                    {
                        "full": "metrics",
                        "name": "metrics"
                    },
                    {
                        "full": "dummyTable",
                        "name": "dummyTable"
                    },
                    {
                        "full": "outputTable",
                        "name": "outputTable"
                    },
                    {
                        "full": "[timeColumn]",
                        "name": "timeColumn",
                        "optional": true
                    },
                    {
                        "full": "[useSystemTime=false]",
                        "name": "useSystemTime",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[keyColumn]",
                        "name": "keyColumn",
                        "optional": true
                    },
                    {
                        "full": "[updateTime]",
                        "name": "updateTime",
                        "optional": true
                    },
                    {
                        "full": "[useSessionStartTime=true]",
                        "name": "useSessionStartTime",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[snapshotDir]",
                        "name": "snapshotDir",
                        "optional": true
                    },
                    {
                        "full": "[snapshotIntervalInMsgCount]",
                        "name": "snapshotIntervalInMsgCount",
                        "optional": true
                    },
                    {
                        "full": "[raftGroup]",
                        "name": "raftGroup",
                        "optional": true
                    },
                    {
                        "full": "[forceTriggerTime]",
                        "name": "forceTriggerTime",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [createSessionWindowEngine](https://docs.dolphindb.cn/zh/funcs/c/createSessionWindowEngine.html)\n\n\n\n#### 语法\n\ncreateSessionWindowEngine(name, sessionGap, metrics, dummyTable, outputTable, \\[timeColumn], \\[useSystemTime=false], \\[keyColumn], \\[updateTime], \\[useSessionStartTime=true], \\[snapshotDir], \\[snapshotIntervalInMsgCount], \\[raftGroup], \\[forceTriggerTime])\n\n#### 详情\n\n创建流数据会话窗口引擎。\n\n`createSessionWindowEngine` 的参数绝大多数与 `createTimeSeriesEngine` 一样，只有 *sessionGap* 和 *useSessionStartTime* 是它独有的参数。*sessionGap* 决定了一个会话窗口何时结束，*useSessionStartTime* 决定了输出表时间列的时间为各个窗口的起始时刻还是结束时刻。\n\n更多流数据引擎的应用场景说明可以参考 [流计算引擎](https://docs.dolphindb.cn/zh/funcs/themes/streamingEngine.html)。\n\n自 2.00.11 版本开始，*dummyTable* 和 *outputTable*支持 array vector，但不支持在计算中使用 array vector，即 *metrics* 中不能包含 array vector 列。\n\n#### 计算规则\n\n若某条数据之后，经过 *sessionGap* 指定的时间长度内，没有新数据到来，就进行一次窗口截断（以截断前最后一条数据的时间戳 + *sessionGap* 作为窗口的结束时刻）。窗口结束后新到来的一条数据将触发该窗口的计算。\n\n**Note:** 如果不使用数据输入引擎时的系统时间作为时间列进行计算，输入流数据表中时间列（*timeColumn*）所指示的时间戳必须为非递减序列；如果同时指定了分组列（*keyColumn*），则按照分组分别进行计算，组内数据的时间戳必须为非递减序列。否则，乱序数据将被直接丢弃，不参与计算。\n\n#### 参数\n\n由于会话窗口引擎的绝大多数参数与时间序列引擎重合，请参照 [createTimeSeriesEngine](https://docs.dolphindb.cn/zh/funcs/c/createTimeSeriesEngine.html) 中参数介绍。这里仅介绍与时间序列引擎不同的参数：\n\n**sessionGap** 必选参数，正整数标量，是判断窗口结束的时间指标，表示某条数据到来后若等待该时间仍无更新的数据到来，就终止当前窗口。此参数的时间精度取决于 *useSystemTime* 参数。\n\n**useSessionStartTime**: 可选参数，布尔值，默认值为 true，表示输出表中的时刻为数据窗口起始时刻，即每个窗口中第一条数据的时间戳。若设置为 false，则表示输出表中的时刻为数据窗口结束时刻，即每个窗口中最后一条数据的时刻+ *sessionGap*。如果指定 *updateTime* ，*useSessionStartTime* 必须为 true。\n\n**forceTriggerTime** 可选参数，非负整数，单位与 *timeColumn* 的时间精度一致。该参数仅在设置 *useSystemTime* = false 时起效。当系统收到最后一条数据后，经过 *forceTriggerTime* 时间，将强制触发未计算的窗口进行计算。\n\n**Note:** 若设置了 *keyColumn*，则各分组内进行上述操作。\n\n#### 返回值\n\n返回一个表对象。\n\n#### 例子\n\n\\*\\*例1.\\*\\*下例通过 `createSessionWindowEngine` 函数创建了一个会话窗口引擎，设置 *sessionGap*=5 ms，基于连续交易活动时间段而非固定时间段（区别于时间序列引擎）进行窗口划分。\n\n会话窗口引擎识别每只股票的交易活跃期：当某股票在 5ms 内没有新交易数据时，窗口结束并输出该活动期内的成交量总和。\n\n```\nshare streamTable(1000:0, `time`sym`volume, [TIMESTAMP, SYMBOL, INT]) as trades\nshare table(10000:0, `time`sym`sumVolume, [TIMESTAMP, SYMBOL, INT]) as output1\nengine_sw = createSessionWindowEngine(name = \"engine_sw\", sessionGap = 5, metrics = <sum(volume)>, dummyTable = trades, outputTable = output1, timeColumn = `time, keyColumn=`sym)\nsubscribeTable(tableName=\"trades\", actionName=\"append_engine_sw\", offset=0, handler=append!{engine_sw}, msgAsTable=true)\n\nn = 5\ntimev = 2018.10.12T10:01:00.000 + (1..n)\nsymv=take(`A`B`C,n)\nvolumev = (1..n)%1000\ninsert into trades values(timev, symv, volumev)\n\nn = 5\ntimev = 2018.10.12T10:01:00.010 + (1..n)\nvolumev = (1..n)%1000\nsymv=take(`A`B`C,n)\ninsert into trades values(timev, symv, volumev)\n\nn = 6\ntimev = 2018.10.12T10:01:00.020 + 1 2 3 8 14 20\nvolumev = (1..n)%1000\nsymv=take(`A`B`C,n)\ninsert into trades values(timev, symv, volumev)\n\nselect * from output1;\n```\n\n输出返回：\n\n| time                    | sym | volume |\n| ----------------------- | --- | ------ |\n| 2018.10.12T10:01:00.001 | A   | 5      |\n| 2018.10.12T10:01:00.002 | B   | 7      |\n| 2018.10.12T10:01:00.003 | C   | 3      |\n| 2018.10.12T10:01:00.011 | A   | 5      |\n| 2018.10.12T10:01:00.012 | B   | 7      |\n| 2018.10.12T10:01:00.013 | C   | 3      |\n| 2018.10.12T10:01:00.021 | A   | 1      |\n| 2018.10.12T10:01:00.022 | B   | 2      |\n| 2018.10.12T10:01:00.023 | C   | 3      |\n\n\\*\\*例2.\\*\\*通过指定 *forceTriggerTime*，可以强制触发尚未计算的窗口计算。\n\n清理环境：\n\n```\ndropStreamEngine(`engine_sw)\nunsubscribeTable(, tableName=\"trades\", actionName=\"append_engine_sw\")\n```\n\n重新创建会话引擎，此时指定 *forceTriggerTime* 为 1000ms，意味着在引擎收到最后一条消息后，经过 1000ms，将会触发所有分组数据的计算和输出：\n\n```\nshare streamTable(1000:0, `time`sym`volume, [TIMESTAMP, SYMBOL, INT]) as trades\nshare table(10000:0, `time`sym`sumVolume, [TIMESTAMP, SYMBOL, INT]) as output1\nengine_sw = createSessionWindowEngine(name = \"engine_sw\", sessionGap = 5, metrics = <sum(volume)>, dummyTable = trades, outputTable = output1, timeColumn = `time, keyColumn=`sym, forceTriggerTime=1000)\nsubscribeTable(tableName=\"trades\", actionName=\"append_engine_sw\", offset=0, handler=append!{engine_sw}, msgAsTable=true)\n\nn = 5\ntimev = 2018.10.12T10:01:00.000 + (1..n)\nsymv=take(`A`B`C,n)\nvolumev = (1..n)%1000\ninsert into trades values(timev, symv, volumev)\n\nn = 5\ntimev = 2018.10.12T10:01:00.010 + (1..n)\nvolumev = (1..n)%1000\nsymv=take(`A`B`C,n)\ninsert into trades values(timev, symv, volumev)\n\nn = 6\ntimev = 2018.10.12T10:01:00.020 + 1 2 3 8 14 20\nvolumev = (1..n)%1000\nsymv=take(`A`B`C,n)\ninsert into trades values(timev, symv, volumev)\n\nsleep(1100)\nselect * from output1;\n```\n\n再次查询输出表，可以得到以下结果。可见 *forceTriggerTime* 成功强制触发了最后 3 个已结束但未计算的窗口。而在例 1 中，由于未设置 *forceTriggerTime*，且没有后续数据触发计算，这些窗口未能输出结果。\n\n| time                    | sym | volume |\n| ----------------------- | --- | ------ |\n| 2018.10.12T10:01:00.001 | A   | 5      |\n| 2018.10.12T10:01:00.002 | B   | 7      |\n| 2018.10.12T10:01:00.003 | C   | 3      |\n| 2018.10.12T10:01:00.011 | A   | 5      |\n| 2018.10.12T10:01:00.012 | B   | 7      |\n| 2018.10.12T10:01:00.013 | C   | 3      |\n| 2018.10.12T10:01:00.021 | A   | 1      |\n| 2018.10.12T10:01:00.022 | B   | 2      |\n| 2018.10.12T10:01:00.023 | C   | 3      |\n| 2018.10.12T10:01:00.028 | A   | 4      |\n| 2018.10.12T10:01:00.034 | B   | 5      |\n| 2018.10.12T10:01:00.040 | C   | 6      |\n\n\\*\\*例3.\\*\\*设置 *useSessionStartTime* 为 false， 输出窗口结束时刻。\n\n清理环境：\n\n```\ndropStreamEngine(`engine_sw)\nunsubscribeTable(, tableName=\"trades\", actionName=\"append_engine_sw\")\n```\n\n重新创建会话引擎，此时设置 *useSessionStartTime* 为 false，使输出表中的时间列显示每个会话窗口的结束时刻（即最后一条数据时间+*sessionGap*），而不是默认的窗口开始时刻。\n\n```\nshare streamTable(1000:0, `time`sym`volume, [TIMESTAMP, SYMBOL, INT]) as trades\nshare table(10000:0, `time`sym`sumVolume, [TIMESTAMP, SYMBOL, INT]) as output1\nengine_sw = createSessionWindowEngine(name = \"engine_sw\", sessionGap = 5, metrics = <sum(volume)>, dummyTable = trades, outputTable = output1, timeColumn = `time, keyColumn=`sym, useSessionStartTime=false, forceTriggerTime=1000)\nsubscribeTable(tableName=\"trades\", actionName=\"append_engine_sw\", offset=0, handler=append!{engine_sw}, msgAsTable=true)\n\nn = 5\ntimev = 2018.10.12T10:01:00.000 + (1..n)\nsymv=take(`A`B`C,n)\nvolumev = (1..n)%1000\ninsert into trades values(timev, symv, volumev)\n\nn = 5\ntimev = 2018.10.12T10:01:00.010 + (1..n)\nvolumev = (1..n)%1000\nsymv=take(`A`B`C,n)\ninsert into trades values(timev, symv, volumev)\n\nn = 6\ntimev = 2018.10.12T10:01:00.020 + 1 2 3 8 14 20\nvolumev = (1..n)%1000\nsymv=take(`A`B`C,n)\ninsert into trades values(timev, symv, volumev)\n\nsleep(1100)\nselect * from output1;\n```\n\n| time                    | sym | sumVolume |\n| ----------------------- | --- | --------- |\n| 2018.10.12 10:01:00.008 | C   | 3         |\n| 2018.10.12 10:01:00.009 | A   | 5         |\n| 2018.10.12 10:01:00.010 | B   | 7         |\n| 2018.10.12 10:01:00.018 | C   | 3         |\n| 2018.10.12 10:01:00.019 | A   | 5         |\n| 2018.10.12 10:01:00.020 | B   | 7         |\n| 2018.10.12 10:01:00.026 | A   | 1         |\n| 2018.10.12 10:01:00.027 | B   | 2         |\n| 2018.10.12 10:01:00.028 | C   | 3         |\n| 2018.10.12 10:01:00.033 | A   | 4         |\n| 2018.10.12 10:01:00.039 | B   | 5         |\n| 2018.10.12 10:01:00.045 | C   | 6         |\n"
    },
    "createSnapshotJoinEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/createsnapshotjoinengine.html",
        "signatures": [
            {
                "full": "createSnapshotJoinEngine(name, leftTable, rightTable, outputTable, metrics, matchingColumn, [timeColumn], [outputElapsedMicroseconds=false], [keepLeftDuplicates=false], [keepRightDuplicates=false], [isInnerJoin=true], [snapshotDir], [snapshotIntervalInMsgCount])",
                "name": "createSnapshotJoinEngine",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "leftTable",
                        "name": "leftTable"
                    },
                    {
                        "full": "rightTable",
                        "name": "rightTable"
                    },
                    {
                        "full": "outputTable",
                        "name": "outputTable"
                    },
                    {
                        "full": "metrics",
                        "name": "metrics"
                    },
                    {
                        "full": "matchingColumn",
                        "name": "matchingColumn"
                    },
                    {
                        "full": "[timeColumn]",
                        "name": "timeColumn",
                        "optional": true
                    },
                    {
                        "full": "[outputElapsedMicroseconds=false]",
                        "name": "outputElapsedMicroseconds",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[keepLeftDuplicates=false]",
                        "name": "keepLeftDuplicates",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[keepRightDuplicates=false]",
                        "name": "keepRightDuplicates",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[isInnerJoin=true]",
                        "name": "isInnerJoin",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[snapshotDir]",
                        "name": "snapshotDir",
                        "optional": true
                    },
                    {
                        "full": "[snapshotIntervalInMsgCount]",
                        "name": "snapshotIntervalInMsgCount",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [createSnapshotJoinEngine](https://docs.dolphindb.cn/zh/funcs/c/createsnapshotjoinengine.html)\n\n\n\n#### 语法\n\ncreateSnapshotJoinEngine(name, leftTable, rightTable, outputTable, metrics, matchingColumn, \\[timeColumn], \\[outputElapsedMicroseconds=false], \\[keepLeftDuplicates=false], \\[keepRightDuplicates=false], \\[isInnerJoin=true], \\[snapshotDir], \\[snapshotIntervalInMsgCount])\n\n#### 详情\n\n创建流数据表的快照连接引擎。该引擎以*matchingColumn*作为连接列，将两个流数据表进行实时的内连接（等值连接）或外连接（左/右连接）。\n\n**Note:** 不支持乱序处理机制，用户需要自行保证输入的数据有序。\n\n#### 参数\n\n**name**：字符串标量，表示 Snapshot join 引擎的名称，作为其在一个数据节点/计算节点上的唯一标识。可包含字母，数字和下划线，但必须以字母开头。\n\n**leftTable**：表对象，表示左表，其结构必须与输入的流数据表相同。\n\n**rightTable**：表对象，表示右表，其结构必须与输入的流数据表相同。\n\n**outputTable**：计算结果的输出表。在使用 `createSnapshotJoinEngine` 函数之前，需要将输出表预先设立为一个空表，并指定各列列名以及数据类型。\n\n输出表的各列的顺序如下：\n\n1. 连接列。与 *matchingColumn* 中的列以及其顺序一致，可为多列。\n\n2. 时间列（两列）。如果指定了 *timeColumn*，则分别为左表和右表的时间列，类型与 *timeColumn* 列一致；如果未指定 *timeColumn*，则两列分别是 leftTable 和 rightTable 的数据到达时间，类型为 TIMESTAMP。\n\n3. 计算结果列。可为多列。\n\n4. 耗时列。如果指定 *outputElapsedMicroseconds* = true，则指定一个 LONG 类型的列用于记录单次响应计算耗时（单位：微秒）。\n\n5. batchSize 列。如果指定 *outputElapsedMicroseconds* = true, 则指定一个INT类型的列，记录单次响应的数据条数。\n\n**metrics**：以元代码的格式表示计算指标，支持输入元组。有关元代码的更多信息可参考 [Metaprogramming](https://docs.dolphindb.cn/zh/progr/objs/meta_progr.html)。\n\n* 计算指标可以是一个或多个表达式、系统内置或用户自定义函数，但不能是聚合函数。\n\n* *metrics* 内支持调用具有多个返回值的函数，且必须指定列名，例如 \\<func(price) as \\`col1\\`col2>。\n\n* 若在 *metrics* 指定了 *leftTable* 和 *rightTable* 中具有相同名称的列，默认取左表的列，可以通过 \"tableName.colName\" 指定该列来自哪个表。\n\n  **注：** *metrics* 中使用的列名大小写不敏感，不需要与输入表的列名大小写保持一致。\n\n\\*\\*matchingColumn：\\*\\*表示连接列的字符串标量/向量或字符串向量组成的 tuple，支持 Integral, Temporal 或 Literal(UUID 除外)类型。*matchingColumn* 指定规则：\n\n1. 只有一个连接列。当左表和右表的连接列名相同时，*matchingColumn* 是一个字符串标量，否则是一个长度为 2 的 tuple。例如：左表连接列名为 sym，右表连接列名为 sym1，则 *matchingColumn* = \\[\\[\\`sym],\\[\\`sym1]]。\n\n2. 有多个连接列。当左表和右表的连接列名相同时，*matchingColumn* 是一个字符串向量，否则是一个长度为 2 的 tuple。例如：左表连接列名为 timestamp, sym，右表连接列名为 timestamp, sym1，则 *matchingColumn* = \\[\\[\\`timestamp, \\`sym], \\[\\`timestamp,\\`sym1]]。\n\n\\*\\*timeColumn:\\*\\*字符串标量或向量，可选参数。用于指定 leftTable 和 rightTable 中时间列的名称。两表的时间列名称可以不同，但数据类型需保持一致。当 leftTable 和 rightTable 时间列名称相同时，timeColumn 是字符串标量，否则，timeColumn 是长度为2的字符串向量。\n\n**outputElapsedMicroseconds**：布尔值，可选参数，表示是否输出单次响应计算的耗时（从触发计算的数据注入引擎到计算完成的耗时），默认为 false。指定参数 *outputElapsedMicroseconds* 后，在定义 outputTable 时需要在计算结果列后增加一个 LONG 类型的列和 INT 类型的列，详见 *outputTable* 参数说明。\n\n**keepLeftDuplicates**：布尔值，可选参数，表示在进行右连接时，是否匹配左表各分组内的所有数据。\n\n* 若设置为 false（默认值）：仅匹配左表各分组内的最新一条数据。\n\n* 若设置为 true：匹配左表各分组内的所有数据。\n\n**keepRightDuplicates**：布尔值，可选参数，表示在进行左连接时，是否保留右表各分组内的所有数据。\n\n* 若设置为 false（默认值）：仅匹配右表各分组内的最新一条数据。\n\n* 若设置为 true：匹配右表各分组内的所有数据。\n\n\\*\\*isInnerJoin：\\*\\*布尔值，可选参数，表示是否进行内连接。\n\n* 若设置为 true（默认值）：进行内连接，只有左右两表匹配的记录被计算输出。\n\n* 若设置为 false：进行左连接或右连接，保留两个表中的所有记录。对于左右两表中匹配的记录进行计算，而未匹配的记录输出空值。\n\n若要开启快照机制 (snapshot)，必须指定 *snapshotDir* 与 *snapshotIntervalInMsgCount*。\n\n**snapshotDir** 可选参数，字符串，表示保存引擎快照的文件目录。\n\n* 指定的目录必须存在，否则系统会提示异常。\n* 创建流数据引擎时，如果指定了 *snapshotDir*，会检查该目录下是否存在快照。如果存在，会加载该快照，恢复引擎的状态。\n* 多个引擎可以指定同一个目录存储快照，用引擎的名称来区分快照文件。\n* 一个引擎的快照可能会使用三个文件名：\n* 临时存储快照信息：文件名为 \\<engineName>.tmp；\n* 快照生成并刷到磁盘：文件保存为 \\<engineName>.snapshot；\n* 存在同名快照：旧快照自动重命名为 \\<engineName>.old。\n\n**snapshotIntervalInMsgCount** 可选参数，为整数类型，表示每隔多少条数据保存一次流数据引擎快照。\n\n#### 返回值\n\n返回一个左、右两表连接后的表对象。\n\n**连接行为**\n\n由 *isInnerJoin* 参数决定连接方式：\n\n* 当 *isInnerJoin*=true 时，进行内连接，即每次数据注入引擎左表时，会在右表中查找与连接列字段相匹配的记录，匹配成功才会将两表匹配的记录进行连接，并计算 *metrics* 后输出。每次数据注入引擎右表时，亦会做同样操作。\n\n* 当 *isInnerJoin*=false 时，进行外连接，即每次数据注入引擎左表时，与右表进行左连接。无论在右表中是否找到匹配的记录，都会计算 *metrics* 并输出（右表未匹配的记录输出空值）。每次数据注入引擎右表时，亦会做同样操作。\n\n* 当 keepLeftDuplicates=false 时，仅与左表中根据 *matchingColumn* 分组后的最新一条数据进行匹配连接。当 keepLeftDuplicates=true 时，与左表所有数据进行匹配连接。\n\n* 当 keepRightDuplicates=false 时，仅与右表中根据 *matchingColumn* 分组后的最新一条数据进行匹配连接。当 keepRightDuplicates=true 时，与右表所有数据进行匹配连接。\n\nsnapshot join 引擎与 lookup join、equi join 引擎很相似，主要区别如下：\n\n* lookup join 引擎只能由左表的新记录触发连接；而 snapshot join 引擎可以由左表或右表的新记录触发连接。\n\n* equi join 引擎仅匹配最新记录，且没有缓存；而 snapshot join 引擎可以选择与右表/左表所有记录或最新记录进行匹配，且有缓存。\n\n#### 例子\n\n例1. 不指定 \\*outputElapsedMicroseconds，\\*指定 *isInnerJoin*=true，同时指定 *keepLeftDuplicates*=true，*keepRightDuplicates*=true。此时，引擎进行内连接，且匹配左/右表各分组内的所有数据。\n\n```\n//定义输入、输出表\nshare streamTable(1:0, `timestamp`sym1`id`price`val, [TIMESTAMP, SYMBOL, INT, DOUBLE, DOUBLE]) as leftTable\nshare streamTable(1:0, `timestamp`sym2`id`price`qty, [TIMESTAMP, SYMBOL, INT, DOUBLE, DOUBLE]) as rightTable\noutput=table(100:0, [\"id\",\"sym\", \"timestamp1\", \"timestamp2\", \"factor1\", \"factor2\"], \n[INT, SYMBOL, TIMESTAMP, TIMESTAMP, DOUBLE, DOUBLE])\n\ntest_metrics = [<val*10>, <qty>]\n// 创建引擎\ntest_engine = createSnapshotJoinEngine(name = \"test_SJE\", leftTable=leftTable, rightTable=rightTable, \noutputTable=output, metrics=test_metrics, matchingColumn = [[\"id\",\"sym1\"],[\"id\",\"sym2\"]], \ntimeColumn = `timestamp, isInnerJoin=true, keepLeftDuplicates=true,keepRightDuplicates=true)\n\n//将左表数据注入引擎\ntimestamp = 2024.10.10T15:12:01.507+1..10\nsym = take([\"a\",\"b\",\"c\",\"d\"],10)\nid = [1,1,2,1,5,2,4,4,1,4]\nprice = [2.53,7.61,8.07,7.87,7.29,9.39,5.98,9.49,9.20,9.17]\nval = [101,108,101,109,104,100,108,100,107,104]\nleft_data = table(timestamp as timestamp,sym as sym1,id as id,price as price,val as val)\nappendForJoin(test_engine,true, left_data)\n\n//将右表数据注入引擎，此时会触发两表进行右连接\ntimestamp = 2024.10.10T15:12:01.507+1..10\nsym = take([\"a\",\"b\",\"c\",\"d\"],10)\nid = [1,2,4,3,5,5,4,2,5,5]\nprice =  [1.08,9.08,9.97,7.60,1.91,6.77,7.81,8.81,0.61,5.92]\nqty =  [208,200,203,202,204,201,206,207,205,205]\nright_data = table(timestamp as timestamp,sym as sym2,id as id,price as price,qty as qty)\nappendForJoin(test_engine,false, right_data)\n\nselect * from output\n```\n\n结果表中将保留左表所有匹配记录。\n\n| id | sym | timestamp1              | timestamp2              | factor1 | factor2 |\n| -- | --- | ----------------------- | ----------------------- | ------- | ------- |\n| 1  | a   | 2024.10.10T15:12:01.508 | 2024.10.10T15:12:01.508 | 1,010   | 208     |\n| 1  | a   | 2024.10.10T15:12:01.516 | 2024.10.10T15:12:01.508 | 1,070   | 208     |\n| 2  | b   | 2024.10.10T15:12:01.513 | 2024.10.10T15:12:01.509 | 1,000   | 200     |\n| 4  | c   | 2024.10.10T15:12:01.514 | 2024.10.10T15:12:01.510 | 1,080   | 203     |\n| 5  | a   | 2024.10.10T15:12:01.512 | 2024.10.10T15:12:01.512 | 1,040   | 204     |\n| 4  | c   | 2024.10.10T15:12:01.514 | 2024.10.10T15:12:01.514 | 1,080   | 206     |\n| 5  | a   | 2024.10.10T15:12:01.512 | 2024.10.10T15:12:01.516 | 1,040   | 205     |\n\n例2. 不指定 *outputElapsedMicroseconds*，指定 *isInnerJoin*=true，*keepLeftDuplicate*s=false，*keepRightDuplicates*=true。此时，引擎进行内连接，且匹配左表各分组内的最新一条数据。\n\n```\n//首先取消上例中定义的引擎\ndropStreamEngine(\"test_SJE\")\n\n//定义输入、输出表\nshare streamTable(1:0, `timestamp`sym1`id`price`val, [TIMESTAMP, SYMBOL, INT, DOUBLE, DOUBLE]) as leftTable\nshare streamTable(1:0, `timestamp`sym2`id`price`qty, [TIMESTAMP, SYMBOL, INT, DOUBLE, DOUBLE]) as rightTable\noutput=table(100:0, [\"id\",\"sym\", \"timestamp1\", \"timestamp2\", \"factor1\", \"factor2\"], \n[INT, SYMBOL, TIMESTAMP, TIMESTAMP, DOUBLE, DOUBLE])\n\ntest_metrics = [<val*10>, <qty>]\n// 创建引擎\ntest_engine = createSnapshotJoinEngine(name = \"test_SJE\", leftTable=leftTable, rightTable=rightTable, \noutputTable=output, metrics=test_metrics, matchingColumn = [[\"id\",\"sym1\"],[\"id\",\"sym2\"]], \ntimeColumn = `timestamp, isInnerJoin=true, keepLeftDuplicates=false,keepRightDuplicates=true)\n\n//将左表数据注入引擎\ntimestamp = 2024.10.10T15:12:01.507+1..10\nsym = take([\"a\",\"b\",\"c\",\"d\"],10)\nid = [1,1,2,1,5,2,4,4,1,4]\nprice = [2.53,7.61,8.07,7.87,7.29,9.39,5.98,9.49,9.20,9.17]\nval = [101,108,101,109,104,100,108,100,107,104]\nleft_data = table(timestamp as timestamp,sym as sym1,id as id,price as price,val as val)\nappendForJoin(test_engine,true, left_data)\n\n//将右表数据注入引擎，此时会触发两表进行右连接\ntimestamp = 2024.10.10T15:12:01.507+1..10\nsym = take([\"a\",\"b\",\"c\",\"d\"],10)\nid = [1,2,4,3,5,5,4,2,5,5]\nprice =  [1.08,9.08,9.97,7.60,1.91,6.77,7.81,8.81,0.61,5.92]\nqty =  [208,200,203,202,204,201,206,207,205,205]\nright_data = table(timestamp as timestamp,sym as sym2,id as id,price as price,qty as qty)\nappendForJoin(test_engine,false, right_data)\n\nselect * from output\n```\n\n结果表中仅保留左表每个分组中的最新记录，因此比例1中的结果少了一行记录。\n\n| id | sym | timestamp1              | timestamp2              | factor1 | factor2 |\n| -- | --- | ----------------------- | ----------------------- | ------- | ------- |\n| 1  | a   | 2024.10.10T15:12:01.516 | 2024.10.10T15:12:01.508 | 1,070   | 208     |\n| 2  | b   | 2024.10.10T15:12:01.513 | 2024.10.10T15:12:01.509 | 1,000   | 200     |\n| 4  | c   | 2024.10.10T15:12:01.514 | 2024.10.10T15:12:01.510 | 1,080   | 203     |\n| 5  | a   | 2024.10.10T15:12:01.512 | 2024.10.10T15:12:01.512 | 1,040   | 204     |\n| 4  | c   | 2024.10.10T15:12:01.514 | 2024.10.10T15:12:01.514 | 1,080   | 206     |\n| 5  | a   | 2024.10.10T15:12:01.512 | 2024.10.10T15:12:01.516 | 1,040   | 205     |\n\n例3. 不指定 *outputElapsedMicroseconds*，指定 *isInnerJoin*=false，*keepLeftDuplicates*=false，*keepRightDuplicates*=true。此时，引擎进行左连接或右连接。在左连接时，匹配右表各分组内的所有数据；在进行右连接时，仅匹配左表各分组内的最新一条数据。\n\n```\n//首先取消上例中定义的引擎\ndropStreamEngine(\"test_SJE\")\n\n//定义输入、输出表\nshare streamTable(1:0, `timestamp`sym1`id`price`val, [TIMESTAMP, SYMBOL, INT, DOUBLE, DOUBLE]) as leftTable\nshare streamTable(1:0, `timestamp`sym2`id`price`qty, [TIMESTAMP, SYMBOL, INT, DOUBLE, DOUBLE]) as rightTable\noutput=table(100:0, [\"id\",\"sym\", \"timestamp1\", \"timestamp2\", \"factor1\", \"factor2\"], \n[INT, SYMBOL, TIMESTAMP, TIMESTAMP, DOUBLE, DOUBLE])\n\ntest_metrics = [<val*10>, <qty>]\n// 创建引擎\ntest_engine = createSnapshotJoinEngine(name = \"test_SJE\", leftTable=leftTable, rightTable=rightTable, \noutputTable=output, metrics=test_metrics, matchingColumn = [[\"id\",\"sym1\"],[\"id\",\"sym2\"]], \ntimeColumn = `timestamp, isInnerJoin=false, keepLeftDuplicates=false,keepRightDuplicates=true)\n\n//将左表数据注入引擎\ntimestamp = 2024.10.10T15:12:01.507+1..10\nsym = take([\"a\",\"b\",\"c\",\"d\"],10)\nid = [1,1,2,1,5,2,4,4,1,4]\nprice = [2.53,7.61,8.07,7.87,7.29,9.39,5.98,9.49,9.20,9.17]\nval = [101,108,101,109,104,100,108,100,107,104]\nleft_data = table(timestamp as timestamp,sym as sym1,id as id,price as price,val as val)\nappendForJoin(test_engine,true, left_data)\n\n//将右表数据注入引擎，此时会触发两表进行右连接\ntimestamp = 2024.10.10T15:12:01.507+1..10\nsym = take([\"a\",\"b\",\"c\",\"d\"],10)\nid = [1,2,4,3,5,5,4,2,5,5]\nprice =  [1.08,9.08,9.97,7.60,1.91,6.77,7.81,8.81,0.61,5.92]\nqty =  [208,200,203,202,204,201,206,207,205,205]\nright_data = table(timestamp as timestamp,sym as sym2,id as id,price as price,qty as qty)\nappendForJoin(test_engine,false, right_data)\n\nselect * from output\n```\n\n由于引擎进行了右连接，仅保留左表每个分组中的最新记录。\n\n| id | sym | timestamp1              | timestamp2              | factor1 | factor2 |\n| -- | --- | ----------------------- | ----------------------- | ------- | ------- |\n| 1  | a   | 2024.10.10T15:12:01.508 | 1,010                   |         |         |\n| 1  | b   | 2024.10.10T15:12:01.509 | 1,080                   |         |         |\n| 2  | c   | 2024.10.10T15:12:01.510 | 1,010                   |         |         |\n| 1  | d   | 2024.10.10T15:12:01.511 | 1,090                   |         |         |\n| 5  | a   | 2024.10.10T15:12:01.512 | 1,040                   |         |         |\n| 2  | b   | 2024.10.10T15:12:01.513 | 1,000                   |         |         |\n| 4  | c   | 2024.10.10T15:12:01.514 | 1,080                   |         |         |\n| 4  | d   | 2024.10.10T15:12:01.515 | 1,000                   |         |         |\n| 1  | a   | 2024.10.10T15:12:01.516 | 1,070                   |         |         |\n| 4  | b   | 2024.10.10T15:12:01.517 | 1,040                   |         |         |\n| 1  | a   | 2024.10.10T15:12:01.516 | 2024.10.10T15:12:01.508 | 1,070   | 208     |\n| 2  | b   | 2024.10.10T15:12:01.513 | 2024.10.10T15:12:01.509 | 1,000   | 200     |\n| 4  | c   | 2024.10.10T15:12:01.514 | 2024.10.10T15:12:01.510 | 1,080   | 203     |\n| 3  | d   | 2024.10.10T15:12:01.511 | 202                     |         |         |\n| 5  | a   | 2024.10.10T15:12:01.512 | 2024.10.10T15:12:01.512 | 1,040   | 204     |\n| 5  | b   | 2024.10.10T15:12:01.513 | 201                     |         |         |\n| 4  | c   | 2024.10.10T15:12:01.514 | 2024.10.10T15:12:01.514 | 1,080   | 206     |\n| 2  | d   | 2024.10.10T15:12:01.515 | 207                     |         |         |\n| 5  | a   | 2024.10.10T15:12:01.512 | 2024.10.10T15:12:01.516 | 1,040   | 205     |\n| 5  | b   | 2024.10.10T15:12:01.517 | 205                     |         |         |\n\n例4. 指定 *outputElapsedMicroseconds* = true，输出耗时列和 batchSize 列。\n\n```\n//首先取消上例中定义的引擎\ndropStreamEngine(\"test_SJE\")\n\n//定义输入、输出表\nshare streamTable(1:0, `timestamp`sym1`id`price`val, [TIMESTAMP, SYMBOL, INT, DOUBLE, DOUBLE]) as leftTable\nshare streamTable(1:0, `timestamp`sym2`id`price`qty, [TIMESTAMP, SYMBOL, INT, DOUBLE, DOUBLE]) as rightTable\noutput=table(100:0, [\"id\",\"sym\", \"timestamp1\", \"timestamp2\", \"factor1\", \"factor2\", \"timecost\",\"batchsize\"],\n[INT, SYMBOL, TIMESTAMP, TIMESTAMP, DOUBLE, DOUBLE, LONG, INT])\n\ntest_metrics = [<val*10>, <qty>]\n// 创建引擎\ntest_engine = createSnapshotJoinEngine(name = \"test_SJE\", leftTable=leftTable, rightTable=rightTable, \noutputTable=output, metrics=test_metrics, matchingColumn = [[\"id\",\"sym1\"],[\"id\",\"sym2\"]],\ntimeColumn = `timestamp, outputElapsedMicroseconds=true, isInnerJoin=true,\nkeepLeftDuplicates=false,keepRightDuplicates=true)\n\n//将左表数据注入引擎\ntimestamp = 2024.10.10T15:12:01.507+1..10\nsym = take([\"a\",\"b\",\"c\",\"d\"],10)\nid = [1,1,2,1,5,2,4,4,1,4]\nprice = [2.53,7.61,8.07,7.87,7.29,9.39,5.98,9.49,9.20,9.17]\nval = [101,108,101,109,104,100,108,100,107,104]\nleft_data = table(timestamp as timestamp,sym as sym1,id as id,price as price,val as val)\nappendForJoin(test_engine,true, left_data)\n\n//将右表数据注入引擎，此时会触发两表进行右连接\ntimestamp = 2024.10.10T15:12:01.507+1..10\nsym = take([\"a\",\"b\",\"c\",\"d\"],10)\nid = [1,2,4,3,5,5,4,2,5,5]\nprice =  [1.08,9.08,9.97,7.60,1.91,6.77,7.81,8.81,0.61,5.92]\nqty =  [208,200,203,202,204,201,206,207,205,205]\nright_data = table(timestamp as timestamp,sym as sym2,id as id,price as price,qty as qty)\nappendForJoin(test_engine,false, right_data)\n\nselect * from output\n```\n\n| id | sym | timestamp1              | timestamp2              | factor1 | factor2 | timecost | batchsize |\n| -- | --- | ----------------------- | ----------------------- | ------- | ------- | -------- | --------- |\n| 1  | a   | 2024.10.10T15:12:01.516 | 2024.10.10T15:12:01.508 | 1,070   | 208     | 109      | 10        |\n| 2  | b   | 2024.10.10T15:12:01.513 | 2024.10.10T15:12:01.509 | 1,000   | 200     | 109      | 10        |\n| 4  | c   | 2024.10.10T15:12:01.514 | 2024.10.10T15:12:01.510 | 1,080   | 203     | 109      | 10        |\n| 5  | a   | 2024.10.10T15:12:01.512 | 2024.10.10T15:12:01.512 | 1,040   | 204     | 109      | 10        |\n| 4  | c   | 2024.10.10T15:12:01.514 | 2024.10.10T15:12:01.514 | 1,080   | 206     | 109      | 10        |\n| 5  | a   | 2024.10.10T15:12:01.512 | 2024.10.10T15:12:01.516 | 1,040   | 205     | 109      | 10        |\n\n例5. *keepRightDuplicates*、*keepLeftDuplicates* 为 false，不指定时间列 *timeColumn*，此时输出表中的两个时间列为左表、右表数据到达的时间。\n\n```\n//首先取消上例中定义的引擎\ndropStreamEngine(\"test_SJE\")\n\n//定义输入、输出表\nshare streamTable(1:0, `timestamp`sym1`id`price`val, [TIMESTAMP, SYMBOL, INT, DOUBLE, DOUBLE]) as leftTable\nshare streamTable(1:0, `timestamp`sym2`id`price`qty, [TIMESTAMP, SYMBOL, INT, DOUBLE, DOUBLE]) as rightTable\noutput=table(100:0, [\"id\",\"sym\", \"timestamp1\", \"timestamp2\", \"factor1\", \"factor2\"],\n[INT, SYMBOL, TIMESTAMP, TIMESTAMP, DOUBLE, DOUBLE])\n\ntest_metrics = [<val*10>, <qty>]\n// 创建引擎\ntest_engine = createSnapshotJoinEngine(name = \"test_SJE\", leftTable=leftTable, rightTable=rightTable, \noutputTable=output, metrics=test_metrics, matchingColumn = [[\"id\",\"sym1\"],[\"id\",\"sym2\"]], isInnerJoin=true)\n\n//将左表数据注入引擎\ntimestamp = 2024.10.10T15:12:01.507+1..10\nsym = take([\"a\",\"b\",\"c\",\"d\"],10)\nid = [1,1,2,1,5,2,4,4,1,4]\nprice = [2.53,7.61,8.07,7.87,7.29,9.39,5.98,9.49,9.20,9.17]\nval = [101,108,101,109,104,100,108,100,107,104]\nleft_data = table(timestamp as timestamp,sym as sym1,id as id,price as price,val as val)\nappendForJoin(test_engine,true, left_data)\n\n//将右表数据注入引擎，此时会触发两表进行右连接\ntimestamp = 2024.10.10T15:12:01.507+1..10\nsym = take([\"a\",\"b\",\"c\",\"d\"],10)\nid = [1,2,4,3,5,5,4,2,5,5]\nprice =  [1.08,9.08,9.97,7.60,1.91,6.77,7.81,8.81,0.61,5.92]\nqty =  [208,200,203,202,204,201,206,207,205,205]\nright_data = table(timestamp as timestamp,sym as sym2,id as id,price as price,qty as qty)\nappendForJoin(test_engine,false, right_data)\n\nselect * from output\n```\n\n| id | sym | timestamp1              | timestamp2              | factor1 | factor2 |\n| -- | --- | ----------------------- | ----------------------- | ------- | ------- |\n| 1  | a   | 2024.12.20T15:05:49.603 | 2024.12.20T15:05:49.603 | 1,070   | 208     |\n| 2  | b   | 2024.12.20T15:05:49.603 | 2024.12.20T15:05:49.603 | 1,000   | 200     |\n| 4  | c   | 2024.12.20T15:05:49.603 | 2024.12.20T15:05:49.603 | 1,080   | 203     |\n| 5  | a   | 2024.12.20T15:05:49.603 | 2024.12.20T15:05:49.603 | 1,040   | 204     |\n| 4  | c   | 2024.12.20T15:05:49.603 | 2024.12.20T15:05:49.603 | 1,080   | 206     |\n| 5  | a   | 2024.12.20T15:05:49.603 | 2024.12.20T15:05:49.603 | 1,040   | 205     |\n"
    },
    "createSparseReactiveStateEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/createSparseReactiveStateEngine.html",
        "signatures": [
            {
                "full": "createSparseReactiveStateEngine(name, metrics, dummyTable, outputTable, keyColumn, [extraColumn])",
                "name": "createSparseReactiveStateEngine",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "metrics",
                        "name": "metrics"
                    },
                    {
                        "full": "dummyTable",
                        "name": "dummyTable"
                    },
                    {
                        "full": "outputTable",
                        "name": "outputTable"
                    },
                    {
                        "full": "keyColumn",
                        "name": "keyColumn"
                    },
                    {
                        "full": "[extraColumn]",
                        "name": "extraColumn",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [createSparseReactiveStateEngine](https://docs.dolphindb.cn/zh/funcs/c/createSparseReactiveStateEngine.html)\n\n首发版本：3.00.5\n\n\n\n#### 语法\n\ncreateSparseReactiveStateEngine(name, metrics, dummyTable, outputTable, keyColumn, \\[extraColumn])\n\n#### 详情\n\n创建一个稀疏响应式状态引擎，用于对数据进行稀疏状态计算：仅当某些特定的数据到达时，才触发与之相关的状态计算。\n\n该引擎适用于工业场景下“规则只对部分设备/传感器有意义”的稀疏计算需求。相比 `createReactiveStateEngine`，可避免无意义的全量指标更新。\n\n#### 参数\n\n**name** 字符串标量，表示响应式状态引擎的名称，作为其在一个数据节点/计算节点上的唯一标识。可包含字母，数字和下划线，但必须以字母开头。\n\n**metrics** 是一个表，表示稀疏状态计算规则集合。该表至少包含 3 列：\n\n* 前若干列为特定数据的标识列，与 *keyColumn* 指定的列名和顺序一致。\n\n* formula：可以是字符串或元代码，表示该特定数据到达时触发的计算表达式。\n\n* outputMetricKey：字符串标量，为该计算指定指标名。\n\n**dummyTable** 一个表对象，和输入的流数据表的 schema 一致，可以含有数据，亦可为空表。\n\n**outputTable** 计算结果的输出表，可以是内存表或分布式表，引擎会将计算结果写入该表。包含以下列：\n\n* 若干特定数据标识列，与 *keyColumn* 指定的列名和顺序一致。\n\n* 若干保留的原始列，与 *extraColumn* 指定的列名和顺序一致。\n\n* outputMetricKey 列，表示特定数据计算的指标名，其值由 *metrics* 的 outputMetricKey 列指定。\n\n* 计算结果列，表示该指标的计算结果。\n\n**keyColumn** 字符串标量或向量，表示输入表中标识特定数据的主键列名。\n\n**extraColumn** 可选参数，字符串标量或向量，表示输入表中需要保留到输出表的列名。\n\n#### 返回值\n\n返回一个流数据引擎对象句柄。通过向该句柄写入，将数据注入引擎进行计算。\n\n#### 例子\n\n例1. 输入数据包含三个设备 ID A001，A002，A003。每当 A001 的数据到来，计算长度为 3 的滑动窗口内数据的平均值；每当 A002 的数据到来，计算长度为 3 的滑动窗口内的最大值与最小值的差，以及窗口内元素的和 ；当 A003 的数据到来不做任何处理。输入数据中的时间列不做处理，保留到输出表中。\n\n```\n// 创建输入数据表\nshare streamTable(1:0, `timestamp`deviceID`value,\n    [TIMESTAMP, SYMBOL, DOUBLE]) as inputTable\n\n// 创建输出表\nshare streamTable(1000:0, `deviceID`timestamp`outputMetricKey`outputValue,\n    [SYMBOL, TIMESTAMP, STRING, DOUBLE]) as outputTable\n\n// 定义规则\nmetrics = table(\n    [\"A001\", \"A002\", \"A002\"] as deviceID,\n    [\n        \"mavg(value,3) \",\n        \"mmax(value,3)-mmin(value,3)\",\n        \"msum(value,3)\"\n    ] as formula,\n    [\"A001_1\", \"A002_1\", \"A002_2\"] as outputMetricKey\n)\n\n// 创建稀疏状态引擎\nstateEngine = createSparseReactiveStateEngine(\n    name=\"demoengine\",\n    metrics=metrics,\n    dummyTable=inputTable,\n    outputTable=outputTable,\n    keyColumn=\"deviceID\",\n    extraColumn=\"timestamp\"\n)\n// 订阅输入流表\nsubscribeTable(tableName=\"inputTable\", actionName=\"demo1\", handler=tableInsert{stateEngine})\n// 写入数据\ndata = table([2026.02.07T20:29:53.927,2026.02.07T20:29:53.928,2026.02.07T20:29:53.929,2026.02.07T20:29:53.930,2026.02.07T20:29:53.931,2026.02.07T20:29:53.932,2026.02.07T20:29:53.933,2026.02.07T20:29:53.934,2026.02.07T20:29:53.935,2026.02.07T20:29:53.936,2026.02.07T20:29:53.937,2026.02.07T20:29:53.938,2026.02.07T20:29:53.939,2026.02.07T20:29:53.940,2026.02.07T20:29:53.941,2026.02.07T20:29:53.942,2026.02.07T20:29:53.943,2026.02.07T20:29:53.944,2026.02.07T20:29:53.945,2026.02.07T20:29:53.946] as time, \n    [\"A003\",\"A002\",\"A003\",\"A002\",\"A003\",\"A002\",\"A002\",\"A001\",\"A003\",\"A001\",\"A002\",\"A003\",\"A001\",\"A002\",\"A003\",\"A002\",\"A003\",\"A002\",\"A003\",\"A002\"] as deviceID, \n    [47,87,36,63,28,53,65,48,86,40,18,28,61,77,81,73,66,47,29,3] as value)\n\ninputTable.append!(data)\n// 查看结果\nresult = select * from outputTable\nresult\n```\n\n| deviceID | timestamp               | outputMetricKey | outputValue        |\n| -------- | ----------------------- | --------------- | ------------------ |\n| A002     | 2026.02.07 20:29:53.928 | A002\\_1         |                    |\n| A002     | 2026.02.07 20:29:53.928 | A002\\_2         |                    |\n| A002     | 2026.02.07 20:29:53.930 | A002\\_1         |                    |\n| A002     | 2026.02.07 20:29:53.930 | A002\\_2         |                    |\n| A002     | 2026.02.07 20:29:53.932 | A002\\_1         | 34                 |\n| A002     | 2026.02.07 20:29:53.932 | A002\\_2         | 203                |\n| A002     | 2026.02.07 20:29:53.933 | A002\\_1         | 12                 |\n| A002     | 2026.02.07 20:29:53.933 | A002\\_2         | 181                |\n| A001     | 2026.02.07 20:29:53.934 | A001\\_1         |                    |\n| A001     | 2026.02.07 20:29:53.936 | A001\\_1         |                    |\n| A002     | 2026.02.07 20:29:53.937 | A002\\_1         | 47                 |\n| A002     | 2026.02.07 20:29:53.937 | A002\\_2         | 136                |\n| A001     | 2026.02.07 20:29:53.939 | A001\\_1         | 49.666666666666664 |\n| A002     | 2026.02.07 20:29:53.940 | A002\\_1         | 59                 |\n| A002     | 2026.02.07 20:29:53.940 | A002\\_2         | 160                |\n| A002     | 2026.02.07 20:29:53.942 | A002\\_1         | 59                 |\n| A002     | 2026.02.07 20:29:53.942 | A002\\_2         | 168                |\n| A002     | 2026.02.07 20:29:53.944 | A002\\_1         | 30                 |\n| A002     | 2026.02.07 20:29:53.944 | A002\\_2         | 197                |\n| A002     | 2026.02.07 20:29:53.946 | A002\\_1         | 70                 |\n| A002     | 2026.02.07 20:29:53.946 | A002\\_2         | 123                |\n\n**相关函数**：[addSparseReactiveMetrics](https://docs.dolphindb.cn/zh/funcs/a/addSparseReactiveMetrics.html), [getSparseReactiveMetrics](https://docs.dolphindb.cn/zh/funcs/g/getSparseReactiveMetrics.html), [deleteSparseReactiveMetric](https://docs.dolphindb.cn/zh/funcs/d/deleteSparseReactiveMetric.html)\n"
    },
    "createOrderReconstituteEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/createsseorderreconstructionengine.html",
        "signatures": [
            {
                "full": "createSSEOrderReconstructionEngine(name, dummyTable, outputTable, inputColMap)",
                "name": "createSSEOrderReconstructionEngine",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "dummyTable",
                        "name": "dummyTable"
                    },
                    {
                        "full": "outputTable",
                        "name": "outputTable"
                    },
                    {
                        "full": "inputColMap",
                        "name": "inputColMap"
                    }
                ]
            }
        ],
        "markdown": "### [createOrderReconstituteEngine](https://docs.dolphindb.cn/zh/funcs/c/createsseorderreconstructionengine.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\ncreateSSEOrderReconstructionEngine(name, dummyTable, outputTable, inputColMap)\n\n别名：createOrderReconstituteEngine\n\n#### 详情\n\n上交所的逐笔数据中：\n\n* 如果一笔委托单在提交时立即全部成交，则会记录成交数据，而不会记录原始委托。\n\n* 如果一笔委托单在提交时立即部分成交，则会记录对应的成交数据，未成交的部分记录为一笔委托。\n\n此函数定义一个订单还原引擎，根据上交所逐笔数据（一个包含逐笔成交与逐笔委托的数据表），实时还原缺失的原始委托信息。\n\n#### 参数\n\n**name** 字符串标量，表示引擎的名称，作为其在一个数据节点/计算节点上的唯一标识。可包含字母，数字和下划线，但必须以字母开头。\n\n**dummyTable** 一个表对象，和输入的流数据表的 schema 一致，可以含有数据，亦可为空表。\n\n**outputTable**一个表对象，计算结果的输出表，可以是内存表或者分布式表。表结构比 dummyTable 多两列：\n\n* 倒数第二列：INT 类型，标记该条逐笔数据的来源，不同标记值的含义如下：\n\n| 标记值 | 逐笔委托          | 逐笔成交   |\n| --- | ------------- | ------ |\n| 0   | 原始委托          | 原始成交   |\n| 1   | 根据全部即时成交还原的委托 | 即时全部成交 |\n| 2   | 根据部分即时成交还原的委托 | 即时部分成交 |\n\n* 最后一列：LONG 类型，记录输出顺序，从 0 开始递增。\n\n**inputColMap** 一个字典，用于将输入表中的列名映射到引擎计算所需的字段：\n\n* **key**为 STRING 类型，表示引擎所需的字段，字段及其说明见下表。注意，字段名大小写敏感，顺序不限但必须全部指定。\n\n* **value** 为 STRING 类型，必须是 *dummyTable* 的列名。\n\n<table id=\"table_qv4_b5n_mgc\"><thead><tr><th>\n\nkey\n\n</th><th>\n\n字段类型\n\n</th><th>\n\n字段说明\n\n</th></tr></thead><tbody><tr><td>\n\n\"codeColumn\"\n\n</td><td>\n\nSYMBOL\n\n</td><td>\n\n证券代码\n\n</td></tr><tr><td>\n\n\"typeColumn\"\n\n</td><td>\n\nINT\n\n</td><td>\n\n交易类型：\n\n* 如果是逐笔委托单，则：1 表示市价；2 表示限价；3 表示本方最优；10 表示撤单（仅上交所）；11 表示市场状态（仅上交所）\n* 如果是逐笔成交单，则：0 表示成交；1 表示撤单（仅深交所）\n\n</td></tr><tr><td>\n\n\"priceColumn\"\n\n</td><td>\n\nLONG\n\n</td><td>\n\n价格\n\n</td></tr><tr><td>\n\n\"qtyColumn\"\n\n</td><td>\n\nLONG\n\n</td><td>\n\n数量（股数）\n\n</td></tr><tr><td>\n\n\"buyOrderColumn\"\n\n</td><td>\n\nLONG\n\n</td><td>\n\n* 逐笔成交：对应其原始成交中的买方委托序号。\n* 上交所逐笔委托：填充原始委托中的原始订单号，即上交所在新增、删除订单时用以标识订单的唯一编号\n* 深交所逐笔委托：填充 0。此字段为深交所为了补全上交所数据格式而增加的冗余列\n\n</td></tr><tr><td>\n\n\"sellOrderColumn\"\n\n</td><td>\n\nLONG\n\n</td><td>\n\n* 逐笔成交：对应其原始成交中的卖方委托序号。\n* 上交所逐笔委托：填充原始委托中的原始订单号，即上交所在新增、删除订单时用以标识订单的唯一编号\n* 深交所逐笔委托：填充 0。此字段深交所为了补全上交所数据格式而增加的冗余列\n\n</td></tr><tr><td>\n\n\"sideColumn\"\n\n</td><td>\n\nINT\n\n</td><td>\n\n买卖方向：1 表示买单；2 表示卖单\n\n说明：\n\n* 委托单的 BSFlag，必填\n* 撤单的 BSFlag 由原始委托单决定买卖方向，必填\n* 成交单的 BSFlag，不影响结果，非必填\n\n</td></tr><tr><td>\n\n\"msgTypeColumn\"\n\n</td><td>\n\nINT\n\n</td><td>\n\n数据类型：\n\n* 0 表示逐笔委托；\n* 1 表示逐笔成交；\n* -1 表示产品状态。\n\n</td></tr></tbody>\n</table>## 返回值\n\n返回一个表对象，通过向该表对象写入，将数据注入引擎进行计算。\n\n#### 例子\n\n运行以下示例前，请先下载 [demoData.tar.gz](https://docs.dolphindb.cn/zh/funcs/c/demoData.tar.gz)\n\n```\n// 定义引擎参数 dummyTable，即指定输入表的表结构\ncolNames = `SecurityID`Date`Time`SourceType`Type`Price`Qty`BSFlag`BuyNo`SellNo`ApplSeqNum`ChannelNo\ncolTypes = [SYMBOL, DATE, TIME, INT, INT, LONG, LONG, INT, LONG, LONG, LONG, INT]\ndummyOrderTrans = table(1:0, colNames, colTypes)\n\n// 定义引擎参数 colMap，即指定输入表各字段的含义\ncolMap = dict(`codeColumn`typeColumn`priceColumn`qtyColumn`buyOrderColumn`sellOrderColumn`sideColumn`msgTypeColumn, `SecurityID`Type`Price`Qty`BuyNo`SellNo`BSFlag`SourceType)\n\n// 定义引擎参数 outputTable ，即输出表\noutTable =  table(1:0, colNames join [\"mark\",\"index\"], colTypes join [INT,LONG])\n\n// 定义引擎\nengine1 = createSSEOrderReconstructionEngine(name=\"demo\", dummyTable=dummyOrderTrans, outputTable=outTable, inputColMap=colMap)\n\n// 向引擎插入数据，注意修改filename \nschemaTB = select name, typeString as type from dummyOrderTrans.schema().colDefs\ntmp = select * from loadText(filename=\"/home/data/orderReconstituteDemoInput.csv\",schema=schemaTB) order by ApplSeqNum\nengine1.append!(tmp)\n```\n\noutTable 是将 tmp 中数据还原出原始委托后的结果。例如：\n\n**完全成交还原**\n\ntmp 中 600125 标的在 09:30:02.710 时刻有四条成交记录，其中三条记录的卖单号均为 761962，一条记录的卖单号为 643170，均没有对应的委托记录![](https://docs.dolphindb.cn/zh/funcs/images/createSSEOrderReconstructionEngine1.png)。\n\n经过引擎还原后，可以看到 outTable 中 index 分别为 5927 和 5931 的两条记录即为原始的委托信息，委托量分别为 5000（1500+200+3300）和 600，它们在提交时就立即全部成交。\n\n![](https://docs.dolphindb.cn/zh/funcs/images/createSSEOrderReconstructionEngine2.png)\n\n**部分成交还原**\n\ntmp 中 600125 标的在 09:30:09.280 时刻有三条成交记录和一条委托记录，卖单号均为 829709。![](https://docs.dolphindb.cn/zh/funcs/images/createSSEOrderReconstructionEngine3.png)\n\n经过引擎还原后，可以看到 outTable 中，index 为 6593 的记录为原始委托，原始委托量为 81900，等于 tmp 中的委托量 81600 与立即成交量 100 和 200 之和；index 为 6596 的记录为原始委托，在提交时立即全部成交。![](https://docs.dolphindb.cn/zh/funcs/images/createSSEOrderReconstructionEngine4.png)\n"
    },
    "createStreamBroadcastEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/createstreambroadcastengine.html",
        "signatures": [
            {
                "full": "createStreamBroadcastEngine(name, dummyTable, outputTables)",
                "name": "createStreamBroadcastEngine",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "dummyTable",
                        "name": "dummyTable"
                    },
                    {
                        "full": "outputTables",
                        "name": "outputTables"
                    }
                ]
            }
        ],
        "markdown": "### [createStreamBroadcastEngine](https://docs.dolphindb.cn/zh/funcs/c/createstreambroadcastengine.html)\n\n\n\n#### 语法\n\ncreateStreamBroadcastEngine(name, dummyTable, outputTables)\n\n#### 详情\n\n创建流数据广播引擎，将同一份流数据复制后分发至不同的目标表对象。该函数返回一个表对象，通过向该表对象注入数据，实现流数据的多路广播。\n\n该引擎的应用场景是对同一份流数据同时进行不同的处理，例如将拷贝后的一份数据存入磁盘，另一份数据则输入引擎进行后续计算等。\n\n#### 参数\n\n**name** 字符串标量，表示流数据广播引擎的名称，作为其在一个数据节点/计算节点上的唯一标识。可包含字母，数字和下划线，但必须以字母开头。\n\n**dummyTable** 一个表对象，和输入的流数据表的 schema 一致，可以含有数据，亦可为空表。\n\n**outputTables** 由2个及以上表对象组成的元组，每个表对象的结构和 dummyTable 相同。表对象可以是内存表、分布式表或流计算引擎。\n\n#### 返回值\n\n返回一个表对象。\n\n#### 例子\n\n```\nshare streamTable(1:0, `sym`price, [STRING,DOUBLE]) as tickStream\nshare streamTable(1000:0, `sym`factor1, [STRING,DOUBLE]) as resultStream\n\nt=table(100:0, `sym`price, [STRING, DOUBLE])\n\n//定义将要使用的输出表。这里定义1个状态引擎，1个分布式表用于存储数据\nrse = createReactiveStateEngine(name=\"reactiveDemo\", metrics =<cumavg(price)>, dummyTable=tickStream, outputTable=resultStream, keyColumn=\"sym\")\nif(existsDatabase(\"dfs://database1\")){\n\tdropDatabase(\"dfs://database1\")\n}\ndb=database(\"dfs://database1\", VALUE, \"A\"+string(1..10))\npt=db.createPartitionedTable(t,`pt,`sym)\n\n//定义广播引擎\nbroadcastEngine=createStreamBroadcastEngine(name=\"broadcastEngine\", dummyTable=tickStream, outputTables=[loadTable(\"dfs://database1\", `pt),getStreamEngine(\"reactiveDemo\")])\n\n//订阅流数据表tickStream\nsubscribeTable(tableName=`tickStream, actionName=\"sub\", handler=tableInsert{broadcastEngine}, msgAsTable = true)\n\n//订阅的数据注入引擎\nn=100000\nsymbols=take((\"A\" + string(1..10)),n)\nprices=100+rand(1.0,n)\nt1=table(symbols as sym, prices as price)\ntickStream.append!(t1)\n\n// 查看分布式表中数据有100,000 条\nselect count(*) from loadTable(\"dfs://database1\", `pt)\n// output: 100,000\n\n//查看状态引擎状态\ngetStreamEngineStat().ReactiveStreamEngine\n```\n\n| name         | user  | status | lastErrMsg | numGroups | numRows | numMetrics | memoryInUsed | snapshotDir | snapshotInterval | snapshotMsgId | snapshotTimestamp |\n| ------------ | ----- | ------ | ---------- | --------- | ------- | ---------- | ------------ | ----------- | ---------------- | ------------- | ----------------- |\n| reactiveDemo | admin | OK     | 10         | 100,000   | 1       | 2,600      | -1           |             |                  |               |                   |\n"
    },
    "createStreamDispatchEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/createStreamDispatchEngine.html",
        "signatures": [
            {
                "full": "createStreamDispatchEngine(name, dummyTable, keyColumn, outputTable, [dispatchType='hash'], [hashByBatch=false], [outputLock=true], [queueDepth=4096], [outputElapsedTime=false], [mode='buffer'])",
                "name": "createStreamDispatchEngine",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "dummyTable",
                        "name": "dummyTable"
                    },
                    {
                        "full": "keyColumn",
                        "name": "keyColumn"
                    },
                    {
                        "full": "outputTable",
                        "name": "outputTable"
                    },
                    {
                        "full": "[dispatchType='hash']",
                        "name": "dispatchType",
                        "optional": true,
                        "default": "'hash'"
                    },
                    {
                        "full": "[hashByBatch=false]",
                        "name": "hashByBatch",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[outputLock=true]",
                        "name": "outputLock",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[queueDepth=4096]",
                        "name": "queueDepth",
                        "optional": true,
                        "default": "4096"
                    },
                    {
                        "full": "[outputElapsedTime=false]",
                        "name": "outputElapsedTime",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[mode='buffer']",
                        "name": "mode",
                        "optional": true,
                        "default": "'buffer'"
                    }
                ]
            }
        ],
        "markdown": "### [createStreamDispatchEngine](https://docs.dolphindb.cn/zh/funcs/c/createStreamDispatchEngine.html)\n\n\n\n#### 语法\n\ncreateStreamDispatchEngine(name, dummyTable, keyColumn, outputTable, \\[dispatchType='hash'], \\[hashByBatch=false], \\[outputLock=true], \\[queueDepth=4096], \\[outputElapsedTime=false], \\[mode='buffer'])\n\n#### 详情\n\n创建流数据分发引擎，返回一个表对象。该引擎将输入的数据分发到不同的输出表，以实现负载均衡。其中输出表可以是内存表，分布式表或流数据引擎。\n\n引擎特性：\n\n* 支持多线程输入和多线程输出。\n\n* 只提供数据分发功能，不提供指标计算功能。\n\n场景应用：\n\n将快照数据分发给一个或多个计算引擎进行因子计算，以提高计算性能。\n\n#### 参数\n\n**name** 字符串，表示流数据分发引擎的名称，可包含字母，数字和下划线，但必须以字母开头。\n\n**dummyTable** 表对象，和输入的流数据表的 schema 一致，可以含有数据，亦可为空表。\n\n**keyColumn** 字符串。若设置，则会以 *dispatchType* 指定的方式，基于该列分发数据。*keyColumn* 列中的每个唯一值被视为一个 key。\n\n**outputTable** 表对象，若 *outputElapsedTime*= false，则 *outputTable* 的表结构和 *dummyTable* 相同；否则 *outputTable* 比 *dummyTable* 在最后多了一个 LONG 类型和一个 NANOTIMESTAMP 类型的列，分别表示每一个 batch 的输出耗时（单位是微秒）及其输出时的时间戳（精度为纳秒）。\n\n可以指定1\\~100个输出表。引擎会为每个表创建一个线程来接收分发到该表的数据。以 tuple 或嵌套 tuple 的方式指定多张表，例如：outputTable=\\[table1, table2, table3, table4]，表示将注入的数据平均分发到4张表中，每张表的数据不同；outputTable=\\[\\[table1\\_1, table1\\_2], \\[table2\\_1, table2\\_2]]，则会将数据拆分并复制。两份副本分别分发到各个子元素中对应的表中。具体来说，副本1的数据分发到 table1\\_1 table1\\_2，副本2的数据分发到 table2\\_1 和 table2\\_2。此时 table1\\_1 和 table2\\_1 除耗时和时间列外，其它列的数据相同；table1\\_2 和 table2\\_2 除耗时和时间列外，其它列的数据相同。\n\n**dispatchType** 可选参数，字符串，可选值为：\n\n* \"hash\"（默认值）：对 *keyColumn* 列进行哈希计算，并根据计算结果，将数据分发到各个输出表。由于哈希计算得到的分布不一定均匀，因此可能会出现数据分配不均的情况。\n\n* \"uniform\"：按照 *keyColumn* 列，将数据均匀分发到各个输出表。\n\n* \"saltedHash\"：对 *keyColumn* 列进行加盐处理，然后进行哈希计算。通过[加盐处理](https://en.wikipedia.org/wiki/Salt_\\(cryptography\\))，可以确保即使输入相同，也能产生独特的哈希值，从而避免碰撞。该选项在需要进行多层哈希分发的场景（例如分发引擎嵌套分发引擎，且都采用哈希计算进行数据分发）中更为适用。\n\n**Tip:** 建议使用默认的分发方式，即 \"hash\"。如果因为哈希分配不均匀而影响性能，则可以尝试使用 \"uniform\" 方式。\n\n**hashByBatch** 可选参数, 布尔类型。该参数决定了是否将一个 batch 中的所有数据输出到同一个表中。默认为 false，表示对一个 batch 中的所有 key 分组后，按照 *dispatchType* 指定的方式分发数据。 仅当 *dispatchType*='hash' 时，才可设置 *hashByBatch*=true，此时，引擎随机取 batch 中一个 key 进行哈希计算，根据计算结果，将该 batch 中的所有数据输出到某一个表。\n\n**Note:** 当 *hashByBatch*=false 时，可以保证相同 key 的数据被输出到同一张表，但是这种分组操作会增加一些开销。\n\n**outputLock** 可选参数，布尔类型，默认值为 true，表示是否对输出表进行加锁以避免并发访问的冲突。若设置为 false，则不对输出表进行加锁，此时需要保证其他线程不会对输出表进行并发操作。一般情况下，建议使用默认值（true）。\n\n当除了分发引擎以外，还有其他线程（比如其他引擎、流订阅等等）写入到输出表时，输出表需要加锁（因为内存表不允许并发写入），但加锁会增加开销。但在某些场景下，例如在输出线程数量大于等于输入线程数量，且能保证多个输入线程不会同时向一个输出线程写入数据的场景下，如果用户能保证只有一个线程写入输出表，则可以设置该参数为 false，即不对输出表加锁，以提高数据分发的性能。\n\n**queueDepth** 可选参数，正整数，默认为4096（单位为行）。\n\n* *mode* = “buffer” 时，表示每个输出线程的缓存表大小。\n\n* *mode* = “queue” 时，表示每个输出线程的队列深度。\n\n建议根据输入数据的记录数大小，适当调节该参数。如果输入数据量较小但该参数设置过大，则会导致内存空间的浪费；相反，如果输入数据量较大但该参数设置过小，可能会导致数据输出阻塞。\n\n**outputElapsedTime** 可选参数，布尔类型，表示是否输出每个 batch 从注入引擎到分发输出的总耗时。默认为 false，不输出总耗时。若设置为 true，则会在输出表最后两列中输出耗时（单位为微秒）和数据输出的时间戳（单位为纳秒）。\n\n**mode** 可选参数，字符串，可选值为：\n\n* \"buffer\"（默认值）：引擎会为每个输出线程创建一个内存缓存表，并将待分发的数据复制到缓存表中。对于数据写入引擎过程中，可能会并发读写输入表，或频繁 append 数据到引擎且每次 append 的数据量较小的场景，建议使用该配置。\n\n* \"queue\"：引擎为每一个输出线程维护一个数据队列，只将输入表的引用加入到分发队列，不复制数据。此配置要求写入数据的过程中不能对输入表进行并发读写，适合不频繁 append 数据到引擎且每次 append 的数据量较大的场景。\n\n#### 返回值\n\n返回一个表对象。\n\n#### 例子\n\n**例 1** 通过分发引擎，将流数据表中的数据分发到3个状态引擎，以进行因子计算，最终将结果输出到同一个输出表中。\n\n```\n//定义状态引擎的输入和输出表\nshare streamTable(1:0, `sym`price, [STRING,DOUBLE]) as tickStream\nshare streamTable(1000:0, `sym`factor1, [STRING,DOUBLE]) as resultStream\n//定义将要使用的输出表。这里定义3个状态引擎。\nfor(i in 0..2){\nrse = createReactiveStateEngine(name=\"reactiveDemo\"+string(i), metrics =<cumavg(price)>, dummyTable=tickStream, outputTable=resultStream, keyColumn=\"sym\")\n}\n//定义分发引擎\ndispatchEngine=createStreamDispatchEngine(name=\"dispatchDemo\", dummyTable=tickStream, keyColumn=`sym, outputTable=[getStreamEngine(\"reactiveDemo0\"),getStreamEngine(\"reactiveDemo1\"),getStreamEngine(\"reactiveDemo2\")])\n\n//订阅流数据表tickStream\nsubscribeTable(tableName=`tickStream, actionName=\"sub\", handler=tableInsert{dispatchEngine}, msgAsTable = true)\n\n//订阅的数据注入引擎\nn=100000\nsymbols=take((\"A\" + string(1..10)),n)\nprices=100+rand(1.0,n)\nt=table(symbols as sym, prices as price)\ntickStream.append!(t)\n\n\nselect count(*) from resultStream\n100,000\n\n//查看状态引擎状态\ngetStreamEngineStat().ReactiveStreamEngine\n```\n\n| name         | user  | status | lastErrMsg | numGroups | numRows | numMetrics | metrics | snapshotDir | snapshotInterval | snapshotMsgId | snapshotTimestamp | garbageSize | memoryUsed |\n| ------------ | ----- | ------ | ---------- | --------- | ------- | ---------- | ------- | ----------- | ---------------- | ------------- | ----------------- | ----------- | ---------- |\n| dispatchDemo | admin | OK     | 0          | 100,000   | 0       | 0          | -1      | 0           | 0                |               |                   |             |            |\n\n**例 2** 30 只股票的数据持续流入。为了提高因子计算的吞吐量，使用分发引擎将数据按股票代码 sym 分发到 3 个响应式状态引擎，每个引擎独立计算 `cumavg` 因子。\n\n* 采用哈希分发（`dispatchType='hash'`）\n\n  ```\n  dummy = table(1:0, `sym`price, [STRING, DOUBLE])\n  // 定义输出表\n  share streamTable(1000:0, `sym`factor1, [STRING, DOUBLE]) as result_hash0\n  share streamTable(1000:0, `sym`factor1, [STRING, DOUBLE]) as result_hash1\n  share streamTable(1000:0, `sym`factor1, [STRING, DOUBLE]) as result_hash2\n  // 定义响应式状态引擎\n  for(i in 0..2) {\n      createReactiveStateEngine(name=\"rse_hash\" + string(i), metrics=<cumavg(price)>,\n          dummyTable=dummy, outputTable=objByName(\"result_hash\" + string(i)), keyColumn=\"sym\")\n  }\n  // 定义分发引擎\n  dispatchHash = createStreamDispatchEngine(name=\"dispatch_hash\", dummyTable=dummy, keyColumn=`sym,\n      outputTable=[getStreamEngine(\"rse_hash0\"), getStreamEngine(\"rse_hash1\"), getStreamEngine(\"rse_hash2\")],\n      dispatchType='hash')\n\n  // 模拟 30 只股票、共 9 万条数据\n  n = 90000\n  t = table(take(\"A\" + string(1..30), n) as sym, (100 + rand(1.0, n)) as price)\n  dispatchHash.append!(t)\n  sleep(1000)\n\n  result_hash0.size() //27,000\n  result_hash1.size() //36,000\n  result_hash2.size() //27,000\n  ```\n\n* 采用均匀分发（`dispatchType='uniform'`）\n\n  ```\n  dummy = table(1:0, `sym`price, [STRING, DOUBLE])\n  // 定义输出表\n  share streamTable(1000:0, `sym`factor1, [STRING, DOUBLE]) as result_uniform0\n  share streamTable(1000:0, `sym`factor1, [STRING, DOUBLE]) as result_uniform1\n  share streamTable(1000:0, `sym`factor1, [STRING, DOUBLE]) as result_uniform2\n  // 定义响应式状态引擎\n  for(i in 0..2) {\n      createReactiveStateEngine(name=\"rse_uniform\" + string(i), metrics=<cumavg(price)>,\n          dummyTable=dummy, outputTable=objByName(\"result_uniform\" + string(i)), keyColumn=\"sym\")\n  }\n  // 定义分发引擎\n  dispatchUniform = createStreamDispatchEngine(name=\"dispatch_uniform\", dummyTable=dummy, keyColumn=`sym,\n      outputTable=[getStreamEngine(\"rse_uniform0\"), getStreamEngine(\"rse_uniform1\"), getStreamEngine(\"rse_uniform2\")],\n      dispatchType='uniform')\n\n  // 模拟 30 只股票、共 9 万条数据\n  n = 90000\n  t = table(take(\"A\" + string(1..30), n) as sym, (100 + rand(1.0, n)) as price)\n  dispatchUniform.append!(t)\n  sleep(1000)\n\n  result_uniform0.size() //30,000\n  result_uniform1.size() //30,000\n  result_uniform2.size() //30,000\n  ```\n\n可以看出，uniform 分发的各表行数会更均匀。\n\n**例 3** 对于多层分发的场景：engineA 分发至 engine1和 engine2，engine1 分发至 table1\\_1 和 table1\\_2，engine2 分发至 table2\\_1 和 table2\\_2，使用 `dispatchType='saltedHash'` 可有效就避免 hash 分发不均。\n\n```\ndummy = table(1:0, `sym`price, [STRING, DOUBLE])\n// 定义输出表\nshare streamTable(1000:0, `sym`price, [STRING, DOUBLE]) as s_t1_1\nshare streamTable(1000:0, `sym`price, [STRING, DOUBLE]) as s_t1_2\nshare streamTable(1000:0, `sym`price, [STRING, DOUBLE]) as s_t2_1\nshare streamTable(1000:0, `sym`price, [STRING, DOUBLE]) as s_t2_2\n// 定义两层分发引擎\nsalt1 = createStreamDispatchEngine(name=\"salt1\", dummyTable=dummy, keyColumn=`sym,\n    outputTable=[s_t1_1, s_t1_2], dispatchType='saltedHash')\nsalt2 = createStreamDispatchEngine(name=\"salt2\", dummyTable=dummy, keyColumn=`sym,\n    outputTable=[s_t2_1, s_t2_2], dispatchType='saltedHash')\n\nsaltA = createStreamDispatchEngine(name=\"saltA\", dummyTable=dummy, keyColumn=`sym,\n    outputTable=[getStreamEngine(\"salt1\"), getStreamEngine(\"salt2\")], dispatchType='saltedHash')\n// 写入数据\nn = 100000\nt = table(take(\"S\" + string(1..100), n) as sym, rand(100.0, n) as price)\nhashA.append!(t)\nsaltA.append!(t)\nsleep(1000)\n\ns_t1_1.size()//27,000\ns_t1_2.size()//20,000\ns_t2_1.size()//29,000\ns_t2_2.size()//24,000\n```\n\n若使用哈希分发，则多层分发的场景下会出现明显的分发不均。\n\n```\ndummy = table(1:0, `sym`price, [STRING, DOUBLE])\nshare streamTable(1000:0, `sym`price, [STRING, DOUBLE]) as h_t1_1\nshare streamTable(1000:0, `sym`price, [STRING, DOUBLE]) as h_t1_2\nshare streamTable(1000:0, `sym`price, [STRING, DOUBLE]) as h_t2_1\nshare streamTable(1000:0, `sym`price, [STRING, DOUBLE]) as h_t2_2\n\nhash1 = createStreamDispatchEngine(name=\"hash1\", dummyTable=dummy, keyColumn=`sym,\n    outputTable=[h_t1_1, h_t1_2], dispatchType='hash')\nhash2 = createStreamDispatchEngine(name=\"hash2\", dummyTable=dummy, keyColumn=`sym,\n    outputTable=[h_t2_1, h_t2_2], dispatchType='hash')\n\nhashA = createStreamDispatchEngine(name=\"hashA\", dummyTable=dummy, keyColumn=`sym,\n    outputTable=[getStreamEngine(\"hash1\"), getStreamEngine(\"hash2\")], dispatchType='hash')\n\nn = 100000\nt = table(take(\"S\" + string(1..100), n) as sym, rand(100.0, n) as price)\nhashA.append!(t)\nsleep(1000)\n\nh_t1_1.size()//56,000\nh_t1_2.size()//0\nh_t2_1.size()//44,000\nh_t2_2.size()//0\n```\n\n**例 4** hashByBatch 可以设置是否将整批数据发往同一张表。\n\n```\ndummy = table(1:0, `sym`price, [STRING, DOUBLE])\n\nshare streamTable(1000:0, `sym`price, [STRING, DOUBLE]) as out_batchOn_0\nshare streamTable(1000:0, `sym`price, [STRING, DOUBLE]) as out_batchOn_1\n\nshare streamTable(1000:0, `sym`price, [STRING, DOUBLE]) as out_batchOff_0\nshare streamTable(1000:0, `sym`price, [STRING, DOUBLE]) as out_batchOff_1\n\n// hashByBatch=true: 一个 batch 的所有数据输出到同一张表\ndispatchBatchOn = createStreamDispatchEngine(name=\"dispatch_batchOn\", dummyTable=dummy, keyColumn=`sym,\n    outputTable=[out_batchOn_0, out_batchOn_1],\n    dispatchType='hash', hashByBatch=true)\n\n// hashByBatch=false: 同一 batch 内按 key 分组后分发到不同表\ndispatchBatchOff = createStreamDispatchEngine(name=\"dispatch_batchOff\", dummyTable=dummy, keyColumn=`sym,\n    outputTable=[out_batchOff_0, out_batchOff_1],\n    dispatchType='hash', hashByBatch=false)\n\n// 写入数据\nt = table(take(`A`B`C`D`E, 1000) as sym, rand(100.0, 1000) as price)\ndispatchBatchOn.append!(t)\ndispatchBatchOff.append!(t)\nsleep(500)\n\nout_batchOn_0.size()//0\nout_batchOn_1.size()//1,000\n\nout_batchOff_0.size()//600\nout_batchOff_1.size()//400\n```\n\n可以看到，*hashByBatch* 开启后，整批数据发往同一张表；关闭后，两表都有数据。\n\n**例 5** 开启 *outputElapsedTime* 后，输出表中将记录分发耗时和输出时间戳。\n\n```\ndummy = table(1:0, `sym`price, [STRING, DOUBLE])\n\n// outputElapsedTime=true 时，输出表需要比 dummyTable 多两列：LONG (耗时微秒) + NANOTIMESTAMP (输出时间戳)\nshare streamTable(1000:0, `sym`price`elapsed`ts, [STRING, DOUBLE, LONG, NANOTIMESTAMP]) as out_elapsed_0\nshare streamTable(1000:0, `sym`price`elapsed`ts, [STRING, DOUBLE, LONG, NANOTIMESTAMP]) as out_elapsed_1\n\ndispatchElapsed = createStreamDispatchEngine(name=\"dispatch_elapsed\", dummyTable=dummy, keyColumn=`sym,\n    outputTable=[out_elapsed_0, out_elapsed_1],\n    outputElapsedTime=true)\n\nt = table(take(`A`B`C, 3000) as sym, rand(100.0, 3000) as price)\ndispatchElapsed.append!(t)\nsleep(500)\n\nselect top 5 * from out_elapsed_0\n```\n\n| sym | price             | elapsed | ts                            |\n| --- | ----------------- | ------- | ----------------------------- |\n| B   | 5.156729068876414 | 81      | 2026.03.21 19:39:01.860162086 |\n| C   | 14.33727939481318 | 81      | 2026.03.21 19:39:01.860162086 |\n| B   | 56.25857125414968 | 81      | 2026.03.21 19:39:01.860162086 |\n| C   | 65.14644184269626 | 81      | 2026.03.21 19:39:01.860162086 |\n| B   | 48.80402196403686 | 81      | 2026.03.21 19:39:01.860162086 |\n"
    },
    "createStreamGraph": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/createStreamGraph.html",
        "signatures": [
            {
                "full": "createStreamGraph(name)",
                "name": "createStreamGraph",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    }
                ]
            }
        ],
        "markdown": "### [createStreamGraph](https://docs.dolphindb.cn/zh/funcs/c/createStreamGraph.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\ncreateStreamGraph(name)\n\n#### 详情\n\n创建一个声明式流图，支持以下功能：\n\n* 控制流图的生命周期（如初始化、运行、销毁）；\n* 配置订阅与私有流表的行为；\n* 定义数据源（如持久化流表、高可用流数据表、流计算引擎等）。\n\n#### 参数\n\n**name** 字符串标量，表示流图的名字。可以传入完整的流图全限定名（如 \"catalog\\_name.orca\\_graph.graph\\_name\"），也可以仅提供流图名（如 \"factors\"）；系统会根据当前的 catalog 设置自动补全为对应的全限定名。\n\n#### 返回值\n\nStreamGraph 对象。\n\n#### 例子\n\n创建一个名为 indicators 的流图。\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\ng = createStreamGraph(\"indicators\") \n```\n\n**相关函数：**[dropStreamGraph](https://docs.dolphindb.cn/zh/funcs/d/dropStreamGraph.html), [startStreamGraph](https://docs.dolphindb.cn/zh/funcs/s/startStreamGraph.html), [stopStreamGraph](https://docs.dolphindb.cn/zh/funcs/s/stopStreamGraph.html), [StreamGraph::dropGraph](https://docs.dolphindb.cn/zh/funcs/s/StreamGraph_dropGraph.html)\n"
    },
    "createTable": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/createTable.html",
        "signatures": [
            {
                "full": "createDimensionTable(dbHandle, table, tableName, [compressMethods], [sortColumns\\|primaryKey], [keepDuplicates=ALL], [softDelete=false], [indexes], [encryptMode='plaintext'])",
                "name": "createDimensionTable",
                "parameters": [
                    {
                        "full": "dbHandle",
                        "name": "dbHandle"
                    },
                    {
                        "full": "table",
                        "name": "table"
                    },
                    {
                        "full": "tableName",
                        "name": "tableName"
                    },
                    {
                        "full": "[compressMethods]",
                        "name": "compressMethods",
                        "optional": true
                    },
                    {
                        "full": "[sortColumns\\|primaryKey]",
                        "name": "[sortColumns\\|primaryKey]"
                    },
                    {
                        "full": "[keepDuplicates=ALL]",
                        "name": "keepDuplicates",
                        "optional": true,
                        "default": "ALL"
                    },
                    {
                        "full": "[softDelete=false]",
                        "name": "softDelete",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[indexes]",
                        "name": "indexes",
                        "optional": true
                    },
                    {
                        "full": "[encryptMode='plaintext']",
                        "name": "encryptMode",
                        "optional": true,
                        "default": "'plaintext'"
                    }
                ]
            }
        ],
        "markdown": "### [createTable](https://docs.dolphindb.cn/zh/funcs/c/createTable.html)\n\n是 [createDimensionTable](https://docs.dolphindb.cn/zh/funcs/c/createdimensiontable.html) 的别名。\n\n\n以下是 `createDimensionTable` 函数的文档：\n### [createDimensionTable](https://docs.dolphindb.cn/zh/funcs/c/createdimensiontable.html)\n\n\n\n#### 语法\n\ncreateDimensionTable(dbHandle, table, tableName, \\[compressMethods], \\[sortColumns\\\\|primaryKey], \\[keepDuplicates=ALL], \\[softDelete=false], \\[indexes], \\[encryptMode='plaintext'])\n\n别名：createTable\n\n#### 详情\n\n在分布式数据库中创建一个维度表。维度表是分布式数据库中没有进行分区的表，查询时会将表中所有数据加载到内存，适用于存储不频繁更新的小数据集。\n\n系统会定期检查内存的使用情况，当内存使用超过系统配置参数 *warningMemSize* 设定的阈值时，系统会尝试释放部分缓存。维度表如果长时间未被使用，其占用的内存根据 LRU（Least Recently Used）策略将被释放。用户也可以调用 *clearCachedDatabase* 手动释放维度表的缓存。\n\n维度表与分区表都是根据设置参数 *dfsReplicationFactor* 决定副本的数量。维度表的读写操作也支持事务。\n\n通过在配置项配置 *enableConcurrentDimensionalTableWrite* = true，可以支持对维度表进行并发的写入、修改或删除操作。\n\n#### 参数\n\n**dbHandle** 是 [database](https://docs.dolphindb.cn/zh/funcs/d/database.html) 函数返回的分布式数据库句柄。\n\n**table** 是一个表，系统将根据该表的结构在数据库中创建一个空的维度表。\n\n**tableName** 是一个字符串，表示维度表的名称。表名只能由中文或英文字母、数字或下划线（\\_）组成，且必须以中文或英文字母开头。\n\n**compressMethods** 一个字典，指定某些列使用 lz4, delta, zstd 或 chimp 压缩算法存储。key 为字段名，value 为压缩算法（\"lz4\", \"delta\", \"zstd\" 或 \"chimp\"）。若未指定，默认采用 lz4 压缩算法。有关 Delta 压缩算法，亦称为 delta-of-delta encoding，参考：[Delta Compression Techniques](http://engineering.nyu.edu/~suel/papers/delta-chap.pdf)。\n\n* 对于 DECIMAL,SHORT, INT, LONG 与时间或日期类型数据，建议采用 Delta 算法压缩。\n* 将字符串存储为 SYMBOL 类型数据，实现对字符串类型的压缩。\n* 对于小数部分长度在三位以内的 DOUBLE 类型的数据，可以考虑使用 chimp 算法压缩。\n\n**sortColumns** 字符串标量或向量，用于指定每一分区内的排序列，每次写入磁盘的数据在每一分区内将按 *sortColumns* 进行排序。系统默认 *sortColumns* （指定多列时） 除最后一列外的列字段作为排序的索引列，称作 sort key。每一分区内，同一个 sort key 组合值对应的数据将按最后一列的值顺序连续存放在一起。查询时，若查询条件包含索引列，可以快速定位数据所在的数据块位置，提高查询性能。\n\n* 仅当 dbHandle 指示的数据库采用 \"TSDB\" 引擎（engine=\"TSDB\"）时，本参数才生效。\n* *sortColumns* 只能是 INTEGER, TEMPORAL, LITERAL 类别（除 BLOB） 或 DECIMAL 类型。\n  * 若 *sortColumns* 指定为多列，则 *sortColumns* 的最后一列必须为时间类型或整型，其余列为索引列，且索引列不能为为 TIME, TIMESTAMP, NANOTIME, NANOTIMESTAMP 类型。\n  * 若 *sortColumns* 仅指定一列，则该列作为 sort key，其类型可以是除 TIME, TIMESTAMP, NANOTIME, NANOTIMESTAMP 之外的任意类型。若 *sortColumns* 为时间类型 （非分区列），且同时指定了 *sortKeyMappingFunction*，则查询的过滤条件中 *sortColumns* 只能与相同时间类型的值进行比较。\n* 频繁查询的字段适合设置为 *sortColumns*（建议不超过 4 列），且建议优先把查询频率高的字段作为 *sortColumns* 中位置靠前的列。\n* 为保证性能最优，建议每个分区内索引列的组合数（sort key）不超过 2000 个。\n* *sortColumns* 是每个分区内部 level file 内数据的排序依据，与其是否为分区字段无关。\n\n**primaryKey**字符串标量或向量，用于指定主键列。在数据写入操作中，如果主键相同，新的数据覆盖现有数据。\n\n* 仅当*dbHandle* 指示的数据库采用 “PKEY” 引擎（engine=”PKEY”）时，本参数才生效。\n\n* 主键列支持的类型包括：BOOL, CHAR, SHORT, INT, LONG, INT128, STRING, TIME, SECOND, MINUTE, DATE, MONTH, DATEHOUR, DATETIME, SYMBOL, TIMESTAMP, NANOTIME, NANOTIMESTAMP, UUID, COMPLEX, POINT, IPADDR, DECIMAL32, DECIMAL64, DECIMAL128。\n\n**keepDuplicates** 指定在每个分区内如何处理所有 *sortColumns* 之值皆相同的数据。提供以下选项：\n\n* ALL：保留所有数据，为默认值。\n* LAST：仅保留最新数据\n* FIRST：仅保留第一条数据\n\n**softDelete** 用于启用或禁用软删除功能。默认为 false，即禁用。该参数适于在行数多但删除量小的场景下使用。使用该参数需要同时满足以下条件：\n\n* 由TSDB 存储引擎创建的数据库内的表\n\n* *keepDuplicates* 已设置为 LAST\n\n**Note:** 参数 *sortColumns*, *keepDuplicates* 仅在 `database` 的 *engine* 参数指定为 TSDB 时才有效。\n\n**indexes** 为一个字典。当引擎为 PKEY 时，用于为表中的列指定索引。字典的键是 STRING 类型标量，表示列名；值是 STRING 类型标量，表示为该列指定的索引类型。目前支持设置 “bloomfilter” 索引类型：适用于对大基数列进行点查，且基数越大，索引效果越好，如身份证 ID、订单号、从业务上游同步的外键等数据列。目前支持的类型包括 BOOL, CHAR, SHORT, INT, LONG, BLOB, STRING, DECIMAL32, DECIMAL64, DECIMAL128。\n\n**Note:** 引擎会将所有主键列合并为组合主键，并为组合主键设置 bloomfilter 类型索引。\n\n**encryptMode** 可选参数，字符串标量，指定表的加密方式，默认为不加密（明文模式）。仅 Linux 系统支持该参数。目前支持以下可选值（大小写不区分）：plaintext, aes\\_128\\_ctr, aes\\_128\\_cbc, aes\\_128\\_ecb, aes\\_192\\_ctr, aes\\_192\\_cbc, aes\\_192\\_ecb, aes\\_256\\_ctr, aes\\_256\\_cbc, aes\\_256\\_ecb, sm4\\_128\\_cbc, sm4\\_128\\_ecb。\n\n#### 返回值\n\n一个表。\n\n#### 例子\n\n例1\n\n```\ndb=database(\"dfs://db1\",VALUE,1 2 3)\ntimestamp = [09:34:07,09:36:42,09:36:51,09:36:59,09:32:47,09:35:26,09:34:16,09:34:26,09:38:12]\nsym = `C`MS`MS`MS`IBM`IBM`C`C`C\nprice= 49.6 29.46 29.52 30.02 174.97 175.23 50.76 50.32 51.29\nqty = 2200 1900 2100 3200 6800 5400 1300 2500 8800\nt = table(timestamp, sym, qty, price);\n\ndt=db.createDimensionTable(t,`dt).append!(t);\nselect * from dt;\n```\n\n| timestamp | sym | qty  | price  |\n| --------- | --- | ---- | ------ |\n| 09:34:07  | C   | 2200 | 49.6   |\n| 09:36:42  | MS  | 1900 | 29.46  |\n| 09:36:51  | MS  | 2100 | 29.52  |\n| 09:36:59  | MS  | 3200 | 30.02  |\n| 09:32:47  | IBM | 6800 | 174.97 |\n| 09:35:26  | IBM | 5400 | 175.23 |\n| 09:34:16  | C   | 1300 | 50.76  |\n| 09:34:26  | C   | 2500 | 50.32  |\n| 09:38:12  | C   | 8800 | 51.29  |\n\n例2\n\n```\ndb = database(\"dfs://demodb\", VALUE, 1..10)\nt=table(take(1, 86400) as id, 2020.01.01T00:00:00 + 0..86399 as timestamp, rand(1..100, 86400) as val)\ndt = db.createDimensionTable(t, \"dt\", {timestamp:\"delta\", val:\"delta\"})\ndt.append!(t)\n```\n\n例3. TSDB 存储引擎下创建维度表\n\n```\nif(existsDatabase(\"dfs://dbctable_createDimensionTable\")){\n  dropDatabase(\"dfs://dbctable_createDimensionTable\")\n}\ndb = database(\"dfs://dbctable_createDimensionTable\", VALUE, 1..100, , \"TSDB\")\nt1 = table(1 100 100 300 300 400 500 as id, 1..7 as v)\ndb.createDimensionTable(t1, \"dt\", , \"id\").append!(t1)\ndt=loadTable(\"dfs://dbctable_createDimensionTable\",\"dt\")\n```\n\n例4. PKEY 存储引擎下创建维度表\n\n```\ndb = database(directory=\"dfs://PKDB\", partitionType=VALUE, partitionScheme=1..10, engine=\"PKEY\")\nschematb = table(1:0,`id1`id2`val1`val2`date1`time1,[INT,INT,INT,DECIMAL32(2),DATE,TIME])\npkt = createDimensionTable(dbHandle=db, table=schematb, tableName=\"pkt\", primaryKey=`id1`id2, indexes={\"val1\": \"bloomfilter\", \"val2\": \"bloomfilter\"})\n```\n\n**Related information**\n\n[createPartitionedTable](https://docs.dolphindb.cn/zh/funcs/c/createPartitionedTable.html)\n"
    },
    "createThresholdEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/createthresholdengine.html",
        "signatures": [
            {
                "full": "createThresholdEngine(name, threshold, metrics, dummyTable, outputTable, thresholdColumn, [keyColumn], [timeColumn], [sessionBegin], [sessionEnd], [keyPurgeDaily=false], [forceTriggerSessionEndTime=0], [snapshotDir], [snapshotIntervalInMsgCount], [outputElapsedMicroseconds=false], [outputThreshold=false])",
                "name": "createThresholdEngine",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "threshold",
                        "name": "threshold"
                    },
                    {
                        "full": "metrics",
                        "name": "metrics"
                    },
                    {
                        "full": "dummyTable",
                        "name": "dummyTable"
                    },
                    {
                        "full": "outputTable",
                        "name": "outputTable"
                    },
                    {
                        "full": "thresholdColumn",
                        "name": "thresholdColumn"
                    },
                    {
                        "full": "[keyColumn]",
                        "name": "keyColumn",
                        "optional": true
                    },
                    {
                        "full": "[timeColumn]",
                        "name": "timeColumn",
                        "optional": true
                    },
                    {
                        "full": "[sessionBegin]",
                        "name": "sessionBegin",
                        "optional": true
                    },
                    {
                        "full": "[sessionEnd]",
                        "name": "sessionEnd",
                        "optional": true
                    },
                    {
                        "full": "[keyPurgeDaily=false]",
                        "name": "keyPurgeDaily",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[forceTriggerSessionEndTime=0]",
                        "name": "forceTriggerSessionEndTime",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[snapshotDir]",
                        "name": "snapshotDir",
                        "optional": true
                    },
                    {
                        "full": "[snapshotIntervalInMsgCount]",
                        "name": "snapshotIntervalInMsgCount",
                        "optional": true
                    },
                    {
                        "full": "[outputElapsedMicroseconds=false]",
                        "name": "outputElapsedMicroseconds",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[outputThreshold=false]",
                        "name": "outputThreshold",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [createThresholdEngine](https://docs.dolphindb.cn/zh/funcs/c/createthresholdengine.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\ncreateThresholdEngine(name, threshold, metrics, dummyTable, outputTable, thresholdColumn, \\[keyColumn], \\[timeColumn], \\[sessionBegin], \\[sessionEnd], \\[keyPurgeDaily=false], \\[forceTriggerSessionEndTime=0], \\[snapshotDir], \\[snapshotIntervalInMsgCount], \\[outputElapsedMicroseconds=false], \\[outputThreshold=false])\n\n#### 详情\n\n创建阈值引擎，以实现基于累计值阈值触发的聚合计算，每当阈值列（*thresholdColumn*）的累计值达到特定阈值（*threshold\\**n）时，进行一次聚合计算：\n\n* 若指定 *keyColumn* 进行分组，则聚合计算将在各分组内独立进行。\n* 若指定 *sessionBegin* 和 *sessionEnd*，则仅有 \\[sessionBegin, sessionEnd] 范围内的数据会参与计算。\n\n#### 参数\n\n**name** 字符串标量，表示阈值引擎的名称，作为其在一个数据节点/计算节点上的唯一标识。可包含字母，数字和下划线，但必须以字母开头。\n\n**threshold**正整数标量，表示阈值步长。\n\n**metrics** 以元代码的格式表示计算指标，支持输入元组。有关元代码的更多信息可参考 [元编程](https://docs.dolphindb.cn/zh/progr/objs/meta_progr.html)。\n\n* 计算指标可以是一个或多个系统内置或用户自定义的聚合函数（使用 defg 关键字定义），如 <\\[sum(volume), avg(price)]>；可以对聚合结果使用表达式，如 <\\[avg(price1)-avg(price2)]>；也可对列与列的计算结果进行聚合计算，如 <\\[std(price1-price2)]>。\n\n* *metrics* 内支持调用具有多个返回值的函数，例如 \\<func(price) as \\`col1\\`col2>（可不指定列名）。\n\n* 支持指定为一个常量标量或向量，例如 <1>，<\\[1, 2, 3]> 。当指定为常量向量时，对应的输出列必须设置为数组向量类型。\n\n* 若 *windowSize* 为向量， *windowSize* 每个值可对应 *metrics* 中多个计算指标。例如，*windowSize* 为\\[10,20]时，metrics可为 (<\\[min(volume), max(volume)]>, \\<sum(volume)>)。 *metrics* 也可以嵌套输入元组向量。例如：\\[\\[<\\[min(volume), max(volume)]>, \\<sum(volume)>], \\[\\<avg(volume)>]]\n\n  **Note:**\n\n  * *metrics* 中使用的列名大小写不敏感，不需要与输入表的列名大小写保持一致。\n  * *metrics* 中不可使用嵌套聚合函数。\n\n**dummyTable** 一个表对象，和输入的流数据表的 schema 一致，可以含有数据，亦可为空表。\n\n**outputTable**计算结果的输出表，可以是内存表或分布式表。在使用`createThresholdEngine`函数之前，需要将输出表预先设立为一个空表，并指定各列列名以及数据类型。阈值引擎会将计算结果插入该表。\n\n输出表的列顺序如下：\n\n1. 时间列。如果指定了 *timeColumn*，则输出表中时间列与 *timeColumn* 数据类型一致，用于记录触发引擎计算的数据时间。\n2. 分组列。如果指定了 *keyColumn*，则输出表中分组列和 *keyColumn* 设置的列的类型和顺序保持一致。\n3. 阈值窗口值列。如果指定 *outputThreshold*=true，则指定一个 LONG 类型的列用于记录触发计算的阈值窗口右边界的值。\n4. thresholdColumn 累计和列。如果指定*outputThreshold*=true，则指定一个 DOUBLE 类型的列记录触发计算时，*thresholdColumn* 的累计和。\n5. 耗时列。如果指定 *outputElapsedMicroseconds*=true，则指定一个 LONG 类型的列用于存储耗时（单位：微秒）。\n6. 计算结果列。可为多列。\n\n**keyColumn**可选参数，字符串标量或向量，表示分组列名。若设置，则分组进行聚合计算。\n\n**timeColumn**可选参数，字符串标量或向量，用于指定订阅的流数据表中时间列的名称。\n\n* 注：字符串向量必须是 date 和 time 组成的向量，date 类型为 DATE，time 类型为 TIME, SECOND 或 NANOTIME。此时，输出表第一列的时间类型必须与 concatDateTime(date, time) 的类型一致。\n\n**sessionBegin** 可选参数，可以是与时间列的数据类型对应的 SECOND、TIME 或 NANOTIME 类型的标量或向量，表示每个时间段的起始时刻。如果 *sessionBegin* 是一个向量，它必须是递增的。\n\n**sessionEnd** 可选参数，可以是与时间列的数据类型对应的 SECOND、TIME 或 NANOTIME 类型的标量或向量，表示每个时间段的结束时刻。可在 *sessionEnd* 中指定 00:00:00 表示的次日的零点（即当日的 24:00:00）。\n\n**keyPurgeDaily** 可选参数，是一个布尔值。默认值为 true，表示引擎在收到第一批包含新日期的数据时，先清空之前保存的所有分组，再对这批新数据进行处理。若设置为 false，则引擎不会清理前一天的分组。\n\n**forceTriggerSessionEndTime** 可选参数，非负整数，单位与 timeColumn 的时间精度一致，默认值为 0。若 sessionEnd 时刻对应的窗口数据长时间未发生计算，通过该参数可以设置系统经过多少时间后触发计算并输出。若设置为0，表示不会通过这种方式触发计算。\n\n**Note:** **注：** 当系统时间达到 sessionEnd + forceTriggerSessionEndTime 时触发计算，因此该参数在回放场景下不适用。\n\n**snapshotDir** 可选参数，字符串，表示保存引擎快照的文件目录。\n\n* 指定的目录必须存在，否则系统会提示异常。\n* 创建流数据引擎时，如果指定了 *snapshotDir*，会检查该目录下是否存在快照。如果存在，会加载该快照，恢复引擎的状态。\n* 多个引擎可以指定同一个目录存储快照，用引擎的名称来区分快照文件。\n* 一个引擎的快照可能会使用三个文件名：\n  * 临时存储快照信息：文件名为 \\<engineName>.tmp；\n  * 快照生成并刷到磁盘：文件保存为 \\<engineName>.snapshot；\n  * 存在同名快照：旧快照自动重命名为 \\<engineName>.old。\n\n**snapshotIntervalInMsgCount** 可选参数，为整数类型，表示每隔多少条数据保存一次流数据引擎快照。\n\n**outputElapsedMicroseconds** 可选参数，布尔标量，表示是否输出每个窗口从触发计算到计算完成输出结果的耗时（若指定了 *keyColumn* 则包含数据分组的耗时），默认为 false。指定参数 *outputElapsedMicroseconds* 后，在定义 *outputTable* 时需要在时间列和分组列后增加一个 LONG 类型的列，详见 *outputTable* 参数说明。\n\n**outputThreshold** 可选参数，布尔标量，表示是否输出阈值窗口值和 *thresholdColumn* 累计和。\n\n#### 返回值\n\n一个表对象，通过向该表对象写入，将数据注入阈值引擎进行计算。\n\n#### 例子\n\n**例1** 通过时序聚合引擎计算1分钟 K 线，然后通过 createThresholdEngine 将 1 分钟 K 线聚合为 5 分钟。在窗口左闭右开的情况下，可以提前一分钟结束窗口并计算输出，从而比使用 createTimeSeriesEngine 减少延时。\n\n```\n// 准备数据\nn = 1000000;\nsampleDate = 2019.11.07;\nsymbols = `600519`000001`600000`601766;\ntrade = table(take(sampleDate, n) as date, \n\t(09:30:00.000 + rand(7200000, n/2)).sort!() join (13:00:00.000 + rand(7200000, n/2)).sort!() as time, \n\trand(symbols, n) as symbol, \n\t100+cumsum(rand(0.02, n)-0.01) as price, \n\trand(1000, n) as volume)\n\n// 创建dummyTable, outputTable\t\nshare(streamTable(10:0,`date`time`symbol`price`volumn,[DATE, TIME, SYMBOL, DOUBLE, DOUBLE]), `trades);\nshare(table(1:0, `timestamp`symbol`open`high`low`close, [TIMESTAMP,SYMBOL,DOUBLE,DOUBLE,DOUBLE,DOUBLE]), `outputTable);\ngo\n// 创建阈值引擎\nthresholdEngine = createThresholdEngine(name=\"demo\", threshold=1000000, metrics=<[first(price), max(price), min(price), last(price)]>, dummyTable=trades, outputTable=outputTable, thresholdColumn=`volumn, keyColumn=`symbol, timeColumn=[`date, `time]);\n\n// 插入数据\nthresholdEngine.append!(trade);\n\n// 查询计算结果\nselect * from outputTable\n```\n\n部分结果如下：\n\n| timestamp               | symbol | open               | high               | low                | close              |\n| ----------------------- | ------ | ------------------ | ------------------ | ------------------ | ------------------ |\n| 2019.11.07 09:31:54.986 | 000001 | 99.98404977017083  | 100.52950904161203 | 99.56823161885143  | 100.5279260600172  |\n| 2019.11.07 09:33:51.890 | 000001 | 100.51835866520182 | 100.92578917419537 | 100.49741881850642 | 100.70077057819347 |\n| 2019.11.07 09:35:48.298 | 000001 | 100.71148486480116 | 100.787968895277   | 99.84565304366406  | 100.61527177638374 |\n| 2019.11.07 09:37:49.058 | 000001 | 100.61627630640287 | 101.55438607632183 | 100.48305282644462 | 101.33690219670534 |\n| 2019.11.07 09:39:44.562 | 000001 | 101.32348716112786 | 101.55176323080435 | 100.74830873960164 | 100.77029377058614 |\n| 2019.11.07 09:41:38.118 | 000001 | 100.78262700690422 | 101.24037498458289 | 100.67253582042176 | 100.7765302780131  |\n\n**例2** 通过 *sessionBegin* 和 *sessionEnd* 限定只处理交易时段内的数据。\n\n```\n// 准备数据\nt = table(\n    2024.01.02 2024.01.02 2024.01.02 2024.01.02 2024.01.02 as date,\n    09:20:00.000 09:31:00.000 10:15:00.000 11:35:00.000 13:05:00.000 as time,\n    `A`A`A`A`A as sym,\n    10.1 10.2 10.3 10.4 10.5 as price,\n    200 500 600 700 800 as volume\n)\n```\n\n| date       | time         | sym | price | volume |\n| ---------- | ------------ | --- | ----- | ------ |\n| 2024.01.02 | 09:20:00.000 | A   | 10.1  | 200    |\n| 2024.01.02 | 09:31:00.000 | A   | 10.2  | 500    |\n| 2024.01.02 | 10:15:00.000 | A   | 10.3  | 600    |\n| 2024.01.02 | 11:35:00.000 | A   | 10.4  | 700    |\n| 2024.01.02 | 13:05:00.000 | A   | 10.5  | 800    |\n\n```\n// 创建 dummyTable, outputTable\nshare(streamTable(10:0, `date`time`sym`price`volume, [DATE, TIME, SYMBOL, DOUBLE, DOUBLE]), `trades1)\nshare(table(10:0, `timestamp`sym`sumVol, [TIMESTAMP, SYMBOL, DOUBLE]), `outputTable1)\ngo\n// 创建阈值引擎\nengine = createThresholdEngine(\n    name=\"thresholdDemo1\",\n    threshold=1000,\n    metrics=<[sum(volume)]>,\n    dummyTable=trades1,\n    outputTable=outputTable1,\n    thresholdColumn=`volume,\n    keyColumn=`sym,\n    timeColumn=[`date, `time],\n    sessionBegin=09:30:00.000 13:00:00.000,\n    sessionEnd=11:30:00.000 15:00:00.000\n)\n\n// 插入数据\nengine.append!(t)\n\n// 查询结果\nselect * from outputTable1\n```\n\n| timestamp               | sym | sumVol |\n| ----------------------- | --- | ------ |\n| 2024.01.02 10:15:00.000 | A   | 1,100  |\n\n09:20:00.000 和 11:35:00.000 的数据不在 \\[sessionBegin, sessionEnd] 指定的交易时段内，不参与阈值累计。\n\n**例3** 通过 *keyPurgeDaily* 控制跨日后是否清空前一日分组状态\n\n```\n// 创建 dummyTable, outputTable\nshare(streamTable(10:0, `date`time`sym`price`volume, [DATE, TIME, SYMBOL, DOUBLE, DOUBLE]), `trades)\nshare(table(10:0, `timestamp`sym`sumVol, [TIMESTAMP, SYMBOL, DOUBLE]), `output1)\nshare(table(10:0, `timestamp`sym`sumVol, [TIMESTAMP, SYMBOL, DOUBLE]), `output2)\ngo\n// keyPurgeDaily=true：跨日后清空前一日分组状态\nengine1 = createThresholdEngine(\n    name=\"thresholdDemo2_true\",\n    threshold=1000,\n    metrics=<[sum(volume)]>,\n    dummyTable=trades,\n    outputTable=output1,\n    thresholdColumn=`volume,\n    keyColumn=`sym,\n    timeColumn=[`date, `time],\n    keyPurgeDaily=true\n)\n\n// keyPurgeDaily=false：跨日后保留前一日分组状态\nengine2 = createThresholdEngine(\n    name=\"thresholdDemo2_false\",\n    threshold=1000,\n    metrics=<[sum(volume)]>,\n    dummyTable=trades,\n    outputTable=output2,\n    thresholdColumn=`volume,\n    keyColumn=`sym,\n    timeColumn=[`date, `time],\n    keyPurgeDaily=false\n)\n\n// 准备数据\nt = table(\n    2024.01.02 2024.01.03 2024.01.03 as date,\n    14:59:00.000 09:31:00.000 09:31:01.000 as time,\n    `A`A`A as sym,\n    10.1 10.2 10.3 as price,\n    600 500 700 as volume\n)\n\n// 插入数据\nengine1.append!(t)\nengine2.append!(t)\n\n// 查询结果\nselect * from output1\n```\n\n| timestamp               | sym | sumVol |\n| ----------------------- | --- | ------ |\n| 2024.01.02 14:59:00.000 | A   | 600    |\n| 2024.01.03 09:31:01.000 | A   | 1,200  |\n\n```\nselect * from output2\n```\n\n| timestamp               | sym | sumVol |\n| ----------------------- | --- | ------ |\n| 2024.01.03 09:31:00.000 | A   | 1,100  |\n\n**例4** 通过 outputElapsedMicroseconds 输出每次触发计算的耗时\n\n```\n// 创建 dummyTable, outputTable\nshare(streamTable(10:0, `date`time`sym`price`volume, [DATE, TIME, SYMBOL, DOUBLE, DOUBLE]), `trades)\nshare(table(10:0, `timestamp`sym`elapsed`avgPrice`sumVol, [TIMESTAMP, SYMBOL, LONG, DOUBLE, DOUBLE]), `outputTable)\ngo\n// 创建阈值引擎\nengine = createThresholdEngine(\n    name=\"thresholdDemo4\",\n    threshold=1000,\n    metrics=<[avg(price), sum(volume)]>,\n    dummyTable=trades,\n    outputTable=outputTable,\n    thresholdColumn=`volume,\n    keyColumn=`sym,\n    timeColumn=[`date, `time],\n    outputElapsedMicroseconds=true\n)\n\n// 准备数据\nt = table(\n    2024.01.02 2024.01.02 2024.01.02 as date,\n    09:31:00.000 09:32:00.000 09:33:00.000 as time,\n    `A`A`A as sym,\n    10.1 10.2 10.3 as price,\n    300 400 500 as volume\n)\n\n// 插入数据\nengine.append!(t)\n\n// 查询结果\nselect * from outputTable\n```\n\n| timestamp               | sym | elapsed | avgPrice | sumVol |\n| ----------------------- | --- | ------- | -------- | ------ |\n| 2024.01.02 09:33:00.000 | A   | 1       | 10.2     | 1,200  |\n\n**例5** 通过 *outputThreshold* 输出阈值窗口值和 *thresholdColumn* 累计和\n\n```\n// 创建 dummyTable, outputTable\nshare(streamTable(10:0, `date`time`sym`price`volume, [DATE, TIME, SYMBOL, DOUBLE, DOUBLE]), `trades)\nshare(table(10:0, `timestamp`sym`thresholdValue`cumThreshold`lastPrice, [TIMESTAMP, SYMBOL, LONG, DOUBLE, DOUBLE]), `outputTable)\ngo\n// 创建阈值引擎\nengine = createThresholdEngine(\n    name=\"thresholdDemo5\",\n    threshold=1000,\n    metrics=<[last(price)]>,\n    dummyTable=trades,\n    outputTable=outputTable,\n    thresholdColumn=`volume,\n    keyColumn=`sym,\n    timeColumn=[`date, `time],\n    outputThreshold=true\n)\n\n// 准备数据\nt = table(\n    2024.01.02 2024.01.02 2024.01.02 as date,\n    09:31:00.000 09:32:00.000 09:33:00.000 as time,\n    `A`A`A as sym,\n    10.1 10.2 10.3 as price,\n    300 400 500 as volume\n)\n\n// 插入数据\nengine.append!(t)\n\n// 查询结果\nselect * from outputTable\n```\n\n| timestamp               | sym | thresholdValue | cumThreshold | lastPrice |\n| ----------------------- | --- | -------------- | ------------ | --------- |\n| 2024.01.02 09:33:00.000 | A   | 1,000          | 1,200        | 10.3      |\n"
    },
    "createTimeBucketEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/createtimebucketengine.html",
        "signatures": [
            {
                "full": "createTimeBucketEngine(name,timeCutPoints,metrics,dummyTable,outputTable,timeColumn,[keyColumn],[useWindowStartTime],[closed='left'],[fill='none'],[keyPurgeFreqInSec=-1],[outputElapsedMicroseconds=false],[parallelism=1],[outputHandler],[msgAsTable=false],[snapshotDir],[snapshotIntervalInMsgCount])",
                "name": "createTimeBucketEngine",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "timeCutPoints",
                        "name": "timeCutPoints"
                    },
                    {
                        "full": "metrics",
                        "name": "metrics"
                    },
                    {
                        "full": "dummyTable",
                        "name": "dummyTable"
                    },
                    {
                        "full": "outputTable",
                        "name": "outputTable"
                    },
                    {
                        "full": "timeColumn",
                        "name": "timeColumn"
                    },
                    {
                        "full": "[keyColumn]",
                        "name": "keyColumn",
                        "optional": true
                    },
                    {
                        "full": "[useWindowStartTime]",
                        "name": "useWindowStartTime",
                        "optional": true
                    },
                    {
                        "full": "[closed='left']",
                        "name": "closed",
                        "optional": true,
                        "default": "'left'"
                    },
                    {
                        "full": "[fill='none']",
                        "name": "fill",
                        "optional": true,
                        "default": "'none'"
                    },
                    {
                        "full": "[keyPurgeFreqInSec=-1]",
                        "name": "keyPurgeFreqInSec",
                        "optional": true,
                        "default": "-1"
                    },
                    {
                        "full": "[outputElapsedMicroseconds=false]",
                        "name": "outputElapsedMicroseconds",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[parallelism=1]",
                        "name": "parallelism",
                        "optional": true,
                        "default": "1"
                    },
                    {
                        "full": "[outputHandler]",
                        "name": "outputHandler",
                        "optional": true
                    },
                    {
                        "full": "[msgAsTable=false]",
                        "name": "msgAsTable",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[snapshotDir]",
                        "name": "snapshotDir",
                        "optional": true
                    },
                    {
                        "full": "[snapshotIntervalInMsgCount]",
                        "name": "snapshotIntervalInMsgCount",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [createTimeBucketEngine](https://docs.dolphindb.cn/zh/funcs/c/createtimebucketengine.html)\n\n\n\n#### 语法\n\ncreateTimeBucketEngine(name,timeCutPoints,metrics,dummyTable,outputTable,timeColumn,\\[keyColumn],\\[useWindowStartTime],\\[closed='left'],\\[fill='none'],\\[keyPurgeFreqInSec=-1],\\[outputElapsedMicroseconds=false],\\[parallelism=1],\\[outputHandler],\\[msgAsTable=false],\\[snapshotDir],\\[snapshotIntervalInMsgCount])\n\n#### 详情\n\n创建一个自定义窗口长度（长度相同或不同）的时间序列聚合引擎。该引擎基于数据时间，按照指定的长度对输入数据进行窗口划分，并在窗口内执行增量聚合计算。通常和时序聚合引擎（createTimeSeriesEngine ）级联使用，接收其输出秒级或分钟级聚合结果（例如 K 线）进行进一步处理。\n\n**Note:** 不支持乱序处理机制，用户需要自行保证输入的数据有序。\n\n**窗口**\n\n* 窗口边界：窗口的左、右边界由*timeCutPoints* 向量的任意两个相邻元素确定。\n\n* 边界开闭：由 *closed* 确定边界是左闭右开或者左开右闭。\n\n* 窗口关闭时机：窗口左开右闭时，收到的第一条时间戳大于等于右边界的数据触发窗口关闭；窗口左闭右开时，收到的第一条时间戳大于等于右边界时间戳减1的数据触发窗口关闭。例如，对于窗口 \\[09:00, 09:05)，当收到数据的时间戳大于等于 09:04 时，窗口关闭。\n\n* 窗口输出时间戳：窗口输出时间戳的精度同 *timeColumn*。若 *useWindowStartTime* = true，显示为窗口起始时间；反之，显示时间为数据窗口终止时间。\n\n**计算**\n\n* 参与计算的数据时间范围：*timeCutPoints* 向量中第一个元素和最后一个元素确定的时间范围内的数据会参与计算。该向量的时间精度决定了计算窗口的时间精度。例如，当 *timeCutPoints =*\\[09:00m, 09:05m]，且窗口左闭右开时，窗口的时间精度为分钟。此时，只有在大于等于 09:00m 且小于等于 09:04m 的数据会参与计算，而大于 09:04m 的数据（如 09:04:00.100）则不参与计算。\n\n* 分组计算或全局计算：若指定了 *keyColumn*，则按照分组分别进行窗口计算，否则进行全局计算。\n\n* 计算结果填充：未指定 *fill* 或指定 *fill* = \"none\" 时，只输出计算结果不为空的窗口；若指定了 *fill*，则输出所有窗口，且根据 *fill* 规则对结果为空的窗口进行填充。\n\n#### 参数\n\n**name** 字符串标量，表示时间序列分组引擎的名称，作为其在一个数据节点/计算节点上的唯一标识。可包含字母，数字和下划线，但必须以字母开头。\n\n**timeCutPoints** MINUTE 或 SECOND 类型向量，且不能包含空值。由 *timeCutPoints* 向量的任意两个相邻元素确定窗口的左、右边界。注意：\n\n* *timeCutPoints* 指定的时间精度必须不高于 *timeColumn* 列的精度。\n\n* *timeCutPoints* 指定的时间精度决定关闭窗口右边界的时间精度。如果 *timeCutPoints* 是 MINUTE 类型，则窗口右边界的时间精度是分；如果 *timeCutPoints* 是 SECOND 类型，则窗口右边界的时间精度是秒。\n\n**metrics** 以元代码的格式表示计算指标，支持输入元组。有关元代码的更多信息可参考 [元编程](https://docs.dolphindb.cn/zh/progr/objs/meta_progr.html)。\n\n* 计算指标可以是一个或多个系统内置或用户自定义的聚合函数（使用 defg 关键字定义），如 <\\[sum(volume), avg(price)]>；可以对聚合结果使用表达式，如 <\\[avg(price1)-avg(price2)]>；也可对列与列的计算结果进行聚合计算，如 <\\[std(price1-price2)]>。\n\n* *metrics* 内支持调用具有多个返回值的函数，例如 \\<func(price) as \\`col1\\`col2>（可不指定列名）。\n\n**dummyTable** 一个表对象，和输入的流数据表的 schema 一致，可以含有数据，亦可为空表。\n\n**outputTable**计算结果的输出表，可以是内存表或者分布式表。在使用 createTimeBucketEngine 函数之前，需要将输出表预先设立为一个空表，并指定各列列名以及数据类型。引擎会将计算结果插入该表。\n\n输出表的列顺序如下：\n\n1. 时间列（1列）。\n\n   * 当 *timeColumn* 为标量时，时间列的数据类型与 *timeColumn* 列 一致。\n   * 当 *timeColumn* 为向量时，时间列的数据类型与 *timeColumn* 中指定的日期列和时间列应用 `concatDateTime` 函数后的类型一致。\n\n2. 分组列。如果 *keyColumn* 不为空，则其后几列和 *keyColumn* 设置的列及其顺序保持一致。\n\n3. 耗时列。如果指定 *outputElapsedMicroseconds* = true，则指定一个 LONG 类型的列用于存储耗时（单位：微秒）。\n\n4. 计算结果列，数量和 *metrics* 中指定的算子个数相同。若 *metrics* 指定的某个算子返回多个计算结果，则它们将以数组向量的形式输出，因此，该算子对应的计算结果列必须的类型必须是数组向量。\n\n**timeColumn** 字符串标量或长度为2的向量，用于输入表中时间列的名称。\n\n注：若 *timeColumn* 指定为向量，则第一个元素（date）的类型为 DATE，第二个元素（time）的类型为 TIME, SECOND 或 NANOTIME。此时，输出表第一列的时间类型必须与 concatDateTime(date, time) 的类型一致。\n\n**keyColumn** 可选参数，字符串标量或向量，表示分组列名。若设置，则分组进行聚合计算，例如以每支股票为一组进行聚合计算。\n\n**useWindowStartTime** 可选参数。布尔值，表示输出表中的时间是否为数据窗口起始时间。默认值为 false，表示输出表中的时间为窗口结束时间。\n\n**closed** 字符串，用于确定滑动窗口边界的开闭情况。可选值为 'left' 或 'right'，默认值为 'left'。\n\n* closed = 'left'： 窗口左闭右开。\n\n* closed = 'right'： 窗口左开右闭。\n\n**fill** 可选参数，一个标量或向量，指定某个分组的某个窗口无数据时的处理方法。可取以下值：\n\n* 'none': 不输出结果。\n* 'null': 输出结果为 NULL。\n* 'ffill': 输出上一个有数据的窗口的结果。\n* '具体数值'：该值的数据类型需要和对应的 *metrics* 计算结果的类型保持一致。\n\n*fill* 可以输入向量，长度与 *metrics* 元素个数保持一致，表示为每个 *metrics* 指定不同的 *fill* 方式。若为向量，向量中各项只能是 'null', 'ffill' 或一个数值，不能是 'none'。\n\n**keyPurgeFreqInSec** 正整数，表示清理窗口数据为空的分组的时间间隔，单位为秒。指定该参数后，若当前数据注入时间与上一次清理时间的间隔大于等于 *keyPurgeFreqInSec*，则触发对当前窗口数据为空的分组信息的清理。若指定该参数，则必须指定 *keyColumn*，且不能指定 *fill。*\n\n**outputElapsedMicroseconds** 布尔值，表示是否输出每个窗口从触发计算到计算完成输出结果的耗时（若指定了 *keyColumn* 则包含数据分组的耗时），默认为 false。指定参数 *outputElapsedMicroseconds* 后，在定义 *outputTable* 时需要在时间列和分组列后增加一个 LONG 类型的列，详见 *outputTable* 参数说明。\n\n**parallelism** 为不超过 63 的正整数，可选参数，表示并行计算的工作线程数，默认值为 1。在计算量较大时，合理地调整该参数能够有效利用计算资源，降低计算耗时。建议小于机器核数，推荐值为 4 到 8 。\n\n**outputHandler** 一元函数。设置此参数时，引擎计算结束后，不再将计算结果写到输出表，而是会调用此函数处理计算结果。\n\n**msgAsTable** 布尔标量，表示在设置了参数 outputHandler 时，将引擎的计算结果以表的结构调用函数。默认值为 false，此时将计算结果的每一列作为元素组成元组。\n\n若要开启快照机制 (snapshot)，必须指定 *snapshotDir* 与 *snapshotIntervalInMsgCount*。\n\n**snapshotDir** 可选参数，字符串，表示保存引擎快照的文件目录。\n\n* 指定的目录必须存在，否则系统会提示异常。\n\n* 创建流数据引擎时，如果指定了 *snapshotDir*，会检查该目录下是否存在快照。如果存在，会加载该快照，恢复引擎的状态。\n\n* 多个引擎可以指定同一个目录存储快照，用引擎的名称来区分快照文件。\n\n* 一个引擎的快照可能会使用三个文件名：\n\n  * 临时存储快照信息：文件名为 *\\<engineName>.tmp*；\n\n  * 快照生成并刷到磁盘：文件保存为 *\\<engineName>.snapshot*；\n\n  * 存在同名快照：旧快照自动重命名为 *\\<engineName>.old*。\n\n**snapshotIntervalInMsgCount** 可选参数，为整数类型，表示每隔多少条数据保存一次流数据引擎快照。\n\n#### 返回值\n\n返回一个表对象，通过向该表对象写入，将数据注入引擎进行计算。\n\n#### 例子\n\n通过时序聚合引擎计算1分钟 K 线，然后通过 createTimeBucketEngine 将 1 分钟 K 线聚合为 5 分钟。在窗口左闭右开的情况下，可以提前一分钟结束窗口并计算输出，从而比使用 createTimeSeriesEngine 减少延时。\n\n```\nshare streamTable(1000:0, `time`sym`price`volume, [TIMESTAMP, SYMBOL, DOUBLE, INT]) as trades\nshare streamTable(10000:0, `time`sym`firstPrice`maxPrice`minPrice`lastPrice`sumVolume, [TIMESTAMP, SYMBOL, DOUBLE, DOUBLE, DOUBLE, DOUBLE, INT]) as output1\ntimeSeries1 = createTimeSeriesEngine(name=\"timeSeries1\", windowSize=60000, step=60000, metrics=<[first(price), max(price), min(price), last(price), sum(volume)]>, dummyTable=trades, outputTable=output1, timeColumn=`time, useSystemTime=false, keyColumn=`sym, useWindowStartTime=false)\nsubscribeTable(tableName=\"trades\", actionName=\"timeSeries1\", offset=0, handler=append!{timeSeries1}, msgAsTable=true);\n\n// 定义 createTimeBucketEngine 的输出表和窗口区间\nshare streamTable(10000:0, `time`sym`firstPrice`maxPrice`minPrice`lastPrice`sumVolume, [TIMESTAMP, SYMBOL, DOUBLE, DOUBLE, DOUBLE, DOUBLE, INT]) as output2\ntimeCutPoints=[10:00m, 10:05m, 10:10m, 10:15m]\n\ntimeBucket1 = createTimeBucketEngine(name=\"timeBucket1\", timeCutPoints=timeCutPoints, metrics=<[first(firstPrice), max(maxPrice), min(minPrice), last(lastPrice), sum(sumVolume)]>, dummyTable=output1, outputTable=output2, timeColumn=`time,  keyColumn=`sym)\nsubscribeTable(tableName=\"output1\", actionName=\"timeBucket1\", offset=0, handler=append!{timeBucket1}, msgAsTable=true);\n\n\ninsert into trades values(2024.10.08T10:01:01.785,`A, 10.83, 2110)\ninsert into trades values(2024.10.08T10:01:02.125,`B,21.73, 1600)\ninsert into trades values(2024.10.08T10:01:12.457,`A,10.79, 2850)\ninsert into trades values(2024.10.08T10:03:10.789,`A,11.81, 2250)\ninsert into trades values(2024.10.08T10:03:12.005,`B, 22.96, 1980)\ninsert into trades values(2024.10.08T10:08:02.236,`A, 11.25, 2400)\ninsert into trades values(2024.10.08T10:08:04.412,`B, 23.03, 2130)\ninsert into trades values(2024.10.08T10:08:05.152,`B, 23.18, 1900)\ninsert into trades values(2024.10.08T10:08:30.021,`A, 11.04, 2300)\ninsert into trades values(2024.10.08T10:10:20.123,`A, 11.85, 2200)\ninsert into trades values(2024.10.08T10:11:02.236,`A, 11.06, 2200)\ninsert into trades values(2024.10.08T10:13:04.412,`B, 23.15, 1880)\ninsert into trades values(2024.10.08T10:15:12.005,`B, 22.06, 2100)\n\nsleep(10)\n\n// 查看时序引擎输出的 1 分钟 K 线结果\nselect * from output1;\n\n```\n\n| time                    | sym | firstPrice | maxPrice | minPrice | lastPrice | sumVolume |\n| ----------------------- | --- | ---------- | -------- | -------- | --------- | --------- |\n| 2024.10.08T10:02:00.000 | A   | 10.83      | 10.83    | 10.79    | 10.79     | 4,960     |\n| 2024.10.08T10:02:00.000 | B   | 21.73      | 21.73    | 21.73    | 21.73     | 1,600     |\n| 2024.10.08T10:04:00.000 | A   | 11.81      | 11.81    | 11.81    | 11.81     | 2,250     |\n| 2024.10.08T10:04:00.000 | B   | 22.96      | 22.96    | 22.96    | 22.96     | 1,980     |\n| 2024.10.08T10:09:00.000 | A   | 11.25      | 11.25    | 11.04    | 11.04     | 4,700     |\n| 2024.10.08T10:09:00.000 | B   | 23.03      | 23.18    | 23.03    | 23.18     | 4,030     |\n| 2024.10.08T10:11:00.000 | A   | 11.85      | 11.85    | 11.85    | 11.85     | 2,200     |\n| 2024.10.08T10:14:00.000 | B   | 23.15      | 23.15    | 23.15    | 23.15     | 1,880     |\n\n查看 5 分钟 K 线结果：\n\n```\n`select * from output2;`\n```\n\n| time                    | sym | firstPrice | maxPrice | minPrice | lastPrice | sumVolume |\n| ----------------------- | --- | ---------- | -------- | -------- | --------- | --------- |\n| 2024.10.08T10:05:00.000 | A   | 10.83      | 11.81    | 10.79    | 11.81     | 7,210     |\n| 2024.10.08T10:05:00.000 | B   | 21.73      | 22.96    | 21.73    | 22.96     | 3,580     |\n| 2024.10.08T10:10:00.000 | A   | 11.25      | 11.25    | 11.04    | 11.04     | 4,700     |\n| 2024.10.08T10:10:00.000 | B   | 23.03      | 23.18    | 23.03    | 23.18     | 4,030     |\n| 2024.10.08T10:15:00.000 | B   | 23.15      | 23.15    | 23.15    | 23.15     | 1,880     |\n"
    },
    "createTimeSeriesAggregator": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/createTimeSeriesAggregator.html",
        "signatures": [
            {
                "full": "createTimeSeriesEngine(name, windowSize, step, metrics, dummyTable, outputTable, [timeColumn], [useSystemTime=false], [keyColumn], [garbageSize], [updateTime], [useWindowStartTime], [roundTime=true], [snapshotDir], [snapshotIntervalInMsgCount], [fill='none'], [forceTriggerTime], [raftGroup], [keyPurgeFreqInSec=-1], [closed='left'], [outputElapsedMicroseconds=false], [subWindow], [parallelism=1], [acceptedDelay=0], [outputHandler], [msgAsTable=false])",
                "name": "createTimeSeriesEngine",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "windowSize",
                        "name": "windowSize"
                    },
                    {
                        "full": "step",
                        "name": "step"
                    },
                    {
                        "full": "metrics",
                        "name": "metrics"
                    },
                    {
                        "full": "dummyTable",
                        "name": "dummyTable"
                    },
                    {
                        "full": "outputTable",
                        "name": "outputTable"
                    },
                    {
                        "full": "[timeColumn]",
                        "name": "timeColumn",
                        "optional": true
                    },
                    {
                        "full": "[useSystemTime=false]",
                        "name": "useSystemTime",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[keyColumn]",
                        "name": "keyColumn",
                        "optional": true
                    },
                    {
                        "full": "[garbageSize]",
                        "name": "garbageSize",
                        "optional": true
                    },
                    {
                        "full": "[updateTime]",
                        "name": "updateTime",
                        "optional": true
                    },
                    {
                        "full": "[useWindowStartTime]",
                        "name": "useWindowStartTime",
                        "optional": true
                    },
                    {
                        "full": "[roundTime=true]",
                        "name": "roundTime",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[snapshotDir]",
                        "name": "snapshotDir",
                        "optional": true
                    },
                    {
                        "full": "[snapshotIntervalInMsgCount]",
                        "name": "snapshotIntervalInMsgCount",
                        "optional": true
                    },
                    {
                        "full": "[fill='none']",
                        "name": "fill",
                        "optional": true,
                        "default": "'none'"
                    },
                    {
                        "full": "[forceTriggerTime]",
                        "name": "forceTriggerTime",
                        "optional": true
                    },
                    {
                        "full": "[raftGroup]",
                        "name": "raftGroup",
                        "optional": true
                    },
                    {
                        "full": "[keyPurgeFreqInSec=-1]",
                        "name": "keyPurgeFreqInSec",
                        "optional": true,
                        "default": "-1"
                    },
                    {
                        "full": "[closed='left']",
                        "name": "closed",
                        "optional": true,
                        "default": "'left'"
                    },
                    {
                        "full": "[outputElapsedMicroseconds=false]",
                        "name": "outputElapsedMicroseconds",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[subWindow]",
                        "name": "subWindow",
                        "optional": true
                    },
                    {
                        "full": "[parallelism=1]",
                        "name": "parallelism",
                        "optional": true,
                        "default": "1"
                    },
                    {
                        "full": "[acceptedDelay=0]",
                        "name": "acceptedDelay",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[outputHandler]",
                        "name": "outputHandler",
                        "optional": true
                    },
                    {
                        "full": "[msgAsTable=false]",
                        "name": "msgAsTable",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [createTimeSeriesAggregator](https://docs.dolphindb.cn/zh/funcs/c/createTimeSeriesAggregator.html)\n\n是 [createTimeSeriesEngine](https://docs.dolphindb.cn/zh/funcs/c/createTimeSeriesEngine.html) 的别名。\n\n\n以下是 `createTimeSeriesEngine` 函数的文档：\n### [createTimeSeriesEngine](https://docs.dolphindb.cn/zh/funcs/c/createTimeSeriesEngine.html)\n\n\n\n#### 语法\n\ncreateTimeSeriesEngine(name, windowSize, step, metrics, dummyTable, outputTable, \\[timeColumn], \\[useSystemTime=false], \\[keyColumn], \\[garbageSize], \\[updateTime], \\[useWindowStartTime], \\[roundTime=true], \\[snapshotDir], \\[snapshotIntervalInMsgCount], \\[fill='none'], \\[forceTriggerTime], \\[raftGroup], \\[keyPurgeFreqInSec=-1], \\[closed='left'], \\[outputElapsedMicroseconds=false], \\[subWindow], \\[parallelism=1], \\[acceptedDelay=0], \\[outputHandler], \\[msgAsTable=false])\n\n别名：createTimeSeriesAggregator\n\n#### 详情\n\n创建流数据时间序列引擎，以实现基于时间的滑动窗口或滚动窗口进行实时计算。\n\n时序引擎的聚合计算的算子分为增量计算和全量计算两种。增量计算算子不会保留历史数据，每次有数据进来就会进行增量计算；而全量计算算子（例如自定义的聚合函数，或未经优化的内置聚合函数，亦或是嵌套了状态函数的函数）会保留窗口内完整的数据，待触发输出时进行全量计算。\n\n时序引擎对以下聚合计算算子进行了优化，实现了增量计算，显著提升了性能：corr, covar, first, last, max, med, min, percentile, quantile, std, var, sum, sum2, sum3, sum4, wavg, wsum, count, firstNot, ifirstNot, lastNot, ilastNot, imax, imin, nunique, prod, sem, mode, searchK, beta, avg, covarp。\n\n更多流数据引擎的应用场景说明可以参考 [流计算引擎](https://docs.dolphindb.cn/zh/funcs/themes/streamingEngine.html)。\n\n##### 窗口\n\n* 窗口边界规整：对起始窗口左边界进行规整。（详情请参考 *step* 和 *roundTime* 的参数说明以及 `规整规则表`）\n\n* 窗口确定：\n\n  * *windowSize* 确定窗口长度。\n\n  * *closed* 确定窗口左闭右开或左开右闭。\n\n  * *step* 确定滑动的步长。\n\n  其中，*windowSize* 与 *step* 的单位取决于 *useSystemTime* 参数。若 *useSystemTime* = true， *windowSize* 与 *step* 的单位是毫秒。若 *useSystemTime* = false，*windowSize* 与 *step* 的单位同 *timeColumn* 列的精度一致。\n\n* 窗口截取：*useSystemTime* 参数决定了如何截取窗口，可以基于数据的时间列，亦可以基于数据注入系统的时间进行截取。\n\n##### 计算\n\n* 乱序数据处理规则：\n  * 若指定了 *timeColumn*，则 *timeColumn* 的时间必须为非递减序列；若同时指定了 *keyColumn*，则按照分组分别进行滑动窗口计算，*timeColumn* 在每组内的时间必须为非递减序列。否则，时间乱序的数据在计算中会被直接丢弃。\n  * 若希望接收指定范围内的乱序数据，可以设置 *acceptedDelay*，详见 *acceptedDelay* 参数说明。\n\n* 触发规则：若指定了 *timeColumn*，当前窗口的计算将由该窗口结束后收到的第一条数据触发；若设置 *useSystemTime* = true，窗口结束后会自动触发计算。\n\n* 强制触发规则：对长时间未触发计算的窗口数据，可以通过设置 *updateTime* 或 *forceTriggerTime* 强制触发计算。具体规则请参考参数说明。\n\n* 窗口填充规则：未指定 *fill* 或指定 *fill* = \"none\" 时，只会输出计算结果不为空的窗口；若指定了 *fill*，则会输出所有窗口，且根据 *fill* 规则对结果为空的窗口进行填充。\n\n##### 其它功能\n\n* 支持数据/状态清理：清理引擎中堆积的数据和不再需要的状态信息。（详情请参考 *garbageSize* 和 *keyPurgeFreqInSec* 的参数说明）\n\n* 快照机制：启用快照机制之后，系统若出现异常，可及时将流数据引擎恢复到最新的快照状态。（详情请参考 *snapshotDir* 和 *snapshotIntervalInMsgCount* 的参数说明）\n\n#### 参数\n\n**name** 字符串标量，表示时间序列引擎的名称，作为其在一个数据节点/计算节点上的唯一标识。可包含字母，数字和下划线，但必须以字母开头。\n\n**windowSize** 正整数标量或向量，表示滑动窗口的长度。\n\n**step** 正整数标量，表示滑动窗口移动的步长。 *windowSize* 必须是 *step* 的整数倍，否则会抛出异常。*windowSize* 和 *step* 的单位与 *useSystemTime* 有关：\n\n* 若 *useSystemTime* 为 true，则 *windowSize* 和 *step* 的单位为毫秒。\n\n* 若 *useSystemTime* 为 false，则 *windowSize* 和 *step* 的单位与 *timeColumn* 的时间精度一致。\n\n**metrics** 以元代码的格式表示计算指标，支持输入元组。有关元代码的更多信息可参考 [元编程](https://docs.dolphindb.cn/zh/progr/objs/meta_progr.html)。\n\n* 计算指标可以是一个或多个系统内置或用户自定义的聚合函数（使用 defg 关键字定义），如 <\\[sum(volume), avg(price)]>；可以对聚合结果使用表达式，如 <\\[avg(price1)-avg(price2)]>；也可对列与列的计算结果进行聚合计算，如 <\\[std(price1-price2)]>。\n\n* *metrics* 内支持调用具有多个返回值的函数，例如 \\<func(price) as \\`col1\\`col2>（可不指定列名）。\n\n* 支持指定为一个常量标量或向量，例如 <1>，<\\[1, 2, 3]> 。当指定为常量向量时，对应的输出列必须设置为数组向量类型。\n\n* 若 *windowSize* 为向量， *windowSize* 每个值可对应 *metrics* 中多个计算指标。例如，*windowSize* 为\\[10,20]时，metrics可为 (<\\[min(volume), max(volume)]>, \\<sum(volume)>)。 *metrics* 也可以嵌套输入元组向量。例如：\\[\\[<\\[min(volume), max(volume)]>, \\<sum(volume)>], \\[\\<avg(volume)>]]\n\n  **Note:**\n\n  * *metrics* 中使用的列名大小写不敏感，不需要与输入表的列名大小写保持一致。\n  * *metrics* 中不可使用嵌套聚合函数。\n\n**dummyTable** 一个表对象，和输入的流数据表的 schema 一致，可以含有数据，亦可为空表。\n\n**outputTable** 计算结果的输出表，可以是内存表或者分布式表。在使用 `createTimeSeriesEngine` 函数之前，需要将输出表预先设立为一个空表，并指定各列列名以及数据类型。时间序列引擎会将计算结果插入该表。\n\n* 输出表的列顺序如下：\n\n  1. 时间列。其中：\n\n     * 若 *useSystemTime* = true，为 TIMESTAMP 类型；反之，该列数据类型与 *timeColumn* 列一致。\n\n     * 若 *useWindowStartTime* = true，显示时间为数据窗口起始时间；反之，显示时间为数据窗口终止时间。\n\n  2. 分组列。如果 *keyColumn* 不为空，则其后几列和 *keyColumn* 设置的列及其顺序保持一致。\n\n  3. 耗时列。如果指定 *outputElapsedMicroseconds* = true，则指定一个 LONG 类型的列用于存储耗时（单位：微秒）。\n\n  4. 计算结果列。可为多列。\n\n  **Note:** 自 2.00.10 版本开始，引擎支持通过自定义聚合函数，将多个计算结果以 array vector 的形式输出，此时必须在 *outputTable* 中指定对应列类型为 array vector，详见例2。\n\n**timeColumn** 可选参数，字符串标量或向量。当 *useSystemTime* = false 时，必须指定该参数。 该参数用于指定订阅的流数据表中时间列的名称。\n\n**Note:** 字符串向量必须是 date 和 time 组成的向量，date 类型为 DATE，time 类型为 TIME, SECOND 或 NANOTIME。此时，输出表第一列的时间类型必须与 [concatDateTime(date, time)](https://docs.dolphindb.cn/zh/funcs/c/concatDateTime.html) 的类型一致。\n\n**useSystemTime** 可选参数，布尔值，表示是否使用数据注入引擎时的系统时间作为时间列进行计算。\n\n* 当 *useSystemTime* = true时，时间序列引擎会按照数据注入时间序列引擎的时刻（毫秒精度的本地系统时间，与数据中的时间列无关），每隔固定时间截取固定长度窗口的流数据进行计算。只要一个数据窗口中含有数据，数据窗口结束后就会自动进行计算。结果中的第一列为计算发生的时间戳，与数据中的时间无关。\n\n* 当 *useSystemTime* = false（缺省值）时，时间序列引擎根据流数据中的 *timeColumn* 列来截取数据窗口。一个数据窗口结束后的第一条新数据才会触发该数据窗口的计算。请注意，触发计算的数据并不会参与该次计算。\n\n  例如，一个数据窗口从 10:10:10 到 10:10:19。若 *useSystemTime* = true，则只要该窗口中至少有一条数据，该窗口的计算会在窗口结束后的 10:10:20 触发。若 *useSystemTime* = false，且 10:10:19 后的第一条数据为 10:10:25，则该窗口的计算会在 10:10:25 触发。\n\n**keyColumn** 可选参数，字符串标量或向量，表示分组列名。若设置，则分组进行聚合计算，例如以每支股票为一组进行聚合计算。\n\n分组字段支持数组向量类型（见例 5）。当分组字段包含数组向量时，引擎会先将数组向量展开为一维向量（flatten），再基于展开后的记录进行分组。此时需满足以下条件：\n\n* 所有数组向量在每一行中的元素长度必须一致；\n\n* *metrics* 中的表达式的计算结果长度，必须与数组向量展开后的总长度一致（例如：`sum(iif(flatten(orderTypeList)!=2,0，flatten(orderQtyList)/180))`。\n\n**garbageSize** 可选参数，正整数，默认值是 50,000（单位为行）。随着订阅的流数据不断积累，注入时间序列引擎，存放在内存中的数据会越来越多，这时需要清理不再需要的历史数据。当内存中历史数据行数超过 *garbageSize* 值时，系统会清理本次计算不需要的历史数据。如果指定了 *keyColumn*，内存清理是各组内独立进行的。当一个组在内存中的历史数据记录数超出 *garbageSize* 时，会清理该组中本次计算中不需要的历史数据。\n\n**Note:** 对于增量计算算子，系统会自动清理不再需要的历史数据。而对于全量计算算子，需要指定该参数来触发清理历史数据。\n\n**updateTime** 可选参数，非负整数，单位与 timeColumn 的时间精度一致。用于指定比 *step* 更短的计算时间间隔。*step* 必须是 *updateTime* 的整数倍。要设置 *updateTime*， *useSystemTime* 必须设为 false。\n\n如果没有指定 *updateTime*，一个数据窗口结束前，不会发生对该数据窗口数据的计算。若一个窗口长时间未触发计算，可以指定 updateTime，分多次触发当前窗口数据的计算。计算触发的规则为：\n\n* updateTime 指定为正整数值时：\n\n  * 从当前窗口的左边界开始，每隔 *updateTime* 时间，若有新的数据到来，则对当前窗口内该数据之前的所有数据进行计算。\n\n  * 如果系统经过 2 \\* *updateTime* （至少2秒）后仍有未被处理的数据，则触发对当前窗口内所有数据的计算。\n\n  * 若分组计算，则每组内进行上述操作。\n\n* updateTime 指定为 0 时：在新的数据到来后，立即对当前窗口的最新数据计算并输出。\n\n指定 *updateTime* 后，建议使用键值内存表作为输出表。因为每次计算均会增加一条记录，输出表若使用普通内存表或流数据表，则会产生大量带有相同时间戳的结果。因为键值流数据表不可更新记录，输出表亦不推荐使用键值流数据表。\n\n**useWindowStartTime** 可选参数，布尔值，表示输出表中的时间是否为数据窗口起始时间。默认值为 false，表示输出表中的时间为数据窗口起始时间 + *windowSize* 。若 *windowSize* 是向量， *useWindowStartTime* 必须为 false。\n\n**roundTime** 可选参数，布尔值，表示若数据时间精度为毫秒或者秒且 *step* > 一分钟，如何对窗口边界值进行规整处理。默认值为 true，表示按照既定的多分钟规则进行规整。若为 false，则按一分钟规则进行窗口规整。\n\n若要开启快照机制（snapshot），必须指定 *snapshotDir* 与 *snapshotIntervalInMsgCount*。\n\n**snapshotDir** 可选参数，字符串，表示保存引擎快照的文件目录。\n\n* 指定的目录必须存在，否则系统会提示异常。\n\n* 创建流数据引擎时，如果指定了 *snapshotDir*，会检查该目录下是否存在快照。如果存在，会加载该快照，恢复引擎的状态。\n\n* 多个引擎可以指定同一个目录存储快照，用引擎的名称来区分快照文件。\n\n* 一个引擎的快照可能会使用三个文件名：\n\n  * 临时存储快照信息：文件名为 \\<engineName>.tmp；\n\n  * 快照生成并刷到磁盘：文件保存为 \\<engineName>.snapshot；\n\n  * 存在同名快照：旧快照自动重命名为 \\<engineName>.old。\n\n**snapshotIntervalInMsgCount** 可选参数，为整数类型，表示每隔多少条数据保存一次流数据引擎快照。\n\n**fill** 可选参数，一个标量或向量，指定某个分组的某个窗口无数据时的处理方法。可取以下值：\n\n* 'none': 不输出结果。\n* 'null': 输出结果为 NULL。\n* 'ffill': 输出上一个有数据的窗口的结果。\n* '具体数值'：该值的数据类型需要和对应的 *metrics* 计算结果的类型保持一致。\n\n*fill* 可以输入向量，长度与 *metrics* 元素个数保持一致，表示为每个 *metrics* 指定不同的 *fill* 方式。若为向量，向量中各项只能是 'null', 'ffill' 或一个数值，不能是 'none'。\n\n**forceTriggerTime** 可选参数，是非负整数，单位与 *timeColumn* 的时间精度一致。用于强制触发各个分组未计算的窗口进行计算。要设置 *forceTriggerTime*， *useSystemTime* 必须设置为 false，且不能指定 *updateTime*。强制触发计算及输出规则如下：\n\n1. 未被触发计算的窗口结束后（窗口结束时刻为 t），若收到了其他分组的数据（时间戳为 t1），且满足 t1-t ≥ *forceTriggerTime*，则该窗口将被触发计算。\n\n2. 如果某个分组在最后一个窗口被强制触发计算后，没有再收到新的数据，但其他分组仍然收到了新的数据，那么通过 *fill* 来填充该分组的所有缺失窗口，可以确保在最新时间截面上仍然输出该分组的窗口。如果不指定 *fill*，则最后一个窗口被触发计算后，该分组不会产生新的窗口。\n\n设置 *forceTriggerTime* 或 *updateTime* 时需注意以下几点：\n\n* 设置 *updateTime*，计算发生后仍有属于当前窗口的数据到达时，当前窗口计算结果会再次更新；\n\n* 设置 *forceTriggerTime*，则触发计算之后收到的数据会被丢弃，建议不要设置太小的 *forceTriggerTime*。\n\n* 如果 *timeColumn* 指定的时间为 TIME 类型，数据跨天后无法仅凭时间判断数据的先后顺序，因此会出现跨天无法强制触发的情况。*timeColumn* 的时间需要加上日期。\n\n**raftGroup** 可选参数，表示流数据高可用订阅端 raft 组的 ID (大于1的整数，由流数据高可用相关的配置项 *streamingRaftGroups* 指定)。设置该参数表示开启计算引擎高可用。在 leader 节点创建流数据引擎后，会同步在 follower 节点创建该引擎。每次保存的 snapshot 也会同步到 follower。当 raft 组的 leader 节点宕机时，会自动切换新 leader 节点重新订阅流数据表。请注意，若要指定 *raftGroup*，必须同时指定 *snapshotDir*。\n\n注意，自 3.00.5 版本起，流计算引擎暂不支持高可用功能，*raftGroup* 参数将不生效。\n\n**keyPurgeFreqInSec** 正整数，单位为秒。用于控制定期清理“窗口数据已为空”的分组对应的 key，从而避免 key 持续增长带来的内存占用。指定该参数后，如果当前数据注入时间与上一次清理时间的间隔 ≥ *keyPurgeFreqInSec*，则会删除当前窗口数据为空的分组及其对应的 key。\n\n**Note:**\n\n* 若需指定该参数，必须指定 *forceTriggerTime*，且不能指定 *fill*。\n\n* 可以通过调用 [getStreamEngineStat](https://docs.dolphindb.cn/zh/funcs/g/getStreamEngineStat.html) 函数查看 TimeSeriesEngine 引擎状态的 numGroups 列，来对比响应式状态引擎清理前后分组数的变化。\n\n**closed** 字符串，用于确定滑动窗口边界的开闭情况。可选值为 'left' 或 'right'，默认值为 'left'。\n\n* closed = 'left'： 窗口左闭右开。\n\n* closed = 'right'： 窗口左开右闭。\n\n**outputElapsedMicroseconds** 布尔值，表示是否输出每个窗口从触发计算到计算完成输出结果的耗时（若指定了 *keyColumn* 则包含数据分组的耗时），默认为 false。指定参数 *outputElapsedMicroseconds* 后，在定义 *outputTable* 时需要在时间列和分组列后增加一个 LONG 类型的列，详见 *outputTable* 参数说明。\n\n**subWindow**整型或者 DURATION 数据对。在滑动窗口内指定子窗口，仅计算子窗口内的数据。子窗口边界的开闭情况由参数 *closed* 决定。子窗口结束后收到第一条数据触发对子窗口内数据的计算（参考例4）。当 *subWindow*为整型数据对时，其单位与 *timeColumn* 的时间精度一致。若指定 *subWindow*，则：\n\n* *windowSize*和 *step*必须相等。\n* 不可设置 *updateTime*>0和 *useSystemTime*=true。\n\n**parallelism** 为不超过 63 的正整数，可选参数，表示并行计算的工作线程数，默认值为 1。在计算量较大时，合理地调整该参数能够有效利用计算资源，降低计算耗时。建议小于机器核数，推荐值为 4 到 8 。\n\n**acceptedDelay** 正整数，可选参数。指定每个窗口接收数据的最大延迟，默认值为 0。若设置该参数，则不能设置 *forceTriggerTime* 或 *updateTime*。\n\n* 当 useSystemTime= true 时，*acceptedDelay* 必须小于等于 *windowSize*。在窗口结束后的 *acceptedDelay* 时间内接收到的数据，仍然属于此窗口并参与计算，而不会参与下一个窗口的计算。\n\n* 当 useSystemTime= false 时，该参数用于处理乱序数据。假设当前窗口结束的时间戳为 t ，若收到一条时间戳大于等于 t+*acceptedDelay*的数据，则触发在此之前收到的所有属于当前窗口的数据进行计算输出，并关闭该窗口。\n\n**outputHandler** 一元函数。设置此参数时，引擎计算结束后，不再将计算结果写到输出表，而是会调用此函数处理计算结果。\n\n**msgAsTable** 布尔标量，表示在设置了参数 outputHandler 时，将引擎的计算结果以表的结构调用函数。默认值为 false，此时将计算结果的每一列作为元素组成元组。\n\n##### 规整规则\n\n为了便于观察和对比计算结果，系统会对第一个数据窗口的起始时间进行规整，根据 *step* 参数、数据的时间精度，以及 *roundTime* 参数来确定整数类型的规整尺度 alignmentSize。当时间序列引擎使用分组计算时，所有分组的窗口均进行统一的规整。相同时刻的数据窗口在各组均有相同的边界。\n\n* 当数据时间类型为MONTH时，会以第一条数据对应年份的1月作为窗口的上边界。\n\n* 当数据的时间类型为DATE时，不对第一个数据窗口的边界值进行规整。\n\n* 若数据的时间精度为分钟，如 MINUTE(HH:mm) 类型，alignmentSize 取值如下：\n\n  *若 roundTime = false*：\n\n  | step   | alignmentSize |\n  | ------ | ------------- |\n  | 0\\~2   | 2             |\n  | 3      | 3             |\n  | 4\\~5   | 5             |\n  | 6\\~10  | 10            |\n  | 11\\~15 | 15            |\n  | 16\\~20 | 20            |\n  | 21\\~30 | 30            |\n  | >30    | 60 (1小时)      |\n\n  *若 roundTime = true*:\n\n  当 step <= 30 时，alignmentSize 取值同上表。当 step > 30 时，alignmentSize 取值见下表：\n\n  | step       | alignmentSize |\n  | ---------- | ------------- |\n  | 31\\~60     | 60 (1小时)      |\n  | 61\\~120    | 120 (2小时)     |\n  | 121\\~180   | 180 (3小时)     |\n  | 181\\~300   | 300 (5小时)     |\n  | 301\\~600   | 600 (10小时)    |\n  | 601\\~900   | 900 (15小时)    |\n  | 901\\~1200  | 1200 (20小时)   |\n  | 1201\\~1800 | 1800 (30小时)   |\n  | >1800      | 3600 (60小时)   |\n\n* 若数据的时间精度为秒，如 DATETIME(yyyy-MM-dd HH:mm:ss) 与 SECOND(HH:mm:ss) 类型，alignmentSize 的 取值如下：\n\n  *若 roundTime = false*：\n\n  | step   | alignmentSize |\n  | ------ | ------------- |\n  | 0\\~2   | 2             |\n  | 3      | 3             |\n  | 4\\~5   | 5             |\n  | 6\\~10  | 10            |\n  | 11\\~15 | 15            |\n  | 16\\~20 | 20            |\n  | 21\\~30 | 30            |\n  | >30    | 60 (1分钟)      |\n\n  *若 roundTime = true*：\n\n  当 step <= 30 时，alignmentSize 取值同上表。当 step > 30 时，alignmentSize 取值见下表：\n\n  | step       | alignmentSize |\n  | ---------- | ------------- |\n  | 31\\~60     | 60 (1分钟)      |\n  | 61\\~120    | 120 (2分钟)     |\n  | 121\\~180   | 180 (3分钟)     |\n  | 181\\~300   | 300 (5分钟)     |\n  | 301\\~600   | 600 (10分钟)    |\n  | 601\\~900   | 900 (15分钟)    |\n  | 901\\~1200  | 1200 (20分钟)   |\n  | 1201\\~1800 | 1800 (30分钟)   |\n  | >1800      | 3600 (1小时)    |\n\n* 若数据的时间精度为毫秒，如 TIMESTAMP(yyyy-MM-dd HH:mm:ss.mmm) 与 TIME(HH:mm:ss.mmm) 类型，alignmentSize 的取值如下：\n\n  *若 roundTime = false*:\n\n  | step         | alignmentSize |\n  | ------------ | ------------- |\n  | 0\\~2         | 2             |\n  | 3\\~5         | 5             |\n  | 6\\~10        | 10            |\n  | 11\\~20       | 20            |\n  | 21\\~25       | 25            |\n  | 26\\~50       | 50            |\n  | 51\\~100      | 100           |\n  | 101\\~200     | 200           |\n  | 201\\~250     | 250           |\n  | 251\\~500     | 500           |\n  | 501\\~1000    | 1000（1秒）      |\n  | 1001\\~2000   | 2000（2秒）      |\n  | 2001\\~3000   | 3000（3秒）      |\n  | 3001\\~5000   | 5000（5秒）      |\n  | 5001\\~10000  | 10000（10秒）    |\n  | 10001\\~15000 | 15000（15秒）    |\n  | 15001\\~20000 | 20000（20秒）    |\n  | 20001\\~30000 | 30000（30秒）    |\n  | >30000       | 60000（1分钟）    |\n\n  *若 roundTime = true*:\n\n  若 *step* <= 30000，alignmentSize 取值同上表；若 *step* > 30000，alignmentSize 取值见下表：\n\n  | step             | alignmentSize |\n  | ---------------- | ------------- |\n  | 30001\\~60000     | 60000（1分钟）    |\n  | 60001\\~120000    | 120000（2分钟）   |\n  | 120001\\~300000   | 300000（5分钟）   |\n  | 300001\\~600000   | 600000（10分钟）  |\n  | 600001\\~900000   | 900000（15分钟）  |\n  | 900001\\~1200000  | 1200000（20分钟） |\n  | 1200001\\~1800000 | 1800000（30分钟） |\n  | >1800000         | 3600000（1小时）  |\n\n* 若数据的时间精度为纳秒，如 NANOTIMESTAMP(yyyy-MM-dd HH:mm:ss.nnnnnnnnn) 与 NANOTIME(HH:mm:ss.nnnnnnnnn) 类型，alignmentSize 的取值如下：\n\n  *若 roundTime = false*:\n\n  | step         | alignmentSize |\n  | ------------ | ------------- |\n  | 0\\~2ns       | 2ns           |\n  | 3ns\\~5ns     | 5ns           |\n  | 6ns\\~10ns    | 10ns          |\n  | 11ns\\~20ns   | 20ns          |\n  | 21ns\\~25ns   | 25ns          |\n  | 26ns\\~50ns   | 50ns          |\n  | 51ns\\~100ns  | 100ns         |\n  | 101ns\\~200ns | 200ns         |\n  | 201ns\\~250ns | 250ns         |\n  | 251ns\\~500ns | 500ns         |\n  | >500ns       | 1000ns        |\n\n  *若 roundTime = true*:\n\n  | step        | alignmentSize |\n  | ----------- | ------------- |\n  | 1000ns\\~1ms | 1ms           |\n  | 1ms\\~10ms   | 10ms          |\n  | 10ms\\~100ms | 100ms         |\n  | 100ms\\~1s   | 1s            |\n  | 1s\\~2s      | 2s            |\n  | 2s\\~3s      | 3s            |\n  | 3s\\~5s      | 5s            |\n  | 5s\\~10s     | 10s           |\n  | 10s\\~15s    | 15s           |\n  | 15s\\~20s    | 20s           |\n  | 20s\\~30s    | 30s           |\n  | >30s        | 1min          |\n\n假设第一条数据的时间为 x, 那么根据其类型，第一个数据窗口的左边界的计算规则为：`timeType_cast(x/alignmentSize*alignmentSize+step-windowSize)`。其中，timeType\\_cast 表示依据时间精度，需要强制转换的时间类型；'/' 表示整除。例如，第一条数据的时间为 2018.10.08T01:01:01.365，windowSize 为 120000，step 为 60000，那么 alignmentSize 为 60000，第一个数据窗口的左边界为 `timestamp(2018.10.08T01:01:01.365/60000*60000+60000-120000)`，即 2018.10.08T01:00:00.000。\n\n#### 返回值\n\n一个表对象，通过向该表对象写入，将数据注入时间序列引擎进行计算。\n\n#### 例子\n\n**Note:** 以下例子使用了相同的变量和表名便于比较。每个例子执行结束后，请使用以下命令清除环境中的临时数据：\n\n* [getStreamingStat](https://docs.dolphindb.cn/zh/funcs/g/getStreamingStat.html)：用于查看当前的流数据表订阅者。例如：\n\n  ```\n  getStreamingStat().pubTables\n  ```\n\n* [unsubscribeTable](https://docs.dolphindb.cn/zh/funcs/u/unsubscribeTable.html)：用于取消订阅流数据表。例如，在例子 1 代码运行后取消对 trades 的订阅：\n\n  ```\n  unsubscribeTable(tableName=\"trades\", actionName=\"engine1\")\n  ```\n\n* [dropStreamTable](https://docs.dolphindb.cn/zh/funcs/d/dropStreamTable.html)：用于删除流数据表。例如，删除例子 1 中的流数据表 trades：\n\n  ```\n  dropStreamTable(tableName=\"trades\")\n  ```\n\n* [dropStreamEngine](https://docs.dolphindb.cn/zh/funcs/d/dropStreamEngine.html)：用于流数据引擎。例如，删除例子 1 中的流数据引擎 engine1：\n\n  ```\n  dropStreamEngine(\"engine1\")\n  ```\n\n例1. 时间序列引擎 engine1 订阅流数据表 trades，实时计算表 trades 中过去1分钟内每只股票交易量之和。\n\n```\nshare streamTable(1000:0, [\"time\",\"sym\",\"volume\"], [TIMESTAMP, SYMBOL, INT]) as trades\nshare table(10000:0, [\"time\",\"sym\",\"sumVolume\"], [TIMESTAMP, SYMBOL, INT]) as output1\nengine1 = createTimeSeriesEngine(name=\"engine1\", windowSize=60000, step=60000, metrics=<[sum(volume)]>, dummyTable=trades, outputTable=output1, timeColumn=\"time\", useSystemTime=false, keyColumn=\"sym\", garbageSize=50, useWindowStartTime=false)\nsubscribeTable(tableName=\"trades\", actionName=\"engine1\", offset=0, handler=append!{engine1}, msgAsTable=true);\n\ninsert into trades values(2018.10.08T01:01:01.785,`A,10)\ninsert into trades values(2018.10.08T01:01:02.125,`B,26)\ninsert into trades values(2018.10.08T01:01:10.263,`B,14)\ninsert into trades values(2018.10.08T01:01:12.457,`A,28)\ninsert into trades values(2018.10.08T01:02:10.789,`A,15)\ninsert into trades values(2018.10.08T01:02:12.005,`B,9)\ninsert into trades values(2018.10.08T01:02:30.021,`A,10)\ninsert into trades values(2018.10.08T01:04:02.236,`A,29)\ninsert into trades values(2018.10.08T01:04:04.412,`B,32)\ninsert into trades values(2018.10.08T01:04:05.152,`B,23)\n\nsleep(10)\n\nselect * from output1;\n```\n\n| time                    | sym | sumVolume |\n| ----------------------- | --- | --------- |\n| 2018.10.08T01:02:00.000 | A   | 38        |\n| 2018.10.08T01:02:00.000 | B   | 40        |\n| 2018.10.08T01:03:00.000 | A   | 25        |\n| 2018.10.08T01:03:00.000 | B   | 9         |\n\n下面详细解释时间序列引擎的计算过程。为简便起见，以下提到时间时，省略相同的日期部分，只列出（小时:分钟:秒.毫秒）部分。\n\n首先，时间序列引擎对第一个数据窗口的起始时间进行规整。第一个数据窗口的时间范围是 01:01:00.000 到 01:02:00.000，只包含左边界，不包含右边界。当(01:02:10.789,`A,15)到达时，触发第一个窗口 A 组计算；当(01:02:12.005,`B,9)到达时，触发第一个窗口 B 组计算。\n\n第二个数据窗口的时间范围是 01:02:00.000 到 01:03:00.000。当(01:04:02.236,`A,29)到达时，触发第二个窗口 A 组计算；当(01:04:04.412,`B,32)到达时，触发第二个窗口 B 组计算。\n\n由于 01:05:00.000 及之后没有数据，因此没有对 01:04:00.000 到 01:05:00.000 之间的数据进行计算。\n\n输出表 output1 保存了时间序列引擎的计算结果。由于 *useWindowStartTime* 为 false，因此输出表 output1 中的时间为窗口的结束时间。若将 *useWindowStartTime* 设为 true，则输出表中的时间为窗口的起始时间。例如：\n\n```\noutput2 = table(10000:0, [\"time\",\"sym\",\"sumVolume\"], [TIMESTAMP, SYMBOL, INT])\nengine2 = createTimeSeriesEngine(name=\"engine2\", windowSize=60000, step=60000, metrics=<[sum(volume)]>, dummyTable=trades, outputTable=output2, timeColumn=\"time\", useSystemTime=false, keyColumn=\"sym\", garbageSize=50, useWindowStartTime=true)\nsubscribeTable(tableName=\"trades\", actionName=\"engine2\", offset=0, handler=append!{engine2}, msgAsTable=true)\n\nsleep(10)\nselect * from output2;\n```\n\n| time                    | sym | sumVolume |\n| ----------------------- | --- | --------- |\n| 2018.10.08T01:01:00.000 | A   | 38        |\n| 2018.10.08T01:01:00.000 | B   | 40        |\n| 2018.10.08T01:02:00.000 | A   | 25        |\n| 2018.10.08T01:02:00.000 | B   | 9         |\n\n下例中指定 *updateTime* 为 1000（毫秒）：\n\n```\nshare keyedTable([\"time\",\"sym\"],10000:0, [\"time\",\"sym\",\"sumVolume\"], [TIMESTAMP, SYMBOL, INT]) as output3\nengine3 = 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)\nsubscribeTable(tableName=\"trades\", actionName=\"engine3\", offset=0, handler=append!{engine3}, msgAsTable=true)\n\nsleep(2001)\nselect * from output3;\n```\n\n| time                    | sym | sumVolume |\n| ----------------------- | --- | --------- |\n| 2018.10.08T01:02:00.000 | A   | 38        |\n| 2018.10.08T01:02:00.000 | B   | 40        |\n| 2018.10.08T01:03:00.000 | A   | 25        |\n| 2018.10.08T01:03:00.000 | B   | 9         |\n| 2018.10.08T01:05:00.000 | B   | 55        |\n| 2018.10.08T01:05:00.000 | A   | 29        |\n\n例2. 下例中指定 *updateTime* 为 0（毫秒）：\n\n```\nshare streamTable(1000:0, [\"time\",\"sym\",\"volume\"], [TIMESTAMP, SYMBOL, INT]) as trades\nshare table(1000:0, [\"time\",\"sym\",\"sumVolume\"], [TIMESTAMP, SYMBOL, INT]) as output4\nengine4 = createTimeSeriesEngine(name=\"engine4\", windowSize=60000, step=60000, metrics=<[sum(volume)]>, dummyTable=trades, outputTable=output4, timeColumn=\"time\", useSystemTime=false, keyColumn=\"sym\", garbageSize=50, updateTime=0, useWindowStartTime=false)\nsubscribeTable(tableName=\"trades\", actionName=\"engine4\", offset=0, handler=append!{engine4}, msgAsTable=true);\n\ninsert into trades values(2018.10.08T01:01:01.785,`A,10)\ninsert into trades values(2018.10.08T01:01:02.125,`B,26)\ninsert into trades values(2018.10.08T01:01:10.263,`B,14)\ninsert into trades values(2018.10.08T01:01:12.457,`A,28)\n\nsleep(100)\n\ninsert into trades values(2018.10.08T01:01:12.557,`B,21)\ninsert into trades values(2018.10.08T01:01:12.557,`A,28)\n\n\nselect * from output4;\n\n```\n\n*updateTime*=0 时，每收到一批数据就触发一次计算输出：\n\n* 01:01:12.457 时，触发了第一批数据中 A、B 两组数据的计算输出。\n\n* 01:01:12.557 时，再次触发第二批数据中 A、B 两组数据的计算输出。\n\n最终得到：\n\n| time                    | sym | sumVolume |\n| ----------------------- | --- | --------- |\n| 2018.10.08 01:02:00.000 | A   | 38        |\n| 2018.10.08 01:02:00.000 | B   | 40        |\n| 2018.10.08 01:02:00.000 | B   | 61        |\n| 2018.10.08 01:02:00.000 | A   | 66        |\n\n下面以最后一个数据窗口为例，介绍时间序列引擎指定 *updateTime* 时如何进行计算。假设 time 列时间亦为数据进入时间序列引擎的时刻。\n\n1. 在 01:04:04.236 时，A 分组的第一条记录到达后已经过 2000 毫秒，触发一次 A 组计算，输出表增加一条记录(01:05:00.000, \\`A, 29)。\n\n2. 在 01:04:05.152 时的 B 组记录为 01:04:04.412 所在小窗口\\[01:04:04.000, 01:04:05.000)之后第一条记录，触发一次 B 组计算，输出表增加一条记录(01:05:00,\"B\",32)。\n\n3. 2 秒（2\\*updateTime个时间单位）后，在 01:04:07.152 时，由于 01:04:05.152 时的 B 组记录仍未参与计算，触发一次B组计算，输出一条记录(01:05:00,\"B\",55)。由于输出表的主键为 time 和 sym，并且输出表中已有(01:05:00,\"B\",32)这条记录，因此将该记录更新为(01:05:00,\"B\",55)。\n\n下例中，共享流数据表 \"pubT\" 包含两个时间列，类型分别时 DATE 和 SECOND，创建时间序列引擎时，通过设置 *timeColumn* 来将原来流数据表的两个时间列整合为输出表 streamMinuteBar\\_1min 中的一个类型为 DATETIME 的时间列。\n\n```\ncolNames=[\"symbol\",\"date\",\"minute\",\"price\",\"type\",\"volume\"]\ncolTypes=[SYMBOL, DATE, SECOND, DOUBLE, STRING, INT]\npubTable = streamTable(10000:0,colNames,colTypes)\nshare pubTable as pubT\n\ncolNames = [\"time\",\"symbol\",\"open\",\"max\",\"min\",\"close\",\"volume\",\"amount\",\"ret\",\"vwap\"]\ncolTypes = [DATETIME, SYMBOL, DOUBLE, DOUBLE, DOUBLE, DOUBLE, INT, DOUBLE, DOUBLE, DOUBLE]\nshare streamTable(10000:0,colNames, colTypes) as streamMinuteBar_1min\n\ntsAggrOHLC = createTimeSeriesEngine(name=\"subT\", windowSize=60, step=60, metrics=<[first(price) as open ,max(price) as max,min(price) as min ,last(price) as close ,sum(volume) as volume ,wsum(volume, price) as amount ,(last(price)-first(price))/first(price) as ret, (wsum(volume, price)/sum(volume)) as vwap]>, dummyTable=pubTable, outputTable=streamMinuteBar_1min, timeColumn=[\"date\",\"minute\"], useSystemTime=false, keyColumn=\"symbol\", fill=\"none\")\nsubscribeTable(tableName=\"pubT\", actionName=\"subT\", offset=-1, handler=append!{tsAggrOHLC}, msgAsTable=true)\n\ninsert into pubT values(\"000001\", 2021.04.05, 09:25:01, 1, 'B', 1)\ninsert into pubT values(\"000001\", 2021.04.05, 09:30:05, 2, 'B', 1)\ninsert into pubT values(\"000001\", 2021.04.05, 09:31:06, 3, 'B', 1)\ninsert into pubT values(\"000001\", 2021.04.05, 09:35:05, 4, 'S', 4)\ninsert into pubT values(\"000001\", 2021.04.05, 09:40:05, 5, 'S', 5)\ninsert into pubT values(\"000001\", 2021.04.06, 09:25:05, 6, 'S', 6)\n\npubT\n```\n\n| symbol | date       | minute   | price | type | volume |\n| ------ | ---------- | -------- | ----- | ---- | ------ |\n| 000001 | 2021.04.05 | 09:25:01 | 1     | B    | 1      |\n| 000001 | 2021.04.05 | 09:30:05 | 2     | B    | 1      |\n| 000001 | 2021.04.05 | 09:31:06 | 3     | B    | 1      |\n| 000001 | 2021.04.05 | 09:35:05 | 4     | S    | 4      |\n| 000001 | 2021.04.05 | 09:40:05 | 5     | S    | 5      |\n| 000001 | 2021.04.06 | 09:25:05 | 6     | S    | 6      |\n\n```\nselect * from streamMinuteBar_1min\n```\n\n| time                | symbol | open | max | min | close | volume | amount | ret | vwap |\n| ------------------- | ------ | ---- | --- | --- | ----- | ------ | ------ | --- | ---- |\n| 2021.04.05T09:26:00 | 000001 | 1    | 1   | 1   | 1     | 1      | 1      | 0   | 1    |\n| 2021.04.05T09:31:00 | 000001 | 2    | 2   | 2   | 2     | 1      | 2      | 1   | 2    |\n| 2021.04.05T09:32:00 | 000001 | 3    | 3   | 3   | 3     | 1      | 3      | 2   | 3    |\n| 2021.04.05T09:36:00 | 000001 | 4    | 4   | 4   | 4     | 4      | 16     | 3   | 4    |\n| 2021.04.05T09:41:00 | 000001 | 5    | 5   | 5   | 5     | 5      | 25     | 4   | 5    |\n\n```\nshare streamTable(1000:0, [\"time\",\"sym\",\"qty\"], [DATETIME, SYMBOL, INT]) as trades\nshare table(10000:0, [\"time\",\"sym\",\"sumQty\"], [DATETIME, SYMBOL, INT]) as output5\n\nengine = createTimeSeriesEngine(name=\"engine\", windowSize=6, step=6, metrics=<sum(qty)>, dummyTable=trades, outputTable=output5, timeColumn=\"time\",keyColumn=\"sym\", forceTriggerTime=7,fill=1000)\nsubscribeTable(tableName=\"trades\", actionName=\"engine\", offset=0, handler=append!{engine}, msgAsTable=true)\nsleep(1000)\ninsert into engine values(2018.08.01T14:05:43,`A,1)\ninsert into engine values(2018.08.01T14:05:43,`C,3)\nsleep(10)\ninsert into engine values(2018.08.01T14:05:44,`B,1)\nsleep(80)\ninsert into engine values(2018.08.01T14:05:52,`B,3)\nsleep(20)\ninsert into engine values(2018.08.01T14:05:54,`A,3)\nsleep(10)\ninsert into engine values(2018.08.01T14:05:55,`A,5)\nsleep(20)\ninsert into engine values(2018.08.01T14:05:57,`B,5)\nsleep(50)\ninsert into engine values(2018.08.01T14:06:12,`A,1)\nsleep(50)\nselect * from output5 order by sym\n```\n\n| time                | sum | Qty   |\n| ------------------- | --- | ----- |\n| 2018.08.01T14:05:46 | A   | 1     |\n| 2018.08.01T14:05:52 | A   | 1,000 |\n| 2018.08.01T14:05:58 | A   | 8     |\n| 2018.08.01T14:06:04 | A   | 1,000 |\n| 2018.08.01T14:06:10 | A   | 1,000 |\n| 2018.08.01T14:05:46 | B   | 1     |\n| 2018.08.01T14:05:52 | B   | 1,000 |\n| 2018.08.01T14:05:58 | B   | 8     |\n| 2018.08.01T14:05:46 | C   | 3     |\n| 2018.08.01T14:05:52 | C   | 1,000 |\n\n例3. 下例计算每个分组窗口的第一个和最后一个 volume，组合后输出为一个数组向量。\n\n```\n//通过 defg 自定义一个函数，引擎在调用该函数时会将返回值转换为数组向量\ndefg toVector(x){\n\treturn x\t\n}\nshare streamTable(1000:0, [\"time\",\"sym\",\"volume\",\"price\"], [TIMESTAMP, SYMBOL, DOUBLE,DOUBLE]) as trades\n//定义输出表，对应 toVector 指标输出的列需要定义为数组向量类型，此例中将其定义为 DOUBLE[]\nshare table(10000:0, [\"time\",\"sym\",\"sumVolume\",\"avg\"], [TIMESTAMP,STRING,DOUBLE[],DOUBLE]) as output6\n//metrics 中调用了 toVector 函数，将1分钟窗口内的第一个 volume 和最后一个 volume 组合到一个向量中。\nengine1 = createTimeSeriesEngine(name=\"engine1\", windowSize=60000, step=60000, metrics=<[toVector([first(volume),last(volume)]),avg(volume+price)]>, dummyTable=trades, outputTable=output6, timeColumn=\"time\", keyColumn=\"sym\" , useSystemTime=false, garbageSize=50, useWindowStartTime=false)\n\ntimes = sort(2023.10.08T00:00:00.000 + rand(1..(1+3000*200), 30))\nsyms = rand(\"A\"+string(1..10), 30)\nvolumes = rand(rand(100.0, 10) join 2.3 NULL NULL NULL NULL, 30)\nprices = rand(rand(100.0, 10) join 2.3 NULL NULL NULL NULL, 30)\nt=table(times as time, syms as sym, volumes as volume,prices as price)\n\nengine1.append!(t)\n\nselect * from output6 where time between 2023.10.08T00:01:00.000 and 2023.10.08T00:05:00.000 order by time,sym \n```\n\n| time                    | sym | sumVolume      | avg      |\n| ----------------------- | --- | -------------- | -------- |\n| 2023.10.08T00:01:00.000 | A1  | \\[57.66,]      | 80.428   |\n| 2023.10.08T00:01:00.000 | A2  | \\[,]           |          |\n| 2023.10.08T00:02:00.000 | A7  | \\[,]           |          |\n| 2023.10.08T00:02:00.000 | A8  | \\[,]           |          |\n| 2023.10.08T00:03:00.000 | A2  | \\[,41.25]      | 101.7832 |\n| 2023.10.08T00:03:00.000 | A3  | \\[41.25,41.25] | 68.4897  |\n| 2023.10.08T00:03:00.000 | A6  | \\[,]           |          |\n| 2023.10.08T00:03:00.000 | A8  | \\[19.17,19.17] | 93.9934  |\n| 2023.10.08T00:04:00.000 | A7  | \\[,]           |          |\n| 2023.10.08T00:05:00.000 | A3  | \\[2.05,2.05]   | 95.433   |\n| 2023.10.08T00:05:00.000 | A5  | \\[55.93,55.93] | 116.4669 |\n| 2023.10.08T00:05:00.000 | A9  | \\[42.66,42.66] |          |\n\n例4.本例将说明 *subWindow* 参数的作用。\n\n```\nshare streamTable(1000:0, [\"time\",\"sym\",\"volume\"], [TIMESTAMP, SYMBOL, INT]) as trades\nshare table(10000:0, [\"time\",\"sym\",\"sumVolume\"], [TIMESTAMP, SYMBOL, INT]) as output7\n//在长度为 1 分钟的窗口内指定一个子窗口，未指定 closed 时，子窗口左闭右开。这里子窗口为每分钟的[0s, 10s)\nengine4 = createTimeSeriesEngine(name=\"engine4\", windowSize=60000, step=60000, metrics=<[sum(volume)]>, dummyTable=trades, outputTable=output7, timeColumn=\"time\", useSystemTime=false, keyColumn=\"sym\", garbageSize=50, useWindowStartTime=true, subWindow=0s:10s)\n\nsubscribeTable(tableName=\"trades\", actionName=\"engine4\", offset=0, handler=append!{engine4}, msgAsTable=true);\n\ninsert into trades values(2018.10.08T01:01:01.785,`A,10)\ninsert into trades values(2018.10.08T01:01:02.125,`B,26)\ninsert into trades values(2018.10.08T01:01:10.000,`A,14)\ninsert into trades values(2018.10.08T01:01:12.457,`A,28)\n\nsleep(10)\n\nselect * from output7;\n```\n\n2018.10.08T01:01:10.000 时刻的数据触发 \\[2018.10.08T01:01:00.000, 2018.10.08T01:01:10.000) 区间内 A 组数据对应的 volume 的总和。在子窗口结束后没有再收到 B 组的数据，因此 B 组子窗口内数据未被触发计算。\n\n| time                    | sym | sumVolume |\n| :---------------------- | :-- | :-------- |\n| 2018.10.08T01:01:10.000 | A   | 10        |\n\n例5. 本例展示如何对包含多档价格与数量的数组向量字段，在时间窗口内按股票、买卖方向及委托价格分组，计算各价位的委托金额和委托笔数。\n\n```\nshare streamTable(1000:0, [\"time\",\"sym\",\"side\",\"orderPrice\",\"orderQty\"],   \n    [TIMESTAMP, SYMBOL, SYMBOL, DOUBLE[], INT[]]) as orderStream  \n  \nshare table(10000:0, [\"time\",\"sym\",\"side\", \"orderPrice\", \"totalValue\", \"orderCount\"],   \n    [TIMESTAMP, SYMBOL, SYMBOL, DOUBLE, DOUBLE, INT]) as result  \n  \n// 创建时序聚合引擎：按股票代码、买卖方向和委托价格分组  \nengine = createTimeSeriesEngine(  \n    name=\"orderEngine\",   \n    windowSize=60000,   \n    step=60000,   \n    metrics=<[  \n        sum(orderPrice * orderQty),               \n        count(orderPrice)                 \n    ]>,   \n    dummyTable=orderStream,   \n    outputTable=result,   \n    timeColumn=\"time\",   \n    keyColumn=`sym`side`orderPrice, \n    useSystemTime=false  \n)  \n\n \nn = 100  \ntime = 2023.01.01T09:30:00.000 + (1..n)*1000  \nsym = take(`AAPL`MSFT, n)  \nside = take(`Buy`Sell, n)  \norderPrice = arrayVector((1..n) * 5, rand(100.0 105.0, 5*n))  \norderQty = arrayVector((1..n) * 5, rand(100 1000, 5*n)) \n   \ninsert into engine values(time, sym, side, orderPrice, orderQty)\n\n// 查看结果表\nselect * from result\n```\n\n| time                    | sym  | side | orderPrice | totalValue | orderCount |\n| ----------------------- | ---- | ---- | ---------- | ---------- | ---------- |\n| 2023.01.01 09:31:00.000 | AAPL | Buy  | 100        | 4,430,000  | 74         |\n| 2023.01.01 09:31:00.000 | AAPL | Buy  | 105        | 5,050,500  | 76         |\n| 2023.01.01 09:31:00.000 | MSFT | Sell | 100        | 4,720,000  | 76         |\n| 2023.01.01 09:31:00.000 | MSFT | Sell | 105        | 3,654,000  | 69         |\n\n例6. 将 *windowSize* 设为向量，同时计算 1 分钟窗口和 3 分钟窗口。\n\n当 *windowSize* 为向量时，每个窗口长度可以对应一组独立的指标。本例同时输出 1 分钟成交量之和和 3 分钟价格均值。\n\n```\nshare streamTable(1000:0, [\"time\",\"sym\",\"volume\",\"price\"], [TIMESTAMP, SYMBOL, INT, DOUBLE]) as tradesWS\nshare table(1000:0, [\"time\",\"sym\",\"sum1m\",\"avgPrice3m\"], [TIMESTAMP, SYMBOL, INT, DOUBLE]) as outputWS\n\nengineWS = createTimeSeriesEngine(\n  name=\"engineWS\",\n  windowSize=[60000, 180000],\n  step=60000,\n  metrics=(<[sum(volume) as sum1m]>, <[avg(price) as avgPrice3m]>),\n  dummyTable=tradesWS,\n  outputTable=outputWS,\n  timeColumn=\"time\",\n  keyColumn=\"sym\",\n  useSystemTime=false\n)\n\nsubscribeTable(tableName=\"tradesWS\", actionName=\"engineWS\", offset=0, handler=append!{engineWS}, msgAsTable=true)\n\ninsert into tradesWS values(2024.01.01T10:00:10.000, `A, 10, 100.0)\ninsert into tradesWS values(2024.01.01T10:00:20.000, `B, 16, 104.0)\ninsert into tradesWS values(2024.01.01T10:00:40.000, `A, 20, 101.0)\ninsert into tradesWS values(2024.01.01T10:01:10.000, `A, 15, 102.0)\ninsert into tradesWS values(2024.01.01T10:01:20.000, `B, 20, 105.0)\ninsert into tradesWS values(2024.01.01T10:02:05.000, `A, 30, 103.0)\ninsert into tradesWS values(2024.01.01T10:03:10.000, `A, 12, 104.0)\n\nsleep(10)\nselect * from outputWS\n```\n\n输出如下：\n\n| time                    | sym | sum1m | avgPrice3m |\n| ----------------------- | --- | ----- | ---------- |\n| 2024.01.01 10:01:00.000 | A   | 30    | 100.5      |\n| 2024.01.01 10:01:00.000 | B   | 16    | 104        |\n| 2024.01.01 10:02:00.000 | A   | 15    | 101        |\n| 2024.01.01 10:03:00.000 | A   | 30    | 101.5      |\n\n其中：\n\n* `windowSize=[60000, 180000]` 分别对应 1 分钟和 3 分钟窗口。\n\n* *metrics* 的第一个元素对应 1 分钟窗口，第二个元素对应 3 分钟窗口。\n\n* 输出表中两个结果列分别保存不同窗口长度下的聚合结果。\n\n例7. 设置 *roundTime* 和 *step* 控制窗口的规整方式。\n\n当时间精度为毫秒或秒，且 *step* 大于 1 分钟时，*roundTime* 会影响首个窗口边界的规整结果。本例使用两个参数相同、仅 *roundTime* 不同的引擎进行对比。\n\n```\nshare streamTable(1000:0, [\"time\",\"volume\"], [TIMESTAMP, INT]) as tradesRT\nshare table(1000:0, [\"time\",\"sumVolume\"], [TIMESTAMP, INT]) as outputRTTrue\nshare table(1000:0, [\"time\",\"sumVolume\"], [TIMESTAMP, INT]) as outputRTFalse\n\nengineRTTrue = createTimeSeriesEngine(\n   name=\"engineRTTrue\",\n   windowSize=240000,\n   step=120000,\n   metrics=<[sum(volume) as sumVolume]>,\n   dummyTable=tradesRT,\n   outputTable=outputRTTrue,\n   timeColumn=\"time\",\n   useSystemTime=false,\n   roundTime=true\n)\n\nengineRTFalse = createTimeSeriesEngine(\n   name=\"engineRTFalse\",\n   windowSize=240000,\n   step=120000,\n   metrics=<[sum(volume) as sumVolume]>,\n   dummyTable=tradesRT,\n   outputTable=outputRTFalse,\n   timeColumn=\"time\",\n   useSystemTime=false,\n   roundTime=false\n)\n\nsubscribeTable(tableName=\"tradesRT\", actionName=\"engineRTTrue\", offset=0, handler=append!{engineRTTrue}, msgAsTable=true)\nsubscribeTable(tableName=\"tradesRT\", actionName=\"engineRTFalse\", offset=0, handler=append!{engineRTFalse}, msgAsTable=true)\n\ninsert into tradesRT values(2024.01.01T10:03:30.500, 10)\ninsert into tradesRT values(2024.01.01T10:04:20.000, 20)\ninsert into tradesRT values(2024.01.01T10:06:01.000, 5)\n```\n\n对于 *roundTime*=true 的引擎，执行 `select * from outputRTTrue`，输出如下：\n\n| time                    | sumVolume |\n| ----------------------- | --------- |\n| 2024.01.01 10:04:00.000 | 10        |\n| 2024.01.01 10:06:00.000 | 30        |\n\n对于 *roundTime*=false 的引擎，执行 `select * from outputRTFalse`，输出如下：\n\n| time                    | sumVolume |\n| ----------------------- | --------- |\n| 2024.01.01 10:05:00.000 | 30        |\n\n* 本例中第一条数据时间为 `x=2024.01.01T10:03:30.500`；*windowSize* 为 240000（4 分钟）。\n\n* 当 *roundTime*=true 时，*step*=120000 属于毫秒精度下的 60001\\~120000 区间，对应的 alignmentSize 为 120000（2 分钟）。先将 x 按 2 分钟规整：`timestamp(x/120000*120000)=2024.01.01T10:02:00.000`；再代入公式得到左边界 `2024.01.01T10:02:00.000 + 120000 - 240000 = 2024.01.01T10:00:00.000`，所以首个窗口为 \\[10:00:00.000, 10:04:00.000)。\n\n* 当 *roundTime*=false 时，数据为毫秒精度且 *step*>30000，对应的 alignmentSize 为 60000（1 分钟）。先将 x 按 1 分钟规整：`timestamp(x/60000*60000)=2024.01.01T10:03:00.000`；再代入公式得到左边界 `2024.01.01T10:03:00.000 + 120000 - 240000 = 2024.01.01T10:01:00.000`，所以首个窗口为 \\[10:01:00.000, 10:05:00.000)。\n\n* 10:03:30.500 这条记录在两种设置下都落入首个窗口，但首个窗口的起止范围不同；进一步地，10:04:20.000 在 *roundTime*=true 时落入下一个窗口 \\[10:02, 10:06)，而在 *roundTime*=false 时仍落入首个窗口 \\[10:01, 10:05)。\n\n例8. 设置 *closed* 控制边界点归属\n\n*closed*='left' 表示左闭右开，*closed*='right' 表示左开右闭。若数据恰好落在窗口边界上，不同设置会影响该数据属于哪个窗口。\n\n```\nshare streamTable(1000:0, [\"time\",\"volume\"], [TIMESTAMP, INT]) as tradesCL\nshare table(1000:0, [\"time\",\"sumVolume\"], [TIMESTAMP, INT]) as outputLeft\nshare table(1000:0, [\"time\",\"sumVolume\"], [TIMESTAMP, INT]) as outputRight\n\nengineLeft = createTimeSeriesEngine(\n   name=\"engineLeft\",\n   windowSize=60000,\n   step=60000,\n   metrics=<[sum(volume) as sumVolume]>,\n   dummyTable=tradesCL,\n   outputTable=outputLeft,\n   timeColumn=\"time\",\n   useSystemTime=false,\n   closed=\"left\"\n)\n\nengineRight = createTimeSeriesEngine(\n   name=\"engineRight\",\n   windowSize=60000,\n   step=60000,\n   metrics=<[sum(volume) as sumVolume]>,\n   dummyTable=tradesCL,\n   outputTable=outputRight,\n   timeColumn=\"time\",\n   useSystemTime=false,\n   closed=\"right\"\n)\n\nsubscribeTable(tableName=\"tradesCL\", actionName=\"engineLeft\", offset=0, handler=append!{engineLeft}, msgAsTable=true)\nsubscribeTable(tableName=\"tradesCL\", actionName=\"engineRight\", offset=0, handler=append!{engineRight}, msgAsTable=true)\n\ninsert into tradesCL values(2024.01.01T10:00:10.000, 10)\ninsert into tradesCL values(2024.01.01T10:01:00.000, 20)\ninsert into tradesCL values(2024.01.01T10:01:10.000, 1)\n```\n\n对于 *closed*=\"left\" 的引擎， 执行 `select * from outputLeft`，输出如下：\n\n| time                    | sumVolume |\n| ----------------------- | --------- |\n| 2024.01.01 10:01:00.000 | 10        |\n\n对于 *closed*=\"right\" 的引擎，执行 `select * from outputRight`，输出如下\n\n| time                    | sumVolume |\n| ----------------------- | --------- |\n| 2024.01.01 10:01:00.000 | 30        |\n\n* *closed*=\"left\" 时，第 2 条记录的时间正好是 10:01:00.000，属于下一个窗口 \\[10:01, 10:02)，因此第一个窗口只统计到 10。\n\n* *closed*=\"right\" 时，同一条边界数据属于前一个窗口 (10:00, 10:01]，因此第一个窗口统计结果变为 `10 + 20 = 30`。\n\n例9. 设置 *outputElapsedMicroseconds* 与 *acceptedDelay*\n\n* 通过 *acceptedDelay* 接收窗口结束后一定范围内到达的乱序数据；\n\n* 通过 *outputElapsedMicroseconds*=true 输出每个结果从触发计算到写出结果的耗时。\n\n```\nshare streamTable(1000:0, [\"time\",\"sym\",\"volume\"], [TIMESTAMP, SYMBOL, INT]) as tradesAD\nshare table(1000:0, [\"time\",\"sym\",\"elapsedUs\",\"sumVolume\"], [TIMESTAMP, SYMBOL, LONG, INT]) as outputAD\n\nengineAD = createTimeSeriesEngine(\n   name=\"engineAD\",\n   windowSize=60000,\n   step=60000,\n   metrics=<[sum(volume) as sumVolume]>,\n   dummyTable=tradesAD,\n   outputTable=outputAD,\n   timeColumn=\"time\",\n   keyColumn=\"sym\",\n   useSystemTime=false,\n   acceptedDelay=5000,\n   outputElapsedMicroseconds=true\n)\n\nsubscribeTable(tableName=\"tradesAD\", actionName=\"engineAD\", offset=0, handler=append!{engineAD}, msgAsTable=true)\n\ninsert into tradesAD values(2024.01.01T10:00:10.000, `A, 10)\ninsert into tradesAD values(2024.01.01T10:00:40.000, `A, 20)\ninsert into tradesAD values(2024.01.01T10:01:02.000, `A, 1)\ninsert into tradesAD values(2024.01.01T10:00:55.000, `A, 30)\ninsert into tradesAD values(2024.01.01T10:01:06.000, `A, 2)\n\nsleep(10)\nselect * from outputAD\n```\n\n输出如下：\n\n| time                    | sym | elapsedUs | sumVolume |\n| ----------------------- | --- | --------- | --------- |\n| 2024.01.01 10:01:00.000 | A   | 2         | 60        |\n\n* 本例中窗口为 \\[10:00:00, 10:01:00)。\n\n* 当 *acceptedDelay*=5000 时，窗口在结束后的 5 秒内仍可接收迟到数据。\n\n* 第 4 条记录 10:00:55.000 虽然晚于 10:01:02.000 到达，但仍在允许延迟范围内，因此仍计入第一个窗口。\n\n* 第 5 条记录时间为 10:01:06.000，满足“收到时间戳大于等于当前窗口结束的时间戳 + acceptedDelay 的数据”这一条件，因此触发第一个窗口输出，结果为 10 + 20 + 30 = 60。\n\n例10. 设置 outputHandler 与 msgAsTable\n\n设置 *outputHandler* 后，引擎计算结果不会写入 outputTable，而是调用定义的一元函数处理计算结果。*msgAsTable* 用于控制回调参数的结构：\n\n* *msgAsTable*=false：回调参数是由各列组成的元组；\n\n* *msgAsTable*=true：回调参数是一个表。\n\n```\nshare streamTable(1000:0, [\"time\",\"volume\"], [TIMESTAMP, INT]) as tradesOH\nshare table(1000:0, [\"time\",\"sumVolume\"], [TIMESTAMP, INT]) as ignoredTuple\nshare table(1000:0, [\"time\",\"sumVolume\"], [TIMESTAMP, INT]) as ignoredTable\nshare table(1000:0, [\"time\",\"sumVolume\"], [TIMESTAMP, INT]) as tupleResult\nshare table(1000:0, [\"time\",\"sumVolume\"], [TIMESTAMP, INT]) as tableResult\n\ndef handleTuple(msg){\n   tupleResult.tableInsert(msg[0],msg[1])\n}\n\ndef handleTable(msg){\n   tableResult.append!(msg)\n}\n\nengineTuple = createTimeSeriesEngine(\n   name=\"engineTuple\",\n   windowSize=60000,\n   step=60000,\n   metrics=<[sum(volume) as sumVolume]>,\n   dummyTable=tradesOH,\n   outputTable=ignoredTuple,\n   timeColumn=\"time\",\n   useSystemTime=false,\n   outputHandler=handleTuple,\n   msgAsTable=false\n)\n\nengineTable = createTimeSeriesEngine(\n   name=\"engineTable\",\n   windowSize=60000,\n   step=60000,\n   metrics=<[sum(volume) as sumVolume]>,\n   dummyTable=tradesOH,\n   outputTable=ignoredTable,\n   timeColumn=\"time\",\n   useSystemTime=false,\n   outputHandler=handleTable,\n   msgAsTable=true\n)\n\nsubscribeTable(tableName=\"tradesOH\", actionName=\"engineTuple\", offset=0, handler=append!{engineTuple}, msgAsTable=true)\nsubscribeTable(tableName=\"tradesOH\", actionName=\"engineTable\", offset=0, handler=append!{engineTable}, msgAsTable=true)\n\ninsert into tradesOH values(2024.01.01T10:00:10.000, 10)\ninsert into tradesOH values(2024.01.01T10:00:40.000, 20)\ninsert into tradesOH values(2024.01.01T10:01:10.000, 5)\n```\n\n分别执行 `select * from tupleResult` 和 `select * from tableResult`。\n\ntupleResult 和 tableResult 的结果都为：\n\n| time                    | sumVolume |\n| ----------------------- | --------- |\n| 2024.01.01 10:01:00.000 | 30        |\n\n* engineTuple 中，`handleTuple` 接收到的是列元组，一元函数中使用 `tableInsert` 将 `msg[0]` 和 `msg[1]` 插入到目标表。\n\n* engineTable 中，`handleTable` 直接接收到结果表，一元函数中使用 `append!` 将结果表插入到目标表。\n\n分别执行 `select * from ignoredTuple` 和 `select * from ignoredTable`，输出结果均为空。这是因为设置了 *outputHandler*，计算结果不会写入 ignoredTuple 和 ignoredTable。\n\n**Related information**\n\n[createDailyTimeSeriesEngine](https://docs.dolphindb.cn/zh/funcs/c/createDailyTimeSeriesEngine.html)\n"
    },
    "createTimeSeriesEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/createTimeSeriesEngine.html",
        "signatures": [
            {
                "full": "createTimeSeriesEngine(name, windowSize, step, metrics, dummyTable, outputTable, [timeColumn], [useSystemTime=false], [keyColumn], [garbageSize], [updateTime], [useWindowStartTime], [roundTime=true], [snapshotDir], [snapshotIntervalInMsgCount], [fill='none'], [forceTriggerTime], [raftGroup], [keyPurgeFreqInSec=-1], [closed='left'], [outputElapsedMicroseconds=false], [subWindow], [parallelism=1], [acceptedDelay=0], [outputHandler], [msgAsTable=false])",
                "name": "createTimeSeriesEngine",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "windowSize",
                        "name": "windowSize"
                    },
                    {
                        "full": "step",
                        "name": "step"
                    },
                    {
                        "full": "metrics",
                        "name": "metrics"
                    },
                    {
                        "full": "dummyTable",
                        "name": "dummyTable"
                    },
                    {
                        "full": "outputTable",
                        "name": "outputTable"
                    },
                    {
                        "full": "[timeColumn]",
                        "name": "timeColumn",
                        "optional": true
                    },
                    {
                        "full": "[useSystemTime=false]",
                        "name": "useSystemTime",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[keyColumn]",
                        "name": "keyColumn",
                        "optional": true
                    },
                    {
                        "full": "[garbageSize]",
                        "name": "garbageSize",
                        "optional": true
                    },
                    {
                        "full": "[updateTime]",
                        "name": "updateTime",
                        "optional": true
                    },
                    {
                        "full": "[useWindowStartTime]",
                        "name": "useWindowStartTime",
                        "optional": true
                    },
                    {
                        "full": "[roundTime=true]",
                        "name": "roundTime",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[snapshotDir]",
                        "name": "snapshotDir",
                        "optional": true
                    },
                    {
                        "full": "[snapshotIntervalInMsgCount]",
                        "name": "snapshotIntervalInMsgCount",
                        "optional": true
                    },
                    {
                        "full": "[fill='none']",
                        "name": "fill",
                        "optional": true,
                        "default": "'none'"
                    },
                    {
                        "full": "[forceTriggerTime]",
                        "name": "forceTriggerTime",
                        "optional": true
                    },
                    {
                        "full": "[raftGroup]",
                        "name": "raftGroup",
                        "optional": true
                    },
                    {
                        "full": "[keyPurgeFreqInSec=-1]",
                        "name": "keyPurgeFreqInSec",
                        "optional": true,
                        "default": "-1"
                    },
                    {
                        "full": "[closed='left']",
                        "name": "closed",
                        "optional": true,
                        "default": "'left'"
                    },
                    {
                        "full": "[outputElapsedMicroseconds=false]",
                        "name": "outputElapsedMicroseconds",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[subWindow]",
                        "name": "subWindow",
                        "optional": true
                    },
                    {
                        "full": "[parallelism=1]",
                        "name": "parallelism",
                        "optional": true,
                        "default": "1"
                    },
                    {
                        "full": "[acceptedDelay=0]",
                        "name": "acceptedDelay",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[outputHandler]",
                        "name": "outputHandler",
                        "optional": true
                    },
                    {
                        "full": "[msgAsTable=false]",
                        "name": "msgAsTable",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [createTimeSeriesEngine](https://docs.dolphindb.cn/zh/funcs/c/createTimeSeriesEngine.html)\n\n\n\n#### 语法\n\ncreateTimeSeriesEngine(name, windowSize, step, metrics, dummyTable, outputTable, \\[timeColumn], \\[useSystemTime=false], \\[keyColumn], \\[garbageSize], \\[updateTime], \\[useWindowStartTime], \\[roundTime=true], \\[snapshotDir], \\[snapshotIntervalInMsgCount], \\[fill='none'], \\[forceTriggerTime], \\[raftGroup], \\[keyPurgeFreqInSec=-1], \\[closed='left'], \\[outputElapsedMicroseconds=false], \\[subWindow], \\[parallelism=1], \\[acceptedDelay=0], \\[outputHandler], \\[msgAsTable=false])\n\n别名：createTimeSeriesAggregator\n\n#### 详情\n\n创建流数据时间序列引擎，以实现基于时间的滑动窗口或滚动窗口进行实时计算。\n\n时序引擎的聚合计算的算子分为增量计算和全量计算两种。增量计算算子不会保留历史数据，每次有数据进来就会进行增量计算；而全量计算算子（例如自定义的聚合函数，或未经优化的内置聚合函数，亦或是嵌套了状态函数的函数）会保留窗口内完整的数据，待触发输出时进行全量计算。\n\n时序引擎对以下聚合计算算子进行了优化，实现了增量计算，显著提升了性能：corr, covar, first, last, max, med, min, percentile, quantile, std, var, sum, sum2, sum3, sum4, wavg, wsum, count, firstNot, ifirstNot, lastNot, ilastNot, imax, imin, nunique, prod, sem, mode, searchK, beta, avg, covarp。\n\n更多流数据引擎的应用场景说明可以参考 [流计算引擎](https://docs.dolphindb.cn/zh/funcs/themes/streamingEngine.html)。\n\n##### 窗口\n\n* 窗口边界规整：对起始窗口左边界进行规整。（详情请参考 *step* 和 *roundTime* 的参数说明以及 `规整规则表`）\n\n* 窗口确定：\n\n  * *windowSize* 确定窗口长度。\n\n  * *closed* 确定窗口左闭右开或左开右闭。\n\n  * *step* 确定滑动的步长。\n\n  其中，*windowSize* 与 *step* 的单位取决于 *useSystemTime* 参数。若 *useSystemTime* = true， *windowSize* 与 *step* 的单位是毫秒。若 *useSystemTime* = false，*windowSize* 与 *step* 的单位同 *timeColumn* 列的精度一致。\n\n* 窗口截取：*useSystemTime* 参数决定了如何截取窗口，可以基于数据的时间列，亦可以基于数据注入系统的时间进行截取。\n\n##### 计算\n\n* 乱序数据处理规则：\n  * 若指定了 *timeColumn*，则 *timeColumn* 的时间必须为非递减序列；若同时指定了 *keyColumn*，则按照分组分别进行滑动窗口计算，*timeColumn* 在每组内的时间必须为非递减序列。否则，时间乱序的数据在计算中会被直接丢弃。\n  * 若希望接收指定范围内的乱序数据，可以设置 *acceptedDelay*，详见 *acceptedDelay* 参数说明。\n\n* 触发规则：若指定了 *timeColumn*，当前窗口的计算将由该窗口结束后收到的第一条数据触发；若设置 *useSystemTime* = true，窗口结束后会自动触发计算。\n\n* 强制触发规则：对长时间未触发计算的窗口数据，可以通过设置 *updateTime* 或 *forceTriggerTime* 强制触发计算。具体规则请参考参数说明。\n\n* 窗口填充规则：未指定 *fill* 或指定 *fill* = \"none\" 时，只会输出计算结果不为空的窗口；若指定了 *fill*，则会输出所有窗口，且根据 *fill* 规则对结果为空的窗口进行填充。\n\n##### 其它功能\n\n* 支持数据/状态清理：清理引擎中堆积的数据和不再需要的状态信息。（详情请参考 *garbageSize* 和 *keyPurgeFreqInSec* 的参数说明）\n\n* 快照机制：启用快照机制之后，系统若出现异常，可及时将流数据引擎恢复到最新的快照状态。（详情请参考 *snapshotDir* 和 *snapshotIntervalInMsgCount* 的参数说明）\n\n#### 参数\n\n**name** 字符串标量，表示时间序列引擎的名称，作为其在一个数据节点/计算节点上的唯一标识。可包含字母，数字和下划线，但必须以字母开头。\n\n**windowSize** 正整数标量或向量，表示滑动窗口的长度。\n\n**step** 正整数标量，表示滑动窗口移动的步长。 *windowSize* 必须是 *step* 的整数倍，否则会抛出异常。*windowSize* 和 *step* 的单位与 *useSystemTime* 有关：\n\n* 若 *useSystemTime* 为 true，则 *windowSize* 和 *step* 的单位为毫秒。\n\n* 若 *useSystemTime* 为 false，则 *windowSize* 和 *step* 的单位与 *timeColumn* 的时间精度一致。\n\n**metrics** 以元代码的格式表示计算指标，支持输入元组。有关元代码的更多信息可参考 [元编程](https://docs.dolphindb.cn/zh/progr/objs/meta_progr.html)。\n\n* 计算指标可以是一个或多个系统内置或用户自定义的聚合函数（使用 defg 关键字定义），如 <\\[sum(volume), avg(price)]>；可以对聚合结果使用表达式，如 <\\[avg(price1)-avg(price2)]>；也可对列与列的计算结果进行聚合计算，如 <\\[std(price1-price2)]>。\n\n* *metrics* 内支持调用具有多个返回值的函数，例如 \\<func(price) as \\`col1\\`col2>（可不指定列名）。\n\n* 支持指定为一个常量标量或向量，例如 <1>，<\\[1, 2, 3]> 。当指定为常量向量时，对应的输出列必须设置为数组向量类型。\n\n* 若 *windowSize* 为向量， *windowSize* 每个值可对应 *metrics* 中多个计算指标。例如，*windowSize* 为\\[10,20]时，metrics可为 (<\\[min(volume), max(volume)]>, \\<sum(volume)>)。 *metrics* 也可以嵌套输入元组向量。例如：\\[\\[<\\[min(volume), max(volume)]>, \\<sum(volume)>], \\[\\<avg(volume)>]]\n\n  **Note:**\n\n  * *metrics* 中使用的列名大小写不敏感，不需要与输入表的列名大小写保持一致。\n  * *metrics* 中不可使用嵌套聚合函数。\n\n**dummyTable** 一个表对象，和输入的流数据表的 schema 一致，可以含有数据，亦可为空表。\n\n**outputTable** 计算结果的输出表，可以是内存表或者分布式表。在使用 `createTimeSeriesEngine` 函数之前，需要将输出表预先设立为一个空表，并指定各列列名以及数据类型。时间序列引擎会将计算结果插入该表。\n\n* 输出表的列顺序如下：\n\n  1. 时间列。其中：\n\n     * 若 *useSystemTime* = true，为 TIMESTAMP 类型；反之，该列数据类型与 *timeColumn* 列一致。\n\n     * 若 *useWindowStartTime* = true，显示时间为数据窗口起始时间；反之，显示时间为数据窗口终止时间。\n\n  2. 分组列。如果 *keyColumn* 不为空，则其后几列和 *keyColumn* 设置的列及其顺序保持一致。\n\n  3. 耗时列。如果指定 *outputElapsedMicroseconds* = true，则指定一个 LONG 类型的列用于存储耗时（单位：微秒）。\n\n  4. 计算结果列。可为多列。\n\n  **Note:** 自 2.00.10 版本开始，引擎支持通过自定义聚合函数，将多个计算结果以 array vector 的形式输出，此时必须在 *outputTable* 中指定对应列类型为 array vector，详见例2。\n\n**timeColumn** 可选参数，字符串标量或向量。当 *useSystemTime* = false 时，必须指定该参数。 该参数用于指定订阅的流数据表中时间列的名称。\n\n**Note:** 字符串向量必须是 date 和 time 组成的向量，date 类型为 DATE，time 类型为 TIME, SECOND 或 NANOTIME。此时，输出表第一列的时间类型必须与 [concatDateTime(date, time)](https://docs.dolphindb.cn/zh/funcs/c/concatDateTime.html) 的类型一致。\n\n**useSystemTime** 可选参数，布尔值，表示是否使用数据注入引擎时的系统时间作为时间列进行计算。\n\n* 当 *useSystemTime* = true时，时间序列引擎会按照数据注入时间序列引擎的时刻（毫秒精度的本地系统时间，与数据中的时间列无关），每隔固定时间截取固定长度窗口的流数据进行计算。只要一个数据窗口中含有数据，数据窗口结束后就会自动进行计算。结果中的第一列为计算发生的时间戳，与数据中的时间无关。\n\n* 当 *useSystemTime* = false（缺省值）时，时间序列引擎根据流数据中的 *timeColumn* 列来截取数据窗口。一个数据窗口结束后的第一条新数据才会触发该数据窗口的计算。请注意，触发计算的数据并不会参与该次计算。\n\n  例如，一个数据窗口从 10:10:10 到 10:10:19。若 *useSystemTime* = true，则只要该窗口中至少有一条数据，该窗口的计算会在窗口结束后的 10:10:20 触发。若 *useSystemTime* = false，且 10:10:19 后的第一条数据为 10:10:25，则该窗口的计算会在 10:10:25 触发。\n\n**keyColumn** 可选参数，字符串标量或向量，表示分组列名。若设置，则分组进行聚合计算，例如以每支股票为一组进行聚合计算。\n\n分组字段支持数组向量类型（见例 5）。当分组字段包含数组向量时，引擎会先将数组向量展开为一维向量（flatten），再基于展开后的记录进行分组。此时需满足以下条件：\n\n* 所有数组向量在每一行中的元素长度必须一致；\n\n* *metrics* 中的表达式的计算结果长度，必须与数组向量展开后的总长度一致（例如：`sum(iif(flatten(orderTypeList)!=2,0，flatten(orderQtyList)/180))`。\n\n**garbageSize** 可选参数，正整数，默认值是 50,000（单位为行）。随着订阅的流数据不断积累，注入时间序列引擎，存放在内存中的数据会越来越多，这时需要清理不再需要的历史数据。当内存中历史数据行数超过 *garbageSize* 值时，系统会清理本次计算不需要的历史数据。如果指定了 *keyColumn*，内存清理是各组内独立进行的。当一个组在内存中的历史数据记录数超出 *garbageSize* 时，会清理该组中本次计算中不需要的历史数据。\n\n**Note:** 对于增量计算算子，系统会自动清理不再需要的历史数据。而对于全量计算算子，需要指定该参数来触发清理历史数据。\n\n**updateTime** 可选参数，非负整数，单位与 timeColumn 的时间精度一致。用于指定比 *step* 更短的计算时间间隔。*step* 必须是 *updateTime* 的整数倍。要设置 *updateTime*， *useSystemTime* 必须设为 false。\n\n如果没有指定 *updateTime*，一个数据窗口结束前，不会发生对该数据窗口数据的计算。若一个窗口长时间未触发计算，可以指定 updateTime，分多次触发当前窗口数据的计算。计算触发的规则为：\n\n* updateTime 指定为正整数值时：\n\n  * 从当前窗口的左边界开始，每隔 *updateTime* 时间，若有新的数据到来，则对当前窗口内该数据之前的所有数据进行计算。\n\n  * 如果系统经过 2 \\* *updateTime* （至少2秒）后仍有未被处理的数据，则触发对当前窗口内所有数据的计算。\n\n  * 若分组计算，则每组内进行上述操作。\n\n* updateTime 指定为 0 时：在新的数据到来后，立即对当前窗口的最新数据计算并输出。\n\n指定 *updateTime* 后，建议使用键值内存表作为输出表。因为每次计算均会增加一条记录，输出表若使用普通内存表或流数据表，则会产生大量带有相同时间戳的结果。因为键值流数据表不可更新记录，输出表亦不推荐使用键值流数据表。\n\n**useWindowStartTime** 可选参数，布尔值，表示输出表中的时间是否为数据窗口起始时间。默认值为 false，表示输出表中的时间为数据窗口起始时间 + *windowSize* 。若 *windowSize* 是向量， *useWindowStartTime* 必须为 false。\n\n**roundTime** 可选参数，布尔值，表示若数据时间精度为毫秒或者秒且 *step* > 一分钟，如何对窗口边界值进行规整处理。默认值为 true，表示按照既定的多分钟规则进行规整。若为 false，则按一分钟规则进行窗口规整。\n\n若要开启快照机制（snapshot），必须指定 *snapshotDir* 与 *snapshotIntervalInMsgCount*。\n\n**snapshotDir** 可选参数，字符串，表示保存引擎快照的文件目录。\n\n* 指定的目录必须存在，否则系统会提示异常。\n\n* 创建流数据引擎时，如果指定了 *snapshotDir*，会检查该目录下是否存在快照。如果存在，会加载该快照，恢复引擎的状态。\n\n* 多个引擎可以指定同一个目录存储快照，用引擎的名称来区分快照文件。\n\n* 一个引擎的快照可能会使用三个文件名：\n\n  * 临时存储快照信息：文件名为 \\<engineName>.tmp；\n\n  * 快照生成并刷到磁盘：文件保存为 \\<engineName>.snapshot；\n\n  * 存在同名快照：旧快照自动重命名为 \\<engineName>.old。\n\n**snapshotIntervalInMsgCount** 可选参数，为整数类型，表示每隔多少条数据保存一次流数据引擎快照。\n\n**fill** 可选参数，一个标量或向量，指定某个分组的某个窗口无数据时的处理方法。可取以下值：\n\n* 'none': 不输出结果。\n* 'null': 输出结果为 NULL。\n* 'ffill': 输出上一个有数据的窗口的结果。\n* '具体数值'：该值的数据类型需要和对应的 *metrics* 计算结果的类型保持一致。\n\n*fill* 可以输入向量，长度与 *metrics* 元素个数保持一致，表示为每个 *metrics* 指定不同的 *fill* 方式。若为向量，向量中各项只能是 'null', 'ffill' 或一个数值，不能是 'none'。\n\n**forceTriggerTime** 可选参数，是非负整数，单位与 *timeColumn* 的时间精度一致。用于强制触发各个分组未计算的窗口进行计算。要设置 *forceTriggerTime*， *useSystemTime* 必须设置为 false，且不能指定 *updateTime*。强制触发计算及输出规则如下：\n\n1. 未被触发计算的窗口结束后（窗口结束时刻为 t），若收到了其他分组的数据（时间戳为 t1），且满足 t1-t ≥ *forceTriggerTime*，则该窗口将被触发计算。\n\n2. 如果某个分组在最后一个窗口被强制触发计算后，没有再收到新的数据，但其他分组仍然收到了新的数据，那么通过 *fill* 来填充该分组的所有缺失窗口，可以确保在最新时间截面上仍然输出该分组的窗口。如果不指定 *fill*，则最后一个窗口被触发计算后，该分组不会产生新的窗口。\n\n设置 *forceTriggerTime* 或 *updateTime* 时需注意以下几点：\n\n* 设置 *updateTime*，计算发生后仍有属于当前窗口的数据到达时，当前窗口计算结果会再次更新；\n\n* 设置 *forceTriggerTime*，则触发计算之后收到的数据会被丢弃，建议不要设置太小的 *forceTriggerTime*。\n\n* 如果 *timeColumn* 指定的时间为 TIME 类型，数据跨天后无法仅凭时间判断数据的先后顺序，因此会出现跨天无法强制触发的情况。*timeColumn* 的时间需要加上日期。\n\n**raftGroup** 可选参数，表示流数据高可用订阅端 raft 组的 ID (大于1的整数，由流数据高可用相关的配置项 *streamingRaftGroups* 指定)。设置该参数表示开启计算引擎高可用。在 leader 节点创建流数据引擎后，会同步在 follower 节点创建该引擎。每次保存的 snapshot 也会同步到 follower。当 raft 组的 leader 节点宕机时，会自动切换新 leader 节点重新订阅流数据表。请注意，若要指定 *raftGroup*，必须同时指定 *snapshotDir*。\n\n注意，自 3.00.5 版本起，流计算引擎暂不支持高可用功能，*raftGroup* 参数将不生效。\n\n**keyPurgeFreqInSec** 正整数，单位为秒。用于控制定期清理“窗口数据已为空”的分组对应的 key，从而避免 key 持续增长带来的内存占用。指定该参数后，如果当前数据注入时间与上一次清理时间的间隔 ≥ *keyPurgeFreqInSec*，则会删除当前窗口数据为空的分组及其对应的 key。\n\n**Note:**\n\n* 若需指定该参数，必须指定 *forceTriggerTime*，且不能指定 *fill*。\n\n* 可以通过调用 [getStreamEngineStat](https://docs.dolphindb.cn/zh/funcs/g/getStreamEngineStat.html) 函数查看 TimeSeriesEngine 引擎状态的 numGroups 列，来对比响应式状态引擎清理前后分组数的变化。\n\n**closed** 字符串，用于确定滑动窗口边界的开闭情况。可选值为 'left' 或 'right'，默认值为 'left'。\n\n* closed = 'left'： 窗口左闭右开。\n\n* closed = 'right'： 窗口左开右闭。\n\n**outputElapsedMicroseconds** 布尔值，表示是否输出每个窗口从触发计算到计算完成输出结果的耗时（若指定了 *keyColumn* 则包含数据分组的耗时），默认为 false。指定参数 *outputElapsedMicroseconds* 后，在定义 *outputTable* 时需要在时间列和分组列后增加一个 LONG 类型的列，详见 *outputTable* 参数说明。\n\n**subWindow**整型或者 DURATION 数据对。在滑动窗口内指定子窗口，仅计算子窗口内的数据。子窗口边界的开闭情况由参数 *closed* 决定。子窗口结束后收到第一条数据触发对子窗口内数据的计算（参考例4）。当 *subWindow*为整型数据对时，其单位与 *timeColumn* 的时间精度一致。若指定 *subWindow*，则：\n\n* *windowSize*和 *step*必须相等。\n* 不可设置 *updateTime*>0和 *useSystemTime*=true。\n\n**parallelism** 为不超过 63 的正整数，可选参数，表示并行计算的工作线程数，默认值为 1。在计算量较大时，合理地调整该参数能够有效利用计算资源，降低计算耗时。建议小于机器核数，推荐值为 4 到 8 。\n\n**acceptedDelay** 正整数，可选参数。指定每个窗口接收数据的最大延迟，默认值为 0。若设置该参数，则不能设置 *forceTriggerTime* 或 *updateTime*。\n\n* 当 useSystemTime= true 时，*acceptedDelay* 必须小于等于 *windowSize*。在窗口结束后的 *acceptedDelay* 时间内接收到的数据，仍然属于此窗口并参与计算，而不会参与下一个窗口的计算。\n\n* 当 useSystemTime= false 时，该参数用于处理乱序数据。假设当前窗口结束的时间戳为 t ，若收到一条时间戳大于等于 t+*acceptedDelay*的数据，则触发在此之前收到的所有属于当前窗口的数据进行计算输出，并关闭该窗口。\n\n**outputHandler** 一元函数。设置此参数时，引擎计算结束后，不再将计算结果写到输出表，而是会调用此函数处理计算结果。\n\n**msgAsTable** 布尔标量，表示在设置了参数 outputHandler 时，将引擎的计算结果以表的结构调用函数。默认值为 false，此时将计算结果的每一列作为元素组成元组。\n\n##### 规整规则\n\n为了便于观察和对比计算结果，系统会对第一个数据窗口的起始时间进行规整，根据 *step* 参数、数据的时间精度，以及 *roundTime* 参数来确定整数类型的规整尺度 alignmentSize。当时间序列引擎使用分组计算时，所有分组的窗口均进行统一的规整。相同时刻的数据窗口在各组均有相同的边界。\n\n* 当数据时间类型为MONTH时，会以第一条数据对应年份的1月作为窗口的上边界。\n\n* 当数据的时间类型为DATE时，不对第一个数据窗口的边界值进行规整。\n\n* 若数据的时间精度为分钟，如 MINUTE(HH:mm) 类型，alignmentSize 取值如下：\n\n  *若 roundTime = false*：\n\n  | step   | alignmentSize |\n  | ------ | ------------- |\n  | 0\\~2   | 2             |\n  | 3      | 3             |\n  | 4\\~5   | 5             |\n  | 6\\~10  | 10            |\n  | 11\\~15 | 15            |\n  | 16\\~20 | 20            |\n  | 21\\~30 | 30            |\n  | >30    | 60 (1小时)      |\n\n  *若 roundTime = true*:\n\n  当 step <= 30 时，alignmentSize 取值同上表。当 step > 30 时，alignmentSize 取值见下表：\n\n  | step       | alignmentSize |\n  | ---------- | ------------- |\n  | 31\\~60     | 60 (1小时)      |\n  | 61\\~120    | 120 (2小时)     |\n  | 121\\~180   | 180 (3小时)     |\n  | 181\\~300   | 300 (5小时)     |\n  | 301\\~600   | 600 (10小时)    |\n  | 601\\~900   | 900 (15小时)    |\n  | 901\\~1200  | 1200 (20小时)   |\n  | 1201\\~1800 | 1800 (30小时)   |\n  | >1800      | 3600 (60小时)   |\n\n* 若数据的时间精度为秒，如 DATETIME(yyyy-MM-dd HH:mm:ss) 与 SECOND(HH:mm:ss) 类型，alignmentSize 的 取值如下：\n\n  *若 roundTime = false*：\n\n  | step   | alignmentSize |\n  | ------ | ------------- |\n  | 0\\~2   | 2             |\n  | 3      | 3             |\n  | 4\\~5   | 5             |\n  | 6\\~10  | 10            |\n  | 11\\~15 | 15            |\n  | 16\\~20 | 20            |\n  | 21\\~30 | 30            |\n  | >30    | 60 (1分钟)      |\n\n  *若 roundTime = true*：\n\n  当 step <= 30 时，alignmentSize 取值同上表。当 step > 30 时，alignmentSize 取值见下表：\n\n  | step       | alignmentSize |\n  | ---------- | ------------- |\n  | 31\\~60     | 60 (1分钟)      |\n  | 61\\~120    | 120 (2分钟)     |\n  | 121\\~180   | 180 (3分钟)     |\n  | 181\\~300   | 300 (5分钟)     |\n  | 301\\~600   | 600 (10分钟)    |\n  | 601\\~900   | 900 (15分钟)    |\n  | 901\\~1200  | 1200 (20分钟)   |\n  | 1201\\~1800 | 1800 (30分钟)   |\n  | >1800      | 3600 (1小时)    |\n\n* 若数据的时间精度为毫秒，如 TIMESTAMP(yyyy-MM-dd HH:mm:ss.mmm) 与 TIME(HH:mm:ss.mmm) 类型，alignmentSize 的取值如下：\n\n  *若 roundTime = false*:\n\n  | step         | alignmentSize |\n  | ------------ | ------------- |\n  | 0\\~2         | 2             |\n  | 3\\~5         | 5             |\n  | 6\\~10        | 10            |\n  | 11\\~20       | 20            |\n  | 21\\~25       | 25            |\n  | 26\\~50       | 50            |\n  | 51\\~100      | 100           |\n  | 101\\~200     | 200           |\n  | 201\\~250     | 250           |\n  | 251\\~500     | 500           |\n  | 501\\~1000    | 1000（1秒）      |\n  | 1001\\~2000   | 2000（2秒）      |\n  | 2001\\~3000   | 3000（3秒）      |\n  | 3001\\~5000   | 5000（5秒）      |\n  | 5001\\~10000  | 10000（10秒）    |\n  | 10001\\~15000 | 15000（15秒）    |\n  | 15001\\~20000 | 20000（20秒）    |\n  | 20001\\~30000 | 30000（30秒）    |\n  | >30000       | 60000（1分钟）    |\n\n  *若 roundTime = true*:\n\n  若 *step* <= 30000，alignmentSize 取值同上表；若 *step* > 30000，alignmentSize 取值见下表：\n\n  | step             | alignmentSize |\n  | ---------------- | ------------- |\n  | 30001\\~60000     | 60000（1分钟）    |\n  | 60001\\~120000    | 120000（2分钟）   |\n  | 120001\\~300000   | 300000（5分钟）   |\n  | 300001\\~600000   | 600000（10分钟）  |\n  | 600001\\~900000   | 900000（15分钟）  |\n  | 900001\\~1200000  | 1200000（20分钟） |\n  | 1200001\\~1800000 | 1800000（30分钟） |\n  | >1800000         | 3600000（1小时）  |\n\n* 若数据的时间精度为纳秒，如 NANOTIMESTAMP(yyyy-MM-dd HH:mm:ss.nnnnnnnnn) 与 NANOTIME(HH:mm:ss.nnnnnnnnn) 类型，alignmentSize 的取值如下：\n\n  *若 roundTime = false*:\n\n  | step         | alignmentSize |\n  | ------------ | ------------- |\n  | 0\\~2ns       | 2ns           |\n  | 3ns\\~5ns     | 5ns           |\n  | 6ns\\~10ns    | 10ns          |\n  | 11ns\\~20ns   | 20ns          |\n  | 21ns\\~25ns   | 25ns          |\n  | 26ns\\~50ns   | 50ns          |\n  | 51ns\\~100ns  | 100ns         |\n  | 101ns\\~200ns | 200ns         |\n  | 201ns\\~250ns | 250ns         |\n  | 251ns\\~500ns | 500ns         |\n  | >500ns       | 1000ns        |\n\n  *若 roundTime = true*:\n\n  | step        | alignmentSize |\n  | ----------- | ------------- |\n  | 1000ns\\~1ms | 1ms           |\n  | 1ms\\~10ms   | 10ms          |\n  | 10ms\\~100ms | 100ms         |\n  | 100ms\\~1s   | 1s            |\n  | 1s\\~2s      | 2s            |\n  | 2s\\~3s      | 3s            |\n  | 3s\\~5s      | 5s            |\n  | 5s\\~10s     | 10s           |\n  | 10s\\~15s    | 15s           |\n  | 15s\\~20s    | 20s           |\n  | 20s\\~30s    | 30s           |\n  | >30s        | 1min          |\n\n假设第一条数据的时间为 x, 那么根据其类型，第一个数据窗口的左边界的计算规则为：`timeType_cast(x/alignmentSize*alignmentSize+step-windowSize)`。其中，timeType\\_cast 表示依据时间精度，需要强制转换的时间类型；'/' 表示整除。例如，第一条数据的时间为 2018.10.08T01:01:01.365，windowSize 为 120000，step 为 60000，那么 alignmentSize 为 60000，第一个数据窗口的左边界为 `timestamp(2018.10.08T01:01:01.365/60000*60000+60000-120000)`，即 2018.10.08T01:00:00.000。\n\n#### 返回值\n\n一个表对象，通过向该表对象写入，将数据注入时间序列引擎进行计算。\n\n#### 例子\n\n**Note:** 以下例子使用了相同的变量和表名便于比较。每个例子执行结束后，请使用以下命令清除环境中的临时数据：\n\n* [getStreamingStat](https://docs.dolphindb.cn/zh/funcs/g/getStreamingStat.html)：用于查看当前的流数据表订阅者。例如：\n\n  ```\n  getStreamingStat().pubTables\n  ```\n\n* [unsubscribeTable](https://docs.dolphindb.cn/zh/funcs/u/unsubscribeTable.html)：用于取消订阅流数据表。例如，在例子 1 代码运行后取消对 trades 的订阅：\n\n  ```\n  unsubscribeTable(tableName=\"trades\", actionName=\"engine1\")\n  ```\n\n* [dropStreamTable](https://docs.dolphindb.cn/zh/funcs/d/dropStreamTable.html)：用于删除流数据表。例如，删除例子 1 中的流数据表 trades：\n\n  ```\n  dropStreamTable(tableName=\"trades\")\n  ```\n\n* [dropStreamEngine](https://docs.dolphindb.cn/zh/funcs/d/dropStreamEngine.html)：用于流数据引擎。例如，删除例子 1 中的流数据引擎 engine1：\n\n  ```\n  dropStreamEngine(\"engine1\")\n  ```\n\n例1. 时间序列引擎 engine1 订阅流数据表 trades，实时计算表 trades 中过去1分钟内每只股票交易量之和。\n\n```\nshare streamTable(1000:0, [\"time\",\"sym\",\"volume\"], [TIMESTAMP, SYMBOL, INT]) as trades\nshare table(10000:0, [\"time\",\"sym\",\"sumVolume\"], [TIMESTAMP, SYMBOL, INT]) as output1\nengine1 = createTimeSeriesEngine(name=\"engine1\", windowSize=60000, step=60000, metrics=<[sum(volume)]>, dummyTable=trades, outputTable=output1, timeColumn=\"time\", useSystemTime=false, keyColumn=\"sym\", garbageSize=50, useWindowStartTime=false)\nsubscribeTable(tableName=\"trades\", actionName=\"engine1\", offset=0, handler=append!{engine1}, msgAsTable=true);\n\ninsert into trades values(2018.10.08T01:01:01.785,`A,10)\ninsert into trades values(2018.10.08T01:01:02.125,`B,26)\ninsert into trades values(2018.10.08T01:01:10.263,`B,14)\ninsert into trades values(2018.10.08T01:01:12.457,`A,28)\ninsert into trades values(2018.10.08T01:02:10.789,`A,15)\ninsert into trades values(2018.10.08T01:02:12.005,`B,9)\ninsert into trades values(2018.10.08T01:02:30.021,`A,10)\ninsert into trades values(2018.10.08T01:04:02.236,`A,29)\ninsert into trades values(2018.10.08T01:04:04.412,`B,32)\ninsert into trades values(2018.10.08T01:04:05.152,`B,23)\n\nsleep(10)\n\nselect * from output1;\n```\n\n| time                    | sym | sumVolume |\n| ----------------------- | --- | --------- |\n| 2018.10.08T01:02:00.000 | A   | 38        |\n| 2018.10.08T01:02:00.000 | B   | 40        |\n| 2018.10.08T01:03:00.000 | A   | 25        |\n| 2018.10.08T01:03:00.000 | B   | 9         |\n\n下面详细解释时间序列引擎的计算过程。为简便起见，以下提到时间时，省略相同的日期部分，只列出（小时:分钟:秒.毫秒）部分。\n\n首先，时间序列引擎对第一个数据窗口的起始时间进行规整。第一个数据窗口的时间范围是 01:01:00.000 到 01:02:00.000，只包含左边界，不包含右边界。当(01:02:10.789,`A,15)到达时，触发第一个窗口 A 组计算；当(01:02:12.005,`B,9)到达时，触发第一个窗口 B 组计算。\n\n第二个数据窗口的时间范围是 01:02:00.000 到 01:03:00.000。当(01:04:02.236,`A,29)到达时，触发第二个窗口 A 组计算；当(01:04:04.412,`B,32)到达时，触发第二个窗口 B 组计算。\n\n由于 01:05:00.000 及之后没有数据，因此没有对 01:04:00.000 到 01:05:00.000 之间的数据进行计算。\n\n输出表 output1 保存了时间序列引擎的计算结果。由于 *useWindowStartTime* 为 false，因此输出表 output1 中的时间为窗口的结束时间。若将 *useWindowStartTime* 设为 true，则输出表中的时间为窗口的起始时间。例如：\n\n```\noutput2 = table(10000:0, [\"time\",\"sym\",\"sumVolume\"], [TIMESTAMP, SYMBOL, INT])\nengine2 = createTimeSeriesEngine(name=\"engine2\", windowSize=60000, step=60000, metrics=<[sum(volume)]>, dummyTable=trades, outputTable=output2, timeColumn=\"time\", useSystemTime=false, keyColumn=\"sym\", garbageSize=50, useWindowStartTime=true)\nsubscribeTable(tableName=\"trades\", actionName=\"engine2\", offset=0, handler=append!{engine2}, msgAsTable=true)\n\nsleep(10)\nselect * from output2;\n```\n\n| time                    | sym | sumVolume |\n| ----------------------- | --- | --------- |\n| 2018.10.08T01:01:00.000 | A   | 38        |\n| 2018.10.08T01:01:00.000 | B   | 40        |\n| 2018.10.08T01:02:00.000 | A   | 25        |\n| 2018.10.08T01:02:00.000 | B   | 9         |\n\n下例中指定 *updateTime* 为 1000（毫秒）：\n\n```\nshare keyedTable([\"time\",\"sym\"],10000:0, [\"time\",\"sym\",\"sumVolume\"], [TIMESTAMP, SYMBOL, INT]) as output3\nengine3 = 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)\nsubscribeTable(tableName=\"trades\", actionName=\"engine3\", offset=0, handler=append!{engine3}, msgAsTable=true)\n\nsleep(2001)\nselect * from output3;\n```\n\n| time                    | sym | sumVolume |\n| ----------------------- | --- | --------- |\n| 2018.10.08T01:02:00.000 | A   | 38        |\n| 2018.10.08T01:02:00.000 | B   | 40        |\n| 2018.10.08T01:03:00.000 | A   | 25        |\n| 2018.10.08T01:03:00.000 | B   | 9         |\n| 2018.10.08T01:05:00.000 | B   | 55        |\n| 2018.10.08T01:05:00.000 | A   | 29        |\n\n例2. 下例中指定 *updateTime* 为 0（毫秒）：\n\n```\nshare streamTable(1000:0, [\"time\",\"sym\",\"volume\"], [TIMESTAMP, SYMBOL, INT]) as trades\nshare table(1000:0, [\"time\",\"sym\",\"sumVolume\"], [TIMESTAMP, SYMBOL, INT]) as output4\nengine4 = createTimeSeriesEngine(name=\"engine4\", windowSize=60000, step=60000, metrics=<[sum(volume)]>, dummyTable=trades, outputTable=output4, timeColumn=\"time\", useSystemTime=false, keyColumn=\"sym\", garbageSize=50, updateTime=0, useWindowStartTime=false)\nsubscribeTable(tableName=\"trades\", actionName=\"engine4\", offset=0, handler=append!{engine4}, msgAsTable=true);\n\ninsert into trades values(2018.10.08T01:01:01.785,`A,10)\ninsert into trades values(2018.10.08T01:01:02.125,`B,26)\ninsert into trades values(2018.10.08T01:01:10.263,`B,14)\ninsert into trades values(2018.10.08T01:01:12.457,`A,28)\n\nsleep(100)\n\ninsert into trades values(2018.10.08T01:01:12.557,`B,21)\ninsert into trades values(2018.10.08T01:01:12.557,`A,28)\n\n\nselect * from output4;\n\n```\n\n*updateTime*=0 时，每收到一批数据就触发一次计算输出：\n\n* 01:01:12.457 时，触发了第一批数据中 A、B 两组数据的计算输出。\n\n* 01:01:12.557 时，再次触发第二批数据中 A、B 两组数据的计算输出。\n\n最终得到：\n\n| time                    | sym | sumVolume |\n| ----------------------- | --- | --------- |\n| 2018.10.08 01:02:00.000 | A   | 38        |\n| 2018.10.08 01:02:00.000 | B   | 40        |\n| 2018.10.08 01:02:00.000 | B   | 61        |\n| 2018.10.08 01:02:00.000 | A   | 66        |\n\n下面以最后一个数据窗口为例，介绍时间序列引擎指定 *updateTime* 时如何进行计算。假设 time 列时间亦为数据进入时间序列引擎的时刻。\n\n1. 在 01:04:04.236 时，A 分组的第一条记录到达后已经过 2000 毫秒，触发一次 A 组计算，输出表增加一条记录(01:05:00.000, \\`A, 29)。\n\n2. 在 01:04:05.152 时的 B 组记录为 01:04:04.412 所在小窗口\\[01:04:04.000, 01:04:05.000)之后第一条记录，触发一次 B 组计算，输出表增加一条记录(01:05:00,\"B\",32)。\n\n3. 2 秒（2\\*updateTime个时间单位）后，在 01:04:07.152 时，由于 01:04:05.152 时的 B 组记录仍未参与计算，触发一次B组计算，输出一条记录(01:05:00,\"B\",55)。由于输出表的主键为 time 和 sym，并且输出表中已有(01:05:00,\"B\",32)这条记录，因此将该记录更新为(01:05:00,\"B\",55)。\n\n下例中，共享流数据表 \"pubT\" 包含两个时间列，类型分别时 DATE 和 SECOND，创建时间序列引擎时，通过设置 *timeColumn* 来将原来流数据表的两个时间列整合为输出表 streamMinuteBar\\_1min 中的一个类型为 DATETIME 的时间列。\n\n```\ncolNames=[\"symbol\",\"date\",\"minute\",\"price\",\"type\",\"volume\"]\ncolTypes=[SYMBOL, DATE, SECOND, DOUBLE, STRING, INT]\npubTable = streamTable(10000:0,colNames,colTypes)\nshare pubTable as pubT\n\ncolNames = [\"time\",\"symbol\",\"open\",\"max\",\"min\",\"close\",\"volume\",\"amount\",\"ret\",\"vwap\"]\ncolTypes = [DATETIME, SYMBOL, DOUBLE, DOUBLE, DOUBLE, DOUBLE, INT, DOUBLE, DOUBLE, DOUBLE]\nshare streamTable(10000:0,colNames, colTypes) as streamMinuteBar_1min\n\ntsAggrOHLC = createTimeSeriesEngine(name=\"subT\", windowSize=60, step=60, metrics=<[first(price) as open ,max(price) as max,min(price) as min ,last(price) as close ,sum(volume) as volume ,wsum(volume, price) as amount ,(last(price)-first(price))/first(price) as ret, (wsum(volume, price)/sum(volume)) as vwap]>, dummyTable=pubTable, outputTable=streamMinuteBar_1min, timeColumn=[\"date\",\"minute\"], useSystemTime=false, keyColumn=\"symbol\", fill=\"none\")\nsubscribeTable(tableName=\"pubT\", actionName=\"subT\", offset=-1, handler=append!{tsAggrOHLC}, msgAsTable=true)\n\ninsert into pubT values(\"000001\", 2021.04.05, 09:25:01, 1, 'B', 1)\ninsert into pubT values(\"000001\", 2021.04.05, 09:30:05, 2, 'B', 1)\ninsert into pubT values(\"000001\", 2021.04.05, 09:31:06, 3, 'B', 1)\ninsert into pubT values(\"000001\", 2021.04.05, 09:35:05, 4, 'S', 4)\ninsert into pubT values(\"000001\", 2021.04.05, 09:40:05, 5, 'S', 5)\ninsert into pubT values(\"000001\", 2021.04.06, 09:25:05, 6, 'S', 6)\n\npubT\n```\n\n| symbol | date       | minute   | price | type | volume |\n| ------ | ---------- | -------- | ----- | ---- | ------ |\n| 000001 | 2021.04.05 | 09:25:01 | 1     | B    | 1      |\n| 000001 | 2021.04.05 | 09:30:05 | 2     | B    | 1      |\n| 000001 | 2021.04.05 | 09:31:06 | 3     | B    | 1      |\n| 000001 | 2021.04.05 | 09:35:05 | 4     | S    | 4      |\n| 000001 | 2021.04.05 | 09:40:05 | 5     | S    | 5      |\n| 000001 | 2021.04.06 | 09:25:05 | 6     | S    | 6      |\n\n```\nselect * from streamMinuteBar_1min\n```\n\n| time                | symbol | open | max | min | close | volume | amount | ret | vwap |\n| ------------------- | ------ | ---- | --- | --- | ----- | ------ | ------ | --- | ---- |\n| 2021.04.05T09:26:00 | 000001 | 1    | 1   | 1   | 1     | 1      | 1      | 0   | 1    |\n| 2021.04.05T09:31:00 | 000001 | 2    | 2   | 2   | 2     | 1      | 2      | 1   | 2    |\n| 2021.04.05T09:32:00 | 000001 | 3    | 3   | 3   | 3     | 1      | 3      | 2   | 3    |\n| 2021.04.05T09:36:00 | 000001 | 4    | 4   | 4   | 4     | 4      | 16     | 3   | 4    |\n| 2021.04.05T09:41:00 | 000001 | 5    | 5   | 5   | 5     | 5      | 25     | 4   | 5    |\n\n```\nshare streamTable(1000:0, [\"time\",\"sym\",\"qty\"], [DATETIME, SYMBOL, INT]) as trades\nshare table(10000:0, [\"time\",\"sym\",\"sumQty\"], [DATETIME, SYMBOL, INT]) as output5\n\nengine = createTimeSeriesEngine(name=\"engine\", windowSize=6, step=6, metrics=<sum(qty)>, dummyTable=trades, outputTable=output5, timeColumn=\"time\",keyColumn=\"sym\", forceTriggerTime=7,fill=1000)\nsubscribeTable(tableName=\"trades\", actionName=\"engine\", offset=0, handler=append!{engine}, msgAsTable=true)\nsleep(1000)\ninsert into engine values(2018.08.01T14:05:43,`A,1)\ninsert into engine values(2018.08.01T14:05:43,`C,3)\nsleep(10)\ninsert into engine values(2018.08.01T14:05:44,`B,1)\nsleep(80)\ninsert into engine values(2018.08.01T14:05:52,`B,3)\nsleep(20)\ninsert into engine values(2018.08.01T14:05:54,`A,3)\nsleep(10)\ninsert into engine values(2018.08.01T14:05:55,`A,5)\nsleep(20)\ninsert into engine values(2018.08.01T14:05:57,`B,5)\nsleep(50)\ninsert into engine values(2018.08.01T14:06:12,`A,1)\nsleep(50)\nselect * from output5 order by sym\n```\n\n| time                | sum | Qty   |\n| ------------------- | --- | ----- |\n| 2018.08.01T14:05:46 | A   | 1     |\n| 2018.08.01T14:05:52 | A   | 1,000 |\n| 2018.08.01T14:05:58 | A   | 8     |\n| 2018.08.01T14:06:04 | A   | 1,000 |\n| 2018.08.01T14:06:10 | A   | 1,000 |\n| 2018.08.01T14:05:46 | B   | 1     |\n| 2018.08.01T14:05:52 | B   | 1,000 |\n| 2018.08.01T14:05:58 | B   | 8     |\n| 2018.08.01T14:05:46 | C   | 3     |\n| 2018.08.01T14:05:52 | C   | 1,000 |\n\n例3. 下例计算每个分组窗口的第一个和最后一个 volume，组合后输出为一个数组向量。\n\n```\n//通过 defg 自定义一个函数，引擎在调用该函数时会将返回值转换为数组向量\ndefg toVector(x){\n\treturn x\t\n}\nshare streamTable(1000:0, [\"time\",\"sym\",\"volume\",\"price\"], [TIMESTAMP, SYMBOL, DOUBLE,DOUBLE]) as trades\n//定义输出表，对应 toVector 指标输出的列需要定义为数组向量类型，此例中将其定义为 DOUBLE[]\nshare table(10000:0, [\"time\",\"sym\",\"sumVolume\",\"avg\"], [TIMESTAMP,STRING,DOUBLE[],DOUBLE]) as output6\n//metrics 中调用了 toVector 函数，将1分钟窗口内的第一个 volume 和最后一个 volume 组合到一个向量中。\nengine1 = createTimeSeriesEngine(name=\"engine1\", windowSize=60000, step=60000, metrics=<[toVector([first(volume),last(volume)]),avg(volume+price)]>, dummyTable=trades, outputTable=output6, timeColumn=\"time\", keyColumn=\"sym\" , useSystemTime=false, garbageSize=50, useWindowStartTime=false)\n\ntimes = sort(2023.10.08T00:00:00.000 + rand(1..(1+3000*200), 30))\nsyms = rand(\"A\"+string(1..10), 30)\nvolumes = rand(rand(100.0, 10) join 2.3 NULL NULL NULL NULL, 30)\nprices = rand(rand(100.0, 10) join 2.3 NULL NULL NULL NULL, 30)\nt=table(times as time, syms as sym, volumes as volume,prices as price)\n\nengine1.append!(t)\n\nselect * from output6 where time between 2023.10.08T00:01:00.000 and 2023.10.08T00:05:00.000 order by time,sym \n```\n\n| time                    | sym | sumVolume      | avg      |\n| ----------------------- | --- | -------------- | -------- |\n| 2023.10.08T00:01:00.000 | A1  | \\[57.66,]      | 80.428   |\n| 2023.10.08T00:01:00.000 | A2  | \\[,]           |          |\n| 2023.10.08T00:02:00.000 | A7  | \\[,]           |          |\n| 2023.10.08T00:02:00.000 | A8  | \\[,]           |          |\n| 2023.10.08T00:03:00.000 | A2  | \\[,41.25]      | 101.7832 |\n| 2023.10.08T00:03:00.000 | A3  | \\[41.25,41.25] | 68.4897  |\n| 2023.10.08T00:03:00.000 | A6  | \\[,]           |          |\n| 2023.10.08T00:03:00.000 | A8  | \\[19.17,19.17] | 93.9934  |\n| 2023.10.08T00:04:00.000 | A7  | \\[,]           |          |\n| 2023.10.08T00:05:00.000 | A3  | \\[2.05,2.05]   | 95.433   |\n| 2023.10.08T00:05:00.000 | A5  | \\[55.93,55.93] | 116.4669 |\n| 2023.10.08T00:05:00.000 | A9  | \\[42.66,42.66] |          |\n\n例4.本例将说明 *subWindow* 参数的作用。\n\n```\nshare streamTable(1000:0, [\"time\",\"sym\",\"volume\"], [TIMESTAMP, SYMBOL, INT]) as trades\nshare table(10000:0, [\"time\",\"sym\",\"sumVolume\"], [TIMESTAMP, SYMBOL, INT]) as output7\n//在长度为 1 分钟的窗口内指定一个子窗口，未指定 closed 时，子窗口左闭右开。这里子窗口为每分钟的[0s, 10s)\nengine4 = createTimeSeriesEngine(name=\"engine4\", windowSize=60000, step=60000, metrics=<[sum(volume)]>, dummyTable=trades, outputTable=output7, timeColumn=\"time\", useSystemTime=false, keyColumn=\"sym\", garbageSize=50, useWindowStartTime=true, subWindow=0s:10s)\n\nsubscribeTable(tableName=\"trades\", actionName=\"engine4\", offset=0, handler=append!{engine4}, msgAsTable=true);\n\ninsert into trades values(2018.10.08T01:01:01.785,`A,10)\ninsert into trades values(2018.10.08T01:01:02.125,`B,26)\ninsert into trades values(2018.10.08T01:01:10.000,`A,14)\ninsert into trades values(2018.10.08T01:01:12.457,`A,28)\n\nsleep(10)\n\nselect * from output7;\n```\n\n2018.10.08T01:01:10.000 时刻的数据触发 \\[2018.10.08T01:01:00.000, 2018.10.08T01:01:10.000) 区间内 A 组数据对应的 volume 的总和。在子窗口结束后没有再收到 B 组的数据，因此 B 组子窗口内数据未被触发计算。\n\n| time                    | sym | sumVolume |\n| :---------------------- | :-- | :-------- |\n| 2018.10.08T01:01:10.000 | A   | 10        |\n\n例5. 本例展示如何对包含多档价格与数量的数组向量字段，在时间窗口内按股票、买卖方向及委托价格分组，计算各价位的委托金额和委托笔数。\n\n```\nshare streamTable(1000:0, [\"time\",\"sym\",\"side\",\"orderPrice\",\"orderQty\"],   \n    [TIMESTAMP, SYMBOL, SYMBOL, DOUBLE[], INT[]]) as orderStream  \n  \nshare table(10000:0, [\"time\",\"sym\",\"side\", \"orderPrice\", \"totalValue\", \"orderCount\"],   \n    [TIMESTAMP, SYMBOL, SYMBOL, DOUBLE, DOUBLE, INT]) as result  \n  \n// 创建时序聚合引擎：按股票代码、买卖方向和委托价格分组  \nengine = createTimeSeriesEngine(  \n    name=\"orderEngine\",   \n    windowSize=60000,   \n    step=60000,   \n    metrics=<[  \n        sum(orderPrice * orderQty),               \n        count(orderPrice)                 \n    ]>,   \n    dummyTable=orderStream,   \n    outputTable=result,   \n    timeColumn=\"time\",   \n    keyColumn=`sym`side`orderPrice, \n    useSystemTime=false  \n)  \n\n \nn = 100  \ntime = 2023.01.01T09:30:00.000 + (1..n)*1000  \nsym = take(`AAPL`MSFT, n)  \nside = take(`Buy`Sell, n)  \norderPrice = arrayVector((1..n) * 5, rand(100.0 105.0, 5*n))  \norderQty = arrayVector((1..n) * 5, rand(100 1000, 5*n)) \n   \ninsert into engine values(time, sym, side, orderPrice, orderQty)\n\n// 查看结果表\nselect * from result\n```\n\n| time                    | sym  | side | orderPrice | totalValue | orderCount |\n| ----------------------- | ---- | ---- | ---------- | ---------- | ---------- |\n| 2023.01.01 09:31:00.000 | AAPL | Buy  | 100        | 4,430,000  | 74         |\n| 2023.01.01 09:31:00.000 | AAPL | Buy  | 105        | 5,050,500  | 76         |\n| 2023.01.01 09:31:00.000 | MSFT | Sell | 100        | 4,720,000  | 76         |\n| 2023.01.01 09:31:00.000 | MSFT | Sell | 105        | 3,654,000  | 69         |\n\n例6. 将 *windowSize* 设为向量，同时计算 1 分钟窗口和 3 分钟窗口。\n\n当 *windowSize* 为向量时，每个窗口长度可以对应一组独立的指标。本例同时输出 1 分钟成交量之和和 3 分钟价格均值。\n\n```\nshare streamTable(1000:0, [\"time\",\"sym\",\"volume\",\"price\"], [TIMESTAMP, SYMBOL, INT, DOUBLE]) as tradesWS\nshare table(1000:0, [\"time\",\"sym\",\"sum1m\",\"avgPrice3m\"], [TIMESTAMP, SYMBOL, INT, DOUBLE]) as outputWS\n\nengineWS = createTimeSeriesEngine(\n  name=\"engineWS\",\n  windowSize=[60000, 180000],\n  step=60000,\n  metrics=(<[sum(volume) as sum1m]>, <[avg(price) as avgPrice3m]>),\n  dummyTable=tradesWS,\n  outputTable=outputWS,\n  timeColumn=\"time\",\n  keyColumn=\"sym\",\n  useSystemTime=false\n)\n\nsubscribeTable(tableName=\"tradesWS\", actionName=\"engineWS\", offset=0, handler=append!{engineWS}, msgAsTable=true)\n\ninsert into tradesWS values(2024.01.01T10:00:10.000, `A, 10, 100.0)\ninsert into tradesWS values(2024.01.01T10:00:20.000, `B, 16, 104.0)\ninsert into tradesWS values(2024.01.01T10:00:40.000, `A, 20, 101.0)\ninsert into tradesWS values(2024.01.01T10:01:10.000, `A, 15, 102.0)\ninsert into tradesWS values(2024.01.01T10:01:20.000, `B, 20, 105.0)\ninsert into tradesWS values(2024.01.01T10:02:05.000, `A, 30, 103.0)\ninsert into tradesWS values(2024.01.01T10:03:10.000, `A, 12, 104.0)\n\nsleep(10)\nselect * from outputWS\n```\n\n输出如下：\n\n| time                    | sym | sum1m | avgPrice3m |\n| ----------------------- | --- | ----- | ---------- |\n| 2024.01.01 10:01:00.000 | A   | 30    | 100.5      |\n| 2024.01.01 10:01:00.000 | B   | 16    | 104        |\n| 2024.01.01 10:02:00.000 | A   | 15    | 101        |\n| 2024.01.01 10:03:00.000 | A   | 30    | 101.5      |\n\n其中：\n\n* `windowSize=[60000, 180000]` 分别对应 1 分钟和 3 分钟窗口。\n\n* *metrics* 的第一个元素对应 1 分钟窗口，第二个元素对应 3 分钟窗口。\n\n* 输出表中两个结果列分别保存不同窗口长度下的聚合结果。\n\n例7. 设置 *roundTime* 和 *step* 控制窗口的规整方式。\n\n当时间精度为毫秒或秒，且 *step* 大于 1 分钟时，*roundTime* 会影响首个窗口边界的规整结果。本例使用两个参数相同、仅 *roundTime* 不同的引擎进行对比。\n\n```\nshare streamTable(1000:0, [\"time\",\"volume\"], [TIMESTAMP, INT]) as tradesRT\nshare table(1000:0, [\"time\",\"sumVolume\"], [TIMESTAMP, INT]) as outputRTTrue\nshare table(1000:0, [\"time\",\"sumVolume\"], [TIMESTAMP, INT]) as outputRTFalse\n\nengineRTTrue = createTimeSeriesEngine(\n   name=\"engineRTTrue\",\n   windowSize=240000,\n   step=120000,\n   metrics=<[sum(volume) as sumVolume]>,\n   dummyTable=tradesRT,\n   outputTable=outputRTTrue,\n   timeColumn=\"time\",\n   useSystemTime=false,\n   roundTime=true\n)\n\nengineRTFalse = createTimeSeriesEngine(\n   name=\"engineRTFalse\",\n   windowSize=240000,\n   step=120000,\n   metrics=<[sum(volume) as sumVolume]>,\n   dummyTable=tradesRT,\n   outputTable=outputRTFalse,\n   timeColumn=\"time\",\n   useSystemTime=false,\n   roundTime=false\n)\n\nsubscribeTable(tableName=\"tradesRT\", actionName=\"engineRTTrue\", offset=0, handler=append!{engineRTTrue}, msgAsTable=true)\nsubscribeTable(tableName=\"tradesRT\", actionName=\"engineRTFalse\", offset=0, handler=append!{engineRTFalse}, msgAsTable=true)\n\ninsert into tradesRT values(2024.01.01T10:03:30.500, 10)\ninsert into tradesRT values(2024.01.01T10:04:20.000, 20)\ninsert into tradesRT values(2024.01.01T10:06:01.000, 5)\n```\n\n对于 *roundTime*=true 的引擎，执行 `select * from outputRTTrue`，输出如下：\n\n| time                    | sumVolume |\n| ----------------------- | --------- |\n| 2024.01.01 10:04:00.000 | 10        |\n| 2024.01.01 10:06:00.000 | 30        |\n\n对于 *roundTime*=false 的引擎，执行 `select * from outputRTFalse`，输出如下：\n\n| time                    | sumVolume |\n| ----------------------- | --------- |\n| 2024.01.01 10:05:00.000 | 30        |\n\n* 本例中第一条数据时间为 `x=2024.01.01T10:03:30.500`；*windowSize* 为 240000（4 分钟）。\n\n* 当 *roundTime*=true 时，*step*=120000 属于毫秒精度下的 60001\\~120000 区间，对应的 alignmentSize 为 120000（2 分钟）。先将 x 按 2 分钟规整：`timestamp(x/120000*120000)=2024.01.01T10:02:00.000`；再代入公式得到左边界 `2024.01.01T10:02:00.000 + 120000 - 240000 = 2024.01.01T10:00:00.000`，所以首个窗口为 \\[10:00:00.000, 10:04:00.000)。\n\n* 当 *roundTime*=false 时，数据为毫秒精度且 *step*>30000，对应的 alignmentSize 为 60000（1 分钟）。先将 x 按 1 分钟规整：`timestamp(x/60000*60000)=2024.01.01T10:03:00.000`；再代入公式得到左边界 `2024.01.01T10:03:00.000 + 120000 - 240000 = 2024.01.01T10:01:00.000`，所以首个窗口为 \\[10:01:00.000, 10:05:00.000)。\n\n* 10:03:30.500 这条记录在两种设置下都落入首个窗口，但首个窗口的起止范围不同；进一步地，10:04:20.000 在 *roundTime*=true 时落入下一个窗口 \\[10:02, 10:06)，而在 *roundTime*=false 时仍落入首个窗口 \\[10:01, 10:05)。\n\n例8. 设置 *closed* 控制边界点归属\n\n*closed*='left' 表示左闭右开，*closed*='right' 表示左开右闭。若数据恰好落在窗口边界上，不同设置会影响该数据属于哪个窗口。\n\n```\nshare streamTable(1000:0, [\"time\",\"volume\"], [TIMESTAMP, INT]) as tradesCL\nshare table(1000:0, [\"time\",\"sumVolume\"], [TIMESTAMP, INT]) as outputLeft\nshare table(1000:0, [\"time\",\"sumVolume\"], [TIMESTAMP, INT]) as outputRight\n\nengineLeft = createTimeSeriesEngine(\n   name=\"engineLeft\",\n   windowSize=60000,\n   step=60000,\n   metrics=<[sum(volume) as sumVolume]>,\n   dummyTable=tradesCL,\n   outputTable=outputLeft,\n   timeColumn=\"time\",\n   useSystemTime=false,\n   closed=\"left\"\n)\n\nengineRight = createTimeSeriesEngine(\n   name=\"engineRight\",\n   windowSize=60000,\n   step=60000,\n   metrics=<[sum(volume) as sumVolume]>,\n   dummyTable=tradesCL,\n   outputTable=outputRight,\n   timeColumn=\"time\",\n   useSystemTime=false,\n   closed=\"right\"\n)\n\nsubscribeTable(tableName=\"tradesCL\", actionName=\"engineLeft\", offset=0, handler=append!{engineLeft}, msgAsTable=true)\nsubscribeTable(tableName=\"tradesCL\", actionName=\"engineRight\", offset=0, handler=append!{engineRight}, msgAsTable=true)\n\ninsert into tradesCL values(2024.01.01T10:00:10.000, 10)\ninsert into tradesCL values(2024.01.01T10:01:00.000, 20)\ninsert into tradesCL values(2024.01.01T10:01:10.000, 1)\n```\n\n对于 *closed*=\"left\" 的引擎， 执行 `select * from outputLeft`，输出如下：\n\n| time                    | sumVolume |\n| ----------------------- | --------- |\n| 2024.01.01 10:01:00.000 | 10        |\n\n对于 *closed*=\"right\" 的引擎，执行 `select * from outputRight`，输出如下\n\n| time                    | sumVolume |\n| ----------------------- | --------- |\n| 2024.01.01 10:01:00.000 | 30        |\n\n* *closed*=\"left\" 时，第 2 条记录的时间正好是 10:01:00.000，属于下一个窗口 \\[10:01, 10:02)，因此第一个窗口只统计到 10。\n\n* *closed*=\"right\" 时，同一条边界数据属于前一个窗口 (10:00, 10:01]，因此第一个窗口统计结果变为 `10 + 20 = 30`。\n\n例9. 设置 *outputElapsedMicroseconds* 与 *acceptedDelay*\n\n* 通过 *acceptedDelay* 接收窗口结束后一定范围内到达的乱序数据；\n\n* 通过 *outputElapsedMicroseconds*=true 输出每个结果从触发计算到写出结果的耗时。\n\n```\nshare streamTable(1000:0, [\"time\",\"sym\",\"volume\"], [TIMESTAMP, SYMBOL, INT]) as tradesAD\nshare table(1000:0, [\"time\",\"sym\",\"elapsedUs\",\"sumVolume\"], [TIMESTAMP, SYMBOL, LONG, INT]) as outputAD\n\nengineAD = createTimeSeriesEngine(\n   name=\"engineAD\",\n   windowSize=60000,\n   step=60000,\n   metrics=<[sum(volume) as sumVolume]>,\n   dummyTable=tradesAD,\n   outputTable=outputAD,\n   timeColumn=\"time\",\n   keyColumn=\"sym\",\n   useSystemTime=false,\n   acceptedDelay=5000,\n   outputElapsedMicroseconds=true\n)\n\nsubscribeTable(tableName=\"tradesAD\", actionName=\"engineAD\", offset=0, handler=append!{engineAD}, msgAsTable=true)\n\ninsert into tradesAD values(2024.01.01T10:00:10.000, `A, 10)\ninsert into tradesAD values(2024.01.01T10:00:40.000, `A, 20)\ninsert into tradesAD values(2024.01.01T10:01:02.000, `A, 1)\ninsert into tradesAD values(2024.01.01T10:00:55.000, `A, 30)\ninsert into tradesAD values(2024.01.01T10:01:06.000, `A, 2)\n\nsleep(10)\nselect * from outputAD\n```\n\n输出如下：\n\n| time                    | sym | elapsedUs | sumVolume |\n| ----------------------- | --- | --------- | --------- |\n| 2024.01.01 10:01:00.000 | A   | 2         | 60        |\n\n* 本例中窗口为 \\[10:00:00, 10:01:00)。\n\n* 当 *acceptedDelay*=5000 时，窗口在结束后的 5 秒内仍可接收迟到数据。\n\n* 第 4 条记录 10:00:55.000 虽然晚于 10:01:02.000 到达，但仍在允许延迟范围内，因此仍计入第一个窗口。\n\n* 第 5 条记录时间为 10:01:06.000，满足“收到时间戳大于等于当前窗口结束的时间戳 + acceptedDelay 的数据”这一条件，因此触发第一个窗口输出，结果为 10 + 20 + 30 = 60。\n\n例10. 设置 outputHandler 与 msgAsTable\n\n设置 *outputHandler* 后，引擎计算结果不会写入 outputTable，而是调用定义的一元函数处理计算结果。*msgAsTable* 用于控制回调参数的结构：\n\n* *msgAsTable*=false：回调参数是由各列组成的元组；\n\n* *msgAsTable*=true：回调参数是一个表。\n\n```\nshare streamTable(1000:0, [\"time\",\"volume\"], [TIMESTAMP, INT]) as tradesOH\nshare table(1000:0, [\"time\",\"sumVolume\"], [TIMESTAMP, INT]) as ignoredTuple\nshare table(1000:0, [\"time\",\"sumVolume\"], [TIMESTAMP, INT]) as ignoredTable\nshare table(1000:0, [\"time\",\"sumVolume\"], [TIMESTAMP, INT]) as tupleResult\nshare table(1000:0, [\"time\",\"sumVolume\"], [TIMESTAMP, INT]) as tableResult\n\ndef handleTuple(msg){\n   tupleResult.tableInsert(msg[0],msg[1])\n}\n\ndef handleTable(msg){\n   tableResult.append!(msg)\n}\n\nengineTuple = createTimeSeriesEngine(\n   name=\"engineTuple\",\n   windowSize=60000,\n   step=60000,\n   metrics=<[sum(volume) as sumVolume]>,\n   dummyTable=tradesOH,\n   outputTable=ignoredTuple,\n   timeColumn=\"time\",\n   useSystemTime=false,\n   outputHandler=handleTuple,\n   msgAsTable=false\n)\n\nengineTable = createTimeSeriesEngine(\n   name=\"engineTable\",\n   windowSize=60000,\n   step=60000,\n   metrics=<[sum(volume) as sumVolume]>,\n   dummyTable=tradesOH,\n   outputTable=ignoredTable,\n   timeColumn=\"time\",\n   useSystemTime=false,\n   outputHandler=handleTable,\n   msgAsTable=true\n)\n\nsubscribeTable(tableName=\"tradesOH\", actionName=\"engineTuple\", offset=0, handler=append!{engineTuple}, msgAsTable=true)\nsubscribeTable(tableName=\"tradesOH\", actionName=\"engineTable\", offset=0, handler=append!{engineTable}, msgAsTable=true)\n\ninsert into tradesOH values(2024.01.01T10:00:10.000, 10)\ninsert into tradesOH values(2024.01.01T10:00:40.000, 20)\ninsert into tradesOH values(2024.01.01T10:01:10.000, 5)\n```\n\n分别执行 `select * from tupleResult` 和 `select * from tableResult`。\n\ntupleResult 和 tableResult 的结果都为：\n\n| time                    | sumVolume |\n| ----------------------- | --------- |\n| 2024.01.01 10:01:00.000 | 30        |\n\n* engineTuple 中，`handleTuple` 接收到的是列元组，一元函数中使用 `tableInsert` 将 `msg[0]` 和 `msg[1]` 插入到目标表。\n\n* engineTable 中，`handleTable` 直接接收到结果表，一元函数中使用 `append!` 将结果表插入到目标表。\n\n分别执行 `select * from ignoredTuple` 和 `select * from ignoredTable`，输出结果均为空。这是因为设置了 *outputHandler*，计算结果不会写入 ignoredTuple 和 ignoredTable。\n\n**Related information**\n\n[createDailyTimeSeriesEngine](https://docs.dolphindb.cn/zh/funcs/c/createDailyTimeSeriesEngine.html)\n"
    },
    "createUser": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/createUser.html",
        "signatures": [
            {
                "full": "createUser(userId, password, [groupIds], [isAdmin=false], [authMode])",
                "name": "createUser",
                "parameters": [
                    {
                        "full": "userId",
                        "name": "userId"
                    },
                    {
                        "full": "password",
                        "name": "password"
                    },
                    {
                        "full": "[groupIds]",
                        "name": "groupIds",
                        "optional": true
                    },
                    {
                        "full": "[isAdmin=false]",
                        "name": "isAdmin",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[authMode]",
                        "name": "authMode",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [createUser](https://docs.dolphindb.cn/zh/funcs/c/createUser.html)\n\n\n\n#### 语法\n\ncreateUser(userId, password, \\[groupIds], \\[isAdmin=false], \\[authMode])\n\n#### 详情\n\n创建用户。\n\n*groupIds* 表示的组必须是已经创建了的组。\n\n**Note:** 该函数只能由管理员运行。\n\n#### 参数\n\n**userId** 是表示用户名的字符串。是表示用户名的字符串。只能包含字母、数字、下划线（\\_）、或短横线（-），且必须以字母开头，长度不得超过 30 个字符。\n\n**password** 是表示用户密码的字符串。它不能包含空格或控制字符。\n\n从 2.00.10.10 开始，用户可以通过配置项 *enhancedSecurityVerification* 控制是否对 password 进行复杂性校验。若不设置 *enhancedSecurityVerification*，则不校验；若设置 *enhancedSecurityVerification*=true，则要求密码必须满足以下条件：\n\n* 字符个数为8\\~20\n\n* 至少包含一个大写字母\n\n* 至少包含以下字符之一：!\"#$%&'()\\*+,-./:;<=>?@\\[]^\\_\\`{|}\\~。\n\n**groupIds** 可选参数，是表示用户所属组的字符串标量或向量。\n\n**isAdmin** 可选参数，是表示用户是否为管理员的布尔值。\n\n**authMode**可选参数，指定该用户的登录认证方式。默认为”sha256”，即用户通过 `login` 函数登录，使用 SHA-256 算法认证。另支持指定为”scram”，使用 SCRAM (Salted Challenge Response Authentication Mechanism) 协议登录。\n\n**Note:**\n\n* SCRAM 基于 [IETF's RFC 5802 标准](https://datatracker.ietf.org/doc/html/rfc5802)实现，通过高强度的哈希算法，双向验证等措施，为用户通过密码登录的方式提供更高的安全性。\n* DolphinDB 的 API 已支持 SCRAM 认证方式：\n  * 通过 API 的原生方法连接 DolphinDB 服务器时， API 端将优先采用 SCRAM 方式登录。\n  * 如该用户未启用 SCRAM 认证，则自动回退至默认登录方式。\n* 若不使用 API 提供的封装好的接口，自行使用 SCRAM 登录时，需调用 DolphinDB 服务端函数 scramClientFirst和 scramClientFinal。具体流程与配置要求请见对应函数文档。\n* 启用 SCRAM 认证后，`login`, `resetPwd`, `changePwd` 等密码相关函数仍然有效。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n创建一个名称为 \"JohnSmith\"，密码为 'Qb0507#$' 的非管理员用户，登录时默认使用 SHA-256 算法进行认证。该用户属于组 \"research\" 和组 \"production\"。\n\n```\ncreateUser(`JohnSmith, \"Qb0507#$\", `research`production);\n```\n"
    },
    "createWindowJoinEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/createWindowJoinEngine.html",
        "signatures": [
            {
                "full": "createWindowJoinEngine(name, leftTable, rightTable, outputTable, window, metrics, matchingColumn, [timeColumn], [useSystemTime=false], [garbageSize = 5000], [maxDelayedTime], [nullFill], [outputElapsedMicroseconds=false], [sortByTime], [closed], [snapshotDir], [snapshotIntervalInMsgCount], [cachedTableCapacity=1024], [keyPurgeFreqInSec], [timeoutTrigger])",
                "name": "createWindowJoinEngine",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "leftTable",
                        "name": "leftTable"
                    },
                    {
                        "full": "rightTable",
                        "name": "rightTable"
                    },
                    {
                        "full": "outputTable",
                        "name": "outputTable"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "metrics",
                        "name": "metrics"
                    },
                    {
                        "full": "matchingColumn",
                        "name": "matchingColumn"
                    },
                    {
                        "full": "[timeColumn]",
                        "name": "timeColumn",
                        "optional": true
                    },
                    {
                        "full": "[useSystemTime=false]",
                        "name": "useSystemTime",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[garbageSize = 5000]",
                        "name": "[garbageSize = 5000]"
                    },
                    {
                        "full": "[maxDelayedTime]",
                        "name": "maxDelayedTime",
                        "optional": true
                    },
                    {
                        "full": "[nullFill]",
                        "name": "nullFill",
                        "optional": true
                    },
                    {
                        "full": "[outputElapsedMicroseconds=false]",
                        "name": "outputElapsedMicroseconds",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[sortByTime]",
                        "name": "sortByTime",
                        "optional": true
                    },
                    {
                        "full": "[closed]",
                        "name": "closed",
                        "optional": true
                    },
                    {
                        "full": "[snapshotDir]",
                        "name": "snapshotDir",
                        "optional": true
                    },
                    {
                        "full": "[snapshotIntervalInMsgCount]",
                        "name": "snapshotIntervalInMsgCount",
                        "optional": true
                    },
                    {
                        "full": "[cachedTableCapacity=1024]",
                        "name": "cachedTableCapacity",
                        "optional": true,
                        "default": "1024"
                    },
                    {
                        "full": "[keyPurgeFreqInSec]",
                        "name": "keyPurgeFreqInSec",
                        "optional": true
                    },
                    {
                        "full": "[timeoutTrigger]",
                        "name": "timeoutTrigger",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [createWindowJoinEngine](https://docs.dolphindb.cn/zh/funcs/c/createWindowJoinEngine.html)\n\n\n\n#### 语法\n\ncreateWindowJoinEngine(name, leftTable, rightTable, outputTable, window, metrics, matchingColumn, \\[timeColumn], \\[useSystemTime=false], \\[garbageSize = 5000], \\[maxDelayedTime], \\[nullFill], \\[outputElapsedMicroseconds=false], \\[sortByTime], \\[closed], \\[snapshotDir], \\[snapshotIntervalInMsgCount], \\[cachedTableCapacity=1024], \\[keyPurgeFreqInSec], \\[timeoutTrigger])\n\n#### 详情\n\n创建流数据 window join 引擎。返回一个左、右两表实时 [window join](https://docs.dolphindb.cn/zh/progr/sql/windowjoin.html) 后的表对象。\n\n该引擎与 window join 存在以下区别：\n\n* window join 仅支持聚合计算，window join 引擎支持聚合计算，也支持非聚合计算。\n* 计算指标中的列未指定表名时，window join 默认取右表列，而 window join 引擎默认取左表列。\n\n注入 window join 引擎左、右两表的数据，根据 *matchingColumn* 分组。在各分组内，左表的每条记录，都会同右表中一个时间区间（即窗口）内的数据进行连接，并根据指定的 *metrics* 计算窗口内的数据并输出。\n\n* 普通窗口（*window* 不为 0:0）：\n\n  右表的计算窗口将由左表当前数据的时间戳和 *window* 确定。假设左表当前记录的时间戳为 t，*window* 为 a:b，则右表时间戳属于 \\[t+a, t+b] 的数据将与左表当前记录连接并计算输出。\n\n  触发计算的规则：\n\n  * *useSystemTime*=false：\n    * \\*\\*同组数据触发：\\*\\*各分组当前窗口数据的计算将由该窗口结束后的第一条属于该分组的数据触发。触发计算的数据不参与该窗口的计算。\n    * \\*\\*其它分组数据触发：\\*\\*对于某个分组中未发生计算的窗口，若其窗口右边界 + *maxDelayedTime* < 右表最新收到的任意一个分组数据的时间戳，则该窗口的计算将被新收到的这条数据触发。\n  * *useSystemTime*=true：当系统时间到达各分组未发生计算的窗口的右边界时，触发该窗口的计算。\n* 特殊窗口（*window* 为 0:0）：\n\n  右表的计算窗口将由左表当前数据和其上一条数据的时间戳决定。默认情况下，该窗口左闭右开，假设左表当前记录的时间戳为 t，上一条记录的时间戳为 t0，则右表计算窗口为 \\[t0, t)。可以通过指定参数 *closed* = “right”，设置窗口为左开右闭。 触发计算的规则：\n\n  * *useSystemTime*=false：各分组当前窗口数据的计算将由窗口结束后的第一条属于该分组的右表数据触发。\n  * *useSystemTime*=true：各个分组收到的左表数据将触发对应分组窗口的数据计算输出。\n\n**Note:**\n\n*window*=0:0 时，若 *metrics* 中指定了非聚合的指标，其输出列必须为对应类型的 array vector。\n\n更多流数据引擎的应用场景说明可以参考 [流计算引擎](https://docs.dolphindb.cn/zh/funcs/themes/streamingEngine.html)。\n\n#### 参数\n\n**name** 必选参数，表示 window join 引擎的名称，作为其在一个数据节点/计算节点上的唯一标识。可包含字母，数字和下划线，但必须以字母开头。\n\n**leftTable** 表对象。可以不包含数据，但结构必须与输入的流数据表相同。2.00.9.3 版本开始支持 array vector 类型。\n\n**rightTable** 表对象。可以不包含数据，但结构必须与输入的流数据表相同。\n\n**outputTable** 必选参数，为计算结果的输出表。window join 引擎会将计算结果插入该表。\n\n* 输出表各列的顺序如下：\n  1. 时间列。其中：\n     * 若 *useSystemTime* = true，为 TIMESTAMP 类型；\n     * 若 *useSystemTime* = false，数据类型与 *timeColumn* 列一致。\n  2. 连接列。与 *matchingColumn* 中的列以及其顺序一致，可为多列。\n  3. 计算结果列。可为多列。\n  4. 耗时列。若指定 *outputElapsedMicroseconds* = true，则需要增加一个 LONG 类型和一个 INT 类型的列，分别用于存储引擎内部每个 batch 的数据耗时（单位：微秒）和记录数。\n\n**window** 必选参数，表示滑动窗口区间的整型或 DURATION 数据对，其中左右边界都包含在内。\n\n**metrics** 以元代码的格式表示计算指标，支持输入元组。有关元代码的更多信息可参考 [元编程](https://docs.dolphindb.cn/zh/progr/objs/meta_progr.html)。\n\n* 计算指标可以是一个或多个表达式、系统内置或用户自定义函数。\n* *metrics* 内支持调用具有多个返回值的函数，且必须指定列名，例如 \\<func(price) as \\`col1\\`col2>。\n\n  若在 *metrics* 指定了 *leftTable* 和 *rightTable* 中具有相同名称的列，默认取左表的列，可以通过 \"tableName.colName\" 指定该列来自哪个表。\n\n  **Note:**\n\n  * *metrics* 中使用的列名大小写不敏感，不要求与输入表的列名大小写保持一致。\n  * 在需要输出 array vector 类型结果时，需要显式指定 `toArray` 函数转换类型。\n  * 支持使用 `toColumnarTuple` 函数，将非聚合计算结果转换为列式元组（columnar tuple）。\n  * 当以下函数只计算 *rightTable* 中的数据列时，window join 引擎对它们进行了优化：sum, sum2, avg, std, var, corr, covar, wavg, wsum, beta, max, min, last, first, med, percentile。\n\n**matchingColumn** 表示连接列的字符串标量/向量/tuple，支持 Integral, Temporal 或 Literal（UUID 除外）类型。*matchingColumn* 指定规则为：\n\n1. 只有一个连接列：当左表和右表的连接列名相同时，*matchingColumn* 是一个字符串标量，否则是一个长度为 2 的 tuple，例如：左表连接列名为 sym，右表连接列名为 sym1，则 *matchingColumn* = \\[\\[\\`sym],\\[\\`sym1]]。\n2. 有多个连接列：当左表和右表的连接列名相同时，*matchingColumn* 是一个字符串向量，否则是一个长度为 2 的 tuple，例如：左表连接列名为 timestamp, sym，右表连接列名为 timestamp, sym1，则 *matchingColumn* = \\[\\[\\`timestamp, \\`sym], \\[\\`timestamp,\\`sym1]]。\n\n**timeColumn** 可选参数，当 *useSystemTime* = false 时，指定要连接的两个表中时间列的名称。*leftTable* 和 *rightTable* 时间列名称可以不同，但数据类型需保持一致。当 *leftTable* 和 *rightTable* 时间列名称不同时，*timeColumn* 为一个长度为2的字符串向量。\n\n**useSystemTime** 可选参数，表示 *outputTable* 中第一列（时间列）为系统当前时间（*useSystemTime* = true）或左表的时间列（*useSystemTime* = false）。\n\n**garbageSize** 可选参数，是正整数，默认值是5,000（单位为行）。随着订阅的流数据不断积累进入 window join 引擎，存放在内存中的数据会越来越多，这时需要清理不再需要的历史数据。当左/右两表各个分组内的数据行数超过 *garbageSize* 值时，系统会清理本次计算不需要的历史数据。\n\n**maxDelayedTime** 可选参数，是正整数，用于触发引擎中长时间未输出的分组数据进行计算。 具体来说，若`(某个分组中未发生计算的窗口右边界) + (maxDelayedTime) < (右表最新收到的任意一个分组数据的时间戳)`，则这条数据会触发该窗口计算输出。\n\n指定该参数时，必须同时指定 timeColumn，且两者的单位需一致。默认值为3秒，根据 *`timeColumn`* 的精度换算。例如，若 *timeColumn* 的精度是毫秒，则默认值为3000毫秒。\n\n**nullFill** 和输出表列字段等长且类型一一对应的元组，用于填充以下列中的空值：输出表中包含的左表列、右表列、右表列被聚合计算后的计算结果列。\n\n**outputElapsedMicroseconds** 布尔值，表示是否输出每个 batch 中数据从注入引擎到计算输出的总耗时，以及每个 batch 包含的总记录数，默认为 false。指定参数 *outputElapsedMicroseconds* = true 后，在定义 *outputTables* 时需要在最后增加两列，详见 *outputTable* 参数说明。\n\n**sortByTime** 布尔值，表示是否按全局时间顺序输出数据。默认值为 false，表示不按全局时间输出数据，仅在组内按时间顺序输出数据。注意：当设置 sortByTime=true 时，必须保证输入的左表和右表的数据全局有序，且不可设置 *maxDelayedTime*。\n\n**closed** 字符串，用于确定窗口边界的开闭情况，仅当 *window*为 0:0 时有效 。可选值为 ‘left’ 或 ‘right’，默认值为 ‘left’。\n\n* closed = ‘left’： 窗口左闭右开。\n* closed = ‘right’： 窗口左开右闭。此时必须设置 useSystemTime=false 。\n\n若要开启快照机制（snapshot），必须指定 *snapshotDir* 与 *snapshotIntervalInMsgCount*。\n\n**snapshotDir** 可选参数，字符串，表示保存引擎快照的文件目录。\n\n* 指定的目录必须存在，否则系统会提示异常。\n* 创建流数据引擎时，如果指定了 *snapshotDir*，会检查该目录下是否存在快照。如果存在，会加载该快照，恢复引擎的状态。\n* 多个引擎可以指定同一个目录存储快照，用引擎的名称来区分快照文件。\n* 一个引擎的快照可能会使用三个文件名：\n  * 临时存储快照信息：文件名为 \\<engineName>.tmp；\n  * 快照生成并刷到磁盘：文件保存为 \\<engineName>.snapshot；\n  * 存在同名快照：旧快照自动重命名为 \\<engineName>.old。\n\n**snapshotIntervalInMsgCount** 可选参数，为整数类型，表示每隔多少条数据保存一次流数据引擎快照。\n\n**cachedTableCapacity**可选参数，为正整数，表示引擎为每个不同的分组分别创建的左缓存表和右缓存表的初始容量（以数据条数计）。默认值为 1024。\n\n**keyPurgeFreqInSec**可选参数，为正整数，单位为秒，表示间隔多久检查一次可以清理的分组。*window*=0:0 时不会触发清理。可以清理的分组判断规则如下：\n\n* 左缓存表无未计算的数据，且 `该分组的右缓存表最后一条数据的时间戳 < 右表最新收到的任意一个分组数据的时间戳- maxDelayedTime - window长度` 或 `右缓存表为空`，则该分组可以清理。\n* 待清理的分组数大于等于总分组数的 10% 时，触发清理。\n\n**timeoutTrigger** 可选参数，为布尔标量，表示当右表在较长时间内无数据输入时，是否主动触发计算。开启后可确保所有数据均能在`其窗口的右边界 + [1,3) * maxDelayedTime`时间范围内触发计算。启用*timeoutTrigger* 时，需满足以下条件：\n\n* *useSystemTime*=false\n\n* *sortByTime*=false\n\n* *maxDelayedTime*为正整数。\n\n#### 返回值\n\n返回一个表对象。\n\n#### 例子\n\n```\nshare streamTable(1:0, `time`sym`price, [TIMESTAMP, SYMBOL, DOUBLE]) as leftTable\nshare streamTable(1:0, `time`sym`val, [TIMESTAMP, SYMBOL, DOUBLE]) as rightTable\nshare table(100:0, `time`sym`factor1`factor2`factor3, [TIMESTAMP, SYMBOL, DOUBLE, DOUBLE, DOUBLE]) as output\n\nnullFill= [2012.01.01T00:00:00.000, `NONE, 0.0, 0.0, 0.0]\nwjEngine=createWindowJoinEngine(name=\"test1\", leftTable=leftTable, rightTable=rightTable, outputTable=output,  window=-2:2, metrics=<[price,val,sum(val)]>, matchingColumn=`sym, timeColumn=`time, useSystemTime=false,nullFill=nullFill)\n\nsubscribeTable(tableName=\"leftTable\", actionName=\"joinLeft\", offset=0, handler=appendForJoin{wjEngine, true}, msgAsTable=true)\nsubscribeTable(tableName=\"rightTable\", actionName=\"joinRight\", offset=0, handler=appendForJoin{wjEngine, false}, msgAsTable=true)\n\nn=10\ntp1=table(take(2012.01.01T00:00:00.000+0..10, 2*n) as time, take(`A, n) join take(`B, n) as sym, take(NULL join rand(10.0, n-1),2*n) as price)\ntp1.sortBy!(`time)\nleftTable.append!(tp1)\n\ntp2=table(take(2012.01.01T00:00:00.000+0..10, 2*n) as time, take(`A, n) join take(`B, n) as sym, take(double(1..n),2*n) as val)\ntp2.sortBy!(`time)\nrightTable.append!(tp2)\n\nselect * from output where time between 2012.01.01T00:00:00.000:2012.01.01T00:00:00.001\n```\n\n| time                    | sym | factor1 | factor2 | factor3 |\n| ----------------------- | --- | ------- | ------- | ------- |\n| 2012.01.01T00:00:00.000 | A   | 0       | 1       | 6       |\n| 2012.01.01T00:00:00.000 | A   | 0       | 2       | 6       |\n| 2012.01.01T00:00:00.000 | A   | 0       | 3       | 6       |\n| 2012.01.01T00:00:00.001 | A   | 5.2705  | 1       | 10      |\n| 2012.01.01T00:00:00.001 | A   | 5.2705  | 2       | 10      |\n| 2012.01.01T00:00:00.001 | A   | 5.2705  | 3       | 10      |\n| 2012.01.01T00:00:00.001 | A   | 5.2705  | 4       | 10      |\n| 2012.01.01T00:00:00.000 | B   | 5.2705  | 2       | 9       |\n| 2012.01.01T00:00:00.000 | B   | 5.2705  | 3       | 9       |\n| 2012.01.01T00:00:00.000 | B   | 5.2705  | 4       | 9       |\n| 2012.01.01T00:00:00.001 | B   | 1.0179  | 2       | 14      |\n| 2012.01.01T00:00:00.001 | B   | 1.0179  | 3       | 14      |\n| 2012.01.01T00:00:00.001 | B   | 1.0179  | 4       | 14      |\n| 2012.01.01T00:00:00.001 | B   | 1.0179  | 5       | 14      |\n\n下例展示特殊窗口的计算：\n\n```\nshare streamTable(1:0, `time`sym`price, [TIMESTAMP, SYMBOL, DOUBLE]) as leftTable\nshare streamTable(1:0, `time`sym`val, [TIMESTAMP, SYMBOL, DOUBLE]) as rightTable\n\nv = [1, 5, 10, 15]\ntp1=table(2012.01.01T00:00:00.000+v as time, take(`A   , 4) as sym, rand(10.0,4) as price)\n\nv = [1, 2, 3, 4, 5, 6, 9, 15]\ntp2=table(2012.01.01T00:00:00.000+v as time, take(`A   , 8) as sym, rand(10.0,8) as val)\n\nshare table(100:0, `time`sym`price`val`sum_val, [TIMESTAMP, SYMBOL, DOUBLE, DOUBLE[], DOUBLE]) as output\nwjEngine=createWindowJoinEngine(name=\"test1\", leftTable=leftTable, rightTable=rightTable, outputTable=output,  window=0:0, metrics=<[price, val, sum(val)]>, matchingColumn=`sym, timeColumn=`time, useSystemTime=false)\n\nsubscribeTable(tableName=\"leftTable\", actionName=\"joinLeft\", offset=0, handler=appendForJoin{wjEngine, true}, msgAsTable=true)\nsubscribeTable(tableName=\"rightTable\", actionName=\"joinRight\", offset=0, handler=appendForJoin{wjEngine, false}, msgAsTable=true)\n\nleftTable.append!(tp1)\nrightTable.append!(tp2)\n```\n\n| time                    | sym | price  | val                               | sum\\_val |\n| ----------------------- | --- | ------ | --------------------------------- | -------- |\n| 2012.01.01T00:00:00.001 | A   | 8.8252 | \\[]                               |          |\n| 2012.01.01T00:00:00.005 | A   | 7.1195 | \\[7.495792,9.417891,1.419681,...] | 21.3741  |\n| 2012.01.01T00:00:00.010 | A   | 5.2217 | \\[4.840462,8.086567,3.495306]     | 16.4223  |\n| 2012.01.01T00:00:00.015 | A   | 9.2517 | \\[]                               |          |\n\n当 window=0:0 时，默认情况下，该窗口左闭右开。下例中指定参数 *closed* = \"right\"，将窗口设置为左开右闭。\n\n```\nunsubscribeTable(tableName=\"leftTable\", actionName=\"joinLeft\")\nunsubscribeTable(tableName=\"rightTable\", actionName=\"joinRight\")\nundef(`leftTable,SHARED)\nundef(`rightTable,SHARED)\ndropAggregator(name=\"test1\")\n\nshare streamTable(1:0, `time`sym`price, [TIMESTAMP, SYMBOL, DOUBLE]) as leftTable\nshare streamTable(1:0, `time`sym`val, [TIMESTAMP, SYMBOL, DOUBLE]) as rightTable\n\nv1 = [1, 5, 10, 15]\ntp1=table(2012.01.01T00:00:00.000+v1 as time, take(`A, 4) as sym, rand(10.0,4) as price)\n\nv2 = [1, 2, 3, 4, 5, 6, 9, 15]\ntp2=table(2012.01.01T00:00:00.000+v2 as time, take(`A, 8) as sym, rand(10.0,8) as val)\n\nshare table(100:0, `time`sym`price`val`sum_val, [TIMESTAMP, SYMBOL, DOUBLE, DOUBLE[], DOUBLE]) as output\nwjEngine=createWindowJoinEngine(name=\"test1\", leftTable=leftTable, rightTable=rightTable, outputTable=output,  window=0:0, metrics=<[price, val, sum(val)]>, matchingColumn=\"sym\", timeColumn=\"time\", useSystemTime=false, closed=\"right\")\n\nsubscribeTable(tableName=\"leftTable\", actionName=\"joinLeft\", offset=0, handler=appendForJoin{wjEngine, true}, msgAsTable=true)\nsubscribeTable(tableName=\"rightTable\", actionName=\"joinRight\", offset=0, handler=appendForJoin{wjEngine, false}, msgAsTable=true)\n\nleftTable.append!(tp1)\nrightTable.append!(tp2)\nsleep(100)\nselect * from output\n```\n\n返回：\n\n```\ntime\t                  sym\tprice\tval\t                      sum_val\n2012.01.01T00:00:00.001\tA\t9.7366\t[7.8310]\t                  7.831\n2012.01.01T00:00:00.005\tA\t2.6537\t[1.8564,4.6238,8.2536,3.1028]     17.8368\n2012.01.01T00:00:00.010\tA\t3.9586\t[0.8413,8.0684]\t           8.9098\n```\n\n下例展示指定 *sortByTime* = true 时，引擎将按时间顺序输出数据。\n\n```\n//清理引擎及变量\nunsubscribeTable(tableName=\"leftTable\", actionName=\"joinLeft\")\nunsubscribeTable(tableName=\"rightTable\", actionName=\"joinRight\")\nundef(`leftTable,SHARED)\nundef(`rightTable,SHARED)\ndropAggregator(name=\"test1\")\n\n//定义引擎\nshare streamTable(1:0, `time`sym`price, [TIMESTAMP, SYMBOL, DOUBLE]) as leftTable\nshare streamTable(1:0, `time`sym`val, [TIMESTAMP, SYMBOL, DOUBLE]) as rightTable\nshare table(100:0, `time`sym`factor1`factor2`factor3, [TIMESTAMP, SYMBOL, DOUBLE, DOUBLE, DOUBLE]) as output\nnullFill= [2012.01.01T00:00:00.000, `NONE, 0.0, 0.0, 0.0]\nwjEngine=createWindowJoinEngine(name=\"test1\", leftTable=leftTable, rightTable=rightTable, outputTable=output,  window=-2:2, metrics=<[price,val,sum(val)]>, matchingColumn=`sym, timeColumn=`time, useSystemTime=false,nullFill=nullFill, sortByTime=true)\n\n//定义数据\nsubscribeTable(tableName=\"leftTable\", actionName=\"joinLeft\", offset=0, handler=appendForJoin{wjEngine, true}, msgAsTable=true)\nsubscribeTable(tableName=\"rightTable\", actionName=\"joinRight\", offset=0, handler=appendForJoin{wjEngine, false}, msgAsTable=true)\n\nn=10\ntp1=table(take(2012.01.01T00:00:00.000+0..10, 2*n) as time, take(`A, n) join take(`B, n) as sym, take(NULL join rand(10.0, n-1),2*n) as price)\ntp1.sortBy!(`time)\nleftTable.append!(tp1)\n\ntp2=table(take(2012.01.01T00:00:00.000+0..10, 2*n) as time, take(`A, n) join take(`B, n) as sym, take(double(1..n),2*n) as val)\ntp2.sortBy!(`time)\nrightTable.append!(tp2)\n\nsleep(100)\nselect * from output where time between 2012.01.01T00:00:00.000:2012.01.01T00:00:00.001\n```\n\n| time                    | sym | factor1 | factor2 | factor3 |\n| ----------------------- | --- | ------- | ------- | ------- |\n| 2012.01.01T00:00:00.000 | A   | 0       | 1       | 6       |\n| 2012.01.01T00:00:00.000 | A   | 0       | 2       | 6       |\n| 2012.01.01T00:00:00.000 | A   | 0       | 3       | 6       |\n| 2012.01.01T00:00:00.000 | B   | 3.9389  | 2       | 9       |\n| 2012.01.01T00:00:00.000 | B   | 3.9389  | 3       | 9       |\n| 2012.01.01T00:00:00.000 | B   | 3.9389  | 4       | 9       |\n| 2012.01.01T00:00:00.001 | A   | 3.9389  | 1       | 10      |\n| 2012.01.01T00:00:00.001 | A   | 3.9389  | 2       | 10      |\n| 2012.01.01T00:00:00.001 | A   | 3.9389  | 3       | 10      |\n| 2012.01.01T00:00:00.001 | A   | 3.9389  | 4       | 10      |\n| 2012.01.01T00:00:00.001 | B   | 4.9875  | 2       | 14      |\n| 2012.01.01T00:00:00.001 | B   | 4.9875  | 3       | 14      |\n| 2012.01.01T00:00:00.001 | B   | 4.9875  | 4       | 14      |\n| 2012.01.01T00:00:00.001 | B   | 4.9875  | 5       | 14      |\n"
    },
    "crossStat": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/crossStat.html",
        "signatures": [
            {
                "full": "crossStat(X, Y)",
                "name": "crossStat",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [crossStat](https://docs.dolphindb.cn/zh/funcs/c/crossStat.html)\n\n\n\n#### 语法\n\ncrossStat(X, Y)\n\n#### 详情\n\n返回的结果是一个元组，结果中的每个元素依次为 count(X), sum(X), sum(Y), sum2(X), sum2(Y), sum(X\\*Y) 的计算结果。\n\n#### 参数\n\n**X** 和 **Y** 是长度相同的数值型向量。\n\n#### 例子\n\n```\nx=1 NULL 2 3\ny=4 3 NULL 2\ncrossStat(x,y);\n// output\n(2,4,6,10,20,10)\n```\n"
    },
    "cubicHermiteSplineFit": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cubichermitesplinefit.html",
        "signatures": [
            {
                "full": "cubicHermiteSplineFit(X, Y, derivative, [extrapolate=true])",
                "name": "cubicHermiteSplineFit",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "derivative",
                        "name": "derivative"
                    },
                    {
                        "full": "[extrapolate=true]",
                        "name": "extrapolate",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [cubicHermiteSplineFit](https://docs.dolphindb.cn/zh/funcs/c/cubichermitesplinefit.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\ncubicHermiteSplineFit(X, Y, derivative, \\[extrapolate=true])\n\n#### 详情\n\n对一组数值向量 *X*和*Y* 进行三次埃尔米特（Hermite）插值。\n\n#### 参数\n\n**X** 数值型向量，表示用于插值的点的 x 坐标（自变量）。*X* 必须严格递增，且至少包含两个元素。\n\n**Y** 与 *X*等长的数值型向量，表示用于插值的点的 y 坐标（因变量）。\n\n**derivative** 与 *X*等长的数值型向量，表示 *Y* 对 *X* 的一阶导数。\n\n**extrapolate** 可选参数，布尔标量，表示当预测点超出已知数据范围时是否进行外插。默认为 true。\n\n#### 返回值\n\n一个字典，包含以下键值对：\n\n* modelName：字符串“CubicHermiteSpline”，表示模型名称。\n* X：DOUBLE 类型向量，即输入 *X* 。\n* extrapolate：布尔标量，即输入 *extrapolate*。\n* coeffs：数值型向量，表示根据输入数据点拟合得到的多项式系数。\n* predict：模型的预测函数。可通过 `model.predict(X)` 或`predict(model, X)` 调用。其中：\n  * model：`cubicHermiteSplineFit` 函数返回的字典。\n  * X：数值型向量，表示需要求值的点的 x 坐标，`predict` 函数将返回在 *X* 点处的插值结果。\n\n#### 例子\n\n对 x 和 y 进行三次埃尔米特（Hermite）插值。\n\n```\nx = [0.0000,0.0800,0.1000,0.1700,0.2000,0.2500,0.3000,0.4000,0.5000,0.6000,0.7000,0.7500,0.8000,0.9000,1.0000]\ny = [1.2157,1.4000,1.4000,1.4000,1.4055,1.4323,1.4585,1.5096,1.5291,1.4985,1.4562,1.4440,1.4427,1.4461,1.4504]\nN = shape(x)[0]\nderv = take([0.0], N)\nderv[0] = (y[1] - y[0]) \\ (x[1] - x[0])\nderv[N-1]  = (y[N-1] - y[N-2]) \\ (x[N-1] - x[N-2])\nfor (i in 1..(N-2)) {\n\tderv[i] = (y[i+1] - y[i-1]) \\ (x[i+1] - x[i-1])\n}\n\nmodel = cubicHermiteSplineFit(x, y, derv)\nmodel;\n\n/* output:\nmodelName->CubicHermiteSpline\nX->[0,0.08,0.1,0.17,0.2,0.25,0.3,0.4,0.5,0.6,0.7,0.75,0.8,0.9,1]\ncoeffs->#0                   #1                   #2                 #3    \n-------------------- -------------------- ------------------ ------\n-71.992187499999985  5.759375             2.303749999999999  1.2157\n4607.499999999995452 -184.299999999999869 1.842999999999999  1.4   \n11.224489795918488   -0.785714285714294   0                  1.4   \n102.314814814811015  1.208333333333494    0.055000000000001  1.4   \n-55.2999999999993    5.409999999999942    0.40375            1.4055\n-1.066666666666638   -0.066666666666655   0.53               1.4323\n-15.366666666666818  1.493333333333353    0.515333333333334  1.4585\n-9.249999999999774   -0.655000000000037   0.353              1.5096\n19.199999999999896   -4.424999999999982   -0.055500000000001 1.5291\n11.816666666666725   -1.766666666666675   -0.3645            1.4985\n-4.133333333332982   2.593333333333321    -0.363333333333333 1.4562\n-27.600000000001628  3.560000000000105    -0.134999999999998 1.444 \n-1.549999999999794   0.354999999999965    0.014              1.4427\n-0.450000000000062   0.090000000000012    0.038499999999999  1.4461\n\nextrapolate->1\npredict->cubicHermiteSplinePredict\n*/\n```\n\n通过 `predict` 函数对 x 进行插值预测。\n\n```\npreds = predict(model, x)\npreds;\n\n// output: [1.2157,1.4,1.4,1.4,1.4055,1.4323,1.4585,1.5096,1.5291,1.4985,1.4562,1.444,1.4427,1.4461,1.4504]\n```\n"
    },
    "cubicSpline": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cubicspline.html",
        "signatures": [
            {
                "full": "cubicSpline(x, y, bc_type=\"not-a-knot\")",
                "name": "cubicSpline",
                "parameters": [
                    {
                        "full": "x",
                        "name": "x"
                    },
                    {
                        "full": "y",
                        "name": "y"
                    },
                    {
                        "full": "bc_type=\"not-a-knot\"",
                        "name": "bc_type=\"not-a-knot\""
                    }
                ]
            }
        ],
        "markdown": "### [cubicSpline](https://docs.dolphindb.cn/zh/funcs/c/cubicspline.html)\n\n#### 语法\n\ncubicSpline(x, y, bc\\_type=\"not-a-knot\")\n\n#### 详情\n\n生成三次样条插值曲线。\n\n* 当 *bc\\_type* 是一个字符串标量或长度为 1 的向量时，以此作为曲线两端的限制条件。\n* 当 *bc\\_type* 是一个数据对或长度为 2 的向量时，两个元素分别作为曲线左端和右端的限制。\n\n#### 参数\n\n**x** 是一个数值向量，代表自变量的值。x 的长度不小于 3，必须严格递增，且不包含空值。\n\n**y** 是一个数值向量，代表因变量的值。y 必须与 x 长度相等。\n\n**bc\\_type** 是一个字符串标量、字符串数据对、或长度小于等于 2 的向量，用于限定边界条件。字符串支持”not-a-knot“、”clampe“、”natural“，默认值为”not-a-knot“。\n\n* not-a-knot：曲线的前两段和最后两段的三阶导数相等。\n* clamped：曲线两端点处的一阶导数为零。\n* natural：曲线两端点处的二阶导数为零。\n\n#### 返回值\n\n一个字典，包含如下键：\n\n* c：三次样条函数的分段多项式的系数\n\n* x：输入的 x 向量\n\n* predict：模型的预测函数，`predict` 函数将返回在 X 点处的三次样条插值结果。可通过 `model.predict(X)` 或 `predict(model, X)` 进行调用。其中：\n  * model：字典类型，即 `cubicSpline` 的输出。\n\n  * X： 数值向量，表示需要求值的点的 x 坐标。\n\n* modelName：字符串类型，表示模型名称，值为 “cubicSpline”。\n\n#### 例子\n\n```\nn = 10\nx = 0..(n-1)\ny = sin(x)\nmodel = cubicSpline(x, y, bc_type=\"not-a-knot\")\nprint(model)\n```\n\n返回：\n\n```\nx->[0,1,2,3,4,5,6,7,8,9]\npredict->cubicSplinePredict\nmodelName->cubicSpline\nc->[-0.0418500756165063,-0.2612720445455365,1.1445931049699394,0.0,-0.0418500756165067,-0.3868222713950554,0.4964987890293473,0.8414709848078965,0.1468910600890447,-0.5123724982445756,...]\n\n```\n\n\n\n**Related information**\n\n[cubicSplinePredict](https://docs.dolphindb.cn/zh/funcs/c/cubicsplinepredic.html)\n"
    },
    "cubicSplinePredict": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cubicsplinepredic.html",
        "signatures": [
            {
                "full": "cubicSplinePredict(model, x)",
                "name": "cubicSplinePredict",
                "parameters": [
                    {
                        "full": "model",
                        "name": "model"
                    },
                    {
                        "full": "x",
                        "name": "x"
                    }
                ]
            }
        ],
        "markdown": "### [cubicSplinePredict](https://docs.dolphindb.cn/zh/funcs/c/cubicsplinepredic.html)\n\n#### 语法\n\ncubicSplinePredict(model, x)\n\n#### 详情\n\n根据 *model* 给出的三次样条曲线，预测 x 对应的 y。\n\n#### 参数\n\n**model** 是一个字典，包含两个 key：c 和 x，其中 c 的值是三次样条函数的分段多项式的系数，x 的值是分段多项式的分段点，c 的长度=（x 的长度-1）\\*4。c 和 x 的值均不可包含空值。*model* 可由 `cubicSpline` 函数生成。\n\n**x** 是一个数值型标量或向量要预测的自变量。\n\n#### 返回值\n\nDOUBLE 类型向量。\n\n#### 例子\n\n```\nn = 10\nx = 0..(n-1)\ny = sin(x)\nmodel = cubicSpline(x, y, bc_type=\"not-a-knot\")\n\nnewx = [-0.5, 0.5, 0.7, 1.2, 4.5, 8.9, 9.3]\nret = cubicSplinePredict(model, newx)\n```\n\n返回：\n\n```\n[-0.632383304169291,0.501747281896522,0.658837295715183,0.924963051153032,-0.974025627606784,0.515113155358425,0.03881591118089]\n```\n\n\n\n**Related information**\n\n[cubicSpline](https://docs.dolphindb.cn/zh/funcs/c/cubicspline.html)\n"
    },
    "cumavg": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cumavg.html",
        "signatures": [
            {
                "full": "cumavg(X)",
                "name": "cumavg",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [cumavg](https://docs.dolphindb.cn/zh/funcs/c/cumavg.html)\n\n\n\n#### 语法\n\ncumavg(X)\n\n参数说明和窗口计算规则请参考: [累计窗口系列（cum 系列）](https://docs.dolphindb.cn/zh/funcs/themes/cumFunctions.html)\n\n#### 详情\n\n计算 *X* 元素的累积平均值。\n\n#### 返回值\n\nDOUBLE 类型，其数据形式同 *X*。\n\n#### 例子\n\n```\nx=[2,3,NULL,4];\n\ncumavg(x);\n[2,2.5,2.5,3]\n\nm=matrix(1 2 3 NULL 4, 5 6 NULL 7 8);\nm;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 5  |\n| 2  | 6  |\n| 3  |    |\n|    | 7  |\n| 4  | 8  |\n\n```\ncumavg(m);\n```\n\n| #0  | #1  |\n| --- | --- |\n| 1   | 5   |\n| 1.5 | 5.5 |\n| 2   | 5.5 |\n| 2   | 6   |\n| 2.5 | 6.5 |\n\n相关函数：[avg](https://docs.dolphindb.cn/zh/funcs/a/avg.html)\n"
    },
    "cumavgTopN": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cumavgTopN.html",
        "signatures": [
            {
                "full": "cumavgTopN(X, S, top, [ascending=true], [tiesMethod='latest'])",
                "name": "cumavgTopN",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "S",
                        "name": "S"
                    },
                    {
                        "full": "top",
                        "name": "top"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[tiesMethod='latest']",
                        "name": "tiesMethod",
                        "optional": true,
                        "default": "'latest'"
                    }
                ]
            }
        ],
        "markdown": "### [cumavgTopN](https://docs.dolphindb.cn/zh/funcs/c/cumavgTopN.html)\n\n\n\n#### 语法\n\ncumavgTopN(X, S, top, \\[ascending=true], \\[tiesMethod='latest'])\n\n部分通用参数说明和窗口计算规则请参考：[cumTopN 系列](https://docs.dolphindb.cn/zh/funcs/themes/cumTopN.html)\n\n#### 详情\n\n在累计窗口内，根据 *ascending* 指定的排序方式将 *X* 按照 *S* 进行稳定排序后，取前 *top* 个元素并计算平均值。\n\n#### 返回值\n\nDOUBLE 类型，其数据形式同 *X*。\n\n#### 例子\n\n```\nX=1 2 3 10 100 4 3\nS = 0.3 0.5 0.1 0.1 0.5 0.2 0.4\ncumavgTopN(X, S, 6)\n// output\n[1,1.5,2,4,23.199,20,20.167]\n\nX = matrix(1..10, 11..20)\nS = matrix(2022.01.01 2022.02.03 2022.01.23 NULL 2021.12.29 2022.01.20 2022.01.23 2022.01.22 2022.01.24 2022.01.24, NULL 2022.02.03 2022.01.23 2022.04.06 NULL 2022.02.03 2022.02.03 2022.02.05 2022.02.08 2022.02.03)\ncumavgTopN(X, S, 6)\n```\n\n| #0   | #1      |\n| ---- | ------- |\n| 1    |         |\n| 1.5  | 12      |\n| 2    | 12.5    |\n| 2    | 13      |\n| 2.75 | 13      |\n| 3.4  | 13.75   |\n| 4    | 14.4    |\n| 5    | 15      |\n| 5    | 15.8333 |\n| 5    | 16      |\n\n```\nid=rand(10,10)\nprice=rand(100,10)\nt=table(id, price)\nselect cumavgTopN(price, id, 6) as result from t\n```\n\n| result  |\n| ------- |\n| 94      |\n| 69.5    |\n| 46.3333 |\n| 55.75   |\n| 57.8    |\n| 49.6667 |\n| 50.5    |\n| 50.5    |\n| 51.5    |\n| 51.5    |\n"
    },
    "cumbeta": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cumbeta.html",
        "signatures": [
            {
                "full": "cumbeta(Y, X)",
                "name": "cumbeta",
                "parameters": [
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [cumbeta](https://docs.dolphindb.cn/zh/funcs/c/cumbeta.html)\n\n\n\n#### 语法\n\ncumbeta(Y, X)\n\n参数说明和窗口计算规则请参考: [累计窗口系列（cum 系列）](https://docs.dolphindb.cn/zh/funcs/themes/cumFunctions.html)\n\n#### 详情\n\n累积计算 *Y* 在 *X* 上的回归系数的最小二乘估计。\n\n#### 返回值\n\nDOUBLE 类型，其数据形式取决于 *X* (*Y*)。\n\n#### 例子\n\n```\nx=1 3 5 7 11 16 23\ny=1 6 9 8 15 23 34;\n\ncumbeta(y,x);\n// output\n[,2.5,2,1.2,1.256757,1.365322,1.440948]\n```\n\n相关函数：[beta](https://docs.dolphindb.cn/zh/funcs/b/beta.html)\n"
    },
    "cumbetaTopN": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cumbetaTopN.html",
        "signatures": [
            {
                "full": "cumbetaTopN(Y, X, S, top, [ascending=true], [tiesMethod='latest'])",
                "name": "cumbetaTopN",
                "parameters": [
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "S",
                        "name": "S"
                    },
                    {
                        "full": "top",
                        "name": "top"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[tiesMethod='latest']",
                        "name": "tiesMethod",
                        "optional": true,
                        "default": "'latest'"
                    }
                ]
            }
        ],
        "markdown": "### [cumbetaTopN](https://docs.dolphindb.cn/zh/funcs/c/cumbetaTopN.html)\n\n\n\n#### 语法\n\ncumbetaTopN(Y, X, S, top, \\[ascending=true], \\[tiesMethod='latest'])\n\n部分通用参数说明和窗口计算规则请参考：[cumTopN 系列](https://docs.dolphindb.cn/zh/funcs/themes/cumTopN.html)\n\n#### 详情\n\n在累计窗口内，根据 *ascending* 指定的排序方式将 *X* 和 *Y* 按照 *S* 进行稳定排序后，取前 *top* 个元素，然后计算 *Y* 在 *X* 上的回归系数的最小二乘估计。\n\n#### 返回值\n\nDOUBLE 类型，其数据形式取决于 *X* (*Y*)。\n\n#### 例子\n\n```\nY=1 2 3 10 100 4 3\nX=1 7 8 9 0 5 8\nS = 0.3 0.5 0.1 0.1 0.5 0.2 0.4\ncumbetaTopN(Y, X, S, 6)\n// output\n[,0.1666,0.2441,0.7483,-6.4428,-6.4428,-6.2293]\n```\n"
    },
    "cumcorr": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cumcorr.html",
        "signatures": [
            {
                "full": "cumcorr(X,Y)",
                "name": "cumcorr",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [cumcorr](https://docs.dolphindb.cn/zh/funcs/c/cumcorr.html)\n\n\n\n#### 语法\n\ncumcorr(X,Y)\n\n参数说明和窗口计算规则请参考: [累计窗口系列（cum 系列）](https://docs.dolphindb.cn/zh/funcs/themes/cumFunctions.html)\n\n#### 详情\n\n累计计算 *X* 和 *Y* 之间的相关性（correlation）。\n\n#### 参数\n\n**X** 和 **Y** 是向量、矩阵或表。\n\n#### 返回值\n\nDOUBLE 类型，其数据形式取决于 *X* (*Y*)。\n\n#### 例子\n\n```\nx = 7 4 5 8 9\ny = 1 7 8 9 0\ncumcorr(x, y);\n\n// output\n[,-1,-0.893405,-0.1524,-0.518751]\n```\n\n相关函数：[corr](https://docs.dolphindb.cn/zh/funcs/c/corr.html)\n"
    },
    "cumcorrTopN": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cumcorrTopN.html",
        "signatures": [
            {
                "full": "cumcorrTopN(X, Y, S, top, [ascending=true], [tiesMethod='latest'])",
                "name": "cumcorrTopN",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "S",
                        "name": "S"
                    },
                    {
                        "full": "top",
                        "name": "top"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[tiesMethod='latest']",
                        "name": "tiesMethod",
                        "optional": true,
                        "default": "'latest'"
                    }
                ]
            }
        ],
        "markdown": "### [cumcorrTopN](https://docs.dolphindb.cn/zh/funcs/c/cumcorrTopN.html)\n\n\n\n#### 语法\n\ncumcorrTopN(X, Y, S, top, \\[ascending=true], \\[tiesMethod='latest'])\n\n部分通用参数说明和窗口计算规则请参考：[cumTopN 系列](https://docs.dolphindb.cn/zh/funcs/themes/cumTopN.html)\n\n#### 详情\n\n在累计窗口内，根据 *ascending* 指定的排序方式将 *X* 和 *Y* 按照 *S* 进行稳定排序后，取前 *top* 个元素，然后计算 *X* 和 *Y* 之间的相关性。\n\n#### 返回值\n\nDOUBLE 类型，其数据形式取决于 *X* (*Y*)。\n\n#### 例子\n\n```\nX=1 2 3 10 13 4 3\nY = 1 7 8 9 0 5 8\nS = 0.3 0.5 0.1 0.1 0.5 0.2 0.4\ncumcorrTopN(X, Y, S, 6)\n// output\n[,1,0.9244,0.6588,-0.1784,-0.1764,-0.1825]\n```\n"
    },
    "cumcount": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cumcount.html",
        "signatures": [
            {
                "full": "cumcount(X)",
                "name": "cumcount",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [cumcount](https://docs.dolphindb.cn/zh/funcs/c/cumcount.html)\n\n\n\n#### 语法\n\ncumcount(X)\n\n参数说明和窗口计算规则请参考: [累计窗口系列（cum 系列）](https://docs.dolphindb.cn/zh/funcs/themes/cumFunctions.html)\n\n#### 详情\n\n计算 *X* 中累积非 NULL 的元素数量。\n\n#### 返回值\n\nINT 类型，其数据形式同 *X*。\n\n#### 例子\n\n```\nx=[1,2,NULL,3,4,NULL,5,6]\ncumcount(x);\n// output\n[1,2,2,3,4,4,5,6]\n\nm=matrix(1 2 3 NULL 4, 5 6 NULL NULL 8);\nm;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 5  |\n| 2  | 6  |\n| 3  |    |\n|    |    |\n| 4  | 8  |\n\n```\ncumcount(m);\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 1  |\n| 2  | 2  |\n| 3  | 2  |\n| 3  | 2  |\n| 4  | 3  |\n\n相关函数：[count](https://docs.dolphindb.cn/zh/funcs/c/count.html)\n"
    },
    "cumcovar": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cumcovar.html",
        "signatures": [
            {
                "full": "cumcovar(X,Y)",
                "name": "cumcovar",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [cumcovar](https://docs.dolphindb.cn/zh/funcs/c/cumcovar.html)\n\n\n\n#### 语法\n\ncumcovar(X,Y)\n\n参数说明和窗口计算规则请参考：[累计窗口系列（cum 系列）](https://docs.dolphindb.cn/zh/funcs/themes/cumFunctions.html)\n\n#### 详情\n\n累积计算 *X* 和 *Y* 的协方（covariance）。\n\n#### 返回值\n\nDOUBLE 类型，其数据形式取决于 *X* (*Y*)。\n\n#### 例子\n\n```\nx = 7 4 5 8 9\ny = 1 7 8 9 0\ncumcovar(x, y);\n// output\n[,-9,-5.166667,-1,-4.5]\n```\n\n相关函数：[covar](https://docs.dolphindb.cn/zh/funcs/c/covar.html)\n"
    },
    "cumcovarp": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cumcovarp.html",
        "signatures": [
            {
                "full": "cumcovarp(X,Y)",
                "name": "cumcovarp",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [cumcovarp](https://docs.dolphindb.cn/zh/funcs/c/cumcovarp.html)\n\n首发版本：3.00.5\n\n\n\n#### 语法\n\ncumcovarp(X,Y)\n\n参数说明和窗口计算规则请参考：[累计窗口系列（cum 系列）](https://docs.dolphindb.cn/zh/funcs/themes/cumFunctions.html)\n\n#### 详情\n\n累积计算 *X* 和 *Y* 的总体协方差。\n\n#### 返回值\n\nDOUBLE 类型，其数据形式取决于 *X* (*Y*)。\n\n#### 例子\n\n```\nx = 7 4 5 8 9\ny = 1 7 8 9 0\ncumcovarp(x, y);\n// output: [0,-4.5,-3.44,-0.75,-3.6]\n```\n\n相关函数：[covarp](https://docs.dolphindb.cn/zh/funcs/c/covarp.html)\n"
    },
    "cumcovarpTopN": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cumcovarpTopN.html",
        "signatures": [
            {
                "full": "cumcovarpTopN(X, Y, S, top, [ascending=true], [tiesMethod='latest'])",
                "name": "cumcovarpTopN",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "S",
                        "name": "S"
                    },
                    {
                        "full": "top",
                        "name": "top"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[tiesMethod='latest']",
                        "name": "tiesMethod",
                        "optional": true,
                        "default": "'latest'"
                    }
                ]
            }
        ],
        "markdown": "### [cumcovarpTopN](https://docs.dolphindb.cn/zh/funcs/c/cumcovarpTopN.html)\n\n首发版本：3.00.5\n\n\n\n#### 语法\n\ncumcovarpTopN(X, Y, S, top, \\[ascending=true], \\[tiesMethod='latest'])\n\n部分通用参数说明和窗口计算规则请参考：[cumTopN 系列](https://docs.dolphindb.cn/zh/funcs/themes/cumTopN.html)\n\n#### 详情\n\n在累计窗口内，根据 *ascending* 指定的排序方式将 *X* 和 *Y* 按照 *S* 进行稳定排序后，取前 *top* 个元素，然后计算 *X* 和 *Y* 的总体协方差。\n\n#### 返回值\n\nDOUBLE 类型，其数据形式取决于 *X* (*Y*)。\n\n#### 例子\n\n```\nX=1 2 3 10 13 4 3\nY = 1 7 8 9 0 5 8\nS = 0.3 0.5 0.1 0.1 0.5 0.2 0.4\ncumcovarpTopN(X, Y, S, 6)\n// output: [0,1.5,2.33,7.25,-3.2,-2.67,-2.78]\n```\n\n相关函数：[covarp](https://docs.dolphindb.cn/zh/funcs/c/covarp.html)\n"
    },
    "cumcovarTopN": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cumcovarTopN.html",
        "signatures": [
            {
                "full": "cumcovarTopN(X, Y, S, top, [ascending=true], [tiesMethod='latest'])",
                "name": "cumcovarTopN",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "S",
                        "name": "S"
                    },
                    {
                        "full": "top",
                        "name": "top"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[tiesMethod='latest']",
                        "name": "tiesMethod",
                        "optional": true,
                        "default": "'latest'"
                    }
                ]
            }
        ],
        "markdown": "### [cumcovarTopN](https://docs.dolphindb.cn/zh/funcs/c/cumcovarTopN.html)\n\n\n\n#### 语法\n\ncumcovarTopN(X, Y, S, top, \\[ascending=true], \\[tiesMethod='latest'])\n\n部分通用参数说明和窗口计算规则请参考：[cumTopN 系列](https://docs.dolphindb.cn/zh/funcs/themes/cumTopN.html)\n\n#### 详情\n\n在累计窗口内，根据 *ascending* 指定的排序方式将 *X* 和 *Y* 按照 *S* 进行稳定排序后，取前 *top* 个元素，然后计算 *X* 和 *Y* 的协方差。\n\n#### 返回值\n\nDOUBLE 类型，其数据形式取决于 *X* (*Y*)。\n\n#### 例子\n\n```\nX=1 2 3 10 13 4 3\nY = 1 7 8 9 0 5 8\nS = 0.3 0.5 0.1 0.1 0.5 0.2 0.4\ncumcovarTopN(X, Y, S, 6)\n// output\n[,3,3.5,9.6666,-4,-3.2,-3.3333]\n```\n"
    },
    "cumdenseRank": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cumdenseRank.html",
        "signatures": [
            {
                "full": "cumdenseRank(X, [ascending=true], [ignoreNA=true], [percent=false], [norm='max'])",
                "name": "cumdenseRank",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[ignoreNA=true]",
                        "name": "ignoreNA",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[percent=false]",
                        "name": "percent",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[norm='max']",
                        "name": "norm",
                        "optional": true,
                        "default": "'max'"
                    }
                ]
            }
        ],
        "markdown": "### [cumdenseRank](https://docs.dolphindb.cn/zh/funcs/c/cumdenseRank.html)\n\n#### 语法\n\ncumdenseRank(X, \\[ascending=true], \\[ignoreNA=true], \\[percent=false], \\[norm='max'])\n\n#### 详情\n\n**Note:**\n\n* 该函数首发于1.30.22.3版本。\n* 若要使用参数 *norm*，*percent* 应为 true\n\n若 *X* 是向量，对 *X* 中的每一个元素，返回其在累计窗口内的密集排名。\n\n* 基于 *ascending* 指定的方式排序。\n\n* 如果 *ignoreNA* = true，则 NULL 值不参与排序，结果中 NULL 值的排名为空。\n\n若 X 是矩阵或内存表，在每列内进行上述计算，返回一个与 *X* 维度相同的矩阵或内存表。\n\n#### 参数\n\n**X** 可以是向量、矩阵或内存表。\n\n**ascending** 是一个布尔值，表示是否按升序排序。默认值是 true。\n\n**ignoreNA** 是一个布尔值，表示是否忽略 NULL 值，true 表示忽略 NULL 值，false 表示 NULL 作为最小值参与排名。默认值为 true。\n\n**percent** 是一个布尔值，表示是否以百分比形式显示返回的排名，默认值为 false。\n\n**norm** 是一个字符串，可为 'max' 或 'minmax' ，在计算百分比时，不同设置值决定了排名的起始值，进而可决定了百分比的计算结果。当 *norm*='max' 时，排名从1开始；当 *norm*='minmax' 时，排名从0开始。以返回 \\[3, 1, 2] 的密集排名百分比为例进行说明：\n\n* 当 *norm*='max' 时，最后一个累计窗口中2的排名为2，窗口中的最大排名数为3，因此结果为2\\3。\n\n* 当 *norm*='minmax' 时，最后一个累计窗口中2的排名为1，窗口中的最大排名数为2，因此结果为1\\2。\n\n#### 返回值\n\nINT/DOUBLE 类型，其数据形式同 *X*。\n\n#### 例子\n\n```\na = 1 3 2 3 4\ncumdenseRank(X=a, ascending=true, ignoreNA=true, percent=false)\n// output\n[0,1,1,2,3]\n\ncumdenseRank(X=a, ascending=true, ignoreNA=true, percent=true, norm=\"max\")\n// output\n[1,1,0.6667,1,1]\n\ncumdenseRank(X=a, ascending=true, ignoreNA=true, percent=true, norm=\"minmax\")\n// output\n[1,1,0.5,1,1]\n\nm = matrix(1 6 2 NULL, 3 0 1 6, 7 3 NULL 2)\ncumdenseRank(X=m, ascending=true, ignoreNA=true, percent=false)\n#0 #1 #2\n-- -- --\n0  0  0 \n1  0  0 \n1  1    \n   3  0\n       \nt = table([4,10,3,4,8,1] as val1, [10,8,1,8,5,2]  as val2)\ncumdenseRank(X=t, ascending=true, ignoreNA=true, percent=false)\n```\n\n| val1 | val2 |\n| ---- | ---- |\n| 0    | 0    |\n| 1    | 0    |\n| 0    | 0    |\n| 1    | 1    |\n| 2    | 1    |\n| 0    | 1    |\n\n"
    },
    "cumfirstNot": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cumfirstNot.html",
        "signatures": [
            {
                "full": "cumfirstNot(X, [k])",
                "name": "cumfirstNot",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[k]",
                        "name": "k",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [cumfirstNot](https://docs.dolphindb.cn/zh/funcs/c/cumfirstNot.html)\n\n\n\n#### 语法\n\ncumfirstNot(X, \\[k])\n\n参数说明和窗口计算规则请参考：[累计窗口系列（cum 系列）](https://docs.dolphindb.cn/zh/funcs/themes/cumFunctions.html)\n\n#### 详情\n\n* 若 *X* 是向量：\n\n  * 如果没有指定 *k*，对 *X* 内的每个元素，返回其之前所有元素中第一个不为 NULL 的元素。\n\n  * 如果指定 *k*，对 *X* 内的每个元素，返回其之前所有元素中第一个不为 *k* 的元素。\n\n* 若 *X* 是矩阵，在每列内进行上述计算，返回一个与 *X* 维度相同的矩阵。\n\n#### 参数\n\n**k** 一个标量。\n\n#### 返回值\n\n返回一个与输入 *X* 相同数据类型和形式的对象。\n\n#### 例子\n\n```\nx=[NULL,1,2,6,NULL,3,4,NULL]\ncumfirstNot(x);\n// output\n[,1,1,1,1,1,1,1]\n\ncumfirstNot(x, 1)\n// output\n[,,2,2,2,2,2,2]\n\nm=matrix(1 2 3 NULL 4, NULL NULL 8 8 9);\nm;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  |    |\n| 2  |    |\n| 3  | 8  |\n|    | 8  |\n| 4  | 9  |\n\n```\ncumfirstNot(m);\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  |    |\n| 1  |    |\n| 1  | 8  |\n| 1  | 8  |\n| 1  | 8  |\n\n相关函数： [firstNot](https://docs.dolphindb.cn/zh/funcs/f/firstNot.html)\n"
    },
    "cumkurtosisTopN": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cumkurtosisTopN.html",
        "signatures": [
            {
                "full": "cumkurtosisTopN(X, S, top, [biased=true], [ascending=true], [tiesMethod='latest'])",
                "name": "cumkurtosisTopN",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "S",
                        "name": "S"
                    },
                    {
                        "full": "top",
                        "name": "top"
                    },
                    {
                        "full": "[biased=true]",
                        "name": "biased",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[tiesMethod='latest']",
                        "name": "tiesMethod",
                        "optional": true,
                        "default": "'latest'"
                    }
                ]
            }
        ],
        "markdown": "### [cumkurtosisTopN](https://docs.dolphindb.cn/zh/funcs/c/cumkurtosisTopN.html)\n\n\n\n#### 语法\n\ncumkurtosisTopN(X, S, top, \\[biased=true], \\[ascending=true], \\[tiesMethod='latest'])\n\n部分通用参数说明和窗口计算规则请参考：[cumTopN 系列](https://docs.dolphindb.cn/zh/funcs/themes/cumTopN.html)\n\n#### 详情\n\n在累计窗口内，根据 *ascending* 指定的排序方式将 *X* 按照 *S* 进行稳定排序后，取前 *top* 个元素并计算峰度。\n\n#### 参数\n\n**biased** 是一个布尔值，表示是否是有偏估计。默认值为 true，表示有偏估计。\n\n#### 返回值\n\nDOUBLE 类型向量或矩阵。\n\n#### 例子\n\n```\nX=1 2 3 10 100 4 3\nS = 0.3 0.5 0.1 0.1 0.5 0.2 0.4\ncumkurtosisTopN(X, S, 6)\n// output\n[,,1.5,2.2304,3.2152,4.1525,4.1554]\n\nX = matrix(1..10, 11..20)\nS = matrix(2022.01.01 2022.02.03 2022.01.23 NULL 2021.12.29 2022.01.20 2022.01.23 2022.01.22 2022.01.24 2022.01.24, NULL 2022.02.03 2022.01.23 2022.04.06 NULL 2022.02.03 2022.02.03 2022.02.05 2022.02.08 2022.02.03)\ncumkurtosisTopN(X, S, 6)\n```\n\n| #0     | #1     |\n| ------ | ------ |\n|        |        |\n|        |        |\n| 1.5    |        |\n| 1.5    | 1.5    |\n| 1.8457 | 1.5    |\n| 1.5092 | 1.8457 |\n| 1.5    | 1.5092 |\n| 1.9204 | 1.5    |\n| 1.9204 | 1.6107 |\n| 1.9204 | 1.7297 |\n\n```\nid=rand(10,10)\nprice=rand(100,10)\nt=table(id, price)\nselect cumkurtosisTopN(price, id, 6) as result from t\n```\n\n| result |\n| ------ |\n|        |\n|        |\n| 1.5    |\n| 1.4036 |\n| 1.537  |\n| 1.8185 |\n| 1.8838 |\n| 2.0968 |\n| 2.6695 |\n| 2.6695 |\n"
    },
    "cumlastNot": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cumlastNot.html",
        "signatures": [
            {
                "full": "cumlastNot(X, [k])",
                "name": "cumlastNot",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[k]",
                        "name": "k",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [cumlastNot](https://docs.dolphindb.cn/zh/funcs/c/cumlastNot.html)\n\n\n\n#### 语法\n\ncumlastNot(X, \\[k])\n\n参数说明和窗口计算规则请参考：[累计窗口系列（cum 系列）](https://docs.dolphindb.cn/zh/funcs/themes/cumFunctions.html)\n\n#### 详情\n\n* 若 *X* 是向量：\n\n  * 如果没有指定 *k*，对 *X* 内的每个元素，返回其之前所有元素中最后一个不为 NULL 的元素。\n\n  * 如果指定 *k*，对 *X* 内的每个元素，返回其之前所有元素中最后一个不为 *k* 的元素。\n\n* 若 *X* 是矩阵，在每列内进行上述计算，返回一个与 *X* 维度相同的矩阵。\n\n#### 参数\n\n**k** 一个标量。\n\n#### 返回值\n\n返回一个与输入 *X* 相同数据类型和形式的对象。\n\n#### 例子\n\n```\nx=[NULL,1,2,6,NULL,3,4,NULL]\ncumlastNot(x);\n// output\n[,1,2,6,6,3,4,4]\n\ncumlastNot(x, 4)\n// output\n[,1,2,6,6,3,3,3]\n\nm=matrix(1 2 3 NULL 4, NULL NULL 8 8 9);\nm;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  |    |\n| 2  |    |\n| 3  | 8  |\n|    | 8  |\n| 4  | 9  |\n\n```\ncumlastNot(m);\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  |    |\n| 2  |    |\n| 3  | 8  |\n| 3  | 8  |\n| 4  | 9  |\n\n相关函数： [lastNot](https://docs.dolphindb.cn/zh/funcs/l/lastNot.html)\n"
    },
    "cummax": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cummax.html",
        "signatures": [
            {
                "full": "cummax(X)",
                "name": "cummax",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [cummax](https://docs.dolphindb.cn/zh/funcs/c/cummax.html)\n\n\n\n#### 语法\n\ncummax(X)\n\n参数说明和窗口计算规则请参考：[累计窗口系列（cum 系列）](https://docs.dolphindb.cn/zh/funcs/themes/cumFunctions.html)\n\n#### 详情\n\n计算 *X* 元素的累计最大值。\n\n#### 返回值\n\n返回一个与输入 *X* 相同数据类型和形式的对象。\n\n#### 例子\n\n```\nx = [7,4,5,8,9]\ncummax(x);\n// output\n[7,7,7,8,9]\n\nm = matrix(6 5 7 8 1, 3 9 4 2 10);\nm;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 6  | 3  |\n| 5  | 9  |\n| 7  | 4  |\n| 8  | 2  |\n| 1  | 10 |\n\n```\ncummax(m);\n```\n\n| #0 | #1 |\n| -- | -- |\n| 6  | 3  |\n| 6  | 9  |\n| 7  | 9  |\n| 8  | 9  |\n| 8  | 10 |\n\n相关函数：[cummin](https://docs.dolphindb.cn/zh/funcs/c/cummin.html), [max](https://docs.dolphindb.cn/zh/funcs/m/max.html)\n"
    },
    "cummdd": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cummdd.html",
        "signatures": [
            {
                "full": "cummdd(X, [ratio=true])",
                "name": "cummdd",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[ratio=true]",
                        "name": "ratio",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [cummdd](https://docs.dolphindb.cn/zh/funcs/c/cummdd.html)\n\n\n\n#### 语法\n\ncummdd(X, \\[ratio=true])\n\n#### 详情\n\n累计计算传入向量数据的最大回撤。\n\n#### 参数\n\n**X** 数值向量，表示用于计算最大回撤的输入数据，一般指累积的收益或收益率。注意：不可为空。\n\n**ratio**布尔标量，表示是否返回最大回撤率。默认值为 true。\n\n* 若为 true，表示返回最大回撤率，即相对于峰值的最大下降百分比，计算公式为：\n\n  ![](https://docs.dolphindb.cn/zh/funcs/images/mdd1.png)\n\n* 若为 false，表示返回基于下降金额绝对值的最大回撤，计算公式为：\n\n  ![](https://docs.dolphindb.cn/zh/funcs/images/mdd2.png)\n\n注意：计算时将忽略空值。\n\n窗口计算规则请参考: [累计窗口系列（cum 系列）](https://docs.dolphindb.cn/zh/funcs/themes/cumFunctions.html)\n\n#### 返回值\n\nDOUBLE 类型向量。\n\n#### 例子\n\n假设有一个投资组合在一段时间内的累积收益变化如下（以天为单位）：\n\n| 日期         | 累积收益 |\n| ---------- | ---- |\n| 2024-10-01 | 36   |\n| 2024-10-02 | 96   |\n| 2024-10-03 | 42   |\n| 2024-10-04 | 100  |\n| 2024-10-05 | 59   |\n| 2024-10-06 | 86   |\n| 2024-10-07 | 25   |\n| 2024-10-08 | 72   |\n\n使用 `cummdd` 计算该数据的累计最大回撤。\n\n```\nx = [36,96,42,100,59,86,25,64,72]\ncummdd(x)\n// Output: [0,0,0.5625,0.5625,0.5625,0.5625,0.75,0.75,0.75]\ncummdd(x, false)\n// Output: [0,0,54,54,54,54,75,75,75]\n```\n\n相关函数：[maxDrawdown](https://docs.dolphindb.cn/zh/funcs/m/maxdrawdown.html)\n"
    },
    "cummed": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cummed.html",
        "signatures": [
            {
                "full": "cummed(X)",
                "name": "cummed",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [cummed](https://docs.dolphindb.cn/zh/funcs/c/cummed.html)\n\n\n\n#### 语法\n\ncummed(X)\n\n参数说明和窗口计算规则请参考：[累计窗口系列（cum 系列）](https://docs.dolphindb.cn/zh/funcs/themes/cumFunctions.html)\n\n#### 详情\n\n计算 *X* 元素的累计中位数。\n\n#### 返回值\n\nDOUBLE 类型，其数据形式同 *X*。\n\n#### 例子\n\n```\nx = [7,9,5,NULL,9]\ncummed(x);\n// output\n[7,8,7,7,8]\n\nm = matrix(6 5 7 8 1, 3 9 4 2 10);\nm;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 6  | 3  |\n| 5  | 9  |\n| 7  | 4  |\n| 8  | 2  |\n| 1  | 10 |\n\n```\ncummed(m);\n```\n\n| #0  | #1  |\n| --- | --- |\n| 6   | 3   |\n| 5.5 | 6   |\n| 6   | 4   |\n| 6.5 | 3.5 |\n| 6   | 4   |\n\n相关函数：[cummax](https://docs.dolphindb.cn/zh/funcs/c/cummax.html), [cummin](https://docs.dolphindb.cn/zh/funcs/c/cummin.html), [med](https://docs.dolphindb.cn/zh/funcs/m/med.html)\n"
    },
    "cummin": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cummin.html",
        "signatures": [
            {
                "full": "cummin(X)",
                "name": "cummin",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [cummin](https://docs.dolphindb.cn/zh/funcs/c/cummin.html)\n\n\n\n#### 语法\n\ncummin(X)\n\n参数说明和窗口计算规则请参考：[累计窗口系列（cum 系列）](https://docs.dolphindb.cn/zh/funcs/themes/cumFunctions.html)\n\n#### 详情\n\n计算 *X* 元素的累计最小值。\n\n#### 返回值\n\n返回一个与输入 *X* 相同数据类型和形式的对象。\n\n#### 例子\n\n```\nx = [7,4,5,NULL,9]\ncummin(x);\n// output\n[7,4,4,4,4]\n\nm = matrix(6 5 7 8 1, 3 9 4 2 10);\nm;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 6  | 3  |\n| 5  | 9  |\n| 7  | 4  |\n| 8  | 2  |\n| 1  | 10 |\n\n```\ncummin(m);\n```\n\n| #0 | #1 |\n| -- | -- |\n| 6  | 3  |\n| 5  | 3  |\n| 5  | 3  |\n| 5  | 2  |\n| 1  | 2  |\n\n相关函数：[cummax](https://docs.dolphindb.cn/zh/funcs/c/cummax.html), [min](https://docs.dolphindb.cn/zh/funcs/m/min.html)\n"
    },
    "cumnunique": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cumnunique.html",
        "signatures": [
            {
                "full": "cumnunique(X, [ignoreNull=false])",
                "name": "cumnunique",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[ignoreNull=false]",
                        "name": "ignoreNull",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [cumnunique](https://docs.dolphindb.cn/zh/funcs/c/cumnunique.html)\n\n\n\n#### 语法\n\ncumnunique(X, \\[ignoreNull=false])\n\n参数说明和窗口计算规则请参考：[cumFunctions](https://docs.dolphindb.cn/zh/funcs/themes/cumFunctions.html)\n\n#### 详情\n\n统计 *X* 元素的累计唯一值数量。若指定 *ignoreNull*=true，则统计唯一值时将不考虑 NULL 值；否则将会统计 NULL 值。\n\n#### 参数\n\n**ignoreNull** 是一个布尔值，表示是否忽略 *X*中 NULL 值。若指定 *ignoreNull*=true，则统计唯一值时将不考虑 NULL 值；否则将会统计 NULL 值。默认值为 false。\n\n#### 返回值\n\nINT 类型，其数据形式同 *X*。\n\n#### 例子\n\n```\nv = [NULL, 1, 2, -6, 0, 1, 2]\ncumnunique(v)\n// output: [1,2,3,4,5,5,5]\n\ncumnunique(v,true)\n// output: [0,1,2,3,4,4,4]\n\nt = table(`a`a`b`c`a`b as id, 20 20 10 40 30 20 as val)\nselect cumnunique(id) as cumVal from t\n```\n\n| cumVal |\n| ------ |\n| 1      |\n| 1      |\n| 2      |\n| 3      |\n| 3      |\n| 3      |\n"
    },
    "cumpercentile": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cumpercentile.html",
        "signatures": [
            {
                "full": "cumpercentile(X, percent, [interpolation='linear'])",
                "name": "cumpercentile",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "percent",
                        "name": "percent"
                    },
                    {
                        "full": "[interpolation='linear']",
                        "name": "interpolation",
                        "optional": true,
                        "default": "'linear'"
                    }
                ]
            }
        ],
        "markdown": "### [cumpercentile](https://docs.dolphindb.cn/zh/funcs/c/cumpercentile.html)\n\n\n\n#### 语法\n\ncumpercentile(X, percent, \\[interpolation='linear'])\n\n部分通用参数说明和窗口计算规则请参考：[累计窗口系列（cum 系列）](https://docs.dolphindb.cn/zh/funcs/themes/cumFunctions.html)\n\n#### 详情\n\n计算 *X* 元素的累计百分位。\n\n#### 参数\n\n**percent** 是 0 到 100 之间的整数或小数。\n\n**interpolation** 是一个字符串，表示当选中的分位点位于在 *X* 的第 i 和第 i+1 个元素之间时，采用的插值方法。它具有以下取值：\n\n* 'linear': ![linear](https://docs.dolphindb.cn/zh/images/linear.png), 其中 ![fraction](https://docs.dolphindb.cn/zh/images/fraction_cumpercentile.png)\n\n* 'lower': ![lower](https://docs.dolphindb.cn/zh/images/lower.png)\n\n* 'higher': ![higher](https://docs.dolphindb.cn/zh/images/higher.png)\n\n* 'nearest': ![lower](https://docs.dolphindb.cn/zh/images/lower.png)和![higher](https://docs.dolphindb.cn/zh/images/higher.png)之中最接近分位点的数据\n\n* 'midpoint': ![midpoint](https://docs.dolphindb.cn/zh/images/midpoint.png)\n\n如果没有指定 *interpolation*，默认采用 'linear'。\n\n#### 返回值\n\nDOUBLE 类型，其数据形式同 *X*。\n\n#### 例子\n\n```\na=1..10;\n\ncumpercentile(a,25);\n\n[1,1.25,1.5,1.75,2,2.25,2.5,2.75,3,3.25]\n\ncumpercentile(a,25,'lower');\n\n[1,1,1,1,2,2,2,2,3,3]\n\ncumpercentile(a,25,'higher');\n\n[1,2,2,2,2,3,3,3,3,4]\n\ncumpercentile(a,25,'midpoint');\n\n[1,1.5,1.5,1.5,2,2.5,2.5,2.5,3,3.5]\n\ncumpercentile(a,25,'nearest');\n\n[1,1,1,2,2,2,2,3,3,3]\n\ncumpercentile(a,50.5);\n\n[1,1.505,2.01,2.515,3.02,3.525,4.03,4.535,5.04,5.545]\n\nm=matrix(1..10, 11..20);\nm;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 11 |\n| 2  | 12 |\n| 3  | 13 |\n| 4  | 14 |\n| 5  | 15 |\n| 6  | 16 |\n| 7  | 17 |\n| 8  | 18 |\n| 9  | 19 |\n| 10 | 20 |\n\n```\ncumpercentile(m,25);\n```\n\n| #0   | #1    |\n| ---- | ----- |\n| 1    | 11    |\n| 1.25 | 11.25 |\n| 1.5  | 11.5  |\n| 1.75 | 11.75 |\n| 2    | 12    |\n| 2.25 | 12.25 |\n| 2.5  | 12.5  |\n| 2.75 | 12.75 |\n| 3    | 13    |\n| 3.25 | 13.25 |\n\n相关函数：[percentile](https://docs.dolphindb.cn/zh/funcs/p/percentile.html)\n"
    },
    "cumPositiveStreak": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cumPositiveStreak.html",
        "signatures": [
            {
                "full": "cumPositiveStreak(X)",
                "name": "cumPositiveStreak",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [cumPositiveStreak](https://docs.dolphindb.cn/zh/funcs/c/cumPositiveStreak.html)\n\n\n\n#### 语法\n\ncumPositiveStreak(X)\n\n参数说明和窗口计算规则请参考：[cumFunctions](https://docs.dolphindb.cn/zh/funcs/themes/cumFunctions.html)\n\n#### 详情\n\n累计计算 *X* 中连续的正数之和的。\n\n#### 返回值\n\nLONG/DOUBLE 类型，其数据形式同 *X*。\n\n#### 例子\n\n```\nx=1 0 -1 1 2 2 2 1 0 -1 0 2;\n\ncumPositiveStreak x;\n// output\n[1,0,0,1,3,5,7,8,0,0,0,2]\n\nm=matrix(1 0 -1 1 2 2 2 1 0 -1 0 2, -1 -2 -1 0 1 3 6 7 0 -1 -2 0);\nm;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | -1 |\n| 0  | -2 |\n| -1 | -1 |\n| 1  | 0  |\n| 2  | 1  |\n| 2  | 3  |\n| 2  | 6  |\n| 1  | 7  |\n| 0  | 0  |\n| -1 | -1 |\n| 0  | -2 |\n| 2  | 0  |\n\n```\ncumPositiveStreak(m);\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 0  |\n| 0  | 0  |\n| 0  | 0  |\n| 1  | 0  |\n| 3  | 1  |\n| 5  | 4  |\n| 7  | 10 |\n| 8  | 17 |\n| 0  | 0  |\n| 0  | 0  |\n| 0  | 0  |\n| 2  | 0  |\n"
    },
    "cumprod": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cumprod.html",
        "signatures": [
            {
                "full": "cumprod(X)",
                "name": "cumprod",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [cumprod](https://docs.dolphindb.cn/zh/funcs/c/cumprod.html)\n\n\n\n#### 语法\n\ncumprod(X)\n\n参数说明和窗口计算规则请参考：[累计窗口系列（cum 系列）](https://docs.dolphindb.cn/zh/funcs/themes/cumFunctions.html)\n\n#### 详情\n\n计算 *X* 元素的累计乘积。\n\n**Note:**\n\n与 [numpy.cumprod](https://numpy.net.cn/doc/stable/reference/generated/numpy.cumprod.html) 的功能基本相同，区别在于 DolphinDB 的 `cumprod` 对矩阵默认按列计算累计乘积（等价于 `numpy.cumprod` 设置 *axis*=0），且只接受一个参数 *X*，不支持 `numpy.cumprod` 中的 *axis*、*dtype* 和 *out* 参数。\n\n#### 返回值\n\nLONG/DOUBLE 类型，其数据形式同 *X*。\n\n#### 例子\n\n```\ncumprod(2 3 4);\n// output\n[2,6,24]\n# 等价于 [2, 2*3, 2*3*4]\n\nm=matrix(1 2 3, 4 5 6);\nm;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 4  |\n| 2  | 5  |\n| 3  | 6  |\n\n```\ncumprod(m);\n```\n\n| #0 | #1  |\n| -- | --- |\n| 1  | 4   |\n| 2  | 20  |\n| 6  | 120 |\n\n相关函数：[prod](https://docs.dolphindb.cn/zh/funcs/p/prod.html)\n"
    },
    "cumrank": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cumrank.html",
        "signatures": [
            {
                "full": "cumrank(X, [ascending=true], [ignoreNA=true], [tiesMethod='min'], [percent=false])",
                "name": "cumrank",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[ignoreNA=true]",
                        "name": "ignoreNA",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[tiesMethod='min']",
                        "name": "tiesMethod",
                        "optional": true,
                        "default": "'min'"
                    },
                    {
                        "full": "[percent=false]",
                        "name": "percent",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [cumrank](https://docs.dolphindb.cn/zh/funcs/c/cumrank.html)\n\n\n\n#### 语法\n\ncumrank(X, \\[ascending=true], \\[ignoreNA=true], \\[tiesMethod='min'], \\[percent=false])\n\n部分通用参数说明和窗口计算规则请参考：[累计窗口系列（cum 系列）](https://docs.dolphindb.cn/zh/funcs/themes/cumFunctions.html)\n\n#### 详情\n\n对 *X* 中的每一个元素，返回其在累计窗口内的排名。\n\n**Note:** 如果 *ignoreNA* = true，则 NULL 值不参与排序，结果中 NULL 值的排名为空。\n\n#### 参数\n\n**ascending** 是一个布尔值，表示是否按升序排序。默认值是 true。\n\n**ignoreNA** 是一个布尔值，表示是否忽略 NULL 值。true 表示忽略 NULL 值（默认值），false 表示 NULL 值参与排名，此时 NULL 值为最小值。\n\n**tiesMethod** 是一个字符串，表示窗口内若存在重复值时，排名如何选取。\n\n* 'min'表示取最小排名。\n* 'max'表示取最大排名。\n* 'average'表示取排名的均值。\n\n**percent** 是一个布尔值，表示是否以百分比形式显示返回的排名，默认值为 false。\n\n#### 返回值\n\nINT 类型，其数据形式同 *X*。\n\n#### 例子\n\n```\ncumrank(1 3 2 3 4);\n// output: [0,1,1,2,4]\n\ncumrank(1 3 2 2 4 NULL, ignoreNA=true);\n// output: [0,1,1,1,4,]\n\ncumrank(1 3 2 2 4 NULL, ignoreNA=false);\n// output: [0,1,1,1,4,0]\n\ncumrank(1 3 2 2 4 NULL, ignoreNA=false, tiesMethod='max');\n// output: [0,1,1,2,4,0]\n\nm=matrix(1 4 2 3 4, 4 NULL 6 1 2);\nm;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 4  |\n| 4  |    |\n| 2  | 6  |\n| 3  | 1  |\n| 4  | 2  |\n\n```\ncumrank(m);\n```\n\n| #0 | #1 |\n| -- | -- |\n| 0  | 0  |\n| 1  |    |\n| 1  | 1  |\n| 2  | 0  |\n| 3  | 1  |\n\n相关函数：[rank](https://docs.dolphindb.cn/zh/funcs/r/rank.html)\n"
    },
    "cumskewTopN": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cumskewTopN.html",
        "signatures": [
            {
                "full": "cumskewTopN(X, S, top, [biased=true], [ascending=true], [tiesMethod='latest'])",
                "name": "cumskewTopN",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "S",
                        "name": "S"
                    },
                    {
                        "full": "top",
                        "name": "top"
                    },
                    {
                        "full": "[biased=true]",
                        "name": "biased",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[tiesMethod='latest']",
                        "name": "tiesMethod",
                        "optional": true,
                        "default": "'latest'"
                    }
                ]
            }
        ],
        "markdown": "### [cumskewTopN](https://docs.dolphindb.cn/zh/funcs/c/cumskewTopN.html)\n\n\n\n#### 语法\n\ncumskewTopN(X, S, top, \\[biased=true], \\[ascending=true], \\[tiesMethod='latest'])\n\n部分通用参数说明和窗口计算规则请参考：[cumTopN 系列](https://docs.dolphindb.cn/zh/funcs/themes/cumTopN.html)\n\n#### 详情\n\n在累计窗口内，根据 *ascending* 指定的排序方式将 *X* 按照 *S* 进行稳定排序后，取前 *top* 个元素并计算斜度。\n\n#### 参数\n\n**biased** 是一个布尔值，表示是否是有偏估计。默认值为 true，表示有偏估计。\n\n#### 返回值\n\nDOUBLE 类型向量或矩阵。\n\n#### 例子\n\n```\nX=1 2 3 10 100 4 3\nS = 0.3 0.5 0.1 0.1 0.5 0.2 0.4\ncumskewTopN(X, S, 6)\n// output\n[,0,0,1.0182,1.4754,1.7635,1.7650]\n\nX = matrix(1..10, 11..20)\nS = matrix(2022.01.01 2022.02.03 2022.01.23 NULL 2021.12.29 2022.01.20 2022.01.23 2022.01.22 2022.01.24 2022.01.24, NULL 2022.02.03 2022.01.23 2022.04.06 NULL 2022.02.03 2022.02.03 2022.02.05 2022.02.08 2022.02.03)\ncumskewTopN(X, S, 6)\n```\n\n| #0      | #1      |\n| ------- | ------- |\n|         |         |\n| 0       |         |\n| 0       | 0       |\n| 0       | 0       |\n| 0.4373  | 0       |\n| 0.158   | 0.4347  |\n| 0       | 0.158   |\n| -0.4448 | 0       |\n| -0.4448 | -0.3599 |\n| -0.4448 | -0.1413 |\n\n```\nid=rand(10,10)\nprice=rand(100,10)\nt=table(id, price)\nselect cumskewTopN(price, id, 6) as result from t\n```\n\n| result  |\n| ------- |\n|         |\n| 0       |\n| -0.6435 |\n| -0.7353 |\n| -0.209  |\n| -0.2864 |\n| -0.0042 |\n| 0.0955  |\n| 0.0955  |\n| -0.5659 |\n"
    },
    "cumstd": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cumstd.html",
        "signatures": [
            {
                "full": "cumstd(X)",
                "name": "cumstd",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [cumstd](https://docs.dolphindb.cn/zh/funcs/c/cumstd.html)\n\n\n\n#### 语法\n\ncumstd(X)\n\n参数说明和窗口计算规则请参考：[累计窗口系列（cum 系列）](https://docs.dolphindb.cn/zh/funcs/themes/cumFunctions.html)\n\n#### 详情\n\n计算 *X* 元素的累计标准差。\n\n#### 返回值\n\nDOUBLE 类型，其数据形式同 *X*。\n\n#### 例子\n\n```\nx = [1,2,4,NULL,8];\ncumstd(x);\n// output\n[,0.707107,1.527525,1.527525,3.095696]\n\nm=matrix(0.15 0.08 0.03 -0.14 -0.09, 0.2 -0.12 -0.16 0.08 0.16);\nm;\n```\n\n| #0    | #1    |\n| ----- | ----- |\n| 0.15  | 0.2   |\n| 0.08  | -0.12 |\n| 0.03  | -0.16 |\n| -0.14 | 0.08  |\n| -0.09 | 0.16  |\n\n```\ncumstd(m);\n```\n\n| #0                | #1                |\n| ----------------- | ----------------- |\n|                   |                   |\n| 0.049497474683058 | 0.226274169979695 |\n| 0.060277137733417 | 0.19731531449265  |\n| 0.123558353285671 | 0.169705627484771 |\n| 0.119707978013163 | 0.16346253393362  |\n\n相关函数：[std](https://docs.dolphindb.cn/zh/funcs/s/std.html)\n"
    },
    "cumstdp": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cumstdp.html",
        "signatures": [
            {
                "full": "cumstdp(X)",
                "name": "cumstdp",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [cumstdp](https://docs.dolphindb.cn/zh/funcs/c/cumstdp.html)\n\n\n\n#### 语法\n\ncumstdp(X)\n\n参数说明和窗口计算规则请参考：[累计窗口系列（cum 系列）](https://docs.dolphindb.cn/zh/funcs/themes/cumFunctions.html)\n\n#### 详情\n\n计算 *X* 元素的累计总体标准差。\n\n#### 返回值\n\nDOUBLE 类型，其数据形式同 *X*。\n\n#### 例子\n\n```\nx = [1,2,4,NULL,8];\ncumstdp(x)\n// output \n[0, 0.5, 1.247219128924647, 1.247219128924647, 2.680951323690902]\n```\n\n```\nm=matrix(0.15 0.08 0.03 -0.14 -0.09, 0.2 -0.12 -0.16 0.08 0.16);\nm;\n```\n\n| #0    | #1    |\n| ----- | ----- |\n| 0.15  | 0.2   |\n| 0.08  | -0.12 |\n| 0.03  | -0.16 |\n| -0.14 | 0.08  |\n| -0.09 | 0.16  |\n\n```\ncumstdp(m);\n```\n\n| col1   | col2   |\n| ------ | ------ |\n| 0      | 0      |\n| 0.035  | 0.16   |\n| 0.0492 | 0.1611 |\n| 0.107  | 0.147  |\n| 0.1071 | 0.1462 |\n"
    },
    "cumstdpTopN": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cumstdpTopN.html",
        "signatures": [
            {
                "full": "cumstdpTopN(X, S, top, [ascending=true], [tiesMethod='latest'])",
                "name": "cumstdpTopN",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "S",
                        "name": "S"
                    },
                    {
                        "full": "top",
                        "name": "top"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[tiesMethod='latest']",
                        "name": "tiesMethod",
                        "optional": true,
                        "default": "'latest'"
                    }
                ]
            }
        ],
        "markdown": "### [cumstdpTopN](https://docs.dolphindb.cn/zh/funcs/c/cumstdpTopN.html)\n\n\n\n#### 语法\n\ncumstdpTopN(X, S, top, \\[ascending=true], \\[tiesMethod='latest'])\n\n部分通用参数说明和窗口计算规则请参考：[cumTopN 系列](https://docs.dolphindb.cn/zh/funcs/themes/cumTopN.html)\n\n#### 详情\n\n在累计窗口内，根据 *ascending* 指定的排序方式将 *X* 按照 *S* 进行稳定排序后，取前 *top* 个元素并计算总体标准差。\n\n#### 返回值\n\nDOUBLE 类型向量或矩阵。\n\n#### 例子\n\n```\nX=1 2 3 10 100 4 3\nS = 0.3 0.5 0.1 0.1 0.5 0.2 0.4\ncumstdpTopN(X, S, 6)\n// output\n[0,0.5,0.8164,3.5355,38.5299,35.8933,35.8116]\n\nX = matrix(1..10, 11..20)\nS = matrix(2022.01.01 2022.02.03 2022.01.23 NULL 2021.12.29 2022.01.20 2022.01.23 2022.01.22 2022.01.24 2022.01.24, NULL 2022.02.03 2022.01.23 2022.04.06 NULL 2022.02.03 2022.02.03 2022.02.05 2022.02.08 2022.02.03)\ncumstdpTopN(X, S, 6)\n```\n\n| #1     | #2     |\n| ------ | ------ |\n| 0      |        |\n| 0.5    | 0      |\n| 0.8165 | 0.5    |\n| 0.8165 | 0.8165 |\n| 1.479  | 0.8165 |\n| 1.8547 | 1.479  |\n| 2.1602 | 1.8547 |\n| 2.3805 | 2.1602 |\n| 2.3805 | 2.5441 |\n| 2.3805 | 2.7689 |\n\n```\nid=rand(10,10)\nprice=rand(100,10)\nt=table(id, price)\nselect cumstdpTopN(price, id, 6) as result from t\n```\n\n| result  |\n| ------- |\n| 0       |\n| 28.5    |\n| 26.8701 |\n| 24.8294 |\n| 22.2657 |\n| 29.4543 |\n| 29.4543 |\n| 30.8081 |\n| 25.5435 |\n| 25.5435 |\n"
    },
    "cumstdTopN": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cumstdTopN.html",
        "signatures": [
            {
                "full": "cumstdTopN(X, S, top, [ascending=true], [tiesMethod='latest'])",
                "name": "cumstdTopN",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "S",
                        "name": "S"
                    },
                    {
                        "full": "top",
                        "name": "top"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[tiesMethod='latest']",
                        "name": "tiesMethod",
                        "optional": true,
                        "default": "'latest'"
                    }
                ]
            }
        ],
        "markdown": "### [cumstdTopN](https://docs.dolphindb.cn/zh/funcs/c/cumstdTopN.html)\n\n\n\n#### 语法\n\ncumstdTopN(X, S, top, \\[ascending=true], \\[tiesMethod='latest'])\n\n部分通用参数说明和窗口计算规则请参考：[cumTopN 系列](https://docs.dolphindb.cn/zh/funcs/themes/cumTopN.html)\n\n#### 详情\n\n在累计窗口内，根据 *ascending* 指定的排序方式将 *X* 按照 *S* 进行稳定排序后，取前 *top* 个元素并计算标准差。\n\n#### 返回值\n\nDOUBLE 类型向量或矩阵。\n\n#### 例子\n\n```\nX=1 2 3 10 100 4 3\nS = 0.3 0.5 0.1 0.1 0.5 0.2 0.4\ncumstdTopN(X, S, 6)\n// output\n[,0.70,1,4.08,43.07,39.31,39.22]\n\nX = matrix(1..10, 11..20)\nS = matrix(2022.01.01 2022.02.03 2022.01.23 NULL 2021.12.29 2022.01.20 2022.01.23 2022.01.22 2022.01.24 2022.01.24, NULL 2022.02.03 2022.01.23 2022.04.06 NULL 2022.02.03 2022.02.03 2022.02.05 2022.02.08 2022.02.03)\ncumstdTopN(X, S, 6)\n```\n\n| #0     | #1     |\n| ------ | ------ |\n|        |        |\n| 0.7071 |        |\n| 1      | 0.7071 |\n| 1      | 1      |\n| 1.7078 | 1      |\n| 2.0736 | 1.7078 |\n| 2.3664 | 2.0736 |\n| 2.6077 | 2.3664 |\n| 2.6077 | 2.7869 |\n| 2.6077 | 3.0332 |\n\n```\nid=rand(10,10)\nprice=rand(100,10)\nt=table(id, price)\nselect cumavgTopN(price, id, 6) as result from t\n```\n\n| result  |\n| ------- |\n| 94      |\n| 69.5    |\n| 46.3333 |\n| 55.75   |\n| 57.8    |\n| 49.6667 |\n| 50.5    |\n| 50.5    |\n| 51.5    |\n| 51.5    |\n"
    },
    "cumsum": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cumsum.html",
        "signatures": [
            {
                "full": "cumsum(X)",
                "name": "cumsum",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [cumsum](https://docs.dolphindb.cn/zh/funcs/c/cumsum.html)\n\n\n\n#### 语法\n\ncumsum(X)\n\n参数说明和窗口计算规则请参考：[累计窗口系列（cum 系列）](https://docs.dolphindb.cn/zh/funcs/themes/cumFunctions.html)\n\n#### 详情\n\n计算 *X* 元素的累计和。\n\n**Note:**\n\n与 NumPy 的 [numpy.cumsum](https://numpy.com.cn/doc/stable/reference/generated/numpy.cumsum.html) 的功能基本相同，区别在于 DolphinDB 的 `cumsum` 对矩阵默认按列累加（等价于 `numpy.cumsum` 设置 *axis*=0），且只接受一个参数 *X*，不支持 `numpy.cumsum` 中的 *axis*、*dtype* 和 *out* 参数。\n\n#### 返回值\n\nLONG/DOUBLE 类型，其数据形式同 *X*。\n\n#### 例子\n\n```\nx=[2,3,4];\ncumsum(x);\n// output\n[2,5,9]\n\nm=matrix(1 2 3, 4 5 6);\nm;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 4  |\n| 2  | 5  |\n| 3  | 6  |\n\n```\ncumsum(m);\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 4  |\n| 3  | 9  |\n| 6  | 15 |\n\n相关函数：[sum](https://docs.dolphindb.cn/zh/funcs/s/sum.html)\n"
    },
    "cumsum2": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cumsum2.html",
        "signatures": [
            {
                "full": "cumsum2(X)",
                "name": "cumsum2",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [cumsum2](https://docs.dolphindb.cn/zh/funcs/c/cumsum2.html)\n\n\n\n#### 语法\n\ncumsum2(X)\n\n参数说明和窗口计算规则请参考：[累计窗口系列（cum 系列）](https://docs.dolphindb.cn/zh/funcs/themes/cumFunctions.html)\n\n#### 详情\n\n计算 *X* 元素的累计平方和。\n\n#### 返回值\n\nDOUBLE 类型，其数据形式同 *X*。\n\n#### 例子\n\n```\nx=[2,3,4];\ncumsum2 x;\n// output\n[4,13,29]\n\nm=matrix(1 2 3, 4 5 6);\nm;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 16 |\n| 5  | 41 |\n| 14 | 77 |\n\n相关函数：[sum2](https://docs.dolphindb.cn/zh/funcs/s/sum2.html)\n"
    },
    "cumsum3": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cumsum3.html",
        "signatures": [
            {
                "full": "cumsum3(X)",
                "name": "cumsum3",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [cumsum3](https://docs.dolphindb.cn/zh/funcs/c/cumsum3.html)\n\n\n\n#### 语法\n\ncumsum3(X)\n\n参数说明和窗口计算规则请参考：[累计窗口系列（cum 系列）](https://docs.dolphindb.cn/zh/funcs/themes/cumFunctions.html)\n\n#### 详情\n\n计算 *X* 元素的累计立方和。\n\n#### 返回值\n\nDOUBLE 类型，其数据形式同 *X*。\n\n#### 例子\n\n```\nx=[2,3,4];\ncumsum3 x;\n// output\n[8,35,99]\n\nm=matrix(1 2 3, 4 5 6);\nm;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 4  |\n| 2  | 5  |\n| 3  | 6  |\n\n```\ncumsum3(m);\n```\n\n| #0 | #1  |\n| -- | --- |\n| 1  | 64  |\n| 9  | 189 |\n| 36 | 405 |\n\n相关函数：[sum](https://docs.dolphindb.cn/zh/funcs/s/sum.html)\n"
    },
    "cumsum4": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cumsum4.html",
        "signatures": [
            {
                "full": "cumsum4(X)",
                "name": "cumsum4",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [cumsum4](https://docs.dolphindb.cn/zh/funcs/c/cumsum4.html)\n\n\n\n#### 语法\n\ncumsum4(X)\n\n参数说明和窗口计算规则请参考：[累计窗口系列（cum 系列）](https://docs.dolphindb.cn/zh/funcs/themes/cumFunctions.html)\n\n#### 详情\n\n计算 *X* 元素的累计四次方和。\n\n#### 返回值\n\nDOUBLE 类型，其数据形式同 *X*。\n\n#### 例子\n\n```\nx=[2,3,4];\ncumsum4 x;\n// output\n[16,97,353]\n\nm=matrix(1 2 3, 4 5 6);\nm;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 4  |\n| 2  | 5  |\n| 3  | 6  |\n\n```\ncumsum4(m);\n```\n\n| #0 | #1   |\n| -- | ---- |\n| 1  | 256  |\n| 17 | 881  |\n| 98 | 2177 |\n\n相关函数：[sum4](https://docs.dolphindb.cn/zh/funcs/s/sum4.html)\n"
    },
    "cumsumTopN": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cumsumTopN.html",
        "signatures": [
            {
                "full": "cumsumTopN(X, S, top, [ascending=true], [tiesMethod='latest'])",
                "name": "cumsumTopN",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "S",
                        "name": "S"
                    },
                    {
                        "full": "top",
                        "name": "top"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[tiesMethod='latest']",
                        "name": "tiesMethod",
                        "optional": true,
                        "default": "'latest'"
                    }
                ]
            }
        ],
        "markdown": "### [cumsumTopN](https://docs.dolphindb.cn/zh/funcs/c/cumsumTopN.html)\n\n\n\n#### 语法\n\ncumsumTopN(X, S, top, \\[ascending=true], \\[tiesMethod='latest'])\n\n部分通用参数说明和窗口计算规则请参考：[cumTopN 系列](https://docs.dolphindb.cn/zh/funcs/themes/cumTopN.html)\n\n#### 详情\n\n在累计窗口内，根据 *ascending* 指定的排序方式将 *X* 按照 *S* 进行稳定排序后，取前 *top* 个元素并计算和。\n\n#### 返回值\n\nLONG 或 DOUBLE 类型向量或矩阵。\n\n#### 例子\n\n```\nX=1 2 3 10 100 4 3\nS = 0.3 0.5 0.1 0.1 0.5 0.2 0.4\ncumsumTopN(X, S, 6)\n// output\n[1,3,6,16,116,120,121]\n\nX = matrix(1..10, 11..20)\nS = matrix(2022.01.01 2022.02.03 2022.01.23 NULL 2021.12.29 2022.01.20 2022.01.23 2022.01.22 2022.01.24 2022.01.24, NULL 2022.02.03 2022.01.23 2022.04.06 NULL 2022.02.03 2022.02.03 2022.02.05 2022.02.08 2022.02.03)\ncumsumTopN(X, S, 6, 4)\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  |    |\n| 3  | 12 |\n| 6  | 25 |\n| 6  | 39 |\n| 11 | 39 |\n| 17 | 55 |\n| 24 | 72 |\n| 30 | 90 |\n| 30 | 95 |\n| 30 | 96 |\n\n```\nid=rand(10,10)\nprice=rand(100,10)\nt=table(id, price)\nselect cumsumTopN(price, id, 6, 4) as result from t\n```\n\n| result |\n| ------ |\n| 32     |\n| 130    |\n| 145    |\n| 223    |\n| 283    |\n| 292    |\n| 344    |\n| 364    |\n| 406    |\n| 333    |\n"
    },
    "cumvar": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cumvar.html",
        "signatures": [
            {
                "full": "cumvar(X)",
                "name": "cumvar",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [cumvar](https://docs.dolphindb.cn/zh/funcs/c/cumvar.html)\n\n\n\n#### 语法\n\ncumvar(X)\n\n参数说明和窗口计算规则请参考：[累计窗口系列（cum 系列）](https://docs.dolphindb.cn/zh/funcs/themes/cumFunctions.html)\n\n#### 详情\n\n计算 *X* 元素的累计方差。\n\n#### 返回值\n\nDOUBLE 类型，其数据形式同 *X*。\n\n#### 例子\n\n```\nx=[2,3,4];\ncumvar(x);\n// output\n[,0.5,1]\n\nm=matrix(0.15 0.08 0.03 -0.14 -0.09, 0.2 -0.12 -0.16 0.08 0.16);\nm;\n```\n\n| #0    | #1    |\n| ----- | ----- |\n| 0.15  | 0.2   |\n| 0.08  | -0.12 |\n| 0.03  | -0.16 |\n| -0.14 | 0.08  |\n| -0.09 | 0.16  |\n\n```\ncumvar(m);\n```\n\n| #0     | #1     |\n| ------ | ------ |\n|        |        |\n| 0.0024 | 0.0512 |\n| 0.0036 | 0.0389 |\n| 0.0152 | 0.0288 |\n| 0.0143 | 0.0267 |\n\n相关函数：[cummax](https://docs.dolphindb.cn/zh/funcs/c/cummax.html), [cummin](https://docs.dolphindb.cn/zh/funcs/c/cummin.html), [cumprod](https://docs.dolphindb.cn/zh/funcs/c/cumprod.html), [cumPositiveStreak](https://docs.dolphindb.cn/zh/funcs/c/cumPositiveStreak.html), [cumsum](https://docs.dolphindb.cn/zh/funcs/c/cumsum.html), [cumavg](https://docs.dolphindb.cn/zh/funcs/c/cumavg.html), [cumstd](https://docs.dolphindb.cn/zh/funcs/c/cumstd.html)\n"
    },
    "cumvarp": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cumvarp.html",
        "signatures": [
            {
                "full": "cumvarp(X)",
                "name": "cumvarp",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [cumvarp](https://docs.dolphindb.cn/zh/funcs/c/cumvarp.html)\n\n\n\n#### 语法\n\ncumvarp(X)\n\n参数说明和窗口计算规则请参考：[累计窗口系列（cum 系列）](https://docs.dolphindb.cn/zh/funcs/themes/cumFunctions.html)\n\n#### 详情\n\n计算 *X* 元素的累计总体方差。\n\n#### 返回值\n\nDOUBLE 类型，其数据形式同 *X*。\n\n#### 例子\n\n```\ncumvarp(1 2 3 NULL 4);\n// output\n[ , 0.25, 0.666666666666667, 0.666666666666667, 1.25]\n\nm=matrix(1.1 3 5.0 7.5 9.2, 1 4.3 7.1 10.6 13.5);\nm;\n```\n\n| col1 | col2 |\n| ---- | ---- |\n| 1.1  | 1    |\n| 3    | 4.3  |\n| 5    | 7.1  |\n| 7.5  | 10.6 |\n| 9.2  | 13.5 |\n\n```\ncumvarp(m);\n```\n\n| col1   | col2    |\n| ------ | ------- |\n| 0      | 0       |\n| 0.9025 | 2.7225  |\n| 2.5356 | 6.2156  |\n| 5.6425 | 12.5025 |\n| 8.5944 | 19.612  |\n\n相关函数： [var](https://docs.dolphindb.cn/zh/funcs/v/varp.html)\n"
    },
    "cumvarpTopN": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cumvarpTopN.html",
        "signatures": [
            {
                "full": "cumvarpTopN(X, S, top, [ascending=true], [tiesMethod='latest'])",
                "name": "cumvarpTopN",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "S",
                        "name": "S"
                    },
                    {
                        "full": "top",
                        "name": "top"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[tiesMethod='latest']",
                        "name": "tiesMethod",
                        "optional": true,
                        "default": "'latest'"
                    }
                ]
            }
        ],
        "markdown": "### [cumvarpTopN](https://docs.dolphindb.cn/zh/funcs/c/cumvarpTopN.html)\n\n\n\n#### 语法\n\ncumvarpTopN(X, S, top, \\[ascending=true], \\[tiesMethod='latest'])\n\n部分通用参数说明和窗口计算规则请参考：[cumTopN 系列](https://docs.dolphindb.cn/zh/funcs/themes/cumTopN.html)\n\n#### 详情\n\n在累计窗口内，根据 *ascending* 指定的排序方式将 *X* 按照 *S* 进行稳定排序后，取前 *top* 个元素并计算总体方差。\n\n#### 返回值\n\nDOUBLE 类型向量或矩阵。\n\n#### 例子\n\n```\nX=1 2 3 10 100 4 3\nS = 0.3 0.5 0.1 0.1 0.5 0.2 0.4\ncumvarpTopN(X, S, 6)\n// output\n[0,0.25,0.6666,12.5,1484.5599,1288.3333,1282.4722]\n\nX = matrix(1..10, 11..20)\nS = matrix(2022.01.01 2022.02.03 2022.01.23 NULL 2021.12.29 2022.01.20 2022.01.23 2022.01.22 2022.01.24 2022.01.24, NULL 2022.02.03 2022.01.23 2022.04.06 NULL 2022.02.03 2022.02.03 2022.02.05 2022.02.08 2022.02.03)\ncumvarpTopN(X, S, 6)\n```\n\n| #1     | #2     |\n| ------ | ------ |\n| 0      |        |\n| 0.25   | 0      |\n| 0.6667 | 0.25   |\n| 0.6667 | 0.6667 |\n| 2.1875 | 0.6667 |\n| 3.44   | 2.1875 |\n| 4.6667 | 3.44   |\n| 5.6667 | 4.6667 |\n| 5.6667 | 6.4722 |\n| 5.6667 | 7.6667 |\n\n```\nid=rand(10,10)\nprice=rand(100,10)\nt=table(id, price)\nselect cumvarpTopN(price, id, 6) as result from t\n```\n\n| result   |\n| -------- |\n| 0        |\n| 182.25   |\n| 124.2222 |\n| 114.5    |\n| 255.44   |\n| 428.4722 |\n| 428.4722 |\n| 416.9167 |\n| 722.9167 |\n| 722.9167 |\n"
    },
    "cumvarTopN": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cumvarTopN.html",
        "signatures": [
            {
                "full": "cumvarTopN(X, S, top, [ascending=true], [tiesMethod='latest'])",
                "name": "cumvarTopN",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "S",
                        "name": "S"
                    },
                    {
                        "full": "top",
                        "name": "top"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[tiesMethod='latest']",
                        "name": "tiesMethod",
                        "optional": true,
                        "default": "'latest'"
                    }
                ]
            }
        ],
        "markdown": "### [cumvarTopN](https://docs.dolphindb.cn/zh/funcs/c/cumvarTopN.html)\n\n\n\n#### 语法\n\ncumvarTopN(X, S, top, \\[ascending=true], \\[tiesMethod='latest'])\n\n部分通用参数说明和窗口计算规则请参考：[cumTopN 系列](https://docs.dolphindb.cn/zh/funcs/themes/cumTopN.html)\n\n#### 详情\n\n在累计窗口内，根据 *ascending* 指定的排序方式将 *X* 按照 *S* 进行稳定排序后，取前 *top* 个元素并计算方差。\n\n#### 返回值\n\nDOUBLE 类型向量或矩阵。\n\n#### 例子\n\n```\nX=1 2 3 10 100 4 3\nS = 0.3 0.5 0.1 0.1 0.5 0.2 0.4\ncumvarTopN(X, S, 6)\n// output\n[,0.5,1,16.6666,1855.7,1546,1538.9666]\n\nX = matrix(1..10, 11..20)\nS = matrix(2022.01.01 2022.02.03 2022.01.23 NULL 2021.12.29 2022.01.20 2022.01.23 2022.01.22 2022.01.24 2022.01.24, NULL 2022.02.03 2022.01.23 2022.04.06 NULL 2022.02.03 2022.02.03 2022.02.05 2022.02.08 2022.02.03)\ncumvarTopN(X, S, 6)\n```\n\n| #0     | #1     |\n| ------ | ------ |\n|        |        |\n| 0.5    |        |\n| 1      | 0.5    |\n| 1      | 1      |\n| 2.9167 | 1      |\n| 4.3    | 2.9167 |\n| 5.6    | 4.3    |\n| 6.8    | 5.6    |\n| 6.8    | 7.7667 |\n| 6.8    | 9.2    |\n\n```\nid=rand(10,10)\nprice=rand(100,10)\nt=table(id, price)\nselect cumvarTopN(price, id, 6) as result from t\n```\n\n| result   |\n| -------- |\n|          |\n| 800      |\n| 808.3333 |\n| 730.25   |\n| 825.2    |\n| 903.3667 |\n| 747.3667 |\n| 856.7    |\n| 887.4667 |\n| 994.9667 |\n"
    },
    "cumwavg": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cumwavg.html",
        "signatures": [
            {
                "full": "cumwavg(X, Y)",
                "name": "cumwavg",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [cumwavg](https://docs.dolphindb.cn/zh/funcs/c/cumwavg.html)\n\n\n\n#### 语法\n\ncumwavg(X, Y)\n\n参数说明和窗口计算规则请参考：[累计窗口系列（cum 系列）](https://docs.dolphindb.cn/zh/funcs/themes/cumFunctions.html)\n\n#### 详情\n\n以 *Y* 为权重，计算 *X* 的累计加权平均。\n\n#### 返回值\n\nDOUBLE 类型，其数据形式同 *X*(*Y*)。\n\n#### 例子\n\n```\ncumwavg(2.2 1.1 3.3, 4 5 6);\n// output\n[2.2,1.588889,2.273333]\n\ncumwavg(1 NULL 1, 1 1 1);\n// output\n[1,1,1]\n```\n\n相关函数：[wavg](https://docs.dolphindb.cn/zh/funcs/w/wavg.html)\n"
    },
    "cumwsum": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cumwsum.html",
        "signatures": [
            {
                "full": "cumwsum(X, Y)",
                "name": "cumwsum",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [cumwsum](https://docs.dolphindb.cn/zh/funcs/c/cumwsum.html)\n\n\n\n#### 语法\n\ncumwsum(X, Y)\n\n参数说明和窗口计算规则请参考：[累计窗口系列（cum 系列）](https://docs.dolphindb.cn/zh/funcs/themes/cumFunctions.html)\n\n#### 详情\n\n计算 *X* 和 *Y* 的累计内积。\n\n#### 返回值\n\nDOUBLE 类型，其数据形式同 *X*(*Y*)。\n\n#### 例子\n\n```\ncumwsum(2.2 1.1 3.3, 4 5 6);\n// output\n[8.8,14.3,34.1]\n\ncumwsum(1 NULL 1, 1 1 1);\n// output\n[1,1,2]\n```\n\n相关函数：[wsum](https://docs.dolphindb.cn/zh/funcs/w/wsum.html)\n"
    },
    "cumwsumTopN": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cumwsumTopN.html",
        "signatures": [
            {
                "full": "cumwsumTopN(X, Y, S, top, [ascending=true], [tiesMethod='latest'])",
                "name": "cumwsumTopN",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "S",
                        "name": "S"
                    },
                    {
                        "full": "top",
                        "name": "top"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[tiesMethod='latest']",
                        "name": "tiesMethod",
                        "optional": true,
                        "default": "'latest'"
                    }
                ]
            }
        ],
        "markdown": "### [cumwsumTopN](https://docs.dolphindb.cn/zh/funcs/c/cumwsumTopN.html)\n\n\n\n#### 语法\n\ncumwsumTopN(X, Y, S, top, \\[ascending=true], \\[tiesMethod='latest'])\n\n部分通用参数说明和窗口计算规则请参考：[cumTopN 系列](https://docs.dolphindb.cn/zh/funcs/themes/cumTopN.html)\n\n#### 详情\n\n在累计窗口内，根据 *ascending* 指定的排序方式将 *X* 和 *Y* 按照 *S* 进行稳定排序后，取前 *top* 个元素，然后计算 *X* 和 *Y* 的内积。\n\n#### 返回值\n\nDOUBLE 类型向量或矩阵。\n\n#### 例子\n\n```\nX=1 2 3 10 13 4 3\nY = 1 7 8 9 0 5 8\nS = 0.3 0.5 0.1 0.1 0.5 0.2 0.4\ncumwsumTopN(X, Y, S, 6)\n```\n\n返回值为：\\[1,15,39,129,129,149,159]\n"
    },
    "curvePredict": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/curvePredict.html",
        "signatures": [
            {
                "full": "curvePredict(curve, dt)",
                "name": "curvePredict",
                "parameters": [
                    {
                        "full": "curve",
                        "name": "curve"
                    },
                    {
                        "full": "dt",
                        "name": "dt"
                    }
                ]
            }
        ],
        "markdown": "### [curvePredict](https://docs.dolphindb.cn/zh/funcs/c/curvePredict.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\ncurvePredict(curve, dt)\n\n#### 详情\n\n在给定的曲线上，预测指定点位（由 *dt*确定）的曲线值。目前仅支持零息利率曲线。\n\n#### 参数\n\n**curve** MKTDATA 类型对象（IrYieldCurve）。\n\n**dt** DOUBLE 类型标量/向量，或 DATE 类型标量/向量。\n\n* 当类型为 DOUBLE 时，表示以“年”为单位的时间。\n\n* 当类型为 DATE 时，表示具体的日期。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\ncurveDict = {\n    \"mktDataType\": \"Curve\",\n    \"curveType\": \"IrYieldCurve\",\n    \"referenceDate\": 2025.08.18,\n    \"currency\": \"CNY\",\n    \"dayCountConvention\": \"ActualActualISDA\",\n    \"compounding\": \"Continuous\",  \n    \"interpMethod\": \"Linear\",\n    \"extrapMethod\": \"Flat\",\n    \"frequency\": \"Annual\",\n    \"dates\": [2025.08.21,\n              2025.08.27,\n              2025.09.03,\n              2025.09.10,\n              2025.09.22,\n              2025.10.20,\n              2025.11.20,\n              2026.02.24,\n              2026.05.20,\n              2026.08.20,\n              2027.02.22,\n              2027.08.20,\n              2028.08.21],\n    \"values\":[1.5113, \n              1.5402, \n              1.5660, \n              1.5574, \n              1.5556, \n              1.5655, \n              1.5703, \n              1.5934, \n              1.6040, \n              1.6020, \n              1.5928, \n              1.5842, \n              1.6068]/100\n}\n\ncurve = parseMktData(curveDict)\n\ncurvePredict(curve, 2025.10.18)\n\n// output: 0.0156\n\ncurvePredict(curve, 1.0)\n// output: 0.0160\n\nprint curvePredict(curve, [2025.10.18, 2026.10.18])\n// output: [0.0156,0.0159]\n\nprint curvePredict(curve, [1.0, 2.0])\n// output: [0.0160,0.0158]\n```\n\n**相关函数：**[parseMktData](https://docs.dolphindb.cn/zh/funcs/p/parseMktData.html)\n"
    },
    "cut": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cut.html",
        "signatures": [
            {
                "full": "cut(X, size|cutPositions)",
                "name": "cut",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "size|cutPositions",
                        "name": "size|cutPositions"
                    }
                ]
            }
        ],
        "markdown": "### [cut](https://docs.dolphindb.cn/zh/funcs/c/cut.html)\n\n\n\n#### 语法\n\ncut(X, size|cutPositions)\n\n#### 详情\n\n将 *X* 分为一系列标量、向量、矩阵（按列）或表（按行）。\n\n* 当 *X* 是标量时：第二个参数只能是 *size*，且 *size* 值只能为1，cut 函数返回由 *X* 组成的元组。\n\n* 当 *X* 是向量时：\n\n  * 若第二个参数为 *size*：cut 函数把 *X* 分成一系列长度为 *size* 的标量（*size* =1时）或向量（*size* >1时）。\n\n  * 若第二个参数为 *cutPositions*，cut 函数先根据 *cutPositions* 将 *X* 分段，然后返回每段子向量组成的元组。\n\n* 当 *X* 是矩阵（表）时：\n\n  * 若第二个参数为 *size*：cut 函数把 *X* 分成一系列列数（行数）为 *size* 的矩阵（表）。\n\n  * 若第二个参数为 *cutPositions*，cut 函数先根据 *cutPositions* 将 *X* 分段，然后返回每个子矩阵（子表）组成的元组。\n\n关于该函数的逆操作，参见 [flatten](https://docs.dolphindb.cn/zh/funcs/f/flatten.html) 函数。\n\n**Note:**\n\n虽然同名，但与 Pandas 的 [pandas.cut](https://pandas.ac.cn/docs/reference/api/pandas.cut.html) 不同。DolphinDB 的 `cut` 用于切分数据结构，且不支持 `pandas.cut` 中的 *right*、*labels*、*retbins* 等参数；而 `pandas.cut` 用于数值分箱分类。\n\n|                                | DolphinDB `cut` | `pandas.cut`   |\n| ------------------------------ | --------------- | -------------- |\n| 作用                             | 将数据结构物理切分成多段    | 将数值数据逻辑分类到不同区间 |\n| 参数 *X* / *x*                   | 标量/向量           | 一维数组（类数组对象）    |\n| 参数 *size* / *bins*(int)        | 每段包含的元素个数       | 要分成的区间数量       |\n| 参数 *cutPositions* / *bins*(序列) | 切分的索引位置（从0开始）   | 数值区间的边界值       |\n\n#### 参数\n\n**X** 是标量/向量。\n\n**size** 是整型标量，必须满足 0<*size*<=*size*(*X*) 条件。\n\n**cutPositions** 是单增的整型向量，用于指定切分段开始的索引。\n\n#### 例子\n\n```\na=1..10;\ncut(a,2);\n// output\n([1,2],[3,4],[5,6],[7,8],[9,10])\n\ncut(a,3);\n// output\n([1,2,3],[4,5,6],[7,8,9],[10])\n\ncut(a,9);\n// output\n([1,2,3,4,5,6,7,8,9],[10])\n\nb = cut(a,2);\nb;\n// output\n([1,2],[3,4],[5,6],[7,8],[9,10])\n\nflatten b;\n// output\n(1,2,3,4,5,6,7,8,9,10)\n\ncut(a, 0 2 7);\n// output\n([1,2],[3,4,5,6,7],[8,9,10])\n\ncut(a, 2 7);\n// output\n([3,4,5,6,7],[8,9,10])\n\nm=matrix(1 5 9, 12 20 23, 25 29 32)\ncut(m,2)\n// output\n\n(#0 #1\n-- --\n1  12\n5  20\n9  23\n,#0\n--\n25\n29\n32\n)\n\ncut(m, 1 2)\n// output\n(#0\n--\n12\n20\n23\n,#0\n--\n25\n29\n32\n)\n```\n\n`cut` 函数在时间数据分析中是一个方便的工具。在下面的例子中，我们用 `cut` 函数计算两个事件发生期间的收入和。\n\n```\nincomes=table(2016.07.31 - 10..1 as date, rand(100,10) as income);\nincomes;\n```\n\n| date       | income |\n| ---------- | ------ |\n| 2016.07.21 | 78     |\n| 2016.07.22 | 61     |\n| 2016.07.23 | 79     |\n| 2016.07.24 | 15     |\n| 2016.07.25 | 78     |\n| 2016.07.26 | 22     |\n| 2016.07.27 | 30     |\n| 2016.07.28 | 81     |\n| 2016.07.29 | 17     |\n| 2016.07.30 | 52     |\n\n```\neventdates = [2016.07.22, 2016.07.25, 2016.07.29];\n\nx = incomes.date.binsrch(eventdates);\nx;\n// output\n[1,4,8]\n\nincomes.date.cut(x);\n// output\n([2016.07.22,2016.07.23,2016.07.24],[2016.07.25,2016.07.26,2016.07.27,2016.07.28],[2016.07.29,2016.07.30])\n\ntable(eventdates as startDate, each(last,incomes.date.cut(x)) as endDate, each(sum,incomes.income.cut(x)) as incomeSum);\n```\n\n| startDate  | endDate    | incomeSum |\n| ---------- | ---------- | --------- |\n| 2016.07.22 | 2016.07.24 | 155       |\n| 2016.07.25 | 2016.07.28 | 211       |\n| 2016.07.29 | 2016.07.30 | 69        |\n"
    },
    "cutPoints": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cutPoints.html",
        "signatures": [
            {
                "full": "cutPoints(X, binNum, [freq])",
                "name": "cutPoints",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "binNum",
                        "name": "binNum"
                    },
                    {
                        "full": "[freq]",
                        "name": "freq",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [cutPoints](https://docs.dolphindb.cn/zh/funcs/c/cutPoints.html)\n\n\n\n#### 语法\n\ncutPoints(X, binNum, \\[freq])\n\n#### 详情\n\n返回具有（*binNum*+1）个元素的向量，这样 *X* 中的数据均匀地分布 *binNum* 个桶中。每个桶由向量中相邻的两个元素决定，只包含下边界不包含上边界。\n\n`cutPoints` 可以用于获取 RANGE 分区数据库的分区方案。\n\n#### 参数\n\n**X** 是一个向量。\n\n**binNum** 是产生桶的数量。\n\n**freq** 是与 *X* 等长的向量。它是 *X* 中每个元素的频率。它是一个可选参数，如果指定了 *freq*，*X* 中的所有元素必须是唯一的，并且按升序存储。\n\n#### 返回值\n\n返回一个向量，其数据类型同 *X*。\n\n#### 例子\n\n```\ncutPoints(2 3 1 4, 2);\n// output\n[1,3,5]\n\ncutPoints(1 2 3 4, 2, 1 1 1 3);\n// output\n[1,4,5]\n```\n"
    },
    "condValueAtRisk": {
        "url": "https://docs.dolphindb.cn/zh/funcs/c/cvar.html",
        "signatures": [
            {
                "full": "condValueAtRisk(returns, method, [confidenceLevel=0.95])",
                "name": "condValueAtRisk",
                "parameters": [
                    {
                        "full": "returns",
                        "name": "returns"
                    },
                    {
                        "full": "method",
                        "name": "method"
                    },
                    {
                        "full": "[confidenceLevel=0.95]",
                        "name": "confidenceLevel",
                        "optional": true,
                        "default": "0.95"
                    }
                ]
            }
        ],
        "markdown": "### [condValueAtRisk](https://docs.dolphindb.cn/zh/funcs/c/cvar.html)\n\n\n\n#### 语法\n\ncondValueAtRisk(returns, method, \\[confidenceLevel=0.95])\n\n#### 详情\n\n条件风险指标（Conditional Value at Risk；也可称 Expected Shortfall），用于计算超过风控指标的损失的平均值。该函数将返回其绝对值，为 DOUBLE 类型。如果没有收益率低于 VaR 的值，则返回 VaR 的值。\n\n#### 参数\n\n**returns** 数值型向量，表示收益率序列。注意，表示收益率的每个元素都应大于 -1 且不能为空。\n\n**method** 字符串类型，表示计算 VaR 的方法，可选值为：\n\n* 'normal' 正态参数法。\n\n* 'logNormal' 对数正态参数法。\n\n* 'historical' 历史模拟法。\n\n* 'monteCarlo' 蒙特卡洛模拟法，使用正态分布进行模拟。\n\n**confidenceLevel** 数值型标量，表示置信水平，合法值域为(0,1)，默认值为 0.95。\n\n#### 返回值\n\nDOUBLE 类型标量。\n\n#### 例子\n\n本例中给定一个假设的收益率序列，通过历史模拟法，计算置信水平为 0.9 的条件风险指标。\n\n```\nreturns = [0.0, -0.0023816107391389394, -0.0028351258634076834, 0.00789570628538656, 0.0022056267475062397, -0.004515475812603498, 0.0031189325339843646, 0.010774648811452205, 0.0030816164453268957, 0.02172541561228001, 0.011106185767699728, -0.005369098699244845, -0.0096490689793588, 0.0025152212699484314, 0.017822140037111668, -0.02837536728283525, 0.018373545076599204, -0.0026401111537113003, 0.019524374522517898, -0.010800546314337627, 0.014073362622486131, -0.00398277532382243, 0.008398647051501285, 0.0024056749358184904, 0.007093080335863512, -0.005332549248384733, -0.008471915938733665, -0.0038788486165083342, -0.01308504169086584, 0.00350496242864784, 0.009036118926745962, 0.0013358223875250545, 0.0036426642608267563, 0.003974568474545581, -0.003944066366522669, -0.011969668605022311, 0.015116930499066374, 0.006931427295653037, -0.0032650627551519267, 0.003407880132851648]\ncondValueAtRisk(returns, 'historical', 0.9);\n//output:0.016057655973\n```\n\n**相关函数**：[valueAtRisk](https://docs.dolphindb.cn/zh/funcs/v/var_0.html)\n"
    },
    "haMvccTable": {
        "url": "https://docs.dolphindb.cn/zh/funcs/h/haMvccTable.html",
        "signatures": [
            {
                "full": "haMvccTable(capacity:size, table, tableName, raftGroup, [defaultValues], [allowNull])",
                "name": "haMvccTable",
                "parameters": [
                    {
                        "full": "capacity:size",
                        "name": "capacity:size"
                    },
                    {
                        "full": "table",
                        "name": "table"
                    },
                    {
                        "full": "tableName",
                        "name": "tableName"
                    },
                    {
                        "full": "raftGroup",
                        "name": "raftGroup"
                    },
                    {
                        "full": "[defaultValues]",
                        "name": "defaultValues",
                        "optional": true
                    },
                    {
                        "full": "[allowNull]",
                        "name": "allowNull",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [haMvccTable](https://docs.dolphindb.cn/zh/funcs/h/haMvccTable.html)\n\n首发版本：3.00.5\n\n\n\n#### 语法\n\nhaMvccTable(capacity:size, table, tableName, raftGroup, \\[defaultValues], \\[allowNull])\n\n#### 详情\n\n创建一个高可用多版本并发控制的表（MVCC 表）。\n\n**Note:**\n\n高可用 MVCC 表的创建、删除及写入操作必须在该 Raft 组的 Leader 节点上执行。Raft 组的 Leader 节点可通过函数 `getHaMvccLeader` 获取。\n\n#### 参数\n\n**capacity** 是正整数，表示表的容量，即建表时系统为该表分配的内存（以记录数为单位）。当记录数超过 *capacity* 时，系统会自动扩充容量。系统首先会分配当前容量1.2\\~2倍的内存，然后复制数据到新的内存空间，最后释放原来的内存。对于规模较大的表，扩容时的内存占用会很高。因此，建议创建内存表时预先分配一个合理的容量。\n\n**size** 是正整数，表示该表新建时的行数。若 *size*=0，创建一个空表；若 *size*>0，则新建表中记录的初始值由 *defaultValues* 决定。\n\n**table** 是一个表对象，高可用 MVCC 表的结构与其一致，它必须是用 `table` 函数创建的空表。\n\n**tableName** 字符串标量，表示高可用 MVCC 表的名字。\n\n**raftGroup** 是一个大于 1 的整数，表示高可用 MVCC 表使用的 Raft 组 ID。该 ID 必须预先在配置项 `mvccTableRaftGroups` 中配置。\n\n**defaultValues** 可选参数，是与表列数等长的元组，表示建表时各列的默认值。默认不指定，此时各列的默认值为 NULL。\n\n**allowNull** 可选参数，是与表列数等长的布尔向量，表示各列是否允许包含空值。默认值为 true，表示全部列允许包含空值。\n\n#### 返回值\n\n返回高可用 MVCC 表的句柄。\n\n#### 例子\n\n```\nschemaTb = table(1:0, `name`id`value, [STRING, INT, DOUBLE])\nhmvcct = haMvccTable(1:0, schemaTb, \"demoHaMvcc\", 2)\n```\n\n**相关函数**：[loadHaMvccTable](https://docs.dolphindb.cn/zh/funcs/l/loadHaMvccTable.html), [dropHaMvccTable](https://docs.dolphindb.cn/zh/funcs/d/dropHaMvccTable.html), [setHaMvccColumnNullability](https://docs.dolphindb.cn/zh/funcs/s/setHaMvccColumnNullability.html), [setHaMvccColumnDefaultValue](https://docs.dolphindb.cn/zh/funcs/s/setHaMvccColumnDefaultValue.html), [getHaMvccRaftGroups](https://docs.dolphindb.cn/zh/funcs/g/getHaMvccRaftGroups.html), [getHaMvccLeader](https://docs.dolphindb.cn/zh/funcs/g/getHaMvccLeader.html), [getHaMvccTableInfo](https://docs.dolphindb.cn/zh/funcs/g/getHaMvccTableInfo.html), [checkpointHaMvcc](https://docs.dolphindb.cn/zh/funcs/c/checkpointHaMvcc.html), [isCheckpointingHaMvcc](https://docs.dolphindb.cn/zh/funcs/i/isCheckpointingHaMvcc.html)\n"
    },
    "hashBucket": {
        "url": "https://docs.dolphindb.cn/zh/funcs/h/hashBucket.html",
        "signatures": [
            {
                "full": "hashBucket(X, buckets)",
                "name": "hashBucket",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "buckets",
                        "name": "buckets"
                    }
                ]
            }
        ],
        "markdown": "### [hashBucket](https://docs.dolphindb.cn/zh/funcs/h/hashBucket.html)\n\n\n\n#### 语法\n\nhashBucket(X, buckets)\n\n#### 详情\n\n将 *X* 中的每个元素哈希到指定数量的桶中，并返回对应的桶编号。\n\n#### 参数\n\n**X** 可以是标量或向量。\n\n**buckets** 是一个正整数。\n\n#### 返回值\n\n一个标量或向量，表示桶编号。\n\n#### 例子\n\n```\nhashBucket(34 45 67, 10);\n\n// output\n[4,5,7]\n\nhashBucket(`AAPL`TSLA`GS`MS`GE`BA`UAL`WMT, 10);\n\n// output\n[9,4,1,8,3,7,5,2]\n```\n"
    },
    "hasNull": {
        "url": "https://docs.dolphindb.cn/zh/funcs/h/hasNull.html",
        "signatures": [
            {
                "full": "hasNull(X)",
                "name": "hasNull",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [hasNull](https://docs.dolphindb.cn/zh/funcs/h/hasNull.html)\n\n\n\n#### 语法\n\nhasNull(X)\n\n#### 详情\n\n判断 *X* 中是否包含 NULL 值。\n\n* 如果 *X* 是标量，当 *X* 为 NULL 值时，该函数返回 true。\n\n* 如果 *X* 是向量，当 *X* 中至少有一个元素为 NULL 时，该函数返回 true。\n\n* 如果 *X* 是矩阵或表，当 *X* 中至少有一列包含 NULL 值时，该函数返回 true。\n\n#### 参数\n\n**X** 可以是标量、向量、矩阵或表。\n\n#### 返回值\n\n一个布尔值。\n\n#### 例子\n\n```\nhasNull NULL;\n// output\ntrue\n\nx=00f;\nhasNull x;\n// output\ntrue\n\nhasNull 5;\n// output\nfalse\n\nhasNull(1 2 NULL 4 NULL 6);\n// output\ntrue\n\nx=((NULL,1),2);\nhasNull x;\n// output\nfalse\n\nm=(1 NULL 3 4 5 6)$2:3;\nhasNull m;\n// output\ntrue\n\nt=table(`AAPL`IBM`MSFT as sym, 2200 NULL 4500 as qty);\nhasNull(t);\n// output\ntrue\n```\n\n相关函数：[isNull](https://docs.dolphindb.cn/zh/funcs/i/isNull.html), [nullFill](https://docs.dolphindb.cn/zh/funcs/n/nullFill.html)\n"
    },
    "haStreamTable": {
        "url": "https://docs.dolphindb.cn/zh/funcs/h/haStreamTable.html",
        "signatures": [
            {
                "full": "haStreamTable(raftGroup, table, tableName, cacheSize, [keyColumn], [retentionMinutes=1440], [preCache])",
                "name": "haStreamTable",
                "parameters": [
                    {
                        "full": "raftGroup",
                        "name": "raftGroup"
                    },
                    {
                        "full": "table",
                        "name": "table"
                    },
                    {
                        "full": "tableName",
                        "name": "tableName"
                    },
                    {
                        "full": "cacheSize",
                        "name": "cacheSize"
                    },
                    {
                        "full": "[keyColumn]",
                        "name": "keyColumn",
                        "optional": true
                    },
                    {
                        "full": "[retentionMinutes=1440]",
                        "name": "retentionMinutes",
                        "optional": true,
                        "default": "1440"
                    },
                    {
                        "full": "[preCache]",
                        "name": "preCache",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [haStreamTable](https://docs.dolphindb.cn/zh/funcs/h/haStreamTable.html)\n\n\n\n#### 语法\n\nhaStreamTable(raftGroup, table, tableName, cacheSize, \\[keyColumn], \\[retentionMinutes=1440], \\[preCache])\n\n#### 详情\n\n创建高可用流数据表。该函数只能在启用流数据高可用后使用。要启用流数据高可用，用户需要在集群配置文件 cluster.cfg 中指定配置参数 *streamingHAMode* 和 *streamingRaftGroups*。系统启动时，配置参数 *streamingRaftGroup* 指定的数据节点/计算节点组成 Raft 组，一个数据节点/计算节点作为 Leader，其他数据节点/计算节点作为 Follower。Raft 组的每个数据节点/计算节点上都有流数据表的副本。\n\n客户端只需订阅 Raft 组中任意一个数据节点/计算节点上的高可用流数据表，并启用订阅的自动重连功能，即把 *reconnect* 参数设置为 true。Leader 上的高可用流数据表会向客户端发布数据。如果 Raft 组中的 Leader 宕机，系统会选举出新的 Leader 继续发布数据，客户端会自动切换订阅到新的 Leader 上的高可用流数据表。\n\n一个 Raft 组可以包含多个高可用流数据表。\n\n#### 参数\n\n**raftGroup** 是一个大于1的整数，用于指定 Raft 组的 ID。\n\n**table** 是一个表对象。它必须是一个由 `table` 函数创建的空表。\n\n**tableName** 是一个字符串，用于指定高可用流数据表的名称。\n\n**cacheSize** 是一个正整数，用于指定高可用流数据表在内存中最多保留多少行。如果 *cacheSize* 是小于1000的正整数，它会被自动调整为1000。\n\n**keyColumn** 可选参数，字符串标量或向量，用于指定主键。设置该参数后，将创建高可用的[键值流数据表](https://docs.dolphindb.cn/zh/funcs/k/keyedStreamTable.html)，其主键不允许包含重复值。\n\n**retentionMinutes** 可选参数，整数，用于指定保留大小超过 1GB 的 log 文件的时间（从文件的最后修改时间开始计算），单位是分钟。默认值是1440，即一天。\n\n**preCache** 可选参数，正整数，用于指定服务重启后从磁盘加载高可用流表到内存的记录条数。默认值同 *cacheSize* 的配置值。\n\n#### 返回值\n\n一张表。\n\n#### 例子\n\n假设配置参数 *streamingRaftGroup*=11:NODE1:NODE2:NODE3，在 Raft 组的任意一个节点如 NODE1 上执行以下脚本创建高可用流数据表 trades：\n\n```\ncolNames = `timestamp`sym`qty`price\ncolTypes = [TIMESTAMP,SYMBOL,INT,DOUBLE]\nt=table(1:0,colNames,colTypes)\nhaStreamTable(11,t,`trades,100000);\n```\n\n在集群的另外一个节点 NODE4 上执行以下脚本订阅表 trades，把订阅的数据保存至分布式数据库中。\n\n```\nif(existsDatabase(\"dfs://stock\")){\n   dropDatabase(\"dfs://stock\")\n}\ndb=database(directory=\"dfs://stock\",partitionType=VALUE,partitionScheme=2018.08.01..2019.12.30)\nt=table(1:0,`timestamp`sym`qty`price,[TIMESTAMP,SYMBOL,INT,DOUBLE])\ntrades_slave=db.createPartitionedTable(table=t,tableName=`trades_slave,partitionColumns=`timestamp);\nsubscribeTable(server=NODE2,tableName=`trades,actionName=`sub_trades,offset=-1,handler=append!{trades_slave},msgAsTable=true,batchSize=1000,throttle=1,hash=-1,reconnect=true);\n\n// 这里subscribeTable函数的第一个参数可以是NODE1,NODE2,NODE3中的任意一个，reconnect参数必须为true。\n```\n\n在 NODE4 上执行以下脚本取消订阅：\n\n```\nunsubscribeTable(server=NODE2,tableName=`trades,actionName=`sub_trades);\n// 这里unsubscribeTable函数的第一个参数可以是 NODE1, NODE2, NODE3 中的任意一个。\n```\n\n相关函数：[keyedStreamTable](https://docs.dolphindb.cn/zh/funcs/k/keyedStreamTable.html), [dropStreamTable](https://docs.dolphindb.cn/zh/funcs/d/dropStreamTable.html), [getStreamingLeader](https://docs.dolphindb.cn/zh/funcs/g/getStreamingLeader.html), [getStreamingRaftGroups](https://docs.dolphindb.cn/zh/funcs/g/getStreamingRaftGroups.html)\n"
    },
    "head": {
        "url": "https://docs.dolphindb.cn/zh/funcs/h/head.html",
        "signatures": [
            {
                "full": "head(X, [n=1])",
                "name": "head",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[n=1]",
                        "name": "n",
                        "optional": true,
                        "default": "1"
                    }
                ]
            }
        ],
        "markdown": "### [head](https://docs.dolphindb.cn/zh/funcs/h/head.html)\n\n\n\n#### 语法\n\nhead(X, \\[n=1])\n\n#### 详情\n\n`head` 返回向量的前 *n* 个元素，或矩阵的前 *n* 列，或表的前 *n* 行。如果 *n* 没有指定，*n* 取默认值1。\n\n#### 参数\n\n**X** 可以是向量、矩阵或表。\n\n**n** 是一个正整数。\n\n#### 返回值\n\n标量、向量、矩阵、字典或表。\n\n#### 例子\n\n```\nx=1..10; head(x);\n// output\n1\n\nx=1..10$2:5;\nx;\n```\n\n| #0 | #1 | #2 | #3 | #4 |\n| -- | -- | -- | -- | -- |\n| 1  | 3  | 5  | 7  | 9  |\n| 2  | 4  | 6  | 8  | 10 |\n\n```\nx.head();\n// output\n[1,2]\n\nhead(x,2);\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 3  |\n| 2  | 4  |\n\n```\nx=table(1..5 as a, 6..10 as b);\nx;\n```\n\n| a | b  |\n| - | -- |\n| 1 | 6  |\n| 2 | 7  |\n| 3 | 8  |\n| 4 | 9  |\n| 5 | 10 |\n\n```\nhead(x);\n// output\nb->6\na->1\n\nx.head(2);\n```\n\n| a | b |\n| - | - |\n| 1 | 6 |\n| 2 | 7 |\n\n相关函数：[tail](https://docs.dolphindb.cn/zh/funcs/t/tail.html)\n"
    },
    "hex": {
        "url": "https://docs.dolphindb.cn/zh/funcs/h/hex.html",
        "signatures": [
            {
                "full": "hex(X, [reverse=false])",
                "name": "hex",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[reverse=false]",
                        "name": "reverse",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [hex](https://docs.dolphindb.cn/zh/funcs/h/hex.html)\n\n#### 语法\n\nhex(X, \\[reverse=false])\n\n#### 详情\n\n把如下数据类型转换为十六进制数据显示：\n\n* INTEGRAL\n* FLOAT\n* COMPLEX\n* BINARY\n\n**Note:** 与 Python 的内置函数 `hex` 类似：\n\n| 特性    | DolphinDB `hex`        | Python `hex`        |\n| ----- | ---------------------- | ------------------- |\n| 支持类型  | 整型、浮点、复数、二进制           | 仅整型                 |\n| 输入形式  | 标量、向量                  | 仅标量                 |\n| 输出格式  | 完整字节表示（如 `\"00000010\"`） | 带 `0x` 前缀（如 `0x10`） |\n| 字节序控制 | 支持 *reverse* 参数        | 无此功能                |\n\n#### 参数\n\n**X** 是一个整型标量或向量。\n\n**reverse** 是一个布尔值，表示高低位是否互换。默认值是 false。\n\n#### 返回值\n\nSTRING 类型的标量或向量，表示数据对应的十六进制数。\n\n#### 例子\n\n```\nhex(16 25);\n//output: [\"00000010\",\"00000019\"]\n\nhex(16 25,true);\n//output: [\"10000000\",\"19000000\"]\n\nhex(compress(1 2 3));\n//output: [\"00\",\"05\",\"ff\",\"01\",\"04\",\"04\",\"00\",\"00\",\"ff\",\"ff\",\"ff\",\"ff\",\"03\",\"00\",\"00\",\"00\",\"ff\",\"ff\",\"ff\",\"ff\",\"0d\",\"00\",\"00\",\"80\",\"c0\",\"01\",\"00\",\"00\",\"00\",\"02\",\"00\",\"00\",\"00\",\"03\",\"00\",\"00\",\"00\"]\n\na = hex\\(123.456 3.1415926\\)\nprint a\n//output: \\[\"405edd2f1a9fbe77\",\"400921fb4d12d84a\"\\]\n```\n\n\n\n**Related information**\n\n[数据类型](https://docs.dolphindb.cn/zh/progr/data_types.html)\n"
    },
    "highDouble": {
        "url": "https://docs.dolphindb.cn/zh/funcs/h/highDouble.html",
        "signatures": [
            {
                "full": "highDouble(X)",
                "name": "highDouble",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [highDouble](https://docs.dolphindb.cn/zh/funcs/h/highDouble.html)\n\n\n\n#### 语法\n\nhighDouble(X)\n\n#### 详情\n\n返回 *X* 的高位 8 字节的数据，为 DOUBLE 类型。\n\n#### 参数\n\n**X** 是一个标量或向量，必须是 16 字节的数据类型。\n\n#### 例子\n\n```\nx=1 2 3 4\ny=4 3 2 1\npoints = point(x, y)\nx1 = highDouble(points)\n// output\n[4,3,2,1]\n```\n\n获取一个复数的虚部（虚数）\n\n```\na=complex(2, 5)\nhighDouble(a)\n// output\n5\n```\n"
    },
    "highLong": {
        "url": "https://docs.dolphindb.cn/zh/funcs/h/highlong.html",
        "signatures": [
            {
                "full": "highLong(X)",
                "name": "highLong",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [highLong](https://docs.dolphindb.cn/zh/funcs/h/highlong.html)\n\n\n\n#### 语法\n\nhighLong(X)\n\n#### 详情\n\n返回 *X* 的高位 8 字节的数据，为 LONG 类型。\n\n#### 参数\n\n**X** 是一个标量、向量、表、数据对或者字典，且必须为16字节的数据类型（支持 UUID、IPADDR、INT128、COMPLEX、POINT）。\n\n#### 例子\n\n```\nx =ipaddr(\"192.168.1.13\")\nx1 = highLong(x)\nprint(x1)\n//output: 0\n\n\nx=1 2 3 4\ny=4 3 2 1\npoints = point(x, y)\nx1 = highLong(points)\n//output:[4616189618054758400,4613937818241073152,4611686018427387904,4607182418800017408]\n```\n\n**Related information**\n\n[lowLong](https://docs.dolphindb.cn/zh/funcs/l/lowlong.html)\n"
    },
    "histogram": {
        "url": "https://docs.dolphindb.cn/zh/funcs/h/histogram.html",
        "signatures": [
            {
                "full": "histogram(X, [bins=10], [range], [density=false], [weights])",
                "name": "histogram",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[bins=10]",
                        "name": "bins",
                        "optional": true,
                        "default": "10"
                    },
                    {
                        "full": "[range]",
                        "name": "range",
                        "optional": true
                    },
                    {
                        "full": "[density=false]",
                        "name": "density",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[weights]",
                        "name": "weights",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [histogram](https://docs.dolphindb.cn/zh/funcs/h/histogram.html)\n\n首发版本：3.00.5，3.00.4.1，3.00.3.2\n\n\n\n#### 语法\n\nhistogram(X, \\[bins=10], \\[range], \\[density=false], \\[weights])\n\n#### 详情\n\n计算数据样本的直方图。\n\n与 `numpy.histogram` 的功能基本相同。\n\n#### 参数\n\n**X** 数值型向量，表示数据样本。\n\n**bins** 可选参数，正整数，或严格单调递增的数值型向量：\n\n* 正整数代表等宽的箱的个数，默认值为 10。\n\n* 数值型向量代表箱的边界，包括最右侧边界。\n\n**range** 可选参数，数据对或长度为 2 的向量，表示箱的上下界，超出范围的值会被忽略。默认值为 `[X.min(), X.max()]`。\n\n**density** 可选参数，布尔值：\n\n* false（默认值），结果是每个箱中样本的计数。\n\n* true，结果是归一化后概率密度函数在每个箱中的值。\n\n**weights** 可选参数，长度与 *X* 相同的数值向量，表示样本的权重。注意，当 *density* 为 false 时，返回加权计数值。\n\n#### 返回值\n\n一个字典，键值对包括：\n\n* H：直方图的值，具体可参考参数 *density* 和 *weights*。\n\n* edges：箱的边界数组。\n\n#### 例子\n\n*bins* 可为整数标量。\n\n```\nX = [3,4,5,6,7,8,9]\nbins = 3\nhistogram(X, bins)\n/*\nH->[2,2,3]\nedges->[3,5,7,9]\n*/\n```\n\n*bins* 可为数值向量。\n\n```\nX = [3,4,5,6,7,8,9]\nbins = [3,6,9]\nhistogram(X, bins)\n/*\nH->[3,4]\nedges->[3,6,9]\n*/\n```\n\n*range* 限定范围。\n\n```\nX = [3,4,5,6,7,8,9]\nbins = [3,6,9]\nrange = [4,8]\nhistogram(X, bins, range)\n/*\nH->[2,3]\nedges->[3,6,9]\n*/\n```\n\n若 *density* 为 true，返回概率密度函数在箱中的值。\n\n```\nX = [3,4,5,6,7,8,9]\nbins = [3,6,9]\nrange = [4,8]\nhistogram(X, bins, range, true)\n/*\nH->[0.133333333333333,0.2]\nedges->[3,6,9]\n*/\n```\n\n*weights* 设置样本权重。\n\n```\nX = [3,4,5,6,7,8,9]\nbins = [3,6,9]\nweights = [2,2,5,5,1,2,3]\nhistogram(X, bins, , false, weights)\n/*\nH->[9,11]\nedges->[3,6,9]\n*/\n```\n"
    },
    "histogram2d": {
        "url": "https://docs.dolphindb.cn/zh/funcs/h/histogram2d.html",
        "signatures": [
            {
                "full": "histogram2d(X, Y, [bins=10], [range], [density=false], [weights])",
                "name": "histogram2d",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "[bins=10]",
                        "name": "bins",
                        "optional": true,
                        "default": "10"
                    },
                    {
                        "full": "[range]",
                        "name": "range",
                        "optional": true
                    },
                    {
                        "full": "[density=false]",
                        "name": "density",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[weights]",
                        "name": "weights",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [histogram2d](https://docs.dolphindb.cn/zh/funcs/h/histogram2d.html)\n\n\n\n#### 语法\n\nhistogram2d(X, Y, \\[bins=10], \\[range], \\[density=false], \\[weights])\n\n#### 详情\n\n计算两组数据样本的二维直方图。\n\n与 `numpy.histogram2d` 的功能基本相同。\n\n#### 参数\n\n**X**, **Y** 两个等长的数值向量，分别作为构造二维直方图的 x 和 y 坐标值。注意：不可包含空值。\n\n**bins** 可选参数，数值标量，严格递增的、长度至少为 2 的数值向量，或者由前两者组成的元组（第一个元素表示 x 维度上的特性，第二个元素表示 y 维度的特性）。默认值为 10。注意：不能包含空值。以下为传入不同形式数据的含义说明：\n\n* 标量：x 和 y 两个维度箱的数目。\n\n* 向量：x 和 y 两个维度分箱的边界。\n\n* 标量组成的二维元组：x 和 y 两个维度分别分箱的数目。\n\n* 向量组成的二维元组：x 和 y 两个维度分别分箱的边界。\n\n* 标量和向量组成的二维元组：标量代表在对应维度上按照均等分箱时箱的数目；向量表示在对应维度上按给定的边界值分箱。\n\n**range** 可选参数，二维向量，形状须为(2, 2)，用来指定每个维度上统计图的最左边界和最右边界（如果 *bins* 参数未显式给出边界值时）。所有超出 *range* 的点将被视为异常点，不会被二维直方图统计。默认为空。\n\n**density** 可选参数，布尔标量。以下为说明：\n\n* 如果为 false（默认值），则表示直方图统计每个二维箱子的样本点个数。\n\n* 如果为 true，则会返回每个箱子的概率密度函数。bin\\_count（当前箱子内的点个数）/sample\\_count（总样本点数）/ bin\\_area（每个箱子的面积）。\n\n**weights** 可选参数，数值向量，长度须与 *X*/*Y* 相同，表示对应样本点（x\\_i, y\\_i）的权重。默认为空。注意：传入向量时不可包含空数据。其中，\n\n* 如果 *density* 为 true，则 weights 会被正则化到 1。\n\n* 如果 *density* 为 false，则每个箱子在二维直方图中的值就是落入这些该箱子的所有点的权重值之和。\n\n#### 返回值\n\n一个字典，包含以下 key：\n\n* H：形状为（nx, ny）的矩阵，表示二维直方图的统计结果。nx 和 ny 分别为 x 轴和 y 轴的分箱个数。矩阵中每个值的含义取决于 *density*，请参考 *density* 参数的说明。\n\n* xedges：长度为 nx + 1 的向量，表示沿着 x 轴分箱时箱子的 x 轴边界。nx 为 x 轴的分箱个数。\n\n* yedges：长度为 ny + 1 的向量，表示沿着 y 轴分箱时箱子的 y 轴边界。ny 为 y 轴的分箱个数。\n\n#### 例子\n\n例 1：传入两组数据样本，设置 x 和 y 两个维度分别分箱的边界、 *density* 为 false，计算其二维直方图的统计结果。\n\n```\nx = [0.1, 0.2, 0.5, 0.7, 0.9]\ny = [0.2, 0.4, 0.6, 0.8, 1.0]\nbins = [[0, 0.3, 0.6, 1.0], [0, 0.5, 1.0]]\ndensity = false\nresult = histogram2d(x, y, bins, ,density)\n\n/* Output:\nH->#0 #1\n-- --\n2  0 \n0  1 \n0  2 \nxedges->[0,0.3,0.6,1]\nyedges->[0,0.5,1]\n*/\n```\n\n例 2：传入两组数据样本，设置 x 均等分箱时箱的数目、y 分箱的边界、权重、*density* 为 true，计算其二维直方图的统计结果。\n\n```\nx = [0.2, 0.4, 0.6, 0.8, 1.0]\ny = [0.3, 0.5, 0.7, 0.9, 1.1]\nbins = [2, [0.3, 0.5, 1.1]]\nweights = [1, 2, 3, 4, 5]\ndensity = true\nresult = histogram2d(x, y, bins, ,density, weights)\n\n/* Output:\nH->#0 #1\n-- --\n1  5 \n0  9 \nxedges->[0.2,0.6,1]\nyedges->[0.3,0.5,1.1]\n*/\n```\n"
    },
    "hmac": {
        "url": "https://docs.dolphindb.cn/zh/funcs/h/hmac.html",
        "signatures": [
            {
                "full": "hmac(key, message, [digest='sha256'])",
                "name": "hmac",
                "parameters": [
                    {
                        "full": "key",
                        "name": "key"
                    },
                    {
                        "full": "message",
                        "name": "message"
                    },
                    {
                        "full": "[digest='sha256']",
                        "name": "digest",
                        "optional": true,
                        "default": "'sha256'"
                    }
                ]
            }
        ],
        "markdown": "### [hmac](https://docs.dolphindb.cn/zh/funcs/h/hmac.html)\n\n\n\n#### 语法\n\nhmac(key, message, \\[digest='sha256'])\n\n#### 详情\n\n采用 HMAC（Hash-based Message Authentication Code，基于哈希的消息认证码）机制，根据给定的密钥和加密信息，通过指定的加密算法生成并返回一个哈希值。\n\n#### 参数\n\n**key** LITERAL 类型标量，表示密钥。\n\n**message** LITERAL 类型标量，表示需要加密的信息。\n\n**digest** 可选参数，STRING 类型标量，表示加密使用的哈希算法。默认值为 sha256。可选值为 sha1, sha224, sha256, sha 384, sha512, md5。\n\n#### 返回值\n\n一个 STRING 类型的哈希值。\n\n#### 例子\n\n```\nhmac(key=\"myKey\", message=\"myMessage\", digest=\"sha256\")\n// output:'71e5f5ca5f64550ee4524909f7cead7b81d8674a657383aec1b003a8a3f05b04'\n\nhmac(key=\"myKey\", message=\"myMessage\", digest=\"sha1\")\n// output:'5033197fa89dedf5088eed6100dfa5a0f67ef1ce'\n\nhmac(key=\"myKey2\", message=\"myMessage\", digest=\"sha256\")\n// output:'40e2a700754cec30ace1e82abfe7fd233f8f6c299050cc21b0e0a4ea42428126'\n```\n"
    },
    "hour": {
        "url": "https://docs.dolphindb.cn/zh/funcs/h/hour.html",
        "signatures": [
            {
                "full": "hour(X)",
                "name": "hour",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [hour](https://docs.dolphindb.cn/zh/funcs/h/hour.html)\n\n\n\n#### 语法\n\nhour(X)\n\n#### 详情\n\n返回对应的小时数。\n\n#### 参数\n\n**X** 是一个时间标量/向量。\n\n#### 返回值\n\nINT 类型标量或向量。\n\n#### 例子\n\n```\nhour(2012.12.03 01:22:01);\n```\n\n返回：1\n\n**Related information**\n\n[date](https://docs.dolphindb.cn/zh/funcs/d/date.html)\n\n[second](https://docs.dolphindb.cn/zh/funcs/s/second.html)\n\n[minute](https://docs.dolphindb.cn/zh/funcs/m/minute.html)\n\n[month](https://docs.dolphindb.cn/zh/funcs/m/month.html)\n\n[year](https://docs.dolphindb.cn/zh/funcs/y/year.html)\n"
    },
    "hourOfDay": {
        "url": "https://docs.dolphindb.cn/zh/funcs/h/hourOfDay.html",
        "signatures": [
            {
                "full": "hourOfDay(X)",
                "name": "hourOfDay",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [hourOfDay](https://docs.dolphindb.cn/zh/funcs/h/hourOfDay.html)\n\n\n\n#### 语法\n\nhourOfDay(X)\n\n#### 详情\n\n返回 *X* 中的小时。\n\n#### 参数\n\n**X** 可以是 TIME, MINUTE, SECOND, DATETIME, TIMESTAMP, NANOTIME, NANOTIMESTAMP 类型的标量或向量。\n\n#### 返回值\n\nINT 类型标量或向量。\n\n#### 例子\n\n```\nhourOfDay(00:46:12);\n// output\n0\n\nhourOfDay([2012.06.12T12:30:00,2012.10.28T17:35:00,2013.01.06T02:36:47,2013.04.06T08:02:14]);\n// output\n[12,17,2,8]\n```\n\n相关函数：[dayOfYear](https://docs.dolphindb.cn/zh/funcs/d/dayOfYear.html), [dayOfMonth](https://docs.dolphindb.cn/zh/funcs/d/dayOfMonth.html), [quarterOfYear](https://docs.dolphindb.cn/zh/funcs/q/quarterOfYear.html), [monthOfYear](https://docs.dolphindb.cn/zh/funcs/m/monthOfYear.html), [weekOfYear](https://docs.dolphindb.cn/zh/funcs/w/weekOfYear.html), [minuteOfHour](https://docs.dolphindb.cn/zh/funcs/m/minuteOfHour.html), [secondOfMinute](https://docs.dolphindb.cn/zh/funcs/s/secondOfMinute.html), [millisecond](https://docs.dolphindb.cn/zh/funcs/m/millisecond.html), [microsecond](https://docs.dolphindb.cn/zh/funcs/m/microsecond.html), [nanosecond](https://docs.dolphindb.cn/zh/funcs/n/nanosecond.html)\n"
    },
    "accumulate": {
        "url": "https://docs.dolphindb.cn/zh/funcs/ho_funcs/accumulate.html",
        "signatures": [
            {
                "full": "accumulate(func, X, [init], [assembleRule|consistent=false])",
                "name": "accumulate",
                "parameters": [
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[init]",
                        "name": "init",
                        "optional": true
                    },
                    {
                        "full": "[assembleRule|consistent=false]",
                        "name": "[assembleRule|consistent=false]"
                    }
                ]
            }
        ],
        "markdown": "### [accumulate](https://docs.dolphindb.cn/zh/funcs/ho_funcs/accumulate.html)\n\n\n\n#### 语法\n\naccumulate(func, X, \\[init], \\[assembleRule|consistent=false])\n\n\\[init] \\<operator>:A X 或 func:A(\\[init], X) 表示不指定 ，使用默认值\n\n\\[init] \\<operator>:AC X 或 func:AC(\\[init], X) 表示指定 ，此例中指定为 C（Consistent）\n\n#### 详情\n\n* 当 func 是一元函数时，accumulate 先输出 *init*，再应用 *func* 在 *init* 上，然后迭代地应用 *func* 到前一个结果上，直至满足 *X* 指定地迭代条件后输出结果。\n\n  * *X* 为整数时，表示 *func* 进行迭代的次数，输出结果包含 *X* + 1 个元素。注意，X 为负数时，将按0处理。\n\n  * *X* 为一元函数时，表示终止条件，返回结果必须为一个布尔标量。若 *X* 应用在前一个结果上的返回值为 true，*func* 继续迭代；否则，*func* 停止迭代。\n\n  * *X* 没有设置或为 NULL，*func* 将进行迭代计算直至输出的结果与前一个结果相同时停止迭代。\n\n* 当 *func* 是二元函数时，`accumulate` 先应用函数 / 运算符在 *init* 和 *X\\[0]* 上，再迭代地应用函数 / 运算符在前一个结果和当前元素上。当 *init* 缺失时，`accumulate` 返回值的第一个元素是 *X\\[0]*。`accumulate` 等同于下面伪代码的执行过程：\n\n  ```\n  result[0]=iif(init==NULL,X[0],<function>(init,X[0]));\n\n  for(i:1~size(X)-1){\n      result[i]=<function>(result[i-1], X[i]);\n  }\n\n  return result;\n  ```\n\n* 当 *func* 是三元函数时，其迭代规则等同于二元函数。\n\n  与 [reduce](https://docs.dolphindb.cn/zh/funcs/ho_funcs/reduce.html) 返回最后一个结果不同，`accumulate` 输出所有中间结果。\n\n#### 参数\n\n* **func**：函数。\n  * 当 *func* 是一元函数时，*X* 可以是非负整数、一元函数或空值。*init* 表示 *func* 的参数，必须指定。\n\n  * *func* 是二元函数时，*X* 是向量、矩阵或表。*init* 表示初始值。\n\n  * *func* 是三元函数时，*X* 必须是一个 Tuple，包含2个元素，分别表示 *func* 的后两个参数。\n\n* **assembleRule** 可选参数，表示如何将子任务的结果合并为函数最终结果。接受一个整数或字符串作为输入，可选值如下：\n\n  * 0 （或 \"D\"）：默认值，表示 DolphinDB 规则，即根据所有子任务的结果来决定最终输出的数据类型和形式。当所有子结果具有相同的数据类型和形式时，多个标量合并为一个向量、多个向量合并为一个矩阵、多个矩阵合并为一个元组、多个字典合并为一张表；否则将所有子结果合并为一个元组输出。\n\n  * 1（或 \"C\"）：表示 Consistent 规则，即认为所有子结果的数据类型和形式都与第一个子结果相同，根据第一个子结果来选择最终结果的数据类型和形式。如果后续子任务返回的结果与第一个子任务的结果类型不一致，系统会尝试对后续结果进行类型转换。如果转换失败则抛出异常。因此，此规则只可在已知子结果的数据类型及形式一致时指定。此规则可使系统免于逐一缓存并检查每个子任务的计算结果，从而提升性能。\n\n  * 2（或 \"U\"）：表示 Tuple 规则，系统不再对各子结果的类型和形式一致性进行检查，而是直接将子结果组装成一个元组输出。\n\n  * 3（或 \"K\"）：表示 kdb+ 规则。与 DolphinDB 规则类似，都会根据所有子结果来决定最终结果形式。主要区别在于，kdb+ 规则下，只要有任一子任务返回向量，则最终结果必为一个元组；而在 DolphinDB 规则下，子任务结果若均为长度相同的向量，则最终结果为一个矩阵。其他情况下，kdb+ 规则的输出与 DolphinDB 规则相同。\n\n  **Note:**\n\n  * 自 2.00.15/3.00.3 版本起，新增了 *assembleRule* 参数。该参数不仅实现了原 *consistent* 参数的功能，还提供了更多的结果合并选项。*consistent* 是一个布尔值，默认值为 false，相当于 *assembleRule*=\"D\"；若为 true，则相当于 *assembleRule*=\"C\"。为保持兼容性，用户仍可使用 *consistent* 参数。如果同时指定 *assemble* 和 *consistent*，将以 *consistent* 的值为准。\n  * *assembleRule* 也可在高阶函数对应的函数模式符号后指定，通过字符 D/C/U/K 表示。以 `eachPre (:P)` 为例，形如 `sub:PU(X)`。不指定则使用默认值 D。\n\n其他相关的 cum 系列函数的参数说明和窗口计算规则请参考: [累计窗口系列（cum 系列）](https://docs.dolphindb.cn/zh/funcs/themes/cumFunctions.html)\n\n#### 返回值\n\n取决于 *assembleRule* 参数的值。\n\n#### 例子\n\n例1. 当*func* 是一元函数时：\n\n通过以下方式定义一个一元函数：\n\n```\ndef func1(x){\n  if(x<5){\n          return x*3\n  }\n  else{\n          return x+3\n  }\n}\n```\n\n当 X 为整数时，输出结果长度为 X + 1：\n\n```\naccumulate(func1, 5, 1)\n```\n\n返回：\\[1,3,9,12,15,18]。\n\n当 X 为一元函数 condition 时，第3次迭代时因 condition 返回 false，停止迭代并输出前 2 次的迭代结果。\n\n```\ndef condition(x){\n  return x<9\n}\naccumulate(func1, condition, 1)\n```\n\n返回：\\[1,3,9]。\n\n当 X 为 NULL（或不指定）时，自定义函数 func2 作为迭代的函数。由于第 4 次迭代结果和第 3 次相同，停止迭代并输出前 3 次迭代结果。\n\n```\ndef func2(x){\n  if(x<5){\n          return x*3\n  }\n  else{\n          return 6\n  }\n}\n\naccumulate(func2,NULL,1)\n```\n\n返回：\\[1,3,9,6]。\n\n例2. *func* 是二元函数时，在一个向量上执行 accumulate：\n\n```\nx = 1 2 3;\naccumulate(add, 1 2 3);\n```\n\n返回：\\[1,3,6]。这样的运算等同于 \\[1, 1+2, 3+3]。\n\n```\n1 +:A x;\n```\n\n返回：\\[2,4,7]。这样的运算等同于 \\[1+1, 2+2, 4+3]。\n\n```\naccumulate(-, x, 2);\n```\n\n返回：\\[1,-1,-4]。这样的运算等同于 \\[2-1, 1-2, -1-3]。\n\n```\naccumulate(mul, x);\n```\n\n返回：\\[1,2,6]。这样的运算等同于 \\[1, 1\\*2, 2\\*3]。\n\n通过以下方式计算累积因式分解：\n\n```\ndef facts(a) {return 1*:A 1..a;};\nfacts 5;\n```\n\n返回：\\[1,2,6,24,120]\n\n通过以下方式计算 log(1) 到 log(i) 之间的累加和。其中，第一行的结果用作第二行 `accumulate` 的第一个参数值：\n\n```\ndef f1(a,b): a+log(b);\naccumulate(f1, 1..5, 0);\n```\n\n返回：\\[0,0.693147,1.791759,3.178054,4.787492]。这等同于：`0+log(1)=0, 0+log(2)=0.693147, 0.693147+log(3)=1.791759, ......`\n\n在下面这个例子中，由于忽略了初始条件，输入向量的第一个元素的数据类型决定了返回值的数据类型。\n\n```\naccumulate(f1, 1..5);\n```\n\n返回：\\[1,1.693147,2.791759,4.178053,5.787491]。\n\n对一个矩阵执行 `accumulate`:\n\n```\nx=1..12$3:4;\nx;\n```\n\n得到：\n\n| col1 | col2 | col3 | col4 |\n| ---- | ---- | ---- | ---- |\n| 1    | 4    | 7    | 10   |\n| 2    | 5    | 8    | 11   |\n| 3    | 6    | 9    | 12   |\n\n```\n+ :A x;\n```\n\n得到：\n\n| col1 | col2 | col3 | col4 |\n| ---- | ---- | ---- | ---- |\n| 1    | 5    | 12   | 22   |\n| 2    | 7    | 15   | 26   |\n| 3    | 9    | 18   | 30   |\n\n例3. *func* 是三元函数时：\n\n```\ndef fun3(x,y,z){\n  return x+y+z\n}\naccumulate(fun3,[[1,2,3],[10,10,10]],5)\n```\n\n返回：\\[16,28,41]。\n\n例 4. 根据两个标志列计算状态列。\n\n假设有一张表包含两个标志列 flag1 和 flag2，希望构造一个状态列 state，其计算逻辑如下：\n\n* 初始值为 0；\n* 当 `state == 0` 且 `flag1 == 1` 时，状态切换为 1；\n* 当 `state == 1` 且 `flag2 == 1` 时，状态切换为 0；\n* 否则保持不变。\n\n```\nid = 1..10\nflag1 = [0, 1, 1, 0, 0, 0, 0, 0, 0, 0]\nflag2 = [0, 0, 0, 0, 0, 1, 1, 0, 0, 0]\nt = table(id, flag1, flag2)\n\ndef updateStateByFlags(state, f1, f2): iif(state==0 && f1==1, 1, iif(state==1 && f2==1, 0, state))\n\nselect *, \n    accumulate(updateStateByFlags, [flag1, flag2], 0) as state\nfrom t\n```\n\n| id | flag1 | flag2 | state |\n| -- | ----- | ----- | ----- |\n| 1  | 0     | 0     | 0     |\n| 2  | 1     | 0     | 1     |\n| 3  | 1     | 0     | 1     |\n| 4  | 0     | 0     | 1     |\n| 5  | 0     | 0     | 1     |\n| 6  | 0     | 1     | 0     |\n| 7  | 0     | 1     | 0     |\n| 8  | 0     | 0     | 0     |\n| 9  | 0     | 0     | 0     |\n| 10 | 0     | 0     | 0     |\n"
    },
    "aggrTopN": {
        "url": "https://docs.dolphindb.cn/zh/funcs/ho_funcs/aggrTopN.html",
        "signatures": [
            {
                "full": "aggrTopN(func, funcArgs, sortingCol, top, [ascending=true])",
                "name": "aggrTopN",
                "parameters": [
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "funcArgs",
                        "name": "funcArgs"
                    },
                    {
                        "full": "sortingCol",
                        "name": "sortingCol"
                    },
                    {
                        "full": "top",
                        "name": "top"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [aggrTopN](https://docs.dolphindb.cn/zh/funcs/ho_funcs/aggrTopN.html)\n\n\n\n#### 语法\n\naggrTopN(func, funcArgs, sortingCol, top, \\[ascending=true])\n\n#### 详情\n\n将 *sortingCol* 根据 *ascending* 指定方式进行排序后，得到 *funcArgs* 中对应的前 *top* 个元素，使用 *func* 指定的聚合函数进行计算。*sortingCol* 包含的 NULL 值当作最小值处理。\n\n#### 参数\n\n* **func** 必须是一个聚合函数。\n\n* **funcArgs** 是 *func* 的参数，可以是标量或向量。 *func* 有多个参数时，它是一个元组。\n\n* **sortingCol** 是一个数值类型或时间类型的向量，提供 *funcArgs* 的排序指标。\n\n* **top** 可以是整数或者浮点数。\n\n  * 如果是整数，表示选取的前 *top* 行数据；\n\n  * 如果是浮点数，表示百分比，必须小于1.0。根据 *funcArgs* 的总行数\\**top* 来确定需要选取的行数。若结果不是整数，则向下取整，至少取一行。\n\n* **ascending** 是一个布尔值，表示是否按升序排序。 默认值是 true。\n\n其他相关 TopN 系列函数参数说明和窗口计算规则请参考: [TopN](https://docs.dolphindb.cn/zh/funcs/themes/TopN.html)\n\n#### 返回值\n\n一个数值型标量。\n\n#### 例子\n\n**例 1** 计算 volume 最大的 3 条数据对应 price 的平均值。\n\n```\nprice = 10.0 20.0 30.0 40.0 50.0\nvolume = 5 2 5 1 4\naggrTopN(func=avg, funcArgs=price, sortingCol=volume, top=3, ascending=false)\n// output:30\n```\n\n**例 2** 计算 volume 最大的 3 条数据 price 和 volume 的相关性，此时 *func* 为双目聚合函数，*funcArgs* 需传入元组。\n\n```\nvolume=2 3 4 5 3\nprice=10.0 20.0 30.0 40.0 50.0\naggrTopN(func=corr, funcArgs=(volume, price), sortingCol=2 3 4 5 3, top=3, ascending=true)\n// output:0.69338\n```\n\n**例 3** 计算 volume 最大的 N 条数据对应 price 的平均值。N 可通过指定 *top* 为整数 N，或为浮点数表示比例。\n\n```\nprice = 10 20 30 40 50\nvolume = 1 2 3 4 5\n// top=3 整数：取前 3 行\naggrTopN(func=avg, funcArgs=price, sortingCol=volume, top=3)\n// 取[10,20,30], output: 20\n\n// top=0.6 浮点数：取前 floor(5*0.6)=3 行\naggrTopN(func=avg, funcArgs=price, sortingCol=volume, top=0.6)\n// 取[10,20,30], output: 20\n\n// top=0.5 浮点数：取前 floor(5*0.5)=2 行，此处向下取整\naggrTopN(func=avg, funcArgs=price, sortingCol=volume, top=0.5)\n// 取[10,20], output: 15\n\n// top=0.01 浮点数：5*0.01=0.05 向下取整为 0，但保底至少取 1 行                                                   \naggrTopN(func=sum, funcArgs=price, sortingCol=volume, top=0.01)                                        \n// 取[10], output: 10\n```\n\n**例 4** 统计每天每只股票因子最小的 40% 的 value 的平均值。\n\n```\ntrade_date=sort(take(2017.01.11..2017.01.12,20))\nsecu_code=take(`600570`600000,20)\nvalue=1..20\ntb=table(trade_date,secu_code,value)  \n```\n\n| trade\\_date | secu\\_code | value |\n| ----------- | ---------- | ----- |\n| 2017.01.11  | 600570     | 1     |\n| 2017.01.11  | 600000     | 2     |\n| 2017.01.11  | 600570     | 3     |\n| 2017.01.11  | 600000     | 4     |\n| 2017.01.11  | 600570     | 5     |\n| 2017.01.11  | 600000     | 6     |\n| 2017.01.11  | 600570     | 7     |\n| 2017.01.11  | 600000     | 8     |\n| 2017.01.11  | 600570     | 9     |\n| 2017.01.11  | 600000     | 10    |\n| 2017.01.12  | 600570     | 11    |\n| 2017.01.12  | 600000     | 12    |\n| 2017.01.12  | 600570     | 13    |\n| 2017.01.12  | 600000     | 14    |\n| 2017.01.12  | 600570     | 15    |\n| 2017.01.12  | 600000     | 16    |\n| 2017.01.12  | 600570     | 17    |\n| 2017.01.12  | 600000     | 18    |\n| 2017.01.12  | 600570     | 19    |\n| 2017.01.12  | 600000     | 20    |\n\n```\nselect aggrTopN(avg, funcArgs=value, sortingCol=value, top=0.4, ascending=true) as factor_value from tb group by trade_date,secu_code\n```\n\n| trade\\_date | secu\\_code | factor\\_value |\n| ----------- | ---------- | ------------- |\n| 2017.01.11  | 600000     | 3             |\n| 2017.01.11  | 600570     | 2             |\n| 2017.01.12  | 600000     | 13            |\n| 2017.01.12  | 600570     | 12            |\n"
    },
    "byColumn": {
        "url": "https://docs.dolphindb.cn/zh/funcs/ho_funcs/byColumn.html",
        "signatures": [
            {
                "full": "byColumn(func, X, [Y])",
                "name": "byColumn",
                "parameters": [
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[Y]",
                        "name": "Y",
                        "optional": true
                    }
                ]
            },
            {
                "full": "func:V(X)",
                "name": "func:V",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            },
            {
                "full": "func:V(X, [Y])",
                "name": "func:V",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[Y]",
                        "name": "Y",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [byColumn](https://docs.dolphindb.cn/zh/funcs/ho_funcs/byColumn.html)\n\n\n\n#### 语法\n\nbyColumn(func, X, \\[Y])\n\n或\n\nfunc:V(X)\n\n或\n\nfunc:V(X, \\[Y])\n\n#### 详情\n\n*func* 为单目函数时，对 *X* 的每一列应用指定函数；*func* 为双目函数时，对 *X* 和 *Y* 的每列执行 func(Xi, Yi) 。\n\n同时指定 X 和 Y 时，则对 X 和 Y 的每列执行 func(Xi, Yi) 。\n\n支持在响应式状态引擎中使用 `byColumn` 函数。\n\n**计算规则**：\n\n* 如果 *X/Y*是矩阵、表或元组，byColumn 对 X/Y 的每一列数据应用指定的函数。\n\n* 如果 X/Y 是数组向量或列式元组：byColumn 首先将对象转置，然后对转置后的对象的每一行应用指定函数。\n\n  * 当 *func* 是向量函数时，byColumn 会把 *func* 的计算结果转置后输出。\n\n  * 当 *func* 是聚合函数时，输出结果是一个向量。特别地，当 *func* 是以下聚合函数时，由于 byColumn 不对 X/Y 进行转置，从而提高了计算性能：sum, sum2, avg, min, max, count, imax, imin, imaxLast, iminLast, prod, std, stdp, var, varp, skew, kurtosis, any, all, corr, covar, wavg, wsum, beta, euclidean, dot, tanimoto\n\n#### 参数\n\n* **func** 一个单目函数，支持以部分应用的形式传入。该函数可以是向量函数（输入与输出为等长的向量），亦可为聚合函数。\n\n* **X** 一个矩阵、表、元组、数组向量、列式元组。\n\n* **Y** 矩阵、表、元组、数组向量、列式元组。\n\n#### 返回值\n\n* 当 *func* 是聚合函数时，\n\n  * 如果 *X/Y*是矩阵、数组向量或列式元组，则输出结果是一个向量。向量的长度与 *X/Y*的列数相同。\n\n  * 如果 *X/Y*是元组，则输出结果是一个元组。\n\n  * 如果 *X/Y*是表，则输出结果是一个表。\n\n* 当 *func* 是向量函数时，输出结果的形式、维度和 *X/Y*的形式、维度相同。\n\n#### 例子\n\n对于不支持矩阵运算的单目向量函数，通过 `byColumn` 进行按列计算，等效于 `each`。\n\n```\ndef myvfunc(x): var(x).log()\nm = matrix(1.1 2.3 2.1 3.5 4.2, 3.3 2.5 4.2 5.1 0, -1 3.3 2 1.7 2.3)\nbyColumn(myvfunc, m)\n```\n\n输出返回： \\[0.3974329364109,1.334211281249665,0.945072533299607]\n\n传入多元函数时，需要把该函数的其他参数通过部分应用进行固定，然后传入 `func`。\n\n```\nbyColumn(autocorr{,2},m)\n```\n\n返回：\\[-0.05,-0.28,-0.06]\n\n输出返回：\n\n```\ncol1 col2 col3\n3.1  5.3  1\n4.3  4.5  5.3\n4.1  6.2  4\n5.5  7.1  3.7\n6.2  2    4.3\n```\n\n```\nbyColumn(add{1 2 3 4 5}, m)\n```\n\n输出返回：\n\n```\ncol1 col2 col3\n2.1  4.3  0\n4.3  4.5  5.3\n5.1  7.2  5\n7.5  9.1  5.7\n9.2  5    7.3\n```\n\n`func` 是一个自定义函数。\n\n```\ndef my_func(x){\n   return iif(x > 0, 1, -1)\n}\nm = matrix(3 -6 5 0, 2 -9 -4 5)\nbyColumn(my_func, m)\n```\n\n输出返回：\n\n```\ncol1 col2\n 1    1\n-1   -1\n 1    -1\n-1    1\n```\n\n`func` 是一个嵌套函数。\n\n```\nm = matrix(1 5 3 , 7 5 2)\nbyColumn(accumulate{def (x, y):iif(x > 5, y-1, y+1), ,1}, m)\n```\n\n输出返回：\n\n```\ncol1 col2\n2    8\n6    4\n2    3\n```\n\n入参是矩阵：\n\n```\nm=matrix([1 3 4 2,1 2 2 1])\nmax:V(m)\n[4,2]\n\ncummax:V(m)\n\ncol1\tcol2\n1\t1\n3\t2\n4\t2\n4\t2\n\nn=matrix([11 5 9 2,8 5 3 2])\ncorr:V(m,n)\n[-0.09,-0.21]\n\n```\n\n入参是表：\n\n```\nqty1 = 2200 1900 2100 3200 6800 5400 1300 2500 8800\nqty2 = 2100 1800  6800 5400 1300 2400 8500 4100 3200\nt = table(qty1, qty2);\nmax:V(t) \n\nqty1\tqty2\n8,800\t8,500\n\ncummax:V(t) \n\nqty1\tqty2\n2,200\t2,100\n2,200\t2,100\n2,200\t6,800\n3,200\t6,800\n6,800\t6,800\n6,800\t6,800\n6,800\t8,500\n6,800\t8,500\n8,800\t8,500\n\n\nqty3 = 7800 5400 5300 2500 1800 2200 3900 3100 1200\nqty4 = 3200 2800 6400 8300 2300 3800 2900 1600 2900\nt1 = table(qty3, qty4);\n\ncorr:V(t,t1)   \n\nqty1\tqty2\n-0.7267\t0.4088\n\n```\n\n入参是元组：\n\n```\ntp=[1 3 4 2,1 2 2 1]\nsum:V(tp)  \n(10,6) \n\ncummax:V(tp) \n([1,3,4,4],[1,2,2,2]) \n\ntp1=[11 23 14 21,10 12 32 21]\n\ncorr:V(tp,tp1)  \n(0.25,0.37)\n```\n\n入参是数组向量：\n\n```\na=array(INT[], 0, 10).append!([1 2 3, 4 5 4, 6 7 8, 1 9 10]);\nsum:V(a) \n[12,23,25] \n\ncummax:V(a)\n[[1,2,3],[4,5,4],[6,7,8],[6,9,10]]\n\nb=array(DOUBLE[], 0, 10).append!([11.8 21.2 23.9, 83.3 90.2 78.2, 86.5 52 36.5, 10.1 12.4 16.8])\ncorr:V(a,b)  \n\n[0.95,-0.13,-0.46]\n```\n\n入参是列式元组：\n\n```\nctp=[1 3 4 2,1 2 2 1]\nctp.setColumnarTuple!()\nsum:V(ctp)  \n[2,5,6,3]\n\ncummax:V(ctp)\n([1,3,4,2],[1,3,4,2])\n\nctp1=[11 23 14 21,10 12 32 21]\nctp1.setColumnarTuple!()\n\ncorr:V(ctp,ctp1) \n[,1,-1,]\n```\n\n**Related information**\n\n[byRow](https://docs.dolphindb.cn/zh/funcs/ho_funcs/byRow.html)\n"
    },
    "byRow": {
        "url": "https://docs.dolphindb.cn/zh/funcs/ho_funcs/byRow.html",
        "signatures": [
            {
                "full": "byRow(func, X, [Y])",
                "name": "byRow",
                "parameters": [
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[Y]",
                        "name": "Y",
                        "optional": true
                    }
                ]
            },
            {
                "full": "func:H(X)",
                "name": "func:H",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            },
            {
                "full": "func:H(X, [Y])",
                "name": "func:H",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[Y]",
                        "name": "Y",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [byRow](https://docs.dolphindb.cn/zh/funcs/ho_funcs/byRow.html)\n\n\n\n#### 语法\n\nbyRow(func, X, \\[Y])\n\n或\n\nfunc:H(X)\n\n或\n\nfunc:H(X, \\[Y])\n\n#### 详情\n\n*func* 为单目函数时，对矩阵 *X* 的每一行应用指定函数。\n\n*func* 为双目函数时，对 *X* 和 *Y* 的每行执行 func(Xi, Yi) 。\n\n**计算规则**\n\n* 如果 *X/Y*是矩阵、表或元组：byRow 首先将对象转置，然后对转置后的对象的每一列应用指定函数。\n\n  * 当 *func* 是向量函数时，byRow 会把 *func* 的计算结果转置后输出。\n\n  * 当 *func* 是聚合函数时，输出结果是一个向量，无需进行转置操作。特别地，当 *func* 是以下聚合函数时，byRow 进行了优化，不会对 *X*/*Y* 进行上步的转置操作，从而提高了计算性能：sum, sum2, avg, min, max, count, imax, imin, imaxLast, iminLast, prod, std, stdp, var, varp, skew, kurtosis, any, all, corr, covar, wavg, wsum, beta, euclidean, dot, tanimoto。\n\n* 如果 X/Y 是数组向量或列式元组，byRow 对 X/Y的每一行数据应用指定函数。\n\n#### 参数\n\n**func** 是一个函数。该函数可以是向量函数（输入与输出均为等长向量），亦可为聚合函数。\n\n**X** 是一个矩阵、表、元组、数组向量、列式元组。\n\n**Y** 可以是矩阵、表、元组、数组向量或列式元组。\n\n其他相关的 row 系列函数的参数说明和窗口计算规则请参考: [行计算系列（row 系列）](https://docs.dolphindb.cn/zh/funcs/themes/rowFunctions.html)\n\n#### 返回值\n\n* 当 *func* 是聚合函数时，输出结果是一个向量。向量的长度与 *X/Y*的行数相同。\n\n* 当 *func* 是向量函数时，输出结果的形式、维度和 *X/Y*的形式、维度相同。\n\n**Note:** 通过 byRow 函数，可以实现与内置 row 系列函数相同的功能，并且计算结果和性能与 row 系列函数相同。例如 byRow(sum, X) 等效于 rowSum(X)。因此 byRow 函数可以应用于所有需要进行行计算的场景中。\n\n#### 例子\n\n入参是矩阵：\n\n```\nm=matrix([1 3 4 2,1 2 2 1])\nmax:H(m)\n[1,3,4,2]\n\ncummax:H(m) \n\ncol1\tcol2\n1\t1\n3\t3\n4\t4\n2\t2\n\nn=matrix([11 5 9 2,8 5 3 2])\ncorr:H(m,n)\n[,,1,]\n```\n\n入参是表：\n\n```\nqty1 = 2200 1900 2100 3200 6800 5400 1300 2500 8800\nqty2 = 2100 1800  6800 5400 1300 2400 8500 4100 3200\nt = table(qty1, qty2);\nmax:H(t) \n[2200,1900,6800,5400,6800,5400,8500,4100,8800]\n\ncummax:H(t) \n\nqty1\tqty2\n2,200\t2,200\n1,900\t1,900\n2,100\t6,800\n3,200\t5,400\n6,800\t6,800\n5,400\t5,400\n1,300\t8,500\n2,500\t4,100\n8,800\t8,800\n\nqty3 = 7800 5400 5300 2500 1800 2200 3900 3100 1200\nqty4 = 3200 2800 6400 8300 2300 3800 2900 1600 2900\nt1 = table(qty3, qty4);\ncorr:H(t,t1)   \n[1,1,1,1,-1,-1,-1,-1,-1]\n```\n\n入参是元组：\n\n```\ntp=[1 3 4 2,1 2 2 1]\nsum:H(tp)  \n[2,5,6,3] \n\ncummax:H(tp) \n([1,3,4,2],[1,3,4,2]) \n\ntp1=[11 23 14 21,10 12 32 21]\ncorr:H(tp,tp1)  \n[,1,-1,]\n```\n\n入参是数组向量：\n\n```\na=array(INT[], 0, 10).append!([1 2 3, 4 5 4, 6 7 8, 1 9 10]);\nsum:H(a) \n[6,13,21,20] \n\ncummax:H(a)\n[[1,2,3],[4,5,5],[6,7,8],[1,9,10]]\n\nb=array(DOUBLE[], 0, 10).append!([11.8 21.2 23.9, 83.3 90.2 78.2, 86.5 52 36.5, 10.1 12.4 16.8])\ncorr:H(a,b)  \n[0.95,0.90,-0.97,0.82]\n```\n\n入参是列式元组：\n\n```\nctp=[1 3 4 2,1 2 2 1]\nctp.setColumnarTuple!()\nsum:H(ctp)  \n[10,6]\n\ncummax:H(ctp)\n([1,3,4,4],[1,2,2,2])\n\nctp1=[11 23 14 21,10 12 32 21]\nctp1.setColumnarTuple!()\n\ncorr:H(ctp,ctp1)\n[0.25, 0.37]\n```\n\n```\nm=matrix(1 1, 2 3, 2 1);\nm;\n```\n\n| col1 | col2 | col3 |\n| ---- | ---- | ---- |\n| 1    | 2    | 2    |\n| 1    | 3    | 1    |\n\n```\nbyRow(add{10 20 30},m);\n```\n\n| col1 | col2 | col3 |\n| ---- | ---- | ---- |\n| 11   | 22   | 32   |\n| 11   | 23   | 31   |\n\n```\nbyRow(mode,m);\n// output\n[2,1]\n```\n\n```\nb=array(DOUBLE[], 0, 10).append!([11.8 21.2 23.9, 83.3 90.2 78.2 86.5, 10.1 12.4 16.8])\nbyRow(add{100},b)\n// output\n[111.8 121.2 123.9,183.3 190.2 178.2 86.5,110.1 112.4 116.8]\nbyRow(imax,b)\n// output\n[2,1,2]\n```\n"
    },
    "call": {
        "url": "https://docs.dolphindb.cn/zh/funcs/ho_funcs/call.html",
        "signatures": [
            {
                "full": "call(func, args...)",
                "name": "call",
                "parameters": [
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "args...",
                        "name": "args..."
                    }
                ]
            }
        ],
        "markdown": "### [call](https://docs.dolphindb.cn/zh/funcs/ho_funcs/call.html)\n\n\n\n#### 语法\n\ncall(func, args...)\n\n#### 详情\n\n用指定的参数调用一个函数。常常用在 [each](https://docs.dolphindb.cn/zh/funcs/ho_funcs/each.html)/[peach](https://docs.dolphindb.cn/zh/funcs/ho_funcs/peach.html) 或 [loop](https://docs.dolphindb.cn/zh/funcs/ho_funcs/loop.html)/[ploop](https://docs.dolphindb.cn/zh/funcs/ho_funcs/ploop.html) 中，用来调用一批函数。\n\n#### 参数\n\n* **func** 是一个函数名。\n\n* **args** 是函数func的参数。\n\n#### 返回值\n\n取决于 `func(args)` 的返回值。\n\n#### 例子\n\n```\ncall(sum, 1..10);\n// output\n55\n// 等同于sum(1..10)\n\neach(call, [avg, sum], [0..10, 0..100]);\n// output\n[5,5050]\n\neach(call{, 1..3},(sin,log));\n// 注意call{, 1..3}是一个部分应用\n```\n\n| sin      | log      |\n| -------- | -------- |\n| 0.841471 | 0        |\n| 0.909297 | 0.693147 |\n| 0.14112  | 1.098612 |\n\n**相关函数：**[nothrowCall](https://docs.dolphindb.cn/zh/funcs/ho_funcs/nothrowcall.html)\n"
    },
    "contextby": {
        "url": "https://docs.dolphindb.cn/zh/funcs/ho_funcs/contextby.html",
        "signatures": [
            {
                "full": "contextby(func, funcArgs, groupingCol, [sortingCol], [semanticFilter=1], [containArgsOfHighOrderFunc=false])",
                "name": "contextby",
                "parameters": [
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "funcArgs",
                        "name": "funcArgs"
                    },
                    {
                        "full": "groupingCol",
                        "name": "groupingCol"
                    },
                    {
                        "full": "[sortingCol]",
                        "name": "sortingCol",
                        "optional": true
                    },
                    {
                        "full": "[semanticFilter=1]",
                        "name": "semanticFilter",
                        "optional": true,
                        "default": "1"
                    },
                    {
                        "full": "[containArgsOfHighOrderFunc=false]",
                        "name": "containArgsOfHighOrderFunc",
                        "optional": true,
                        "default": "false"
                    }
                ]
            },
            {
                "full": "func:X(funcArgs, groupingCol, [sortingCol], [semanticFilter=1])",
                "name": "func:X",
                "parameters": [
                    {
                        "full": "funcArgs",
                        "name": "funcArgs"
                    },
                    {
                        "full": "groupingCol",
                        "name": "groupingCol"
                    },
                    {
                        "full": "[sortingCol]",
                        "name": "sortingCol",
                        "optional": true
                    },
                    {
                        "full": "[semanticFilter=1]",
                        "name": "semanticFilter",
                        "optional": true,
                        "default": "1"
                    }
                ]
            }
        ],
        "markdown": "### [contextby](https://docs.dolphindb.cn/zh/funcs/ho_funcs/contextby.html)\n\n\n\n#### 语法\n\ncontextby(func, funcArgs, groupingCol, \\[sortingCol], \\[semanticFilter=1], \\[containArgsOfHighOrderFunc=false])\n\n或\n\nfuncArg func:X groupingCol\n\n或\n\nfunc:X(funcArgs, groupingCol, \\[sortingCol], \\[semanticFilter=1])\n\n#### 详情\n\n根据 groupingCol 分组，并在组内进行指定计算。\n\n如果func是聚合函数，每组内的所有结果相同。若指定了sortingCol，在计算前，依此列进行组内排序。\n\n**Note:** 当 func 为聚合函数时，用于定义该聚合函数的关键词为 defg。\n\n#### 参数\n\n**func** 是一个函数。**注意**：对于第二种用法，func表示的函数只能有一个参数。\n\n**funcArgs** 是函数func的参数。如果有多个参数，则用元组表示。可以是向量、矩阵或表格，且它们的长度必须相同。\n\n**groupingCol** 是分组变量，可为一组或多组。\n\n**sortingCol** 是可选参数，表示在应用函数func前，依此列进行组内排序。\n\n**semanticFilter** 可选参数，当 *funcArgs* 指定为表时，用于指定表中参与计算的字段。它是一个正整数，可取以下值：\n\n* 0：所有列。\n\n* 1（默认值）：数值列（FLOATING/INTEGRAL/DECIMAL 分类，COMPRESSED 除外）。\n\n* 2：时间列（TEMPORAL 类型）。\n\n* 3：字符串列（LITERAL 类型，BLOB 除外）。\n\n* 4：数值列和时间列。\n\n*funcArgs*, *groupingCol* 和 *sortingCol* 中包含的向量长度相等。\n\n**containArgsOfHighOrderFunc** 可选参数，BOOL 标量。当 *funcArgs* 为元组，且元组中某些元素也为元组时，若设置为 true，则对 *funcArgs* 中元组的每个元素分别进行处理；若设置为 false（默认），则将 *funcArgs* 中的嵌套元组作为一个整体（向量）处理，不展开嵌套结构。\n\n#### 返回值\n\n一个与输入参数长度相同的向量。\n\n#### 例子\n\n例1：声明 sym、price、qty、trade\\_date 四个向量，分别代表股票代码、股价、交易量、交易日期；使用 `contextby` 进行分组计算。\n\n```\nsym=`IBM`IBM`IBM`MS`MS`MS\nprice=172.12 170.32 175.25 26.46 31.45 29.43\nqty=5800 700 9000 6300 2100 5300\ntrade_date=2013.05.08 2013.05.06 2013.05.07 2013.05.08 2013.05.06 2013.05.07;\n```\n\n按股票代码分组，计算各组内股价的平均值。\n\n```\ncontextby(avg, price, sym);\n// 等价于 price avg :X sym;\n// 输出返回：[172.563,172.563,172.563,29.113,29.113,29.113]\n```\n\n选出每只股票中价格高于该股票平均价格的所有股价。\n\n```\nprice at price>contextby(avg, price,sym);\n// 输出返回：[175.25,31.45,29.43]\n```\n\n选出每只股票中价格高于该股票平均价格的所有股票代码。\n\n```\nsym at price>contextby(avg, price,sym);\n// 输出返回：[\"IBM\",\"MS\",\"MS\"]\n```\n\n按股票代码分组，计算各组内以交易量为权重的加权平均价格。\n\n```\ncontextby(wavg, [price, qty], sym);\n// 输出返回：[173.856,173.856,173.856,28.374,28.374,28.374]\n```\n\n按股票代码分组，在各组的时间序列内计算每日价格相对于前一日价格的变化率。以下示例中设置了 *sortingCol*=trade\\_date，确保每只股票组内的数据按 trade\\_date 升序排列后再计算价格变化率。\n\n```\ncontextby(ratios, price, sym, trade_date) - 1;\n// 输出返回：[-0.01786,,0.028946,-0.100917,,-0.064229]\n```\n\n例2：将 groupingCol 指定为多个向量，按股票代码和交易日期进行双重分组，计算每只股票在每个交易日内的累计成交量。\n\n```\nsym=`IBM`IBM`IBM`IBM`IBM`IBM`MS`MS`MS`MS`MS`MS\ndate=2020.12.01 + 0 0 0 1 1 1 0 0 0 1 1 1\nqty=5800 700 9000 1000 3500 3900 6300 2100 5300 7800 1200 4300\ncontextby(cumsum, qty, [sym,date]);\n// 输出返回：[5800,6500,15500,1000,4500,8400,6300,8400,13700,7800,9000,13300]\n```\n\n例3：当 *funcArgs* 是表时，*semanticFilter* 用于控制哪些字段参与函数计算。本例分别演示：\n\n* *semanticFilter*=1：仅对数值列计算；\n\n* *semanticFilter*=2：仅对时间列计算。\n\n```\ndailyOps = table(\n    [2024.06.01, 2024.06.01, 2024.06.02, 2024.06.02] as bizDate,\n    [2024.06.01T20:00:00.000, 2024.06.01T20:05:00.000, 2024.06.02T20:00:00.000, 2024.06.02T20:05:00.000] as snapshotTime,\n    `East`East`South`South as region,\n    [\"store_101\",\"store_102\",\"store_201\",\"store_202\"] as storeId,\n    [23500.5, 19880.0, 30210.3, 28760.4] as salesAmt,\n    [128, 103, 156, 149] as orderCount\n)\ndailyOps;\n```\n\ndailyOps 的原始数据如下：\n\n| bizDate    | snapshotTime            | region | storeId    | salesAmt | orderCount |\n| ---------- | ----------------------- | ------ | ---------- | -------- | ---------- |\n| 2024.06.01 | 2024.06.01 20:00:00.000 | East   | store\\_101 | 23500.5  | 128        |\n| 2024.06.01 | 2024.06.01 20:05:00.000 | East   | store\\_102 | 19880    | 103        |\n| 2024.06.02 | 2024.06.02 20:00:00.000 | South  | store\\_201 | 30210.3  | 156        |\n| 2024.06.02 | 2024.06.02 20:05:00.000 | South  | store\\_202 | 28760.4  | 149        |\n\n设置 *semanticFilter*=1，为 salesAmt 和 orderCount 这两个数值列增加 100；其他列保持不变。\n\n```\ncontextby(add{,100}, dailyOps, dailyOps.region,,1)\n```\n\n输出返回：\n\n| bizDate    | snapshotTime            | region | storeId    | salesAmt | orderCount |\n| ---------- | ----------------------- | ------ | ---------- | -------- | ---------- |\n| 2024.06.01 | 2024.06.01 20:00:00.000 | East   | store\\_101 | 23600.5  | 228        |\n| 2024.06.01 | 2024.06.01 20:05:00.000 | East   | store\\_102 | 19980    | 203        |\n| 2024.06.02 | 2024.06.02 20:00:00.000 | South  | store\\_201 | 30310.3  | 256        |\n| 2024.06.02 | 2024.06.02 20:05:00.000 | South  | store\\_202 | 28860.4  | 249        |\n\n设置 *semanticFilter*=2，为 bizDate 和 snapshotTime 两个时间列增加 1 天；其他列保持不变。\n\n```\ncontextby(temporalAdd{,1d}, dailyOps, dailyOps.region,,2)\n```\n\n输出返回：\n\n| bizDate    | snapshotTime            | region | storeId    | salesAmt | orderCount |\n| ---------- | ----------------------- | ------ | ---------- | -------- | ---------- |\n| 2024.06.02 | 2024.06.02 20:00:00.000 | East   | store\\_101 | 23500.5  | 128        |\n| 2024.06.02 | 2024.06.02 20:05:00.000 | East   | store\\_102 | 19880.0  | 103        |\n| 2024.06.03 | 2024.06.03 20:00:00.000 | South  | store\\_201 | 30210.3  | 156        |\n| 2024.06.03 | 2024.06.03 20:05:00.000 | South  | store\\_202 | 28760.4  | 149        |\n\n例4：在 SQL 查询中使用 `contextby`。\n\n```\nsym=`IBM`IBM`IBM`MS`MS`MS\nprice=172.12 170.32 175.25 26.46 31.45 29.43\nqty=5800 700 9000 6300 2100 5300\ntrade_date=2013.05.08 2013.05.06 2013.05.07 2013.05.08 2013.05.06 2013.05.07;\nt1=table(trade_date,sym,qty,price);\nt1;\n```\n\n| trade\\_date | sym | qty  | price  |\n| ----------- | --- | ---- | ------ |\n| 2013.05.08  | IBM | 5800 | 172.12 |\n| 2013.05.06  | IBM | 700  | 170.32 |\n| 2013.05.07  | IBM | 9000 | 175.25 |\n| 2013.05.08  | MS  | 6300 | 26.46  |\n| 2013.05.06  | MS  | 2100 | 31.45  |\n| 2013.05.07  | MS  | 5300 | 29.43  |\n\n选出股价高于组内平均价的交易记录。\n\n```\nselect trade_date, sym, qty, price from t1 where price > contextby(avg, price,sym);\n```\n\n| trade\\_date | sym | qty  | price  |\n| ----------- | --- | ---- | ------ |\n| 2013.05.07  | IBM | 9000 | 175.25 |\n| 2013.05.06  | MS  | 2100 | 31.45  |\n| 2013.05.07  | MS  | 5300 | 29.43  |\n\n将所有交易日期增加一天。\n\n```\ncontextby(temporalAdd{,1d}, t1, t1.sym,,2)\n```\n\n| trade\\_date | sym | qty   | price  |\n| ----------- | --- | ----- | ------ |\n| 2013.05.09  | IBM | 5,800 | 172.12 |\n| 2013.05.07  | IBM | 700   | 170.32 |\n| 2013.05.08  | IBM | 9,000 | 175.25 |\n| 2013.05.09  | MS  | 6,300 | 26.46  |\n| 2013.05.07  | MS  | 2,100 | 31.45  |\n| 2013.05.08  | MS  | 5,300 | 29.43  |\n\n例5：当 *funcArgs* 为元组时：\n\n```\nsym=`IBM`IBM`IBM`MS`MS`MS\nprice=172.12 170.32 175.25 26.46 31.45 29.43\nqty=5800 700 9000 6300 2100 5300\ntrade_date=2013.05.08 2013.05.06 2013.05.07 2013.05.08 2013.05.06 2013.05.07;\nt = table(sym, price, qty, trade_date)\nt = select * from t order by trade_date\ndefg avgUdf(price, qty){\n    return avg(price*qty)/sum(qty)\n}\ndefg avgUdf1(price){\n    return avg(price)\n}\n// 正常\nselect contextby(func=tmoving{avgUdf1,,,3d}, funcArgs=(trade_date, price) , groupingCol=sym) from t;\n\n// 正常\nselect contextby(func=tmoving{avgUdf,,,3d}, funcArgs=(trade_date,(price, qty) ), groupingCol=sym, containArgsOfHighOrderFunc=true) from t;\n```\n\n此时 `(trade_date, (price, qty))` 是一个元组，包含两个元素：\n\n* 第一个元素是 `trade_date`，表示交易日期列，是一个向量；\n\n* 第二个元素是 `(price, qty)`，它也是一个元组，包含两个元素。如果 containArgsOfHighOrderFunc=false，则将 `(price, qty)` 当成一个整体（即一个向量）来处理。\n"
    },
    "cross": {
        "url": "https://docs.dolphindb.cn/zh/funcs/ho_funcs/cross.html",
        "signatures": [
            {
                "full": "cross(func, X, [Y])",
                "name": "cross",
                "parameters": [
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[Y]",
                        "name": "Y",
                        "optional": true
                    }
                ]
            },
            {
                "full": "func:C(X, [Y])",
                "name": "func:C",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[Y]",
                        "name": "Y",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [cross](https://docs.dolphindb.cn/zh/funcs/ho_funcs/cross.html)\n\n\n\n#### 语法\n\ncross(func, X, \\[Y])\n\n或\n\nX \\<operator>:C Y\n\n或\n\nfunc:C(X, \\[Y])\n\n#### 详情\n\n将 X 和 Y 中元素的两两组合作为参数来调用函数。如果 X 或 Y 是矩阵，以列为单位遍历。以下是 `cross` 高阶函数的伪代码：\n\n```\nfor(i:0~(size(X)-1)){\n\nfor(j:0~(size(Y)-1)){\n\n  result[i,j]=<function>(X[i], Y[j]);\n\n}\n\n}\n\nreturn result;\n```\n\n*pcross* 是并行计算版本的 *cross* 高阶函数。\n\n**Note:**\n\n虽然同名，但与 NumPy 的 [numpy.cross](https://numpy.com.cn/doc/stable/reference/generated/numpy.cross.html) 不同，DolphinDB 的 `cross` 对两个参数的所有元素组合应用指定函数，而 `numpy.cross` 是计算两个参数（向量）的叉积。\n\n#### 参数\n\n* **func** 是一个二元函数。\n\n* **X** 和 **Y** 可以是数据对、向量或矩阵。X 和 Y 可以有不同的数据形式和长度或维度。\n\n* **Y** 是一个可选参数。如果Y没有指定，将会执行cross(func, X, X)，其中func必须是对称二元函数，如 [corr](https://docs.dolphindb.cn/zh/funcs/c/corr.html) 函数。\n\n#### 返回值\n\n假设 X 有 m 个元素或 m 列，Y 有 n 个元素或 n 列，如果 func(X\\[i], Y\\[j]) 是标量，将返回一个 m×n 矩阵，如果 func(X\\[i], Y\\[j]) 是向量，将返回一个长度为 m 的元组，每个元素是一个长度为 n 的元组。\n\n#### 例子\n\n基于以下的 x 和 y 值，两个向量执行 `cross`：\n\n```\nx=1 2;\ny=3 5 7;\nx+:C y;\n```\n\n返回：\n\n| lable | 3 | 5 | 7 |\n| ----- | - | - | - |\n| 1     | 4 | 6 | 8 |\n| 2     | 5 | 7 | 9 |\n\n```\ncross(mul, x, y);\n```\n\n得到：\n\n| lable | 3 | 5  | 7  |\n| ----- | - | -- | -- |\n| 1     | 3 | 5  | 7  |\n| 2     | 6 | 10 | 14 |\n\n```\ncross(pow, x, y);\n```\n\n得到：\n\n| lable | 3 | 5  | 7   |\n| ----- | - | -- | --- |\n| 1     | 1 | 1  | 1   |\n| 2     | 8 | 32 | 128 |\n\n矩阵 m：\n\n```\nm = 1..6$2:3;\nm;\n```\n\n| clo1 | col2 | col3 |\n| ---- | ---- | ---- |\n| 1    | 3    | 5    |\n| 2    | 4    | 6    |\n\n矩阵 n：\n\n```\nn=1..4$2:2;\nn;\n```\n\n| clo1 | col2 |\n| ---- | ---- |\n| 1    | 3    |\n| 2    | 4    |\n\n对矩阵 m 和 n 执行 `cross`：\n\n```\ncross(**, m, n);\n```\n\n得到：\n\n| clo1 | col2 |\n| ---- | ---- |\n| 5    | 11   |\n| 11   | 25   |\n| 17   | 39   |\n\n一个向量和一个矩阵执行 `cross`，返回一个矩阵：\n\n```\ndef topsum(x,n){return sum x[0:n]};\na=1..18$6:3;\na;\n```\n\n得到：\n\n| clo1 | col2 | col3 |\n| ---- | ---- | ---- |\n| 1    | 7    | 13   |\n| 2    | 8    | 14   |\n| 3    | 9    | 15   |\n| 4    | 10   | 16   |\n| 5    | 11   | 17   |\n| 6    | 12   | 18   |\n\n```\nb=2 4;\na topsum :C b;\n```\n\n| 2  | 4  |\n| -- | -- |\n| 3  | 10 |\n| 15 | 34 |\n| 27 | 58 |\n\n一个向量和一个矩阵执行 `cross`，返回一个元组：\n\n```\nx=1 2\ny=1..6$2:3\ncross(add, x, y);\n```\n\n返回：((\\[2,3],\\[4,5],\\[6,7]),(\\[3,4],\\[5,6],\\[7,8]))\n\n```\nx=1 2\ny=1..6$3:2\ncross(add, x, y);\n```\n\n返回：((\\[2,3,4],\\[5,6,7]),(\\[3,4,5],\\[6,7,8]))\n"
    },
    "each": {
        "url": "https://docs.dolphindb.cn/zh/funcs/ho_funcs/each.html",
        "signatures": [
            {
                "full": "each(func, args...)",
                "name": "each",
                "parameters": [
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "args...",
                        "name": "args..."
                    }
                ]
            },
            {
                "full": "func:E(args...)",
                "name": "func:E",
                "parameters": [
                    {
                        "full": "args...",
                        "name": "args..."
                    }
                ]
            }
        ],
        "markdown": "### [each](https://docs.dolphindb.cn/zh/funcs/ho_funcs/each.html)\n\n\n\n#### 语法\n\neach(func, args...)\n\n(把一个函数应用到指定参数中的每个元素。)\n\n或\n\nF :E X\n\n(把一个函数应用到X中的每个元素。)\n\n或\n\nX \\<operator> :E Y\n\n(把一个函数应用到X和Y中的每个元素，X和Y长度相同。)\n\n或\n\nfunc:E(args...)\n\n#### 详情\n\n将指定函数（func）或运算符（operator）按以下规则应用到输入对象(args, X, Y)上：\n\n* 对于矩阵，把函数应用到每一列；\n\n* 对于表，把函数应用到每一行；\n\n* 对于数组向量，把函数应用到每一行；\n\n* 对于字典，把函数应用到字典的每一个 value。\n\nfunc(X) 和 func :E X 的区别是前者将X视作一个输入变量，而后者取遍X中的每一个参数。如果 func 是一个向量函数，应该避免使用 \"each (:E) \" ，因为在元素比较多的时候，元素的比对就会很慢。\n\n*peach* 是并行计算版本的 *each* 高阶函数。对于执行时间较长的任务，*peach* 比 *each* 能节省大量的时间。但对于小任务，*peach* 可能执行时间要比each更长，因为并行函数调用的开销很大。\n\n#### 参数\n\n* **func** 是一个函数。\n\n* **args** 是func的参数。\n\n* **operator** 是一个二元运算符。\n\n* **X** 和 **Y** 可以是数据对、向量、矩阵、表、数组向量或字典。\n\n#### 返回值\n\neach 根据每个子任务计算结果的数据类型和形式，决定返回值的数据形式。若所有子任务的数据类型和形式都相同，则返回 Vector 或 Matrix，否则返回 Tuple。\n\n#### 例子\n\n假设需要计算3个员工的日薪，员工的工时存放在向量x=\\[9,6,8]中，员工的时薪在8小时以下是$10，在8小时以上是$20。考虑下面的 *wage* 函数：\n\n```\nx=[9,6,8]\ndef wage(x){if(x<=8) return 10*x; else return 20*x-80}\nwage x;\n\nThe vector can't be converted to bool scalar.\n```\n\n*wage(x)* 不返回结果，因为x<=8，即 \\[9,6,8]<=8 返回了一个向量的条件值\\[0,1,1]，而不是if 需要的标量。\n\n可使用以下方案来解决这个问题：\n\n```\neach(wage, x);\n\n[100,60,80]\n\nwage :E x;\n\n[100,60,80]\n\ndef wage2(x){return iif(x<=8, 10*x, 20*x-80)};\n// iif 函数是一个逐元素的条件操作\n\nwage2(x);\n\n[100,60,80]\n```\n\n类似的，*each* 也可以用于有多个参数的函数：\n\n```\ndef addeven(x,y){if (x%2==0) return x+y; else return 0}\nx1=1 2 3\nx2=4 5 6;\neach(addeven, x1, x2);\n\n[0,7,0]\n```\n\n*each* 所用数据可以是数据对：\n\n```\nt = table(1 2 3 as id, 4 5 6 as value, `IBM`MSFT`GOOG as name);\nt;\n```\n\n| id | value | name |\n| -- | ----- | ---- |\n| 1  | 4     | IBM  |\n| 2  | 5     | MSFT |\n| 3  | 6     | GOOG |\n\n```\neach(max, t[`id`value]);\n\n[3,6]\n```\n\n*each* 所用数据可以是矩阵：\n\n```\nm=1..12$4:3;\nm;\n```\n\n| col1 | col2 | col3 |\n| ---- | ---- | ---- |\n| 1    | 5    | 9    |\n| 2    | 6    | 10   |\n| 3    | 7    | 11   |\n| 4    | 8    | 12   |\n\n```\neach(add{1 2 3 4}, m);\n// add{1 2 3 4}是一个部分应用，each将向量[1, 2, 3, 4]与矩阵m的每列相加。\n```\n\n| col1 | col2 | col3 |\n| ---- | ---- | ---- |\n| 2    | 6    | 10   |\n| 4    | 8    | 12   |\n| 6    | 10   | 14   |\n| 8    | 12   | 16   |\n\n```\nx=1..6$2:3;\ny=6..1$2:3;\nx;\n```\n\n| col1 | col2 | col3 |\n| ---- | ---- | ---- |\n| 1    | 3    | 5    |\n| 2    | 4    | 6    |\n\n```\ny;\n```\n\n| col1 | col2 | col3 |\n| ---- | ---- | ---- |\n| 6    | 4    | 2    |\n| 5    | 3    | 1    |\n\n```\neach(**, x, y);\n\n[16,24,16]\n// 比如，24=3*4+4*3\n```\n\n当输入对象有多个时，每次取出每个对象相同位置的元素，作为指定函数的参数。例如：\n\n```\nm1 = matrix(1 3 6, 4 6 8, 5 -1 3)\nm2 = matrix(3 -6 0, 2 NULL 3, 6 7 9)\neach(corr, m1, m2)\n// 等价于 corr(m1[0], m2[0]) join corr(m1[1], m2[1]) join corr(m1[2], m2[2])\n\n[-0.216777, 1, -0.142857]\n```\n\n从 2.00.9 版本开始，*each* 所用数据可以是字典：\n\n```\nd=dict(`a`b`c, [[1, 2, 3],[4, 5, 6], [7, 8, 9]])\neach(sum, d)\n\nb->15\nc->24\na->6\n```\n\n下例中，我们在一个部分应用中使用了 *call* 函数，该部分应用将向量\\[1 2 3]作为参数，分别调用函数 *sin* 与 *log*。\n\n```\n// 当 \"functionName\" 为空时，将动态地选择一个函数名字。\neach(call{, 1..3},(sin,log));\n```\n\n| sin      | log      |\n| -------- | -------- |\n| 0.841471 | 0        |\n| 0.909297 | 0.693147 |\n| 0.14112  | 1.098612 |\n\nfunc 为自定义函数，对字典进行操作。当字典的 key 的类型是字符串时，*each* 会对字典进行合并，返回一个表。合并规则如下：\n\n1. 根据第一个字典确定表的 schema，并将字典的 value 写入表中第一行。字段名为该字典的 keys，列数为该字典的 keys 的个数。无论后续被遍历字典 keys 的个数如何变化，表的 schema 不会被修改。\n\n2. 在遍历后续字典时，每一个字典对应表中一行数据。若某个 key 与表字段名相同，则将其 value 追加到表中，若某个 key 与表字段不同，则追加空值到表中。\n\n   ```\n   days = 2023.01.01..2023.01.10\n   def mf(day) {  \n       out = dict(STRING, ANY)\n       if(day==2023.01.05){\n           out[\"v\"] = 3\n       }\n       else{\n           out[\"day\"] = day\n           out[\"v\"] = 1\n       }\n       return out\n   }\n   each(mf, days)\n\n   ```\n\n   | v | day        |\n   | - | ---------- |\n   | 1 | 2023.01.01 |\n   | 1 | 2023.01.02 |\n   | 1 | 2023.01.03 |\n   | 1 | 2023.01.04 |\n   | 3 |            |\n   | 1 | 2023.01.06 |\n   | 1 | 2023.01.07 |\n   | 1 | 2023.01.08 |\n   | 1 | 2023.01.09 |\n   | 1 | 2023.01.10 |\n\n从2.00.12和3.00.0版本开始，each 可以接受多元函数且第一个参数为字典。\n\n对于表 t 中 id 列的每个元素，计算其向前累加直到不小于3经过的周期数（可用 `sumbars` 函数实现）；对 id2 的每个元素，计算其向前累加直到不小于5经过的周期数。因为用 `sumbars` 计算每列数据时，*Y* 不同（分别是3和5），必须用一个二元函数跟 each 搭配使用。对一个表转置（`transpose`），返回一个以列名为键值，列为数值的字典。对字典应用转置函数，则还原为表。\n\n```\nt = table(1..10 as id, 2..11 as id2)\nsumbars:E(t.transpose(), 3 5).transpose()\n```\n\n| id | id2 |\n| -- | --- |\n| 0  | 0   |\n| 2  | 2   |\n| 1  | 2   |\n| 1  | 1   |\n| 1  | 1   |\n| 1  | 1   |\n| 1  | 1   |\n| 1  | 1   |\n| 1  | 1   |\n| 1  | 1   |\n\n**Tip:**\n\n1. 对于执行时间长的任务，使用 *peach* 进行并行计算，可以节约任务执行时间。\n\n   ```\n   m=rand(1,20000:5000)\n   timer f=peach(mskew{,8},m)\n\n   Time elapsed: 3134.71 ms\n   timer f=mskew(m,8)\n\n   Time elapsed: 8810.485 ms\n   ```\n\n2. 当元素数量很多时候，不推荐使用 *:E (each)* 高阶函数，可以使用更高效的向量解决方案。\n\n   ```\n   x=rand(16, 1000000);\n   timer(10){each(wage, x)};\n\n   Time elapsed: 38164.9 ms\n\n   timer(10){iif(x<8,10*x,20*x-80)};\n\n   Time elapsed: 81.516 ms\n   ```\n"
    },
    "eachLeft": {
        "url": "https://docs.dolphindb.cn/zh/funcs/ho_funcs/eachLeft.html",
        "signatures": [
            {
                "full": "eachLeft(func, X, Y, [assembleRule|consistent=false])",
                "name": "eachLeft",
                "parameters": [
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "[assembleRule|consistent=false]",
                        "name": "[assembleRule|consistent=false]"
                    }
                ]
            },
            {
                "full": "func:L(X, Y)",
                "name": "func:L",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            },
            {
                "full": "func:LC(X, Y)",
                "name": "func:LC",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [eachLeft](https://docs.dolphindb.cn/zh/funcs/ho_funcs/eachLeft.html)\n\n#### 语法\n\neachLeft(func, X, Y, \\[assembleRule|consistent=false])\n\nfunc:L(X, Y) 或 X \\<operator>:L Y 表示不指定 ，使用默认值\n\nfunc:LC(X, Y) 或 X \\<operator>:LC Y 表示指定 ，此例中指定为 C（Consistent）\n\n#### 详情\n\n把 func 应用到 *X* 的每个元素上，即依次执行 func(X(i),Y)。\n\n* 对于向量，X(i) 为每个元素\n\n* 对于矩阵，X(i) 为每一列\n\n* 对于表，X(i) 为每一行\n\n* 对于数组向量，X(i) 为每一行\n\n* 对于字典，X(i) 为字典的每一个 value\n\n如果 func 支持向量操作，并且输入数据是一个向量，使用向量函数或运算符比使用 eachLeft 更为高效。\n\n#### 参数\n\n* **func** 是一个二元函数。\n* **X** 和 **Y** 可以是向量、矩阵、表、数组向量或字典。\n* **assembleRule** 可选参数，表示如何将子任务的结果合并为函数最终结果。接受一个整数或字符串作为输入，可选值如下：\n\n  * 0 （或 \"D\"）：默认值，表示 DolphinDB 规则，即根据所有子任务的结果来决定最终输出的数据类型和形式。当所有子结果具有相同的数据类型和形式时，多个标量合并为一个向量、多个向量合并为一个矩阵、多个矩阵合并为一个元组、多个字典合并为一张表；否则将所有子结果合并为一个元组输出。\n\n  * 1（或 \"C\"）：表示 Consistent 规则，即认为所有子结果的数据类型和形式都与第一个子结果相同，根据第一个子结果来选择最终结果的数据类型和形式。如果后续子任务返回的结果与第一个子任务的结果类型不一致，系统会尝试对后续结果进行类型转换。如果转换失败则抛出异常。因此，此规则只可在已知子结果的数据类型及形式一致时指定。此规则可使系统免于逐一缓存并检查每个子任务的计算结果，从而提升性能。\n\n  * 2（或 \"U\"）：表示 Tuple 规则，系统不再对各子结果的类型和形式一致性进行检查，而是直接将子结果组装成一个元组输出。\n\n  * 3（或 \"K\"）：表示 kdb+ 规则。与 DolphinDB 规则类似，都会根据所有子结果来决定最终结果形式。主要区别在于，kdb+ 规则下，只要有任一子任务返回向量，则最终结果必为一个元组；而在 DolphinDB 规则下，子任务结果若均为长度相同的向量，则最终结果为一个矩阵。其他情况下，kdb+ 规则的输出与 DolphinDB 规则相同。\n\n  **Note:**\n\n  * 自 2.00.15/3.00.3 版本起，新增了 *assembleRule* 参数。该参数不仅实现了原 *consistent* 参数的功能，还提供了更多的结果合并选项。*consistent* 是一个布尔值，默认值为 false，相当于 *assembleRule*=\"D\"；若为 true，则相当于 *assembleRule*=\"C\"。为保持兼容性，用户仍可使用 *consistent* 参数。如果同时指定 *assemble* 和 *consistent*，将以 *consistent* 的值为准。\n  * *assembleRule* 也可在高阶函数对应的函数模式符号后指定，通过字符 D/C/U/K 表示。以 `eachPre (:P)` 为例，形如 `sub:PU(X)`。不指定则使用默认值 D。\n\n#### 返回值\n\n取决于 *assembleRule* 的值。\n\n#### 例子\n\n*eachLeft* 作用于两个向量：\n\n```\nx = 4 3 2 1\ny = 3 0 6;\nx +:L y;\n```\n\n| 4  | 3 | 2 | 1 |\n| -- | - | - | - |\n| 7  | 6 | 5 | 4 |\n| 4  | 3 | 2 | 1 |\n| 10 | 9 | 8 | 7 |\n\n```\neachLeft(pow, x, y);\n```\n\n| 4    | 3   | 2  | 1 |\n| ---- | --- | -- | - |\n| 64   | 27  | 8  | 1 |\n| 1    | 1   | 1  | 1 |\n| 4096 | 729 | 64 | 1 |\n\n*eachLeft* 作用于一个矩阵以及一个向量：\n\n```\nx=1..6$2:3;\nx;\n```\n\n| col1 | col2 | col3 |\n| ---- | ---- | ---- |\n| 1    | 3    | 5    |\n| 2    | 4    | 6    |\n\n```\nx ** :L 1 1;\n// output\n[3,7,11]\n```\n\n*eachLeft* 作用于两个矩阵：\n\n```\ny=6..1$2:3;\ny;\n```\n\n| col1 | col2 | col3 |\n| ---- | ---- | ---- |\n| 6    | 4    | 2    |\n| 5    | 3    | 1    |\n\n```\nz = x **:L y;\nz;\n\n// output\n(#0 #1 #2\n-- -- --\n16 10 4\n,#0 #1 #2\n-- -- --\n38 24 10\n,#0 #1 #2\n-- -- --\n60 38 16\n)\n```\n\n```\ntypestr z;\n// output\nANY VECTOR\n```\n\n*eachLeft* 作用于一个字典和一个向量：\n\n```\nd=dict(`a`b`c, [[1, 2, 3],[4, 5, 6], [7, 8, 9]])\neachLeft(add,d,10 20 30)\n// output\na->[11,22,33]\nb->[14,25,36]\nc->[17,28,39]\n```\n\n"
    },
    "eachPost": {
        "url": "https://docs.dolphindb.cn/zh/funcs/ho_funcs/eachPost.html",
        "signatures": [
            {
                "full": "eachPost(func, X, [post], [assembleRule|consistent=false])",
                "name": "eachPost",
                "parameters": [
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[post]",
                        "name": "post",
                        "optional": true
                    },
                    {
                        "full": "[assembleRule|consistent=false]",
                        "name": "[assembleRule|consistent=false]"
                    }
                ]
            },
            {
                "full": "func:O(X, [post])",
                "name": "func:O",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[post]",
                        "name": "post",
                        "optional": true
                    }
                ]
            },
            {
                "full": "func:OC(X, [post])",
                "name": "func:OC",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[post]",
                        "name": "post",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [eachPost](https://docs.dolphindb.cn/zh/funcs/ho_funcs/eachPost.html)\n\n\n\n#### 语法\n\neachPost(func, X, \\[post], \\[assembleRule|consistent=false])\n\nfunc:O(X, \\[post]) 或 X \\<operator>:O \\[post] 表示不指定 ，使用默认值\n\nfunc:OC(X, \\[post]) 或 X \\<operator>:OC \\[post] 表示指定 ，此例中指定为 C（Consistent）\n\n#### 详情\n\n将给定函数/运算符应用到所有相邻的数据对上。\n\n*eachPost* 高阶函数等同于：F(X\\[0], X\\[1]), F(X\\[1], X\\[2]), ..., F(X\\[n], post).\n\n#### 参数\n\n* **func** 是一个二元函数。\n* **X** 可以是向量、矩阵或表。当 *X* 是向量时，*post* 必须是标量；当 *X* 是矩阵时，*post* 必须是标量或向量；当 *X* 是表时，*post* 是标量或表；当 *post* 未指定时，结果的最后一个元素为 NULL。\n* **post** 是可选参数，用于为 *X* 的最后一个元素提供后序值，其数据形式要求取决于 *X* 的数据形式。\n* **assembleRule** 可选参数，表示如何将子任务的结果合并为函数最终结果。接受一个整数或字符串作为输入，可选值如下：\n\n  * 0 （或 \"D\"）：默认值，表示 DolphinDB 规则，即根据所有子任务的结果来决定最终输出的数据类型和形式。当所有子结果具有相同的数据类型和形式时，多个标量合并为一个向量、多个向量合并为一个矩阵、多个矩阵合并为一个元组、多个字典合并为一张表；否则将所有子结果合并为一个元组输出。\n\n  * 1（或 \"C\"）：表示 Consistent 规则，即认为所有子结果的数据类型和形式都与第一个子结果相同，根据第一个子结果来选择最终结果的数据类型和形式。如果后续子任务返回的结果与第一个子任务的结果类型不一致，系统会尝试对后续结果进行类型转换。如果转换失败则抛出异常。因此，此规则只可在已知子结果的数据类型及形式一致时指定。此规则可使系统免于逐一缓存并检查每个子任务的计算结果，从而提升性能。\n\n  * 2（或 \"U\"）：表示 Tuple 规则，系统不再对各子结果的类型和形式一致性进行检查，而是直接将子结果组装成一个元组输出。\n\n  * 3（或 \"K\"）：表示 kdb+ 规则。与 DolphinDB 规则类似，都会根据所有子结果来决定最终结果形式。主要区别在于，kdb+ 规则下，只要有任一子任务返回向量，则最终结果必为一个元组；而在 DolphinDB 规则下，子任务结果若均为长度相同的向量，则最终结果为一个矩阵。其他情况下，kdb+ 规则的输出与 DolphinDB 规则相同。\n\n  **Note:**\n\n  * 自 2.00.15/3.00.3 版本起，新增了 *assembleRule* 参数。该参数不仅实现了原 *consistent* 参数的功能，还提供了更多的结果合并选项。*consistent* 是一个布尔值，默认值为 false，相当于 *assembleRule*=\"D\"；若为 true，则相当于 *assembleRule*=\"C\"。为保持兼容性，用户仍可使用 *consistent* 参数。如果同时指定 *assemble* 和 *consistent*，将以 *consistent* 的值为准。\n  * *assembleRule* 也可在高阶函数对应的函数模式符号后指定，通过字符 D/C/U/K 表示。以 `eachPre (:P)` 为例，形如 `sub:PU(X)`。不指定则使用默认值 D。\n\n#### 返回值\n\n取决于 *assembleRule* 的值。\n\n#### 例子\n\n```\nx=1..10;\neachPost(sub, x);\n// output\n[-1,-1,-1,-1,-1,-1,-1,-1,-1,]\n// 等同于 [1-2, 2-3, ..., 9-10, NULL]\n\n+:O x;\n// output\n[3,5,7,9,11,13,15,17,19,]\n// 等同于 [1+2, 2+3, ..., 9+10, NULL]\n\nx +:O 0;\n// output\n[3,5,7,9,11,13,15,17,19,10]\n// 等同于 [1+2, 2+3, ..., 9+10, 10+0]\n\nx=1..12$3:4;\nx;\n```\n\n| col1 | col2 | col3 | col4 |\n| ---- | ---- | ---- | ---- |\n| 1    | 4    | 7    | 10   |\n| 2    | 5    | 8    | 11   |\n| 3    | 6    | 9    | 12   |\n\n```\n-:O x;\n```\n\n| col1 | col2 | col3 | col4 |\n| ---- | ---- | ---- | ---- |\n| -3   | -3   | -3   |      |\n| -3   | -3   | -3   |      |\n| -3   | -3   | -3   |      |\n\n```\neachPost(\\, x, x[0]);\n```\n\n| col1 | col2     | col3     | col4 |\n| ---- | -------- | -------- | ---- |\n| 0.25 | 0.571429 | 0.7      | 10   |\n| 0.4  | 0.625    | 0.727273 | 5.5  |\n| 0.5  | 0.666667 | 0.75     | 4    |\n\n```\ndef f1(a,b){\n    return (a[`x])+(a[`y])+(b[`x])+(b[`y])\n}\n\nt = table(1 2 3 as x,2 3 4 as y)\nt1 = table(1 as x,2 as y)\neachPost(f1,t,t1)\n\n// output\n(8,12,[10])\n```\n"
    },
    "eachPre": {
        "url": "https://docs.dolphindb.cn/zh/funcs/ho_funcs/eachPre.html",
        "signatures": [
            {
                "full": "eachPre(func, X, [pre], [assembleRule|consistent=false])",
                "name": "eachPre",
                "parameters": [
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[pre]",
                        "name": "pre",
                        "optional": true
                    },
                    {
                        "full": "[assembleRule|consistent=false]",
                        "name": "[assembleRule|consistent=false]"
                    }
                ]
            },
            {
                "full": "func:P([pre], X)",
                "name": "func:P",
                "parameters": [
                    {
                        "full": "[pre]",
                        "name": "pre",
                        "optional": true
                    },
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            },
            {
                "full": "func:PC([pre], X)",
                "name": "func:PC",
                "parameters": [
                    {
                        "full": "[pre]",
                        "name": "pre",
                        "optional": true
                    },
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [eachPre](https://docs.dolphindb.cn/zh/funcs/ho_funcs/eachPre.html)\n\n#### 语法\n\neachPre(func, X, \\[pre], \\[assembleRule|consistent=false])\n\nfunc:P(\\[pre], X) 或 \\[pre] \\<operator>:P X 表示不指定 ，使用默认值\n\nfunc:PC(\\[pre], X) 或 \\[pre] \\<operator>:PC X 表示指定 \\*assembleRule，\\*此例中指定为 C（Consistent）\n\n#### 详情\n\n将给定函数/运算符应用于X中所有相邻的数据对。\n\n*eachPre* 高阶函数等同于： F(X\\[0], pre), F(X\\[1], X\\[0]), ..., F(X\\[n], X\\[n-1])。\n\n内置函数 [ratios](https://docs.dolphindb.cn/zh/funcs/r/ratios.html) 和 [deltas](https://docs.dolphindb.cn/zh/funcs/d/deltas.html) 也是通过用 *eachPre* 高阶函数实现。定义如下：\n\n* function deltas(a){return a\\[0] -:P a}\n\n* function ratios(a){return a\\[0] :P a}\n\n#### 参数\n\n* **func** 是一个二元函数。\n* **X** 可以是向量、矩阵或表。当X是向量时，pre必须是标量；当X是矩阵时，pre必须是标量或向量；当X是表时，pre必须是标量或表；当pre未指定时，结果的第一个元素为NULL。\n* **pre** 可选参数，用于为计算提供初始的前序值，其数据形式要求取决于 *X* 的数据形式。\n* **assembleRule** 可选参数，表示如何将子任务的结果合并为函数最终结果。接受一个整数或字符串作为输入，可选值如下：\n\n  * 0 （或 \"D\"）：默认值，表示 DolphinDB 规则，即根据所有子任务的结果来决定最终输出的数据类型和形式。当所有子结果具有相同的数据类型和形式时，多个标量合并为一个向量、多个向量合并为一个矩阵、多个矩阵合并为一个元组、多个字典合并为一张表；否则将所有子结果合并为一个元组输出。\n\n  * 1（或 \"C\"）：表示 Consistent 规则，即认为所有子结果的数据类型和形式都与第一个子结果相同，根据第一个子结果来选择最终结果的数据类型和形式。如果后续子任务返回的结果与第一个子任务的结果类型不一致，系统会尝试对后续结果进行类型转换。如果转换失败则抛出异常。因此，此规则只可在已知子结果的数据类型及形式一致时指定。此规则可使系统免于逐一缓存并检查每个子任务的计算结果，从而提升性能。\n\n  * 2（或 \"U\"）：表示 Tuple 规则，系统不再对各子结果的类型和形式一致性进行检查，而是直接将子结果组装成一个元组输出。\n\n  * 3（或 \"K\"）：表示 kdb+ 规则。与 DolphinDB 规则类似，都会根据所有子结果来决定最终结果形式。主要区别在于，kdb+ 规则下，只要有任一子任务返回向量，则最终结果必为一个元组；而在 DolphinDB 规则下，子任务结果若均为长度相同的向量，则最终结果为一个矩阵。其他情况下，kdb+ 规则的输出与 DolphinDB 规则相同。\n\n  **Note:**\n\n  * 自 2.00.15/3.00.3 版本起，新增了 *assembleRule* 参数。该参数不仅实现了原 *consistent* 参数的功能，还提供了更多的结果合并选项。*consistent* 是一个布尔值，默认值为 false，相当于 *assembleRule*=\"D\"；若为 true，则相当于 *assembleRule*=\"C\"。为保持兼容性，用户仍可使用 *consistent* 参数。如果同时指定 *assemble* 和 *consistent*，将以 *consistent* 的值为准。\n  * *assembleRule* 也可在高阶函数对应的函数模式符号后指定，通过字符 D/C/U/K 表示。以 `eachPre (:P)` 为例，形如 `sub:PU(X)`。不指定则使用默认值 D。\n\n#### 返回值\n\n取决于 *assembleRule* 的值。\n\n#### 例子\n\n```\nx=1..10;\neachPre(sub, x);\n```\n\n返回：\\[,1,1,1,1,1,1,1,1,1]。该用法等同于 \\[NULL, 2-1, ..., 10-9]\n\n```\neachPre(sub, x,,assembleRule=\"U\");\n```\n\n返回：(,1,1,1,1,1,1,1,1,1)\n\n```\n-:P x;\n```\n\n返回：\\[,1,1,1,1,1,1,1,1,1]。该用法等同于 \\[NULL, 2-1, ..., 10-9]\n\n```\neachPre(+, x);\n```\n\n返回：\\[,3,5,7,9,11,13,15,17,19]。该用法等同于 \\[NULL, 2+1, ..., ]。\n\n```\n0 +:P x;\n```\n\n返回：\\[1,3,5,7,9,11,13,15,17,19]。该用法等同于 \\[1+0, 2+1, ..., ]。\n\n```\nx=1..12$3:4;\nx;\n```\n\n返回：\n\n| col1 | col2 | col3 | col4 |\n| ---- | ---- | ---- | ---- |\n| 1    | 4    | 7    | 10   |\n| 2    | 5    | 8    | 11   |\n| 3    | 6    | 9    | 12   |\n\n```\n- :P x;\n```\n\n返回：\n\n| col1 | col2 | col3 | col4 |\n| ---- | ---- | ---- | ---- |\n|      | 3    | 3    | 3    |\n|      | 3    | 3    | 3    |\n|      | 3    | 3    | 3    |\n\n```\neachPre(\\, x, x[0]);\n```\n\n返回：\n\n| col1 | col2 | col3 | col4     |\n| ---- | ---- | ---- | -------- |\n| 1    | 4    | 1.75 | 1.428571 |\n| 1    | 2.5  | 1.6  | 1.375    |\n| 1    | 2    | 1.5  | 1.333333 |\n\n```\ndef f1(a,b){\n    return (a[`x])+(a[`y])+(b[`x])+(b[`y])\n}\n\nt = table(1 2 3 as x,2 3 4 as y)\nt1 = table(1 as x,2 as y)\neachPre(f1,t,t1)\n```\n\n返回：(\\[6],8,12)\n\n对比不同的结果组装方式。\n\n```\ntab = table(til(5) as a,`a`a`b`b`c as b)\nselect *, contextby({x,y->isNull(y) ? [x] : [y,x]}:P,a,b) as c from tab\n//使用默认（DolphinDB）规则组装结果\na b c    \n- - -----\n0 a [0]  \n1 a [0,1]\n2 b [2]  \n3 b [2,3]\n4 c 4    \n\nselect *, contextby({x,y->isNull(y) ? [x] : [y,x]}:PU,a,b) as c from tab\n//使用 Tuple 规则组装结果，可以发现最后一行记录的 c 列也输出一个向量\na b c    \n- - -----\n0 a [0]  \n1 a [0,1]\n2 b [2]  \n3 b [2,3]\n4 c [4]  \n```\n\n"
    },
    "eachRight": {
        "url": "https://docs.dolphindb.cn/zh/funcs/ho_funcs/eachRight.html",
        "signatures": [
            {
                "full": "eachRight(func, X, Y, [assembleRule|consistent=false])",
                "name": "eachRight",
                "parameters": [
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "[assembleRule|consistent=false]",
                        "name": "[assembleRule|consistent=false]"
                    }
                ]
            },
            {
                "full": "func:R(X, Y)",
                "name": "func:R",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            },
            {
                "full": "func:RC(X, Y)",
                "name": "func:RC",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [eachRight](https://docs.dolphindb.cn/zh/funcs/ho_funcs/eachRight.html)\n\n\n\n#### 语法\n\neachRight(func, X, Y, \\[assembleRule|consistent=false])\n\nfunc:R(X, Y) 或 X \\<operator>:R Y 表示不指定 ，使用默认值\n\nfunc:RC(X, Y) 或 X \\<operator>:RC Y 表示指定 ，此例中指定为 C（Consistent）\n\n#### 详情\n\n把 func 应用到 *Y* 的每个元素上，即依次执行 func(X,Y(i))。\n\n* 对于向量，Y(i) 为每个元素\n\n* 对于矩阵，Y(i) 为每一列\n\n* 对于表，Y(i) 为每一行\n\n* 对于数组向量，Y(i) 为每一行\n\n* 对于字典，Y(i) 为字典的每一个 value\n\n如果 func 支持向量操作，并且输入数据是一个向量，为性能考虑，应直接使用向量函数或运算符，不要使用 *eachRight*。\n\n#### 参数\n\n* **func** 是一个二元函数。\n* **X** 和 **Y** 可以是向量，矩阵、表、数组向量或字典。\n* **assembleRule** 可选参数，表示如何将子任务的结果合并为函数最终结果。接受一个整数或字符串作为输入，可选值如下：\n\n  * 0 （或 \"D\"）：默认值，表示 DolphinDB 规则，即根据所有子任务的结果来决定最终输出的数据类型和形式。当所有子结果具有相同的数据类型和形式时，多个标量合并为一个向量、多个向量合并为一个矩阵、多个矩阵合并为一个元组、多个字典合并为一张表；否则将所有子结果合并为一个元组输出。\n\n  * 1（或 \"C\"）：表示 Consistent 规则，即认为所有子结果的数据类型和形式都与第一个子结果相同，根据第一个子结果来选择最终结果的数据类型和形式。如果后续子任务返回的结果与第一个子任务的结果类型不一致，系统会尝试对后续结果进行类型转换。如果转换失败则抛出异常。因此，此规则只可在已知子结果的数据类型及形式一致时指定。此规则可使系统免于逐一缓存并检查每个子任务的计算结果，从而提升性能。\n\n  * 2（或 \"U\"）：表示 Tuple 规则，系统不再对各子结果的类型和形式一致性进行检查，而是直接将子结果组装成一个元组输出。\n\n  * 3（或 \"K\"）：表示 kdb+ 规则。与 DolphinDB 规则类似，都会根据所有子结果来决定最终结果形式。主要区别在于，kdb+ 规则下，只要有任一子任务返回向量，则最终结果必为一个元组；而在 DolphinDB 规则下，子任务结果若均为长度相同的向量，则最终结果为一个矩阵。其他情况下，kdb+ 规则的输出与 DolphinDB 规则相同。\n\n  **Note:**\n\n  * 自 2.00.15/3.00.3 版本起，新增了 *assembleRule* 参数。该参数不仅实现了原 *consistent* 参数的功能，还提供了更多的结果合并选项。*consistent* 是一个布尔值，默认值为 false，相当于 *assembleRule*=\"D\"；若为 true，则相当于 *assembleRule*=\"C\"。为保持兼容性，用户仍可使用 *consistent* 参数。如果同时指定 *assemble* 和 *consistent*，将以 *consistent* 的值为准。\n  * *assembleRule* 也可在高阶函数对应的函数模式符号后指定，通过字符 D/C/U/K 表示。以 `eachPre (:P)` 为例，形如 `sub:PU(X)`。不指定则使用默认值 D。\n\n#### 返回值\n\n取决于 *assembleRule* 的值。\n\n#### 例子\n\n*eachRight* 作用于两个向量：\n\n```\nx = 4 3 2 1\ny = 3 0 6;\neachRight(add, x, y);\n```\n\n| 3 | 0 | 6  |\n| - | - | -- |\n| 7 | 4 | 10 |\n| 6 | 3 | 9  |\n| 5 | 2 | 8  |\n| 4 | 1 | 7  |\n\n```\nx pow :R y;\n```\n\n| 3  | 0 | 6    |\n| -- | - | ---- |\n| 64 | 1 | 4096 |\n| 27 | 1 | 729  |\n| 8  | 1 | 64   |\n| 1  | 1 | 1    |\n\n*eachRight* 作用于一个矩阵以及一个向量：\n\n```\nx=1..6$2:3;\nx;\n```\n\n| col1 | col2 | col3 |\n| ---- | ---- | ---- |\n| 1    | 3    | 5    |\n| 2    | 4    | 6    |\n\n```\n1 1 ** :R x;\n// output\n[3,7,11]\n```\n\n*eachRight* 作用于两个矩阵：\n\n```\ny=6..1$3:2;\ny;\n```\n\n| col1 | col2 |\n| ---- | ---- |\n| 6    | 3    |\n| 5    | 2    |\n| 4    | 1    |\n\n```\neachRight(**, x, y);\n\n// output\n(#0\n--\n41\n56\n,#0\n--\n14\n20\n)\n```\n\n*eachRight* 作用于一个字典和一个向量：\n\n```\nd=dict(`a`b`c, [[1, 2, 3],[4, 5, 6], [7, 8, 9]])\neachRight(add,10 20 30,d)\n// output\na->[11,22,33]\nb->[14,25,36]\nc->[17,28,39]\n```\n"
    },
    "groupby": {
        "url": "https://docs.dolphindb.cn/zh/funcs/ho_funcs/groupby.html",
        "signatures": [
            {
                "full": "groupby(func, funcArgs, groupingCol)",
                "name": "groupby",
                "parameters": [
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "funcArgs",
                        "name": "funcArgs"
                    },
                    {
                        "full": "groupingCol",
                        "name": "groupingCol"
                    }
                ]
            },
            {
                "full": "func:G(funcArgs, groupingCol)",
                "name": "func:G",
                "parameters": [
                    {
                        "full": "funcArgs",
                        "name": "funcArgs"
                    },
                    {
                        "full": "groupingCol",
                        "name": "groupingCol"
                    }
                ]
            }
        ],
        "markdown": "### [groupby](https://docs.dolphindb.cn/zh/funcs/ho_funcs/groupby.html)\n\n#### 语法\n\ngroupby(func, funcArgs, groupingCol)\n\n或\n\nfuncArg func:G groupingCol\n\n或\n\nfunc:G(funcArgs, groupingCol)\n\n#### 详情\n\n对 *groupingCol* 排序后分组，然后在每个分组中计算 func(funcArgs)。每组的计算结果可以是标量，向量或字典。该函数的输出结果是一个表，它的行数与分组数相等。\n\n#### 参数\n\n* **func** 是一个函数。\n* **funcArgs** 是函数 func 的参数。如果有多个参数，则用元组表示。\n* **groupingCol** 表示分组变量。可以是向量，表示一个分组列；也可以是等长向量组成的元组，表示多个分组列。\n\n*groupingCol*和 *funcArgs*中的每个参数都是相同长度的向量。\n\n**Note:** 对于第二种情况，*func* 表示的函数只能有一个参数。\n\n#### 返回值\n\n一张表。\n\n#### 例子\n\n```\nsym=`IBM`IBM`IBM`MS`MS`MS$symbol;\nprice=172.12 170.32 175.25 26.46 31.45 29.43;\nqty=5800 700 9000 6300 2100 5300;\ntrade_date=2013.05.08 2013.05.06 2013.05.07 2013.05.08 2013.05.06 2013.05.07;\ngroupby(avg, price, sym);\n```\n\n| sym | avg\\_price |\n| --- | ---------- |\n| IBM | 172.563333 |\n| MS  | 29.113333  |\n\n```\nprice avg :G sym;\n```\n\n| sym | avg\\_price |\n| --- | ---------- |\n| IBM | 172.563333 |\n| MS  | 29.113333  |\n\n```\ngroupby(wavg, [price, qty], sym);\n// 计算每个股票标记数量加权后的平均价格\n```\n\n| sym | avg\\_price |\n| --- | ---------- |\n| IBM | 173.856129 |\n| MS  | 28.373869  |\n\n```\nsym = `C`MS`MS`MS`IBM`IBM`C`C`C$SYMBOL\nprice= 49.6 29.46 29.52 30.02 174.97 175.23 50.76 50.32 51.29\nqty = 2200 1900 2100 3200 6800 5400 1300 2500 8800\ntimestamp = [09:34:07,09:36:42,09:36:51,09:36:59,09:32:47,09:35:26,09:34:16,09:34:26,09:38:12]\n\ngroupby(max, price, [sym,minute(timestamp)])\n```\n\n| sym | groupingKey | max\\_price |\n| --- | ----------- | ---------- |\n| C   | 09:34m      | 50.76      |\n| C   | 09:38m      | 51.29      |\n| IBM | 09:32m      | 174.97     |\n| IBM | 09:35m      | 175.23     |\n| MS  | 09:36m      | 30.02      |\n\n"
    },
    "loop": {
        "url": "https://docs.dolphindb.cn/zh/funcs/ho_funcs/loop.html",
        "signatures": [
            {
                "full": "loop(func, args...)",
                "name": "loop",
                "parameters": [
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "args...",
                        "name": "args..."
                    }
                ]
            },
            {
                "full": "func:U(args…)",
                "name": "func:U",
                "parameters": [
                    {
                        "full": "args…",
                        "name": "args…"
                    }
                ]
            }
        ],
        "markdown": "### [loop](https://docs.dolphindb.cn/zh/funcs/ho_funcs/loop.html)\n\n#### 语法\n\nloop(func, args...)\n\n或\n\nfunc:U(args…)\n\n或\n\nfunc:U X\n\n或\n\nX func:U Y\n\n#### 详情\n\nloop 高阶函数与 [each](https://docs.dolphindb.cn/zh/funcs/ho_funcs/each.html) 高阶函数很相似，区别在于函数返回值的格式和类型。ploop 是相应的并行版本。\n\neach 高阶函数根据每个子任务计算结果的数据类型和形式，决定返回值的数据形式。若所有子任务的数据类型和形式都相同， 则返回 Vector 或 Matrix，否则返回 Tuple。而 loop 总是返回 Tuple。\n\n#### 参数\n\n* **func** 是一个函数。\n\n* **args/X/Y** 是 *func* 的参数。\n\n#### 返回值\n\n一个元组。\n\n#### 例子\n\n函数入参是矩阵时：\n\n```\nm=matrix([1 3 4 2,1 2 2 1])\nmax:U(m) \n```\n\n返回：(4,2)\n\n```\nn=matrix([11 5 9 2,8 5 3 2])\nm add:U n\n```\n\n返回：(\\[12,8,13,4],\\[9,7,5,3])\n\n函数入参是数组向量时：\n\n```\na=array(INT[], 0, 10).append!([1 2 3, 4 5 4, 6 7 8, 1 9 10]);\nsum:U(a)\n```\n\n返回：(6,13,21,20)\n\n下例中，通过 loop 函数将数组转换为元组。\n\n```\na=[1,2,3,4,5]\nasis:U(a)\n```\n\n返回：(1,2,3,4,5)\n\n"
    },
    "moving": {
        "url": "https://docs.dolphindb.cn/zh/funcs/ho_funcs/moving.html",
        "signatures": [
            {
                "full": "moving(func, funcArgs, window, [minPeriods])",
                "name": "moving",
                "parameters": [
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "funcArgs",
                        "name": "funcArgs"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "[minPeriods]",
                        "name": "minPeriods",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [moving](https://docs.dolphindb.cn/zh/funcs/ho_funcs/moving.html)\n\n#### 语法\n\nmoving(func, funcArgs, window, \\[minPeriods])\n\n#### 详情\n\n应用函数/运算符到给定对象的一个滚动窗口上。\n\n当第一个滑动窗口出现时高阶函数开始计算，每计算一次，滑动窗口向右移动一个元素。\n\n内置函数 [msum](https://docs.dolphindb.cn/zh/funcs/m/msum.html), [mcount](https://docs.dolphindb.cn/zh/funcs/m/mcount.html) 和 [mavg](https://docs.dolphindb.cn/zh/funcs/m/mavg.html) 为各自的计算场景进行了优化，因此比 `moving` 高阶函数有更好的性能。\n\n#### 参数\n\n* **func** 是一个**聚合**函数。\n\n  **Note:** 使用该参数时，用于定义相应聚合函数的关键词为 **defg**。有关 **defg** 的详细用法，参考：[自定义聚合函数](https://docs.dolphindb.cn/zh/tutorials/udaf.html)。\n\n* **funcArgs** 是函数 func 的参数。可为向量、字典或矩阵。如果有多个参数，则用元组表示，并且每个参数的长度（向量/字典的元素个数）必须相同。\n\n* **window** 是正整型 或 DURATION 标量。\n\n  * 当 *window* 是整型时，表示以窗口内元素个数衡量的滑动窗口的长度。\n\n  * 当 *window* 是 DURATION 时，表示以时间衡量的滑动窗口的长度。此时，*X* 必须是带有时间类型行索引的索引矩阵或者索引序列。\n\n* **minPeriods** 是一个正整数。表示滑动窗口中最少包含的非 NULL 有效观测值数量。如果滑动窗口中的非 NULL 有效观测值数量小于 *minPeriods*，那么该窗口的结果为 NULL 值。默认值与 *window* 相等。 如果 *window* 是 DURATION，且需要设置 *minPeriods* 时，*minPeriods* 必须是 1。\n\n有关其他 m 系列函数的参数说明和窗口计算规则，参考: [滑动窗口系列（m 系列）](https://docs.dolphindb.cn/zh/funcs/themes/mFunctions.html)\n\n#### 返回值\n\n一个向量，长度与输入参数的长度相同。\n\n#### 例子\n\n计算 APPL 相对于市场（SPY） 的 moving beta，移动窗口长度为 10。\n\n```\ndate=2016.08.01..2016.08.31\ndate=date[1<=weekday(date)<=5]\naaplRet=0.0177 -0.0148 0.0125 0.0008 0.0152 0.0083 0.0041 -0.0074 -0.0006 0.0023 0.0120 -0.0009 -0.0015 -0.0013 0.0026 -0.0078 0.0031 -0.0075 -0.0043 -0.0059 -0.0011 -0.0077 0.0009\nspyRet=-0.0008 -0.0064 0.0029 0.0011 0.0082 -0.0006 0.0006 -0.0025 0.0046 -0.0009 0.0029 -0.0052 0.0019 0.0022 -0.0015 0.0000 0.0020 -0.0051 -0.0007 -0.0019 0.0049 -0.0016 -0.0028\nt=table(date, aaplRet, spyRet);\nt;\n```\n\n输出返回：\n\n| date       | aaplRet | spyRet  |\n| ---------- | ------- | ------- |\n| 2016.08.01 | 0.0177  | -0.0008 |\n| 2016.08.02 | -0.0148 | -0.0064 |\n| 2016.08.03 | 0.0125  | 0.0029  |\n| 2016.08.04 | 0.0008  | 0.0011  |\n| 2016.08.05 | 0.0152  | 0.0082  |\n| 2016.08.08 | 0.0083  | -0.0006 |\n| 2016.08.09 | 0.0041  | 0.0006  |\n| 2016.08.10 | -0.0074 | -0.0025 |\n| 2016.08.11 | -0.0006 | 0.0046  |\n| 2016.08.12 | 0.0023  | -0.0009 |\n| 2016.08.15 | 0.012   | 0.0029  |\n| 2016.08.16 | -0.0009 | -0.0052 |\n| 2016.08.17 | -0.0015 | 0.0019  |\n| 2016.08.18 | -0.0013 | 0.0022  |\n| 2016.08.19 | 0.0026  | -0.0015 |\n| 2016.08.22 | -0.0078 | 0       |\n| 2016.08.23 | 0.0031  | 0.002   |\n| 2016.08.24 | -0.0075 | -0.0051 |\n| 2016.08.25 | -0.0043 | -0.0007 |\n| 2016.08.26 | -0.0059 | -0.0019 |\n| 2016.08.29 | -0.0011 | 0.0049  |\n| 2016.08.30 | -0.0077 | -0.0016 |\n| 2016.08.31 | 0.0009  | -0.0028 |\n\n通过以下语句计算移动 beta：\n\n```\nupdate t set beta_value=moving(beta, [aaplRet, spyRet],10);\nt;\n```\n\n输出返回：\n\n| date       | aaplRet | spyRet  | beta\\_value |\n| ---------- | ------- | ------- | ----------- |\n| 2016.08.01 | 0.0177  | -0.0008 |             |\n| 2016.08.02 | -0.0148 | -0.0064 |             |\n| 2016.08.03 | 0.0125  | 0.0029  |             |\n| 2016.08.04 | 0.0008  | 0.0011  |             |\n| 2016.08.05 | 0.0152  | 0.0082  |             |\n| 2016.08.08 | 0.0083  | -0.0006 |             |\n| 2016.08.09 | 0.0041  | 0.0006  |             |\n| 2016.08.10 | -0.0074 | -0.0025 |             |\n| 2016.08.11 | -0.0006 | 0.0046  |             |\n| 2016.08.12 | 0.0023  | -0.0009 | 1.601173    |\n| 2016.08.15 | 0.012   | 0.0029  | 1.859846    |\n| 2016.08.16 | -0.0009 | -0.0052 | 1.248804    |\n| 2016.08.17 | -0.0015 | 0.0019  | 1.114282    |\n| 2016.08.18 | -0.0013 | 0.0022  | 1.064296    |\n| 2016.08.19 | 0.0026  | -0.0015 | 0.512656    |\n| 2016.08.22 | -0.0078 | 0       | 0.614963    |\n| 2016.08.23 | 0.0031  | 0.002   | 0.642491    |\n| 2016.08.24 | -0.0075 | -0.0051 | 0.70836     |\n| 2016.08.25 | -0.0043 | -0.0007 | 0.977279    |\n| 2016.08.26 | -0.0059 | -0.0019 | 1.064465    |\n| 2016.08.29 | -0.0011 | 0.0049  | 0.422221    |\n| 2016.08.30 | -0.0077 | -0.0016 | 0.793236    |\n| 2016.08.31 | 0.0009  | -0.0028 | 0.588027    |\n\n*minPeriods* 的作用：\n\n```\nmoving(avg, 1..4, 3);\n```\n\n输出返回：\\[,,2,3]\n\n```\nmoving(avg, 1..4, 3, 1);\n```\n\n输出返回：\\[1,1.5,2,3]\n\n```\nv1=indexedSeries(2020.08.01..2020.08.04,1..4)\nmoving(avg, v1, 3d, 1);\n```\n\n输出返回：\n\n| label      | col1 |\n| ---------- | ---- |\n| 2020.08.01 | 1    |\n| 2020.08.02 | 1.5  |\n| 2020.08.03 | 2    |\n| 2020.08.04 | 3    |\n\n*moving* 高阶函数的参数 *func* 的所有参数必须要有相同的长度。如果 *func* 的参数长度不等，例如 [percentile](https://docs.dolphindb.cn/zh/funcs/p/percentile.html) 函数，可以使用 [部分应用](https://docs.dolphindb.cn/zh/progr/partial_app.html) 产生一个新的函数以满足此要求。请见下例：\n\n```\nmoving(percentile{,50},1..20, 10);\n```\n\n输出返回：\\[,,,,,,,,,5.5,6.5,7.5,8.5,9.5,10.5,11.5,12.5,13.5,14.5,15.5]\n\n#### 性能提示\n\n计算移动均值时，应该使用内置函数 `mavg` 而不是 `moving` 高阶函数，这是因为内置版本是经过优化的版本，运行速度比高阶函数更快。\n\n```\nn=1000000\nx=norm(0,1, n);\ntimer mavg(x, 10);\n```\n\n输出返回：Time elapsed: 3.501ms\n\n```\ntimer moving(avg, x, 10);\n```\n\n输出返回：Time elapsed: 976.03ms\n\n"
    },
    "movingValid": {
        "url": "https://docs.dolphindb.cn/zh/funcs/ho_funcs/movingvalid.html",
        "signatures": [
            {
                "full": "movingValid(func, funcArgs, window, [minPeriods], [combined=true])",
                "name": "movingValid",
                "parameters": [
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "funcArgs",
                        "name": "funcArgs"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "[minPeriods]",
                        "name": "minPeriods",
                        "optional": true
                    },
                    {
                        "full": "[combined=true]",
                        "name": "combined",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [movingValid](https://docs.dolphindb.cn/zh/funcs/ho_funcs/movingvalid.html)\n\n首发版本：3.00.5\n\n\n\n#### 语法\n\nmovingValid(func, funcArgs, window, \\[minPeriods], \\[combined=true])\n\n#### 详情\n\n按最近 *window* 个有效数据（非空值）构造滑动窗口，对每个窗口调用聚合函数 *func* 计算结果。每计算一次，滑动窗口向右移动一个元素。\n\n若 *funcArgs* 包含数组向量或列式元组，则按展开后的数据序列，从本行最后一个元素起向左追溯，取最近 *window* 个有效数据参与计算。\n\n#### 参数\n\n**func** 是一个聚合函数。\n\n**Note:** 使用该参数时，用于定义相应聚合函数的关键词为 **defg**。有关 **defg** 的详细用法，参考：[自定义聚合函数](https://docs.dolphindb.cn/zh/tutorials/udaf.html)。\n\n**funcArgs** 是函数 func 的参数。可为向量、数组向量、列式元组、字典或矩阵。如果有多个参数，则用元组表示，并且每个参数的长度（向量/字典的元素个数）必须相同。当 *combined* 为 true 时，同一行中每个参数的元素个数必须相同。\n\n**window** 是正整型，表示窗口内非空元素个数。\n\n**minPeriods** 是一个正整数。表示滑动窗口中最少包含的非 NULL 有效观测值数量。如果滑动窗口中的非 NULL 有效观测值数量小于 *minPeriods* ，那么该窗口的结果为 NULL 值。默认值与 *window* 相等。\n\n**combined** 可选参数，是一个布尔值，表示在 *func* 为多参数时有效数据的判定方式：\n\n* true（默认值）：展开后相同位置均为非空值的参数组合才被认定为有效数据。\n\n* false：各参数独立追溯，分别取其最近的 *window* 个有效数据参与计算\n\n#### 返回值\n\n一个向量，长度与输入参数的长度相同。\n\n#### 例子\n\n例1. 计算一个向量的移动有效平均值，窗口长度为3。\n\n```\nx = 1 2 NULL 3 4 NULL NULL NULL 5 6 \nmovingValid(func=avg, funcArgs=x, window=3, minPeriods=3)\n// output:[,,,2,3,3,3,3,4,5]\n```\n\n例2. 根据数组向量列，计算每个时刻过去 3 个有效数据的因子值。\n\n```\ndefg myFactor(x){\n    return (max(x)-min(x))*2\n}\ntimeCol = 09:30:00 + 1..13\nvalue = arrayVector(3 4 5 6 9 11 12 15 16 17 18 21 23,9 1 15 NULL NULL NULL 16 18 4 1 11 NULL 2 14 8 NULL NULL NULL 15 9 16 18 10)\nt = table(timeCol, value)\n```\n\n| timeCol  | value        |\n| -------- | ------------ |\n| 09:30:01 | \\[9, 1, 15]  |\n| 09:30:02 | \\[null]      |\n| 09:30:03 | \\[null]      |\n| 09:30:04 | \\[null]      |\n| 09:30:05 | \\[16, 18, 4] |\n| 09:30:06 | \\[1, 11]     |\n| 09:30:07 | \\[null]      |\n| 09:30:08 | \\[2, 14, 8]  |\n| 09:30:09 | \\[null]      |\n| 09:30:10 | \\[null]      |\n| 09:30:11 | \\[null]      |\n| 09:30:12 | \\[15, 9, 16] |\n| 09:30:13 | \\[18, 10]    |\n\n```\nselect movingValid(myFactor,value,3,3) from t\n```\n\nmovingValid\\_myFactor --- 28 28 28 28 28 20 20 24 24 24 24 14 16\n\n例3. 不同 *minPeriods* 对结果的影响：\n\n```\nval = 1 2 4 NULL 5 NULL 7 9 10\nmovingValid(func=min, funcArgs=val, window=3, minPeriods=3)\n// output: [,,1,1,2,2,4,5,7]\nmovingValid(func=min, funcArgs=val, window=3, minPeriods=2)\n// output: [,1,1,1,2,2,4,5,7]\n```\n\n例4. 多参数时不同有效数据的判定方式对结果的影响：\n\ncombined=true 时\n\n```\nx = arrayVector(2 5 6 8 10 12, 10 20 30 40 NULL NULL 50 NULL NULL 60 70 80)\ny = arrayVector(2 5 6 8 10 12, 1 NULL 2 3 NULL 5 1 NULL 2 7 8 5)\nmovingValid(func=covar, funcArgs=[x,y], window=2, minPeriods=2, combined=true)\n```\n\n| x    | \\[10, 20]  | \\[30, 40, null]         | \\[null]                 | \\[50, null]             | \\[null, 60]            | \\[70, 80]              |\n| ---- | ---------- | ----------------------- | ----------------------- | ----------------------- | ---------------------- | ---------------------- |\n| y    | \\[1, null] | \\[2, 3, null]           | \\[5]                    | \\[1, null]              | \\[2, 7]                | \\[8, 5]                |\n| 窗口计算 |            | covar(\\[30,40], \\[2,3]) | covar(\\[30,40], \\[2,3]) | covar(\\[40,50], \\[3,1]) | covar(\\[50,60],\\[1,7]) | covar(\\[70,80],\\[8,5]) |\n| 结果   | null       | 5                       | 5                       | -10                     | 30                     | -15                    |\n\ncombined=false 时\n\n```\nx = arrayVector(2 5 6 8 10 12, 10 20 30 40 NULL NULL 50 NULL NULL 60 70 80)\ny = arrayVector(2 5 6 8 10 12, 1 NULL 2 3 NULL 5 1 NULL 2 7 8 5)\nmovingValid(func=covar, funcArgs=[x,y], window=2, minPeriods=2, combined=false)\n```\n\n<table id=\"table_fz4_j3k_g3c\"><thead><tr><th>\n\nx\n\n</th><th>\n\n\\[10, 20]\n\n</th><th>\n\n\\[30, 40, null]\n\n</th><th>\n\n\\[null]\n\n</th><th>\n\n\\[50, null]\n\n</th><th>\n\n\\[null, 60]\n\n</th><th>\n\n\\[70, 80]\n\n</th></tr></thead><tbody><tr><td>\n\ny\n\n</td><td>\n\n\\[1, null]\n\n</td><td>\n\n\\[2, 3, null]\n\n</td><td>\n\n\\[5]\n\n</td><td>\n\n\\[1, null]\n\n</td><td>\n\n\\[2, 7]\n\n</td><td>\n\n\\[8, 5]\n\n</td></tr><tr><td>\n\n窗口计算\n\n</td><td>\n\n</td><td>\n\ncovar(\\[30,40], \\[2,3])\n\n</td><td>\n\ncovar(\\[30,40],\\[3,5])\n\n</td><td>\n\ncovar(\\[40,50],\\[5,1])\n\n</td><td>\n\ncovar(\\[50,60],\\[2,7])\n\n</td><td>\n\ncovar(\\[70,80],\\[8,5])\n\n</td></tr><tr><td>\n\n结果\n\n</td><td>\n\nnull\n\n</td><td>\n\n5\n\n</td><td>\n\n10\n\n</td><td>\n\n-20\n\n</td><td>\n\n25\n\n</td><td>\n\n-15\n\n</td></tr></tbody>\n</table>\n"
    },
    "nothrowCall": {
        "url": "https://docs.dolphindb.cn/zh/funcs/ho_funcs/nothrowcall.html",
        "signatures": [
            {
                "full": "nothrowCall(func, args...)",
                "name": "nothrowCall",
                "parameters": [
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "args...",
                        "name": "args..."
                    }
                ]
            }
        ],
        "markdown": "### [nothrowCall](https://docs.dolphindb.cn/zh/funcs/ho_funcs/nothrowcall.html)\n\n首发版本：3.00.5\n\n\n\n#### 语法\n\nnothrowCall(func, args...)\n\n别名：nothrow\n\n#### 详情\n\n用指定的参数调用一个函数。调用语法与 call 相同。\n\n与 `call` 的区别在于，`nothrowCall` 在执行过程中即使发生错误也不会抛出异常。但如果提供的参数数量与*func*所需参数数量不匹配，`nothrowCall` 仍会抛出异常。\n\n#### 参数\n\n**func** 是一个函数名。\n\n**args** 是函数 *func* 的参数。\n\n#### 返回值\n\n取决于 `func(args)` 的返回值。\n\n#### 例子\n\n在准备 DolphinDB 系统环境时，通常需要先清理环境，比如删除已存在的流数据表。但有时无法确定某个流数据表是否已存在。若直接调用 [dropStreamTable](https://docs.dolphindb.cn/zh/funcs/d/dropStreamTable.html)，当表不存在时会抛出异常。此时可直接使用 `nothrowCall` 忽略该异常。\n\n以下示例中假设流数据表 orderData 并不存在：\n\n```\ndropStreamTable(`orderData)\n//抛出异常：Can't find stream table orderData\n\nnothrowCall(dropStreamTable, `orderData)\n//正常执行，无异常抛出\n```\n\n**相关函数：**[call](https://docs.dolphindb.cn/zh/funcs/ho_funcs/call.html)\n"
    },
    "nullCompare": {
        "url": "https://docs.dolphindb.cn/zh/funcs/ho_funcs/nullCompare.html",
        "signatures": [
            {
                "full": "nullCompare(func, X, Y)",
                "name": "nullCompare",
                "parameters": [
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [nullCompare](https://docs.dolphindb.cn/zh/funcs/ho_funcs/nullCompare.html)\n\n#### 语法\n\nnullCompare(func, X, Y)\n\n#### 详情\n\n返回一个布尔值，是表达式 “func(X,Y)” 的结果。涉及 NULL 值的计算结果均为 NULL。该函数不受配置项 nullAsMinValueForComparison 影响。\n\n#### 参数\n\n* **func** 是<, >, >=, <=运算符，或函数 between, in。\n\n* **X** 和 **Y** 可以是标量、数据对、向量、矩阵或集合。当 *X* 和 *Y* 都是向量或矩阵时，它们的长度或维度必须相同。\n\n**Note:** *X* 和 *Y* 暂不支持以下数据类型：STRING, SYMBOL, IPADDR, UUID, BLOB 和I NT128。\n\n#### 返回值\n\n一个布尔值。\n\n#### 例子\n\n配置项 *nullAsMinValueForComparison* = true 时，在比较运算中，NULL 元素取相应数据类型的最小值。若使用 nullCompare，则不受该配置影响，依然取 NULL 值。\n\n```\nNULL < 3\n// output\ntrue\nnullCompare(<, NULL, 3)\n// output\nNULL\nm1=matrix(1 2 NULL, NULL 8 4, 4 7 2 )\nm2 = 1..9$3:3\nm1>m2\n```\n\n| col1  | col2  | col3  |\n| ----- | ----- | ----- |\n| false | false | false |\n| false | true  | false |\n| false | false | false |\n\n```\nnullCompare(>,m1,m2)\n```\n\n| col1  | col2  | col3  |\n| ----- | ----- | ----- |\n| false |       | false |\n| false | true  | false |\n|       | false | false |\n\n```\nnullCompare(between, 4 5 NULL, 4:9)\n// output\n[1,1,]\n```\n\n"
    },
    "pcall": {
        "url": "https://docs.dolphindb.cn/zh/funcs/ho_funcs/pcall.html",
        "signatures": [
            {
                "full": "pcall(func, args...)",
                "name": "pcall",
                "parameters": [
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "args...",
                        "name": "args..."
                    }
                ]
            }
        ],
        "markdown": "### [pcall](https://docs.dolphindb.cn/zh/funcs/ho_funcs/pcall.html)\n\n#### 语法\n\npcall(func, args...)\n\n#### 详情\n\n将输入参数分成几个部分，并行计算，最后将结果合并。如果输入参数的长度小于100,000，*pcall* 函数不会并行计算。\n\n#### 参数\n\n* **func** 是一个函数。该函数的输出结果可以是一个向量或表，并且它们的长度必须与输入参数args的长度相同。\n* **args** 是func的参数。它可以是表、向量或元组。输入参数中的所有向量或表列必须长度相同。\n\n#### 返回值\n\n向量或表，取决于 *func* 的输出结果。\n\n#### 例子\n\n```\nx = rand(1.0, 10000000);\ntimer(10) sin(x);\n```\n\n输出返回：\n\nTime elapsed: 739.561 ms\n\n```\ntimer(10) pcall(sin, x);\n```\n\n输出返回：\n\nTime elapsed: 404.56 ms\n\n"
    },
    "pcross": {
        "url": "https://docs.dolphindb.cn/zh/funcs/ho_funcs/pcross.html",
        "signatures": [
            {
                "full": "pcross(func, X, [Y])",
                "name": "pcross",
                "parameters": [
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[Y]",
                        "name": "Y",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [pcross](https://docs.dolphindb.cn/zh/funcs/ho_funcs/pcross.html)\n\n#### 语法\n\npcross(func, X, \\[Y])\n\n#### 详情\n\n*pcross* 是并行计算版本的 *cross* 高阶函数。\n\n"
    },
    "peach": {
        "url": "https://docs.dolphindb.cn/zh/funcs/ho_funcs/peach.html",
        "signatures": [
            {
                "full": "peach(func, args...)",
                "name": "peach",
                "parameters": [
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "args...",
                        "name": "args..."
                    }
                ]
            }
        ],
        "markdown": "### [peach](https://docs.dolphindb.cn/zh/funcs/ho_funcs/peach.html)\n\n\n\n#### 语法\n\npeach(func, args...)\n\n#### 详情\n\n*peach* 是并行计算版本的 *each* 高阶函数。对于执行时间较长的任务，*peach* 比 *each* 能节省大量的时间。但对于小任务，*peach* 可能执行时间要比each更长，因为并行函数调用的开销很大。\n\n#### 例子\n\n对于执行时间长的任务，使用 *peach* 进行并行计算，可以节约任务执行时间。\n\n```\nm=rand(1,20000:5000)\ntimer f=peach(mskew{,8},m)\n\nTime elapsed: 3134.71 ms\ntimer f=mskew(m,8)\n\nTime elapsed: 8810.485 ms\n```\n"
    },
    "pivot": {
        "url": "https://docs.dolphindb.cn/zh/funcs/ho_funcs/pivot.html",
        "signatures": [
            {
                "full": "pivot(func, funcArgs, rowAlignCol, colAlignCol)",
                "name": "pivot",
                "parameters": [
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "funcArgs",
                        "name": "funcArgs"
                    },
                    {
                        "full": "rowAlignCol",
                        "name": "rowAlignCol"
                    },
                    {
                        "full": "colAlignCol",
                        "name": "colAlignCol"
                    }
                ]
            }
        ],
        "markdown": "### [pivot](https://docs.dolphindb.cn/zh/funcs/ho_funcs/pivot.html)\n\n\n\n#### 语法\n\npivot(func, funcArgs, rowAlignCol, colAlignCol)\n\n#### 详情\n\n在指定的二维维度上重组数据，结果为一个矩阵。\n\n假设 *rowAlignCol* 有 n 个不同元素，*colAlignCol* 有 m 个不同元素。该高阶函数将会返回 n 行 m 列的矩阵，*colAlignCol* 的唯一值作为行标签，*rowAlignCol* 的唯一值作为列标签。对于矩阵的每一个元素，将指定函数应用到 *rowAlignCol* 和 *colAlignCol* 所指定的矩阵单元格的元素上。\n\n与 Python 中 pivot 的区别：`pandas.DataFrame.pivot` 只是对数据进行重塑，不做聚合；DolphinDB 的 `pivot` 函数允许每个位置有多条数据，并对其使用聚合函数进行计算。\n\n#### 参数\n\n* **func** 函数。\n\n* **funcArgs** func 的参数。如果 func 有多个参数，那么它是一个元组。\n\n* **rowAlignCol** 行的分组变量。\n\n* **colAlignCol** 列的分组变量。\n\n*rowAlignCol*, *colAlignCol* 和 *funcArgs* 中的每个参数都是相同长度的向量。\n\n#### 返回值\n\n一个矩阵。\n\n#### 例子\n\n本例计算多只股票收益率的两两相关性。\n\n原始数据表有 4 列：sym, price, volume 和 time。\n\n```\nsyms=`600300`600400`600500$SYMBOL\nsym=syms[0 0 0 0 0 0 0 1 1 1 1 1 1 1 2 2 2 2 2 2 2]\ntime=09:40:00+1 30 65 90 130 185 195 10 40 90 140 160 190 200 5 45 80 140 170 190 210\nprice=172.12 170.32 172.25 172.55 175.1 174.85 174.5 36.45 36.15 36.3 35.9 36.5 37.15 36.9 40.1 40.2 40.25 40.15 40.1 40.05 39.95\nvolume=100 * 10 3 7 8 25 6 10 4 5 1 2 8 6 10 2 2 5 5 4 4 3\nt1=table(sym, time, price, volume);\nt1;\n```\n\n| sym    | time     | price  | volume |\n| ------ | -------- | ------ | ------ |\n| 600300 | 09:40:01 | 172.12 | 1000   |\n| 600300 | 09:40:30 | 170.32 | 300    |\n| 600300 | 09:41:05 | 172.25 | 700    |\n| 600300 | 09:41:30 | 172.55 | 800    |\n| 600300 | 09:42:10 | 175.1  | 2500   |\n| 600300 | 09:43:05 | 174.85 | 600    |\n| 600300 | 09:43:15 | 174.5  | 1000   |\n| 600400 | 09:40:10 | 36.45  | 400    |\n| 600400 | 09:40:40 | 36.15  | 500    |\n| 600400 | 09:41:30 | 36.3   | 100    |\n| 600400 | 09:42:20 | 35.9   | 200    |\n| 600400 | 09:42:40 | 36.5   | 800    |\n| 600400 | 09:43:10 | 37.15  | 600    |\n| 600400 | 09:43:20 | 36.9   | 1000   |\n| 600500 | 09:40:05 | 40.1   | 200    |\n| 600500 | 09:40:45 | 40.2   | 200    |\n| 600500 | 09:41:20 | 40.25  | 500    |\n| 600500 | 09:42:20 | 40.15  | 500    |\n| 600500 | 09:42:50 | 40.1   | 400    |\n| 600500 | 09:43:10 | 40.05  | 400    |\n| 600500 | 09:43:30 | 39.95  | 300    |\n\n将数据依据 time 和 sym 维度对齐，并且计算每分钟内股价以交易量为权重的加权平均值。结果为一个矩阵。\n\n```\nstockprice=pivot(wavg, [t1.price, t1.volume], minute(t1.time), t1.sym)\nstockprice.round(2);\n```\n\n| label  | 600300 | 600400 | 600500 |\n| ------ | ------ | ------ | ------ |\n| 09:40m | 171.7  | 36.28  | 40.15  |\n| 09:41m | 172.41 | 36.3   | 40.25  |\n| 09:42m | 175.1  | 36.38  | 40.13  |\n| 09:43m | 174.63 | 36.99  | 40.01  |\n\n计算每分钟的股票收益率：\n\n```\nstockreturn = each(ratios, stockprice)-1\nstockreturn;\n```\n\n| label  | 600300    | 600400   | 600500    |\n| ------ | --------- | -------- | --------- |\n| 09:40m |           |          |           |\n| 09:41m | 0.004108  | 0.000459 | 0.002491  |\n| 09:42m | 0.015602  | 0.002204 | -0.003037 |\n| 09:43m | -0.002677 | 0.016871 | -0.003006 |\n\n计算股票收益率的两两相关性：\n\n```\ncross(corr, stockreturn, stockreturn);\n```\n\n| label  | 600300    | 600400    | 600500    |\n| ------ | --------- | --------- | --------- |\n| 600300 | 1         | -0.719182 | -0.151824 |\n| 600400 | -0.719182 | 1         | -0.577578 |\n| 600500 | -0.151824 | -0.577578 | 1         |\n\n统计每个股票每分钟内的记录数量：\n\n```\npivot(count, price, minute(time), sym);\n```\n\n| label  | 600300 | 600400 | 600500 |\n| ------ | ------ | ------ | ------ |\n| 09:40m | 2      | 2      | 2      |\n| 09:41m | 2      | 1      | 1      |\n| 09:42m | 1      | 2      | 2      |\n| 09:43m | 2      | 2      | 2      |\n\n每个股票每分钟里的最后一条记录：\n\n```\npivot(last, price, minute(time), sym);\n```\n\n| label  | 600300 | 600400 | 600500 |\n| ------ | ------ | ------ | ------ |\n| 09:40m | 170.32 | 36.15  | 40.2   |\n| 09:41m | 172.55 | 36.3   | 40.25  |\n| 09:42m | 175.1  | 36.5   | 40.1   |\n| 09:43m | 174.5  | 36.9   | 39.95  |\n\n**Related information**\n\n[unpivot](https://docs.dolphindb.cn/zh/funcs/u/unpivot.html)\n"
    },
    "ploop": {
        "url": "https://docs.dolphindb.cn/zh/funcs/ho_funcs/ploop.html",
        "signatures": [
            {
                "full": "ploop(func, args...)",
                "name": "ploop",
                "parameters": [
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "args...",
                        "name": "args..."
                    }
                ]
            }
        ],
        "markdown": "### [ploop](https://docs.dolphindb.cn/zh/funcs/ho_funcs/ploop.html)\n\n\n\n#### 语法\n\nploop(func, args...)\n\nploop 是 [loop](https://docs.dolphindb.cn/zh/funcs/ho_funcs/loop.html) 的并行版本。\n"
    },
    "reduce": {
        "url": "https://docs.dolphindb.cn/zh/funcs/ho_funcs/reduce.html",
        "signatures": [
            {
                "full": "reduce(func, X, [init], [assembleRule|consistent=false])",
                "name": "reduce",
                "parameters": [
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[init]",
                        "name": "init",
                        "optional": true
                    },
                    {
                        "full": "[assembleRule|consistent=false]",
                        "name": "[assembleRule|consistent=false]"
                    }
                ]
            },
            {
                "full": "reduce:T(X, [init])",
                "name": "reduce:T",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[init]",
                        "name": "init",
                        "optional": true
                    }
                ]
            },
            {
                "full": "reduce:TC(X, [init])",
                "name": "reduce:TC",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[init]",
                        "name": "init",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [reduce](https://docs.dolphindb.cn/zh/funcs/ho_funcs/reduce.html)\n\n#### 语法\n\nreduce(func, X, \\[init], \\[assembleRule|consistent=false])\n\nreduce:T(X, \\[init]) 或 \\[init] \\<operator>:T X 表示不指定 ，使用默认值\n\nreduce:TC(X, \\[init]) 或 \\[init] \\<operator>:TC X 表示指定 ，此例中指定为 C（Consistent）\n\n#### 详情\n\n该函数与 `accumulate` 的功能相同，唯一区别是返回值不同。`reduce` 返回最后一个结果，而 `accumulate` 输出所有中间结果。关于函数功能描述，参见  [accumulate](https://docs.dolphindb.cn/zh/funcs/ho_funcs/accumulate.html)。\n\n`reduce` 等同于以下伪代码的执行过程：\n\n```\nresult=<function>(init,X[0]);\n\nfor(i:1~size(X)){\n\nresult=<function>(result, X[i]);\n\n}\n\nreturn result;\n```\n\n#### 参数\n\n* **func** 函数。\n  * 当 *func* 是一元函数时，*X* 可以是非负整数、一元函数或空值。*init* 表示 *func* 的参数，必须指定。\n\n  * *func* 是二元函数时，*X* 是向量、矩阵或表。*init* 表示初始值。\n\n  * *func* 是三元函数时，*X* 必须是一个 Tuple，包含2个元素，分别表示 *func* 的后两个参数。\n\n* **assembleRule** 可选参数，表示如何将子任务的结果合并为函数最终结果。接受一个整数或字符串作为输入，可选值如下：\n\n  * 0 （或 \"D\"）：默认值，表示 DolphinDB 规则，即根据所有子任务的结果来决定最终输出的数据类型和形式。当所有子结果具有相同的数据类型和形式时，多个标量合并为一个向量、多个向量合并为一个矩阵、多个矩阵合并为一个元组、多个字典合并为一张表；否则将所有子结果合并为一个元组输出。\n\n  * 1（或 \"C\"）：表示 Consistent 规则，即认为所有子结果的数据类型和形式都与第一个子结果相同，根据第一个子结果来选择最终结果的数据类型和形式。如果后续子任务返回的结果与第一个子任务的结果类型不一致，系统会尝试对后续结果进行类型转换。如果转换失败则抛出异常。因此，此规则只可在已知子结果的数据类型及形式一致时指定。此规则可使系统免于逐一缓存并检查每个子任务的计算结果，从而提升性能。\n\n  * 2（或 \"U\"）：表示 Tuple 规则，系统不再对各子结果的类型和形式一致性进行检查，而是直接将子结果组装成一个元组输出。\n\n  * 3（或 \"K\"）：表示 kdb+ 规则。与 DolphinDB 规则类似，都会根据所有子结果来决定最终结果形式。主要区别在于，kdb+ 规则下，只要有任一子任务返回向量，则最终结果必为一个元组；而在 DolphinDB 规则下，子任务结果若均为长度相同的向量，则最终结果为一个矩阵。其他情况下，kdb+ 规则的输出与 DolphinDB 规则相同。\n\n  **Note:**\n\n  * 自 2.00.15/3.00.3 版本起，新增了 *assembleRule* 参数。该参数不仅实现了原 *consistent* 参数的功能，还提供了更多的结果合并选项。*consistent* 是一个布尔值，默认值为 false，相当于 *assembleRule*=\"D\"；若为 true，则相当于 *assembleRule*=\"C\"。为保持兼容性，用户仍可使用 *consistent* 参数。如果同时指定 *assemble* 和 *consistent*，将以 *consistent* 的值为准。\n  * *assembleRule* 也可在高阶函数对应的函数模式符号后指定，通过字符 D/C/U/K 表示。以 `eachPre (:P)` 为例，形如 `sub:PU(X)`。不指定则使用默认值 D。\n\n#### 返回值\n\n取决于 *assembleRule* 参数的值。\n\n#### 例子\n\n*func* 是一元函数时：\n\n通过以下方式定义一个一元函数：\n\n```\ndef func1(x){\n  if(x<5){\n          return x*3\n  }\n  else{\n          return x+3\n  }\n}\n```\n\n当 X 为整数时，迭代 X 次，输出最后一个结果：\n\n```\nreduce(func1, 5, 1)\n```\n\n返回：18\n\n当 X 为一元函数 condition 时，第3次迭代时因 condition 返回false，停止迭代2次后停止，并输出最后一个结果。\n\n```\ndef condition(x){\n  return x<9\n}\nreduce(func1, condition, 1)\n```\n\n返回：9\n\n当 X 为 NULL（或不指定）时，自定义函数 func2 作为进行迭代的函数。\n\n```\ndef func2(x){\n  if(x<5){\n          return x*3\n  }\n  else{\n          return 6\n  }\n}\n\n//因第4次迭代结果和第3次相同，停止迭代并输出最后一个结果。\nreduce(func2,NULL,1)\n```\n\n返回：6\n\n*func* 是二元函数时，在一个向量上执行 `reduce`：\n\n```\nreduce(mul, 1..10);\n```\n\n返回：3628800，即 10 的阶乘。上例如果由 `accumulate` 高阶函数实现，则是：\n\n```\n*:A 1..10;\n```\n\n返回：\\[1,2,6,24,120,720,5040,40320,362880,3628800]\n\n```\n2 *:T 1..10;\n```\n\n返回：7257600\n\n```\ndef f1(a,b):a+log(b);\nreduce(f1, 1..5, 0);\n```\n\n返回：4.787492\n\n对一个矩阵执行 `reduce`：\n\n```\nx=1..12$3:4;\nx;\n```\n\n得到：\n\n| col1 | col2 | col3 | col4 |\n| ---- | ---- | ---- | ---- |\n| 1    | 4    | 7    | 10   |\n| 2    | 5    | 8    | 11   |\n| 3    | 6    | 9    | 12   |\n\n```\n+ :T x;\n```\n\n返回：\\[22,26,30]\n\n*func* 是三元函数时：\n\n```\ndef fun3(x,y,z){\n  return x+y+z\n}\nreduce(fun3,[[1,2,3],[10,10,10]],5)\n```\n\n返回：41\n\n"
    },
    "rolling": {
        "url": "https://docs.dolphindb.cn/zh/funcs/ho_funcs/rolling.html",
        "signatures": [
            {
                "full": "rolling(func, funcArgs, window, [step=1])",
                "name": "rolling",
                "parameters": [
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "funcArgs",
                        "name": "funcArgs"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "[step=1]",
                        "name": "step",
                        "optional": true,
                        "default": "1"
                    }
                ]
            }
        ],
        "markdown": "### [rolling](https://docs.dolphindb.cn/zh/funcs/ho_funcs/rolling.html)\n\n#### 语法\n\nrolling(func, funcArgs, window, \\[step=1])\n\n#### 详情\n\n应用函数/运算符到给定对象的一个滑动窗口（ *step* 与 *window* 取相同值时为滚动窗口）上。\n\n当第一个滑动窗口出现时，高阶函数开始计算，然后每经过 *step* 个元素就进行一次变量计算。\n\n**Note:**\n\n* 当 *func* 指定为向量函数时，*window* 必须等于 *step*。\n\n* 若窗口内的元素个数小于窗口长度，则该窗口不会计算输出。\n\n和 *moving* 高阶函数类似，即对矩阵来说滑动窗口还是按行计算，而其他高阶函数通常是按列计算。\n\n`rolling` 的 *func* 支持向量函数和聚合函数，而 `moving` 的 *func* 只支持聚合函数。\n\n*func* 为聚合函数时，`rolling` 与 `moving` 的区别是：\n\n1. `rolling` 支持参数 *step*，可以指定窗口滑动的步长；而 `moving` 的滑动步长只能是 1。\n\n2. `rolling` 不输出前 *window* - 1 个 NULL 值结果。\n\n#### 参数\n\n* **func** 聚合函数或向量函数。若 *func* 是向量函数，则 *step* 必须和 *window* 相等。\n\n* **funcArgs** 函数 *func* 的参数。可为向量或矩阵。如果有多个参数，则用元组表示，并且每个参数的长度（向量的元素个数或矩阵的行数）必须相同。\n\n* **window** 滑动窗口长度。\n\n* **step** 应用函数的频率。默认值为1。\n\n#### 返回值\n\n向量或矩阵，取决于 *func* 的类型以及 *funcArgs* 的结构。\n\n#### 例子\n\n*func* 为向量函数：\n\n```\nm = matrix(3 4 6 8 5 2 0 -2, 2 9 NULL 1 3 -4 2 1, NULL 8 9 8 0 1 9 -3)\nrolling(cummax, m, 4, 4)\n```\n\n输出返回：\n\n| col1 | col2 | col3 |\n| ---- | ---- | ---- |\n| 3    | 2    |      |\n| 4    | 9    | 8    |\n| 6    | 9    | 9    |\n| 8    | 9    | 9    |\n| 5    | 3    | 0    |\n| 5    | 3    | 1    |\n| 5    | 3    | 9    |\n| 5    | 3    | 9    |\n\n```\nrolling(cumsum, m, 3, 3)\n```\n\n输出返回：\n\n| col1 | col2 | col3 |\n| ---- | ---- | ---- |\n| 3    | 2    |      |\n| 7    | 11   | 8    |\n| 13   | 11   | 17   |\n| 8    | 1    | 8    |\n| 13   | 4    | 8    |\n| 15   | 0    | 9    |\n\n*func* 为聚合函数：\n\n```\nrolling(sum, m, 4)\n```\n\n输出返回：\n\n| col1 | col2 | col3 |\n| ---- | ---- | ---- |\n| 21   | 12   | 25   |\n| 23   | 13   | 25   |\n| 21   | 0    | 18   |\n| 15   | 2    | 18   |\n| 5    | 2    | 7    |\n\n计算APPL相对于市场(SPY)的beta值，滑动窗口长度为10，频率为5。\n\n```\ndate=2016.08.01..2016.08.31\ndate=date[1<=weekday(date)<=5]\naaplRet=0.0177 -0.0148 0.0125 0.0008 0.0152 0.0083 0.0041 -0.0074 -0.0006 0.0023 0.0120 -0.0009 -0.0015 -0.0013 0.0026 -0.0078 0.0031 -0.0075 -0.0043 -0.0059 -0.0011 -0.0077 0.0009\nspyRet=-0.0008 -0.0064 0.0029 0.0011 0.0082 -0.0006 0.0006 -0.0025 0.0046 -0.0009 0.0029 -0.0052 0.0019 0.0022 -0.0015 0.0000 0.0020 -0.0051 -0.0007 -0.0019 0.0049 -0.0016 -0.0028\nt=table(date, aaplRet, spyRet);\nt;\n```\n\n输出返回：\n\n| date       | aaplRet | spyRet  |\n| ---------- | ------- | ------- |\n| 2016.08.01 | 0.0177  | -0.0008 |\n| 2016.08.02 | -0.0148 | -0.0064 |\n| 2016.08.03 | 0.0125  | 0.0029  |\n| 2016.08.04 | 0.0008  | 0.0011  |\n| 2016.08.05 | 0.0152  | 0.0082  |\n| 2016.08.08 | 0.0083  | -0.0006 |\n| 2016.08.09 | 0.0041  | 0.0006  |\n| 2016.08.10 | -0.0074 | -0.0025 |\n| 2016.08.11 | -0.0006 | 0.0046  |\n| 2016.08.12 | 0.0023  | -0.0009 |\n| 2016.08.15 | 0.012   | 0.0029  |\n| 2016.08.16 | -0.0009 | -0.0052 |\n| 2016.08.17 | -0.0015 | 0.0019  |\n| 2016.08.18 | -0.0013 | 0.0022  |\n| 2016.08.19 | 0.0026  | -0.0015 |\n| 2016.08.22 | -0.0078 | 0       |\n| 2016.08.23 | 0.0031  | 0.002   |\n| 2016.08.24 | -0.0075 | -0.0051 |\n| 2016.08.25 | -0.0043 | -0.0007 |\n| 2016.08.26 | -0.0059 | -0.0019 |\n| 2016.08.29 | -0.0011 | 0.0049  |\n| 2016.08.30 | -0.0077 | -0.0016 |\n| 2016.08.31 | 0.0009  | -0.0028 |\n\n```\n// 计算滚动beta\nbetas = rolling(beta, [aaplRet, spyRet], 10,5);\ndates = rolling(last, date, 10,5);\ntable(dates, betas);\n```\n\n输出返回：\n\n| dates      | betas    |\n| ---------- | -------- |\n| 2016.08.12 | 1.601173 |\n| 2016.08.19 | 0.512656 |\n| 2016.08.26 | 1.064465 |\n\n生成一个带有行标签的矩阵 m，将其作为参数 *func*Args。\n\n当传入参数 *func* 是一个聚合函数，输出带有行标签的结果矩阵。\n\n```\nminBar = 2024.03.08T10:00:00 + 0..9\naaplClose = [170.88,170.88,170.90,171.05,171.18,171.30,171.51,171.49,171.31,171.14]\nibmClose = [150.15,150.18,150.20,150.05,150.18,150.25,150.32,150.30,150.31,150.20]\nm = matrix(aaplClose, ibmClose).rename!(minBar, `aapl`ibm)\n\n// func 也支持传入自定义的聚合函数\nrolling(func=avg, funcArgs=m, window=5, step=2)\n```\n\n输出结果：\n\n<table id=\"table_kqz_mfs_xbc\"><tbody><tr><td>\n\nlabel\n\n</td><td>\n\naapl\n\n</td><td>\n\nibm\n\n</td></tr><tr><td>\n\n2024.03.08T10:00:00\n\n</td><td>\n\n170.978\n\n</td><td>\n\n150.152\n\n</td></tr><tr><td>\n\n2024.03.08T10:00:02\n\n</td><td>\n\n171.188\n\n</td><td>\n\n150.2\n\n</td></tr><tr><td>\n\n2024.03.08T10:00:04\n\n</td><td>\n\n171.358\n\n</td><td>\n\n150.272\n\n</td></tr></tbody>\n</table>承接上例，当传入参数 *func* 是一个部分应用，也可输出带有行标签的结果矩阵。\n\n```\ndefg f1(x,y){\n\treturn (last(x)-first(x))/size(x)+y\n}\nf2 = f1{,1}\nrolling(func=f2, funcArgs=m, window=5, step=2)\n```\n\n输出结果：\n\n<table id=\"table_s2r_nfs_xbc\"><tbody><tr><td>\n\nlabel\n\n</td><td>\n\naapl\n\n</td><td>\n\nibm\n\n</td></tr><tr><td>\n\n2024.03.08T10:00:00\n\n</td><td>\n\n1.06\n\n</td><td>\n\n1.006\n\n</td></tr><tr><td>\n\n2024.03.08T10:00:02\n\n</td><td>\n\n1.122\n\n</td><td>\n\n1.024\n\n</td></tr><tr><td>\n\n2024.03.08T10:00:04\n\n</td><td>\n\n1.026\n\n</td><td>\n\n1.026\n\n</td></tr></tbody>\n</table>**Parent topic:**[函数参考](../../funcs/funcs_intro.md)\n"
    },
    "rowGroupby": {
        "url": "https://docs.dolphindb.cn/zh/funcs/ho_funcs/rowgroupby.html",
        "signatures": [
            {
                "full": "rowGroupby(func, funcArgs, groupingCol, [mode='tuple'], [ascending=true])",
                "name": "rowGroupby",
                "parameters": [
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "funcArgs",
                        "name": "funcArgs"
                    },
                    {
                        "full": "groupingCol",
                        "name": "groupingCol"
                    },
                    {
                        "full": "[mode='tuple']",
                        "name": "mode",
                        "optional": true,
                        "default": "'tuple'"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [rowGroupby](https://docs.dolphindb.cn/zh/funcs/ho_funcs/rowgroupby.html)\n\n#### 语法\n\nrowGroupby(func, funcArgs, groupingCol, \\[mode='tuple'], \\[ascending=true])\n\n#### 详情\n\n对 *groupingCol* 的每一行分组后，在每个分组中计算 *func(funcArgs)*，每组的计算结果是一个标量。该函数将根据 *mode* 指定的形式输出结果。\n\n#### 参数\n\n**func** 一个聚合函数。\n\n**funcArgs** 是函数 *func* 的参数。如果有多个参数，则用元组表示，且每个元素的维度必须和 *groupingCol* 保持一致。\n\n**groupingCol** 非空矩阵或数组向量，用于分组。\n\n**mode** 可选参数，指定 `rowGroupby` 返回值的数据形式，默认为 \"tuple\"。可取值为：\n\n* \"tuple\"：返回一个长度为2的 tuple，其第1个元素是一个数组向量，存储分组变量，第2个元素是一个数组向量，存储各分组中 *funcArgs* 应用 *func* 后的结果。\n\n* \"dict\"：返回一个字典。包含两个元素：'key' 和 'value'，分别存储分组变量和各分组中 *funcArgs* 应用*func* 后的结果。\n\n* \"table\"：返回一个包含两列的表。字段为 \"key\" 和 \"value\"，分别存储分组变量及各分组中 *funcArgs* 应用 *func* 后的结果。\n\n**ascending** 布尔值，表示输出结果按 *groupingCol* 升序还是降序排序。默认值为 true（升序）。\n\n#### 返回值\n\n取决于参数 *mode* 的值。\n\n#### 例子\n\n下例对表 t 中的 price 列按升序排序后分组，对每个分组内对应的 qty 进行求和。\n\n```\nsym=`A`B\nprice = array(DOUBLE[], 0).append!([12.5 12.6 12.5 12.5 12.6, 15.5 15.5 15.5 15.3 15.3])\nqty = array(INT[], 0).append!([201 212 220 215 214, 210 213 223 219 211])\nt=table(sym,price,qty) \n//指定 mode='dict' 时，以字典形式输出结果，其中 key 存储 price 排序后分组的结果，value 存储对 qty 分组求和的结果\nrowGroupby(func=sum,funcArgs=t.qty,groupingCol=t.price,mode='dict') \n\n/* output:\nvalue->[[636,426],[430,646]]\nkey->[[12.5,12.6],[15.3,15.5]]\n*/\n\n//指定 ascending=false，按照 price 降序输出结果。\nrowGroupby(func=sum,funcArgs=t.qty,groupingCol=t.price,mode='dict', ascending=false)\n/* output:\nvalue->[[426,636],[646,430]]\nkey->[[12.6000,12.5000],[15.5000,15.3000]]\n*/\n\n//指定 mode='table' 时，以表的形式输出结果，其中 key 存储 price 排序后分组的结果，value 存储对 qty 分组求和的结果\nrowGroupby(func=sum,funcArgs=t.qty,groupingCol=t.price,mode='table')\n```\n\n| key          | value      |\n| ------------ | ---------- |\n| \\[12.5,12.6] | \\[636,426] |\n| \\[15.3,15.5] | \\[430,646] |\n\n```\n//指定 mode='tuple'，输出结果为 tuple，将 tuple 的两个元素重命名后作为表的一列输出。\nselect rowGroupby(sum, qty, price, 'tuple') as `a`b from t\n```\n\n| a            | b          |\n| ------------ | ---------- |\n| \\[12.5,12.6] | \\[636,426] |\n| \\[15.3,15.5] | \\[430,646] |\n\n接下来通过一个例子来展示如何在矩阵上使用 `rowGroupby` 函数：\n\n```\nm=matrix([32.5 12.6 22.5 42.5 32.6, 17.5 25.5 35.5 17.3 19.3, 17 20.1 30 13 19])\ng=matrix([1 2 2 5 4, 2 2 3 2 1, 1 3 2 3 5])\n//对 g 的每行排序后分组，对 m 的每行在每个组内进行求和\nrowGroupby(func=sum, funcArgs=m, groupingCol=g, mode='table')\n```\n\n| key      | value           |\n| -------- | --------------- |\n| \\[1,2]   | \\[49.5,17.5]    |\n| \\[2,3]   | \\[38.1,20.1]    |\n| \\[2,3]   | \\[52.5,35.5]    |\n| \\[2,3,5] | \\[17.3,13,42.5] |\n| \\[1,4,5] | \\[19.3,32.6,19] |\n\n"
    },
    "segmentby": {
        "url": "https://docs.dolphindb.cn/zh/funcs/ho_funcs/segmentby.html",
        "signatures": [
            {
                "full": "segmentby(func, funcArgs, segment)",
                "name": "segmentby",
                "parameters": [
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "funcArgs",
                        "name": "funcArgs"
                    },
                    {
                        "full": "segment",
                        "name": "segment"
                    }
                ]
            }
        ],
        "markdown": "### [segmentby](https://docs.dolphindb.cn/zh/funcs/ho_funcs/segmentby.html)\n\n\n\n#### 语法\n\nsegmentby(func, funcArgs, segment)\n\n#### 详情\n\n根据 *segment* 参数确定分组方案，把 *funcArgs* 分组，并把函数 *func* 应用到每个分组中。返回的结果与 *segment* 参数的长度相同。\n\n#### 参数\n\n* **func** 是一个函数。\n\n* **funcArgs** 是函数的参数。\n\n* **segment** 是分组向量。segment参数中连续相同的元素为一组。segment的长度必须和funcArgs相同。\n\n#### 返回值\n\n一个与 *segment* 参数长度相同的向量。\n\n#### 例子\n\n下面的例子中，y确定了3个分组：1 1 1、-1 -1 -1和1 1 1。第一个分组的index是0-2，第二个分组的index是3-5，第三个分组的index是6-9。按照这个规则把x分成3组，1 2 3、0 3 2和1 4 5，并把 [cumsum](https://docs.dolphindb.cn/zh/funcs/c/cumsum.html) 函数应用到x的每个分组，计算每个分组的累计和。\n\n```\nx=1 2 3 0 3 2 1 4 5\ny=1 1 1 -1 -1 -1 1 1 1\nsegmentby(cumsum,x,y);\n// output\n[1,3,6,0,3,5,1,5,10]\n```\n\n*segmentby* 可用于止损回测。下面的例子把回报率ret分为两组，分别判断position=1和position=-1这两种情况下，是否需要止损。\n\n```\ndef stoploss(ret, threshold){\n     cumret = cumprod(1+ret)\n     drawDown = cumret.cummax() / cumret - 1\n     firstCutIndex = at(drawDown >= threshold).first() + 1\n     indicator = take(false, ret.size())\n     if(isValid(firstCutIndex) and firstCutIndex < ret.size())\n         indicator[firstCutIndex:] = true\n     return indicator\n}\nposition = 1 1 1 1 1 -1 -1 -1 -1\nret = 0.01 0.02 -0.04 -0.02 -0.01 -0.005 -0.015 0.005 0.025\nsegmentby(stoploss{,0.05}, ret, position);\n// output\n[false,false,false,false,true,false,false,false,false]\n```\n\n计算累积最大值，但遇0即重置该累积最大值。\n\n```\na = [1, 2, 2, 3, 2, 0, 2, 4, 5, 3, 8, 5]\nsegmentby(cummax, a, a==0)\n// output: [1, 2, 2, 3, 3, 0, 2, 4, 5, 5, 8, 8]\n```\n"
    },
    "talib": {
        "url": "https://docs.dolphindb.cn/zh/funcs/ho_funcs/talib.html",
        "signatures": [
            {
                "full": "talib(func, args...)",
                "name": "talib",
                "parameters": [
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "args...",
                        "name": "args..."
                    }
                ]
            }
        ],
        "markdown": "### [talib](https://docs.dolphindb.cn/zh/funcs/ho_funcs/talib.html)\n\n\n\n#### 语法\n\ntalib(func, args...)\n\n#### 详情\n\n当 args 的前几个元素为 NULL 时，DolphinDB 内置滑动窗口函数与 python TA-lib 的处理方式不同：\n\n* DolphinDB 滑动窗口函数：窗口从第一个元素开始进行滑动窗口计算；\n\n* python TA-lib： 保留开始的所有前置 NULL 值，然后从第一个非空元素开始进行滑动窗口计算。\n\n若需要与 python TA-lib 保持一致的处理方式，可以使用 talib 函数。\n\n#### 参数\n\n* **func** 是一个函数名。\n\n* **args** 是函数 func 的参数。\n\n其他相关的 talib 系列函数的参数说明和窗口计算规则请参考: [TA-lib 系列](https://docs.dolphindb.cn/zh/funcs/themes/TAlib.html)\n\n#### 返回值\n\n一个向量，数据类型为 VOID、LONG 或 DOUBLE。\n\n#### 例子\n\n以下例子通过对比说明了 `talib` 函数和 DolphinDB 函数处理 NULL 值的区别。\n\n```\nmsum(NULL 1 2 3 4 5 6 7 8 9, 3)\n```\n\n输出返回：\\[,,3,6,9,12,15,18,21,24]\n\n```\ntalib(msum, NULL 1 2 3 4 5 6 7 8 9, 3)\n```\n\n输出返回：\\[,,,6,9,12,15,18,21,24]\n"
    },
    "tmoving": {
        "url": "https://docs.dolphindb.cn/zh/funcs/ho_funcs/tmoving.html",
        "signatures": [
            {
                "full": "tmoving(func, T, funcArgs, window, [excludedPeriod])",
                "name": "tmoving",
                "parameters": [
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "T",
                        "name": "T"
                    },
                    {
                        "full": "funcArgs",
                        "name": "funcArgs"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "[excludedPeriod]",
                        "name": "excludedPeriod",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [tmoving](https://docs.dolphindb.cn/zh/funcs/ho_funcs/tmoving.html)\n\n#### 语法\n\ntmoving(func, T, funcArgs, window, \\[excludedPeriod])\n\n#### 详情\n\n应用函数/运算符到给定对象的一个滚动窗口上。\n\n内置函数 [tmsum](https://docs.dolphindb.cn/zh/funcs/t/tmsum.html), [tmcount](https://docs.dolphindb.cn/zh/funcs/t/tmcount.html) 和 [tmavg](https://docs.dolphindb.cn/zh/funcs/t/tmavg.html) 为各自的计算场景进行了优化，因此比 *tmoving* 高阶函数有更好的性能。\n\n#### 参数\n\n* **func** 是一个函数。\n\n* **T** 是一个递增的整型或时间类型的向量，且不能包含NULL值。\n\n* **funcArgs** 是函数func的参数。可为向量、字典或表。如果有多个参数，则用元组表示，并且每个参数的长度（向量/字典的元素个数或表的行数）必须相同。\n\n* **window** 是一个正整数或一个 [duration](https://docs.dolphindb.cn/zh/funcs/d/duration.html)，表示滚动窗口的区间大小。\n\n  对于 *T* 中每个元素 *Ti*：\n\n  * 当 *T* 为整型时，确定的窗口区间为 (*Ti* - window, *Ti* ]\n\n  * 当 *T* 为时间类型时， 确定的窗口区间为 (temporalAdd(*Ti*, -window), *Ti*]\n\n* **excludedPeriod** 是　TIME、NANOTIME、MINUTE 和 SECOND 类型的数据对。用于设定一个交易日内的非交易时间段（该时间段被排除在计算窗口之外）。若设置该参数，必须同时保证以下3点：\n\n  * 数据对中的右值必须大于左值。\n\n  * 时间段长度必须小于 (24 - *window*)\n\n  * *T* 中不能包含 *excludedPeriod* 区间内的时间，且数据类型必须是 TIMESTAMP, NANOTIMESTAMP, TIME 或 NANOTIME。\n\n其他相关的 tm 系列函数的参数说明和窗口计算规则请参考: [tmFunctions](https://docs.dolphindb.cn/zh/funcs/themes/tmFunctions.html)\n\n#### 返回值\n\n一个与输入参数长度相同的向量。\n\n#### 例子\n\n```\ndate=2021.08.01 2021.08.02 2021.08.02 2021.08.02 2021.08.03 2021.08.04 2021.08.05 2021.08.06 2021.08.09 2021.08.10 2021.08.14\nvalue=1..11\nt = table(date,value)\ntimer(100) select date, value, tmoving(avg,date,value,3d) from t;\n\n//output: Time elapsed: 7.9 ms\n```\n\n```\ntimer(100) select date, value, tmavg(date, value, 3d) from t;\n\n//output: Time elapsed: 6.805 ms\n```\n\n单独打印计算结果，可以看到，当窗口滑动到2021.08.09，计算窗口范围为 \\[2021.08.07, 2021.08.08, 2021.08.09]，但 7 日和 8 日值缺失，因此不参与计算。\n\n| date       | value | tmoving\\_sum |\n| ---------- | ----- | ------------ |\n| 2021.08.01 | 1     | 1            |\n| 2021.08.02 | 2     | 1.5          |\n| 2021.08.02 | 3     | 2            |\n| 2021.08.02 | 4     | 2.5          |\n| 2021.08.03 | 5     | 3            |\n| 2021.08.04 | 6     | 4            |\n| 2021.08.05 | 7     | 6            |\n| 2021.08.06 | 8     | 7            |\n| 2021.08.09 | 9     | 9            |\n| 2021.08.10 | 10    | 9.5          |\n| 2021.08.14 | 11    | 11           |\n\n下例通过 *excludedPeriod* 参数指定股市上午的休市时间，计算长度为一分钟的滚动窗口内的价格平均值。\n\n```\nexcludedPeriod=(11:30:00:13:00:00)\nts=timestamp(2023.11.01T11:21:00+1..500) join timestamp(2023.11.01T13:00:00+1..500)\nt=table(ts, rand(10.0,size(ts)) as price)\n\n// 通过 excludedPeriod 指定休市时间为11:30:00 到 13:00:00，则此段时间被忽略，不会被作为计算窗口。\nres1=select ts, tmoving(func=avg, T=ts, funcArgs=price, window=1m, excludedPeriod=excludedPeriod) from t\n// 不指定 excludedPeriod 时，休市时间也会被考虑为计算窗口。\nres2=select ts, tmoving(func=avg, T=ts, funcArgs=price, window=1m) from t\n\n// 对比是否指定 excludedPeriod 的计算结果。\nselect * from res1 where ts between timestamp(2023.11.01T13:00:00) and timestamp(2023.11.01T13:01:00)\n\nselect * from res2 where ts between timestamp(2023.11.01T13:00:00) and timestamp(2023.11.01T13:01:00)\n```\n\n下例通过指定多个 *funcArgs* 参数，计算长度为 5 分钟的滚动窗口内债券价格在达到峰值后的最低值。\n\n```\ndata_time = 2023.01.01T00:00:00 + 0..5 * 3600000  \nlast_price_bond = 100 + rand(10.0, 10) \n\ndefg getMinPrice(data_time, last_price_bond){\n        maxPriceTime = atImax(last_price_bond, data_time)\n        maxPrice = max(last_price_bond)\n        newPriceList = min(iif(data_time<maxPriceTime, maxPrice, last_price_bond))\n        return min(newPriceList)\n}\ncalTime = \"5m\"\ntmoving(getMinPrice, data_time, [data_time, last_price_bond], duration(calTime))\n```\n\n"
    },
    "twindow": {
        "url": "https://docs.dolphindb.cn/zh/funcs/ho_funcs/twindow.html",
        "signatures": [
            {
                "full": "twindow(func, funcArgs, T, range, [prevailing=false], [excludedPeriod])",
                "name": "twindow",
                "parameters": [
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "funcArgs",
                        "name": "funcArgs"
                    },
                    {
                        "full": "T",
                        "name": "T"
                    },
                    {
                        "full": "range",
                        "name": "range"
                    },
                    {
                        "full": "[prevailing=false]",
                        "name": "prevailing",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[excludedPeriod]",
                        "name": "excludedPeriod",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [twindow](https://docs.dolphindb.cn/zh/funcs/ho_funcs/twindow.html)\n\n#### 语法\n\ntwindow(func, funcArgs, T, range, \\[prevailing=false], \\[excludedPeriod])\n\n#### 详情\n\n应用函数/运算符到给定对象的滑动窗口。对给定对象的每一个元素，滑动窗口由 *T* 和 *range* 决定。 结果的维度与 *funcArgs* 的维度相同（若 *funcArgs* 是一个元组，结果的维度与该元组中每个元素的维度相同）。\n\n滑动窗口的确定规则（假设 *range* 参数为 d1:d2）：\n\n1. *range* 是整型数据对时：\n\n   * *T* 如果为整型向量，对 *T* 内元素 Ti，可以确定 *T* 对应的窗口范围为 \\[Ti+d1, Ti+d2]。\n\n   * *T* 如果为时间类型向量，*range* 的精度默认为 *T* 的精度，对于 *T* 内元素 Ti，确定的窗口范围为 \\[temporalAdd(Ti, d1, unit), temporalAdd(Ti, d2, unit)]，其中 unit 是 *T* 的精度。\n\n2. *range* 是 DURATION 数据对时，*T* 只能是时间类型向量，对于 *T* 内元素 Ti，确定 *T* 对应的窗口元素范围为 \\[temporalAdd(Ti, d1), temporalAdd(Ti, d2)]。\n\n**Note:** 当左边界大于右边界时，窗口为空，计算结果为 NULL。\n\n与 `tmoving` 函数相比，`twindow` 函数具有更灵活的窗口。`tmoving` 可以视为 `twindow` 指定 *range* 右边界为 0 的特殊情况， 但需要注意以时间长度衡量窗口时，两者对窗口边界的处理有区别：\n\n1. `twindow` 窗口的右边界与多条相同的值匹配时，该窗口会包含所有重复匹配的记录。当其窗口左边界与多条相同的值匹配时， 若 *prevailing* = true，则窗口只包含最后一个值；若 *prevailing* = false，则窗口亦会包含所有重复值。\n\n2. `tmoving` 函数的窗口范围为(Ti - window, Ti] 或 (temporalAdd(Ti - window), Ti]，即 `tmoving` 函数只基于当前滑动到的记录，确定一个向前的窗口， 不考虑右边界是否有重复值；且左边界不包含在内。\n\n#### 参数\n\n* **func** 是一个聚合函数。\n\n* **funcArgs** 是 *func* 的参数。*func* 有多个参数时，它是一个元组。\n\n* **T** 是一个非严格递增的整型或时间类型的向量。\n\n* **range** 是一个整型数据对或 DURATION 数据对，左右边界都包含在内。\n\n* **prevailing** 只能为 0/false，1/true 或 2。\n\n  * 如果 *prevailing* = 0/false，则滑动窗口不对边界重复值做处理，请阅读详情部分。\n\n  * 如果 *prevailing* = 1/true，则滑动窗口边界的选取规则同 [pwj](https://docs.dolphindb.cn/zh/progr/sql/windowjoin.html)。\n\n  * 如果 *prevailing* = 2，（假设 *range* 参数为 d1:d2）：\n\n    * 若 d1 为 0，则滑动窗口将把当前索引对象作为边界，窗口左边的重复值不参与计算。\n\n    * 若 d2 为 0，则滑动窗口将把当前索引对象作为边界，窗口右边的重复值不参与计算。\n\n    * 当前情况下不可以同时设置参数 *excludedPeriod*。\n\n* **excludedPeriod** 是　TIME、NANOTIME、MINUTE 和 SECOND 类型的数据对。用于设定一个交易日内的非交易时间段（该时间段被排除在计算窗口之外）。若设置该参数，必须同时保证以下3点：\n\n  * 数据对中的右值必须大于左值。\n\n  * 时间段长度必须小于 (24 - *range*)\n\n  * *T* 中不能包含 *excludedPeriod* 区间内的时间，且数据类型必须是 TIMESTAMP, NANOTIMESTAMP, TIME 或 NANOTIME。\n\n#### 返回值\n\n一个向量，数据类型为 VOID、INT、LONG 或 DOUBLE。\n\n#### 例子\n\n*prevailing* = false，左边界对应多个重复值，计算窗口会包含所有重复值\n\n```\nt = 2021.01.02 2021.01.02 2021.01.06 2021.03.09 2021.03.10 2021.03.12 2021.03.12\nx = -5 5 NULL -1 2 4 -8\ntwindow(func=min,funcArgs=x,T=t,range=0:2)\n```\n\n输出返回：\\[-5, -5, , -1, -8, -8, -8]\n\n*prevailing* = true，左边界对应多个重复值，计算窗口只包含最后一个值\n\n```\ntwindow(func=min, funcArgs=x, T=t, range=0:3, prevailing=true)\n```\n\n输出返回：\\[5, 5, ,-8, -8, -8, -8]\n\n```\ntwindow(func=max, funcArgs=x, T=t, range=0d:3d)\n```\n\n输出返回：\\[5, 5, , 4, 4, 4, 4]\n\n```\ntwindow(func=max, funcArgs=x, T=t, range=0:3, prevailing=true)\n```\n\n输出返回：\\[5, 5, , 4, 4, -8, -8]\n\n```\ntwindow(func=max, funcArgs=x, T=t, range=0M:3M)\n```\n\n输出返回：\\[5, 5, 4, 4, 4, 4, 4]\n\n```\ntwindow(func=max, funcArgs=x, T=t, range=0M:3M, prevailing=true)\n```\n\n输出返回：\\[5, 5, 4, 4, 4, -8, -8]\n\n```\ny = 4.8 9.6 7.1 3.3 5.9 2.7 6.9\ntwindow(func=corr, funcArgs=(x,y), T=t, range=0:3)\n```\n\n输出返回：\\[1, 1, , -0.685, -0.7893, -1, -1]\n\n```\nt1 = table(`A`A`B`B`C`C as sym, 09:56:03 09:56:07 09:56:02 09:56:05 09:56:04 09:56:06 as time, 10.6 10.7 20.6 11.6 11.7 19.6 as price)\nselect *, twindow(func=avg, funcArgs=t1.price, T=t1.time, range=2s:4s) from t1 context by sym\n```\n\n返回：\n\n| sym | time     | price | window\\_avg |\n| --- | -------- | ----- | ----------- |\n| A   | 09:56:03 | 10.6  | 10.7        |\n| A   | 09:56:07 | 10.7  |             |\n| B   | 09:56:02 | 20.6  | 11.6        |\n| B   | 09:56:05 | 11.6  |             |\n| C   | 09:56:04 | 11.7  | 19.6        |\n| C   | 09:56:06 | 19.6  |             |\n\n下例通过 *excludedPeriod* 参数指定股市上午的休市时间，计算长度为一分钟的滑动窗口内的价格平均值。\n\n```\nexcludedPeriod=(11:30:00:13:00:00)\nts=timestamp(2023.11.01T11:21:00+1..500) join timestamp(2023.11.01T13:00:00+1..500)\nt=table(ts, rand(10.0,size(ts)) as price)\n\n// 通过 excludedPeriod 指定休市时间为11:30:00 到 13:00:00，则此段时间被忽略，不会被作为计算窗口。\nres1=select ts, twindow(func=avg, T=ts, funcArgs=price, range=-1m:0m, excludedPeriod=excludedPeriod) from t\n// 不指定 excludedPeriod 时，休市时间也会被考虑为计算窗口。\nres2=select ts, twindow(func=avg, T=ts, funcArgs=price, range=-1m:0m) from t\n\n// 对比是否指定 excludedPeriod 的计算结果。\nselect * from res1 where ts between timestamp(2023.11.01T13:00:00) and timestamp(2023.11.01T13:01:00)\n\nselect * from res2 where ts between timestamp(2023.11.01T13:00:00) and timestamp(2023.11.01T13:01:00)\n```\n\n只传入前四个参数，且设置 *prevailing* 为 2。\n\n```\nt=[09:30:00.020,09:30:00.020,09:30:00.020,09:30:00.030,09:30:00.040,09:30:00.040]\nv=0 1 2 3 5 4\ntwindow(min,v,t,0ms:10ms,prevailing = 2) \n//Output: [0,1,2,3,4,4]\ntwindow(min,v,t,-10ms:0ms,prevailing = 2) \n//Output: [0,0,0,0,3,3]\n\n//非法输入\ntwindow(min,v,t,-10ms:10ms,prevailing = 2) \n//Output: Usage: twindow(func, funcArgs, T, range, [prevailing=0], [excludedPeriod]). left offset or right offset must be zero when prevailing =2.\ntwindow(min,v,t,0ms:0ms,prevailing = 2) \n//Output: Usage: twindow(func, funcArgs, T, range, [prevailing=0], [excludedPeriod]). 0:0 is illegal window when prevailing =2.\n```\n\n"
    },
    "unifiedCall": {
        "url": "https://docs.dolphindb.cn/zh/funcs/ho_funcs/unifiedCall.html",
        "signatures": [
            {
                "full": "unifiedCall(func, args)",
                "name": "unifiedCall",
                "parameters": [
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "args",
                        "name": "args"
                    }
                ]
            }
        ],
        "markdown": "### [unifiedCall](https://docs.dolphindb.cn/zh/funcs/ho_funcs/unifiedCall.html)\n\n\n\n#### 语法\n\nunifiedCall(func, args)\n\n#### 详情\n\n用指定的参数调用一个函数。同 [call](https://docs.dolphindb.cn/zh/funcs/ho_funcs/call.html) 类似，可以用在 [each/peach](https://docs.dolphindb.cn/zh/funcs/ho_funcs/each.html) 或 [loop](https://docs.dolphindb.cn/zh/funcs/ho_funcs/loop.html)/[ploop](https://docs.dolphindb.cn/zh/funcs/ho_funcs/ploop.html) 函数中，来调用一批函数。区别在于，*call* 函数的args参数个数不确定，由func传入的函数决定。 而 *unifiedCall* 的args只有一个，通过tuple来给func函数传入多个参数。\n\n#### 参数\n\n**func** 是一个函数。\n\n**args** 是一个tuple, tuple的每一个元素作为函数的参数。\n\n#### 返回值\n\n取决于 *func* 的返回值。\n\n#### 例子\n\n```\nunifiedCall(sum, [1..10])\n```\n\n返回：55\n\n```\nunifiedCall(add, ([1,2,3,4,5,6,7,8,9,10],2))\n```\n\n返回：\\[3, 4, 5, 6, 7, 8, 9, 10, 11, 12]\n\n```\neach(unifiedCall, [std, max], [[matrix(1 3 5 7 9, 1 4 7 10 13)], [0..100]]);\n```\n\n得到：\n\n| col1   | col2 |\n| ------ | ---- |\n| 3.1623 | 100  |\n| 4.7434 | 100  |\n\n下面这个例子，自定义一个函数，再通过unifiedCall传入参数，进行调用。\n\n```\ndef f(a,b){return (a+2)*b}\nunifiedCall(f, (5,10))\n```\n\n返回：70\n"
    },
    "window": {
        "url": "https://docs.dolphindb.cn/zh/funcs/ho_funcs/window.html",
        "signatures": [
            {
                "full": "window(func, funcArgs, range)",
                "name": "window",
                "parameters": [
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "funcArgs",
                        "name": "funcArgs"
                    },
                    {
                        "full": "range",
                        "name": "range"
                    }
                ]
            }
        ],
        "markdown": "### [window](https://docs.dolphindb.cn/zh/funcs/ho_funcs/window.html)\n\n\n\n#### 语法\n\nwindow(func, funcArgs, range)\n\n#### 详情\n\n应用函数/运算符到给定对象的滑动窗口。对给定对象的每一个元素，滑动窗口由 *range* 决定。结果的维度与 *funcArgs* 的维度相同（若 *funcArgs* 是一个元组， 结果的维度与该元组中每个元素的维度相同）。\n\n滑动窗口的确定规则（假设 *range* 参数为 d1:d2）：\n\n1. 若 *funcArgs* 为向量，*range* 必须为整型。对 *funcArgs* 中第 i 位的元素，窗口所含元素的位置区间为 \\[i+d1, i+d2] 。\n\n2. 若 *funcArgs* 为索引序列或索引矩阵：\n\n   * 若 *funcArgs* 的索引为时间类型，对 *funcArgs* 中索引为 fi 的元素，其对应的窗口索引范围为 \\[temporalAdd(fi, d1), temporalAdd(fi, d2)]。\n\n   * 若 *funcArgs* 的索引为整型，*range* 必须亦为整型。对 *funcArgs* 中索引为 fi 的元素，其对应的窗口索引范围为 \\[fi+d1, fi+d2] 。\n\n与 `moving` 函数相比，`window` 函数具有更灵活的窗口。`moving` 可以视为 `window` 指定 *range* 右边界为 0 的特殊情况。但需要注意以下两点：\n\n1. 元素个数决定窗口长度时，窗口内元素个数不足时，`moving` 函数将输出空值，但 `window` 会输出计算结果。\n\n2. 时间长度决定窗口长度时，`moving` 确定的窗口左开右闭，但 `window` 确定窗口左闭右闭。详见以下说明：\n\n假定索引类型为 DATETIME, 需要指定一个长度为 “3d” 的窗口进行滑动窗口计算。对于索引中的某个时间点 “2022.01.05T09:00:00”， `moving` 函数根据该时间点确定的窗口为 (2022.01.02T09:00:00，2022.01.05T09:00:00]，`window` 指定 *range* 为 “-2d:0d”， 确定的窗口为 \\[2022.01.03T09:00:00，2022.01.05T09:00:00]。\n\n#### 参数\n\n* **func** 是一个聚合函数。\n\n* **funcArgs** 是 *func* 的参数。*func* 有多个参数时，它是一个元组。\n\n* **range** 是一个整型数据对或 DURATION 数据对，左右边界都包含在内。\n\n**Note:** 如果 *range* 是 DURATION 类型，则 *funcArgs* 必须是一个索引矩阵（indexed matrix）或者是索引序列（indexed series）。\n\n#### 返回值\n\n一个向量，其类型由第一个窗口的计算结果类型决定。\n\n#### 例子\n\n*funcArgs* 为向量, 确定窗口位置区间为 \\[i+1,i+3], i 是 x 的下标。\n\n```\nx = 5 4 NULL -1 2 4\nwindow(min, x, 1:3)\n// output\n[-1, -1, -1, 2, 4, ]\n\ny = 4.8 9.6 7.1 3.3 5.9 2.7\nwindow(corr, (x, y), 1:3)\n// output\n[1, 1, -0.623, -1, , ]\n```\n\n*funcArgs* 为索引序列, 索引为时间类型，确定的窗口范围为 \\[temporalAdd(ti, 1d), temporalAdd(ti, 3d)]，ti 是 t 第 i 个元素对应的值。\n\n```\nt = 2021.01.02 2021.01.05 2021.01.06 2021.01.09 2021.01.10 2021.01.12\nx1 = indexedSeries(t, x)\nwindow(min, x1, 1d:3d)\n```\n\n| label      | col1 |\n| ---------- | ---- |\n| 2021.01.02 | 4    |\n| 2021.01.05 |      |\n| 2021.01.06 | -1   |\n| 2021.01.09 | 2    |\n| 2021.01.10 | 4    |\n| 2021.01.12 |      |\n\n*funcArgs* 为索引矩阵, 索引为时间，确定索引对应的窗口范围 \\[temporalAdd(ti, 1d), temporalAdd(ti, 3d)]，ti 是 t 第 i 个元素对应的值。 以 a, b 列分组进行滑动窗口计算。\n\n```\nt= 2021.01.02 2021.01.05  2021.01.06  2021.01.09 2021.01.10 2021.01.12\nm=matrix(5 4 NULL -1 2 4, 3 2 8 1 0 5)\nm1=m.rename!(t, `a`b).setIndexedMatrix!()\nwindow(min, m1, 1d:3d)\n```\n\n| label      | a  | b |\n| ---------- | -- | - |\n| 2021.01.02 | 4  | 2 |\n| 2021.01.05 |    | 8 |\n| 2021.01.06 | -1 | 1 |\n| 2021.01.09 | 2  | 0 |\n| 2021.01.10 | 4  | 5 |\n| 2021.01.12 |    |   |\n\n```\nt1 = table(`A`A`B`B`C`C as sym, 09:56:03 09:56:07 09:56:02 09:56:05 09:56:04 09:56:06 as time, 10.6 10.7 20.6 11.6 11.7 19.6 as price)\nselect *, window(avg, t1.time.indexedSeries(t1.price), 2s:4s) from t1 context by sym\n```\n\n| sym | time     | price | window\\_avg |\n| --- | -------- | ----- | ----------- |\n| A   | 09:56:03 | 10.6  | 10.7        |\n| A   | 09:56:07 | 10.7  |             |\n| B   | 09:56:02 | 20.6  | 11.6        |\n| B   | 09:56:05 | 11.6  |             |\n| C   | 09:56:04 | 11.7  | 19.6        |\n| C   | 09:56:06 | 19.6  |             |\n"
    },
    "withNullFill": {
        "url": "https://docs.dolphindb.cn/zh/funcs/ho_funcs/withNullFill.html",
        "signatures": [
            {
                "full": "withNullFill(func, x, y, fillValue)",
                "name": "withNullFill",
                "parameters": [
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "x",
                        "name": "x"
                    },
                    {
                        "full": "y",
                        "name": "y"
                    },
                    {
                        "full": "fillValue",
                        "name": "fillValue"
                    }
                ]
            }
        ],
        "markdown": "### [withNullFill](https://docs.dolphindb.cn/zh/funcs/ho_funcs/withNullFill.html)\n\n#### 语法\n\nwithNullFill(func, x, y, fillValue)\n\n#### 详情\n\n* 如果 x 与 y 中相同位置的元素只有一个为NULL，使用 fillValue 替换 NULL 值参与计算。\n* 如果 x 和 y 相同位置的元素均为 NULL，返回 NULL。\n\n#### 参数\n\n* **func** 是一个DolphinDB内置函数，须为双目运算符，例如+, -, \\*, /, , %, pow, and, or 等。\n* **x** 与 **y** 是向量或矩阵。\n* **fillValue** 是一个标量。\n\n#### 返回值\n\n一个与 `func(x, y)` 结果结构和维度一致的向量或矩阵。\n\n#### 例子\n\n```\nx = 0 1 NULL NULL 2\ny = 1 NULL 2 NULL 3;\nadd(x,y);\n// output\n[1,,,,5]\n\nwithNullFill(add, x, y, 0);\n// output\n[1,1,2,,5]\n\nm=matrix(1..5, y);\nm;\n```\n\n| col1 | col2 |\n| ---- | ---- |\n| 1    | 1    |\n| 2    |      |\n| 3    | 2    |\n| 4    |      |\n| 5    | 3    |\n\n```\nadd(x, m);\n```\n\n| col1 | col2 |\n| ---- | ---- |\n| 1    | 1    |\n| 3    |      |\n|      |      |\n|      |      |\n| 7    | 5    |\n\n```\nwithNullFill(add, x, m, 0);\n```\n\n| col1 | col2 |\n| ---- | ---- |\n| 1    | 1    |\n| 3    | 1    |\n| 3    | 2    |\n| 4    |      |\n| 7    | 5    |\n\n"
    },
    "garch": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/garch.html",
        "signatures": [
            {
                "full": "garch(ds, endogColName, order, [maxIter=50])",
                "name": "garch",
                "parameters": [
                    {
                        "full": "ds",
                        "name": "ds"
                    },
                    {
                        "full": "endogColName",
                        "name": "endogColName"
                    },
                    {
                        "full": "order",
                        "name": "order"
                    },
                    {
                        "full": "[maxIter=50]",
                        "name": "maxIter",
                        "optional": true,
                        "default": "50"
                    }
                ]
            }
        ],
        "markdown": "### [garch](https://docs.dolphindb.cn/zh/funcs/g/garch.html)\n\n\n\n#### 语法\n\ngarch(ds, endogColName, order, \\[maxIter=50])\n\n#### 详情\n\n使用广义自回归条件异方差模型（Generalized Autoregressive Conditional Heteroskedasticity，简称 GARCH 模型）来分析单变量时间序列。返回一个字典，表示 GARCH 模型的分析结果，详细说明请参见“返回值”小节。\n\n#### 参数\n\n**ds** 一张内存表或者一个 DataSource 类型构成的向量，包含需要分析的单变量时间序列。注意：不可为空。\n\n**endogColName** 字符串标量，表示 *ds* 中需要分析的时间序列所对应的列名。\n\n**order** 长度为 2 的正整数向量，表示 GARCH 模型的阶数。比如 `order=[1,2]` 表示 GARCH 模型的 p=1，q=2，其中 p 为 GARCH 项个数，q 为 ARCH 项阶数。\n\n**maxIter** 可选参数，正整数标量，表示优化时的最大迭代次数，默认值为 50。\n\n#### 返回值\n\n返回一个字典，表示 GARCH 模型的分析结果，字典有以下成员：\n\n* volConstant：浮点数标量，表示优化得到的 Vol Constant。\n\n* returnsConstant：浮点数标量，表示优化得到的 Returns Constant。\n\n* archTerm：浮点数向量，表示优化得到的 ARCH Term。\n\n* garchTerm：浮点数向量，表示优化得到的 GARCH Term。\n\n* iterations：整数标量，表示优化迭代次数。\n\n* aic：浮点数标量，表示 aic 准则的值。\n\n* bic：浮点数标量，表示 bic 准则的值。\n\n* nobs：整数标量，表示时间序列的观测数量，即拟合使用的数据量。\n\n* model：字典类型，包含拟合后模型的基本信息，有以下成员：\n\n  * order：长度为 2 的正整数向量，表示模型的阶数。\n\n  * endog：浮点数矩阵类型，表示从 *ds* 中转换而来的观测数据。\n\n  * coefficients：浮点数向量类型，表示经过拟合后的外生变量的值。\n\n* predict：函数指针， 指向预测函数，使用方法为 `model.predict(x)`。其中，*model* 表示 garch 函数的输出结果，*x* 为一个正整数，表示预测的步长。预测函数返回一个数组，数组中每个元素分别表示每一步的预测值。\n\n* modelName：模型名称 GARCH。\n\n#### 例子\n\n传入 [macrodata.csv](https://docs.dolphindb.cn/zh/funcs/data/macrodata.csv) 文件，自定义相关参数，计算其使用 GARCH 模型进行分析的结果。\n\n```\ndata = loadText(\"macrodata.csv\");\nmodel = garch(data, \"realgdp\", [1,1]);\nprint(model)\n\n// out:\n\nvolConstant->0.000005999433551\nreturnsConstant->0.008474617943101\narchTerm->[0.70725452294378]\ngarchTerm->[0.248859733003604]\naic->-1353.789403416915774\nbic->-1340.576183784679415\nnobs->201\niterations->38\npredict->garchPredict\nmodel->order->[1,1]\nendog->#0                \n------------------\n0.024942130816387 \n-0.001192952110668\n0.003494532654372 \n...\n\ncoefficients->[-12.023845501294935,-1.104702991485461,0.882087052766567,0.008474617943101]\n\n```\n"
    },
    "gaussianKde": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/gaussiankde.html",
        "signatures": [
            {
                "full": "gaussianKde(X,[weights],[bwMethod=\"scott\"])",
                "name": "gaussianKde",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[weights]",
                        "name": "weights",
                        "optional": true
                    },
                    {
                        "full": "[bwMethod=\"scott\"]",
                        "name": "bwMethod",
                        "optional": true,
                        "default": "\"scott\""
                    }
                ]
            }
        ],
        "markdown": "### [gaussianKde](https://docs.dolphindb.cn/zh/funcs/g/gaussiankde.html)\n\n\n\n#### 语法\n\ngaussianKde(X,\\[weights],\\[bwMethod=\"scott\"])\n\n#### 详情\n\n使用核密度估计方法中的高斯核来估计随机变量的概率密度。\n\n生成的模型可以作为 `gaussianKdePredict` 函数的输入。\n\n#### 参数\n\n**X** 数值向量、矩阵、元组或表类型，表示给定的数据集合。*X* 的每一行表示一个数据点，元素数量至少为 2（即数据点的维度至少为 2），各数据点的维度保持一致，且 *X* 的行数须大于列数。暂时不支持分布式表。\n\n**weights** 数值向量类型，可选参数，表示每一个数据点的权重，默认每个数据点的权重相同。向量中数值必须非负且不全为0；且向量大小须和 *X* 的行数相同。\n\n**bwMethod**数值标量，字符串标量或函数名类型，可选参数，表示带宽的生成方式。默认值为”scott”。\n\n* 若传入数值标量，则表示带宽的大小。\n\n* 若传入字符串标量类型，可选值为”scott”和”silverman”。\n\n* 若传入函数，表示用于计算带宽的函数，其输入值为已传入的参数*X*，执行后得到带宽的值。注意：返回值须为数值标量。\n\n#### 返回值\n\n返回一个字典，字典的内容有：\n\n* X：浮点型向量或矩阵，表示输入的数据集合 *X*。\n\n* cov：浮点型矩阵，表示的是通过 *weights*、*X* 和带宽生成的协方差矩阵的 cholesky 分解矩阵。\n\n* weights：浮点型向量，表示对应的权重。\n\n* predict：函数指针，表示对应的预测函数。其使用方法为 `model.gaussianKdePredict(model,X)`，详情见 gaussianKdePredict。\n\n* bandwidth：浮点型标量，表示的生成的带宽。\n\n#### 例子\n\n下例传入指定的 [*trainset.txt*](https://docs.dolphindb.cn/zh/funcs/data/trainset.txt)，使用高斯核估计来预测数据的概率密度。\n\n```\ntrainData = loadText(\"trainset.txt\",\" \");\nmodel = gaussianKde(trainData)\nmodel\n/* Output\nX->\n#0      #1     \n0.1460  -0.1659\n-1.3717 -1.6650\n-1.6957 -1.1680\n-0.7976 0.6081 \n0.1088  2.5113 \n-0.0724 -0.8210\n-1.7548 -0.3485\n1.1202  0.9004 \n1.0234  0.7907 \n-0.4256 0.7169 \n\npredict->gaussianKdePredict\ncov->\n#0     #1    \n0.7040 0.0   \n0.4921 0.6700\n\nweights->[0.1000,0.1000,0.1000,0.1000,0.1000,0.1000,0.1000,0.1000,0.1000,0.1000]\nbandwidth->0.6812\n*/\n```\n\n承接上例，传入 [*testset.txt*](https://docs.dolphindb.cn/zh/funcs/data/testset.txt) 文件，`gaussianKde` 可与 `gaussianKdePredict` 函数结合使用，生成其对应的预测结果。\n\n```\ntestData = loadText(\"testset.txt\",\" \");\nmodel.predict(testData)\n/* Output\n->[0.0623,0.0730,0.0336,0.0030,0.0001,0.0552....]\n*/\n```\n\n相关函数：[gaussianKdePredict](https://docs.dolphindb.cn/zh/funcs/g/gaussiankdepredict.html)\n"
    },
    "gaussianKdePredict": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/gaussiankdepredict.html",
        "signatures": [
            {
                "full": "gaussianKdePredict(model,X)",
                "name": "gaussianKdePredict",
                "parameters": [
                    {
                        "full": "model",
                        "name": "model"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [gaussianKdePredict](https://docs.dolphindb.cn/zh/funcs/g/gaussiankdepredict.html)\n\n\n\n#### 语法\n\ngaussianKdePredict(model,X)\n\n#### 详情\n\n[gaussianKde](https://docs.dolphindb.cn/zh/funcs/g/gaussiankde.html) 对应的预测函数。使用其生成的模型对数据进行预测。\n\n#### 参数\n\n**model** 字典类型，表示 `gaussianKde` 生成的字典。\n\n**X** 数值向量、矩阵、元组或表类型，表示需要预测的数据。其维度必须和 `gaussianKde` 的数据集合的维度相同。\n\n#### 返回值\n\n函数返回一个浮点型向量，大小和 *X* 的行数相同，表示 *X* 中每个数据点的预测结果。\n\n#### 例子\n\n下例中先使用 `gaussianKde` 生成模型。传入指定的 [*trainset.txt*](https://docs.dolphindb.cn/zh/funcs/data/trainset.txt)，使用高斯核估计来预测数据的概率密度。然后调用 `predict` 函数，通过模型和传入的 [*testset.txt*](https://docs.dolphindb.cn/zh/funcs/data/testset.txt) 文件生成对应的预测结果。\n\n```\ntrainData = loadText(\"trainset.txt\",\" \");\ntestData = loadText(\"testset.txt\",\" \");\nmodel = gaussianKde(trainData)\ngaussianKdePredict(model, testData)\n/*\n->[0.0623,0.0730,0.0336,0.0030,0.0001,0.0552....]\n*/\n```\n\n相关函数：[gaussianKde](https://docs.dolphindb.cn/zh/funcs/g/gaussiankde.html)\n"
    },
    "gaussianNB": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/gaussianNB.html",
        "signatures": [
            {
                "full": "gaussianNB(Y, X, [varSmoothing=1e-9])",
                "name": "gaussianNB",
                "parameters": [
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[varSmoothing=1e-9]",
                        "name": "varSmoothing",
                        "optional": true,
                        "default": "1e-9"
                    }
                ]
            }
        ],
        "markdown": "### [gaussianNB](https://docs.dolphindb.cn/zh/funcs/g/gaussianNB.html)\n\n\n\n#### 语法\n\ngaussianNB(Y, X, \\[varSmoothing=1e-9])\n\n#### 详情\n\n使用高斯朴素贝叶斯（Gaussian Naive Bayes）算法对数据进行分类训练。\n\n#### 参数\n\n**Y** 是一个长度与 *X* 的行数相等的向量，表示 *X* 中每个样本对应的标签。\n\n**X** 是一个表，表示训练集。表中的每一行表示一个样本，每一列表示一个特征。\n\n**varSmoothing** 是一个浮点类型的正数，表示平滑系数。默认值是 1e-9。\n\n#### 返回值\n\n一个字典，包含以下 key：\n\n* modelName：模型名称，为字符串 \"GaussianNB\"\n\n* model：gaussianNB 的内部模型\n\n* varSmoothing：训练时的平滑系数\n\n#### 例子\n\n本例所用数据集 iris.data 可从 <https://archive.ics.uci.edu/ml/datasets/iris> 下载。\n\n```\nDATA_DIR = \"C:/DolphinDB/Data\"\nt = loadText(DATA_DIR+\"/iris.data\")\nt.rename!(`col0`col1`col2`col3`col4, `sepalLength`sepalWidth`petalLength`petalWidth`class)\nt[`classType] = take(0, t.size())\nupdate t set classType = 1 where class = \"Iris-versicolor\"\nupdate t set classType = 2 where class = \"Iris-virginica\"\n\ntraining = select sepalLength, sepalWidth, petalLength, petalWidth from t\nlabels = t.classType\n\nmodel = gaussianNB(labels, training);\n\npredict(model, training);\n```\n"
    },
    "ge": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/ge.html",
        "signatures": [
            {
                "full": "ge(X, Y)",
                "name": "ge",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [ge](https://docs.dolphindb.cn/zh/funcs/g/ge.html)\n\n\n\n#### 语法\n\nge(X, Y) 或 X>=Y\n\n#### 详情\n\n如果 *X* 和 *Y* 都不是集合，返回逐个元素比较 *X*>=*Y* 的结果。\n\n如果 *X* 和 *Y* 都是集合，则检查 *Y* 是否为 *X* 的子集。\n\n#### 参数\n\n**X** 和 **Y** 可以是标量、数据对、向量、矩阵或集合。如果 *X* 或 *Y* 的其中一个是数据对、向量或矩阵，另一个必须是标量，或具有相同长度或维度的数据对、向量或矩阵。\n\n#### 返回值\n\n* 当 *X* 和 *Y* 都不是集合时，返回布尔类型的结果，形式与输入参数的形式相同。\n* 当 *X* 和 *Y* 都是集合时，返回布尔值标量，表示 *Y* 是否为 *X* 的子集。\n\n#### 例子\n\n*X* 是向量：\n\n```\n1 2 3 >= 2;\n// output\n[0,1,1]\n\n1 2 3 >= 0 2 4;\n// output\n[1,1,0]\n\n2:3>=1:6;\n// output\n1 : 0\n\nm1=1..6$2:3;\nm1;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1  | 3  | 5  |\n| 2  | 4  | 6  |\n\n```\nm1 ge 4;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 0  | 0  | 1  |\n| 0  | 1  | 1  |\n\n```\nm2=6..1$2:3;\nm2;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 6  | 4  | 2  |\n| 5  | 3  | 1  |\n\n```\nm1>=m2;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 0  | 0  | 1  |\n| 0  | 1  | 1  |\n\n集合操作：如果 *X*>=*Y*，则 *Y* 是 *X* 的子集。\n\n```\nx=set(4 6);\nx;\n// output\nset(6,4)\ny=set(8 9 4 6);\ny;\n// output\nset(6,4,9,8)\n\ny>=x;\n// output\n1\n\nx>=y;\n// output\n0\n\nx>=x;\n// output\n1\n// x 是 x 的子集\n```\n"
    },
    "gema": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/gema.html",
        "signatures": [
            {
                "full": "gema(X, window, alpha)",
                "name": "gema",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "alpha",
                        "name": "alpha"
                    }
                ]
            }
        ],
        "markdown": "### [gema](https://docs.dolphindb.cn/zh/funcs/g/gema.html)\n\n\n\n#### 语法\n\ngema(X, window, alpha)\n\nTA-lib 系列函数参数说明和窗口计算规则请参考: [TA-lib 系列](https://docs.dolphindb.cn/zh/funcs/themes/TAlib.html)\n\n#### 详情\n\n在给定长度（以元素个数衡量）的滑动窗口内，计算 *X* 的指数移动平均（Exponential Moving Average），该函数是 [ema](https://docs.dolphindb.cn/zh/funcs/e/ema.html) 的扩展。\n\n与 [ema](https://docs.dolphindb.cn/zh/funcs/e/ema.html) 相比，该函数引入了计算系数 *alpha*，其计算公式为：\n\n![gema](https://docs.dolphindb.cn/zh/images/gema.png)\n\n其中：![gemak](https://docs.dolphindb.cn/zh/images/gema_k.png)为第 k 个指数移动平均值，alpha 为计算系数，![xk](https://docs.dolphindb.cn/zh/images/xk.png)为向量![x](https://docs.dolphindb.cn/zh/images/x.png)中第 k 个元素。\n\n#### 参数\n\n**alpha** 是一个0-1之间的浮点数（不包含0, 1），表示计算系数。\n\n#### 返回值\n\nDOUBLE 类型，形式同 *X*。\n\n#### 例子\n\n```\nx=12.1 12.2 12.6 12.8 11.9 11.6 11.2\ngema(x,3,0.5);\n// output\n[,,12.299999999999998,12.55,12.225000000000001,11.912500000000001,11.55625]\n\nx=matrix(12.1 12.2 12.6 12.8 11.9 11.6 11.2, 14 15 18 19 21 12 10)\ngema(x,3,0.1);\n```\n\n| col1    | col2    |\n| ------- | ------- |\n|         |         |\n|         |         |\n| 12.3    | 15.6667 |\n| 12.35   | 16      |\n| 12.305  | 16.5    |\n| 12.2345 | 16.05   |\n| 12.131  | 15.445  |\n\n相关函数：[ema](https://docs.dolphindb.cn/zh/funcs/e/ema.html), [wilder](https://docs.dolphindb.cn/zh/funcs/w/wilder.html), [tema](https://docs.dolphindb.cn/zh/funcs/t/tema.html)\n"
    },
    "generateMachineFingerprint": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/generateMachineFingerprint.html",
        "signatures": [
            {
                "full": "generateMachineFingerprint(outputPath)",
                "name": "generateMachineFingerprint",
                "parameters": [
                    {
                        "full": "outputPath",
                        "name": "outputPath"
                    }
                ]
            }
        ],
        "markdown": "### [generateMachineFingerprint](https://docs.dolphindb.cn/zh/funcs/g/generateMachineFingerprint.html)\n\n\n\n#### 语法\n\ngenerateMachineFingerprint(outputPath)\n\n#### 参数\n\n**outputPath** 是字符串，表示存放机器指纹的目录。\n\n#### 详情\n\n生成机器指纹，用于 license 验证。该命令必须要用户登录后才能执行。Windows 操作系统下执行该函数需要管理员权限。\n\n#### 例子\n\n```\ngenerateMachineFingerprint(\"/home/DolphinDB\")\n```\n"
    },
    "generateUserTicket": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/generateuserticket.html",
        "signatures": [
            {
                "full": "generateUserTicket(userName, expire)",
                "name": "generateUserTicket",
                "parameters": [
                    {
                        "full": "userName",
                        "name": "userName"
                    },
                    {
                        "full": "expire",
                        "name": "expire"
                    }
                ]
            }
        ],
        "markdown": "### [generateUserTicket](https://docs.dolphindb.cn/zh/funcs/g/generateuserticket.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\ngenerateUserTicket(userName, expire)\n\n#### 详情\n\n管理员用户可使用此函数 为指定用户生成动态登录口令，并可设置口令过期时间。用户可使用该口令，通过`authenticateByTicket(ticket)`进行免密登录。\n\n#### 参数\n\n**userName**是一个 STRING 标量，表示要生成登录口令的用户名。\n\n**expire** 是一个 DATETIME 标量，表示登录口令的过期时间。\n\n#### 返回值\n\n字符串标量。\n\n#### 例子\n\n```\nlogin(\"admin\", \"123456\")\ncreateUser(\"user1\", \"123456\")\ntik = generateUserTicket(\"user1\", 2030.12.31T12:00:00)\nauthenticateByTicket(tik)\n//查看当前用户\ngetCurrentSessionAndUser() \n// output: (1659657455,\"user1\",\"192.168.1.177\",57958)\n```\n"
    },
    "genericStateIterate": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/genericStateIterate.html",
        "signatures": [
            {
                "full": "genericStateIterate(X, initial, window, func)",
                "name": "genericStateIterate",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "initial",
                        "name": "initial"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "func",
                        "name": "func"
                    }
                ]
            }
        ],
        "markdown": "### [genericStateIterate](https://docs.dolphindb.cn/zh/funcs/g/genericStateIterate.html)\n\n\n\n#### 语法\n\ngenericStateIterate(X, initial, window, func)\n\n#### 详情\n\n该函数是响应式状态引擎中的函数，基于以元素个数衡量的窗口进行迭代计算。\n\n假设 *X* 指定为 \\[X1, X2, ..., Xn]，该函数计算结果对应输出表中的列为 factor，初始化字段为 initial，*window* 为 w，迭代函数为 func。\n\n对于输入的第 k 条记录（k = 1, 2 …），其计算逻辑为：\n\n* 当 w = 0 时：\n\n  * k = 1 时：factor\\[0] = func(initial\\[0]，, X1\\[0], X2\\[0], … , Xn\\[0])\n\n  * k > 1 时：factor\\[k-1] = func(factor\\[(k-2)], X1\\[k-1], X2\\[k-1], … , Xn\\[k-1])\n\n* 当 w >0 时：\n\n  * k <= w 时：factor\\[k-1] = initial\\[k-1]\n  * k > w 时：factor\\[k-1] = func(factor\\[(k-1-w):k-1], X1\\[k-1], X2\\[k-1], … , Xn\\[k-1])\n\n注意：数据对用于索引时，不包含右边界的值，即 (k-1-w):k-1 的范围是 \\[k-1-w, k-1)。\n\n#### 参数\n\n**X** 表中的字段或对表字段其应用向量函数的计算结果。通过元组方式传入多个列字段。传入 \\[] 表示不指定该参数。\n\n**initial** 表中的字段或对表字段应用向量函数的计算结果。其作用是对输出表的第1\\~*window* 个计算结果进行填充。\n\n**window**非负整数，表示窗口的长度（以元素个数衡量）。\n\n**func** 用户自定义的无状态函数，其返回值必须是标量，以部分应用的方式接收参数。当 *window* > 0 时，其第一个参数为当前记录向前取 *window* 个计算结果组成的向量；当 *window* = 0 时，其第一个参数为当前记录向前取1个计算结果。其后参数依次为 *X* 指定的列。\n\n#### 例子\n\n```\n// define a function\ndef myfunc(x, w){ \nre = sum(x*w)\nreturn re\n}\n\ndateTime = 2021.09.09T09:30:00.000 2021.09.09T09:31:00.000 2021.09.09T09:32:00.000 2021.09.09T09:33:00.000 2021.09.09T09:34:00.000\nsecurityID = `600021`600021`600021`600021`600021\nvolume = 310 280 300 290 240\nprice = 1.5 1.6 1.7 1.6 1.5\nt = table(1:0, `dateTime`securityID`volume`price, [TIMESTAMP, SYMBOL, INT, DOUBLE])\ntableInsert(t, dateTime, securityID, volume, price)\noutput = table(100:0, `securityID`dateTime`factor1, [SYMBOL, TIMESTAMP, DOUBLE])\n\nengine = createReactiveStateEngine(name=\"test\", metrics=[<dateTime>, <genericStateIterate(volume,price,3,myfunc{,})>], dummyTable=t, outputTable=output, keyColumn=`SecurityID, keepOrder=true)\nengine.append!(t)\ndropAggregator(`test)\n```\n\n| securityID | dateTime                | factor1 |\n| ---------- | ----------------------- | ------- |\n| 600021     | 2021.09.09T09:30:00.000 | 1.5     |\n| 600021     | 2021.09.09T09:31:00.000 | 1.6     |\n| 600021     | 2021.09.09T09:32:00.000 | 1.7     |\n| 600021     | 2021.09.09T09:33:00.000 | 1,392   |\n| 600021     | 2021.09.09T09:34:00.000 | 334,872 |\n\n上例计算过程如下：\n\n* 由于窗口为 3，因此对于前 3 条数据，以 price 的值作为 factor1 的输出；\n\n* 第 4 条数据到来时，历史窗口的数据为 \\[1.5, 1.6, 1.7]，当前 volume 的值为 290，因此调用自定义函数 myfunc(\\[1.5, 1.6, 1.7], 290) = 1392；\n\n* 第 5 条数据到来时，历史窗口的数据为 \\[1.6, 1.7, 1392]，当前 volume 的值为 240，因此调用自定义函数 myfunc(\\[1.6, 1.7, 1392], 240) = 334872；\n\n* 若之后继续有数据注入，其计算过程以此类推。\n\n相关函数：[genericTStateIterate](https://docs.dolphindb.cn/zh/funcs/g/genericTStateIterate.html)\n"
    },
    "genericTStateIterate": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/genericTStateIterate.html",
        "signatures": [
            {
                "full": "genericTStateIterate(T, X, initial, window, func, [leftClosed = false])",
                "name": "genericTStateIterate",
                "parameters": [
                    {
                        "full": "T",
                        "name": "T"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "initial",
                        "name": "initial"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "[leftClosed = false]",
                        "name": "[leftClosed = false]"
                    }
                ]
            }
        ],
        "markdown": "### [genericTStateIterate](https://docs.dolphindb.cn/zh/funcs/g/genericTStateIterate.html)\n\n\n\n#### 语法\n\ngenericTStateIterate(T, X, initial, window, func, \\[leftClosed = false])\n\n#### 详情\n\n该函数是响应式状态引擎中的函数，基于以时间衡量的窗口进行迭代计算。\n\n假设时间列为 *T*，*X* 指定为 \\[X1, X2, ..., Xn]，该函数计算结果对应输出表中的列为 factor，初始化字段为 *initial*，*window* 为 w，迭代函数为 func。\n\n以 Tk 表示第 k 条数据的时间戳，对于第 k 条记录(k = 1, 2 ...)，其计算逻辑为：\n\n* Tk ∈ \\[T1, T1+w)：factor\\[k] = initial\\[k]\n\n* 其他情况下，第 k+1 条记录对应的窗口为 (Tk-w, Tk] (leftClosed=false) / \\[Tk-w, Tk] (leftClosed=true)：factor\\[k] = func(subFactor, X1\\[k], X2\\[k], ... , Xn\\[k])，其中 subFactor 为当前窗口范围内 factor 的值。\n\n**Note:**\n\n数据对用于索引时，不包含右边界的值，即 (k-w):k 的范围是 \\[k-w, k)。\n\n#### 参数\n\n**T** 非严格递增的时间类型或整型的向量，且不能包含 NULL 值。注意，时间乱序的数据在计算中会被直接丢弃。\n\n**X** 表中的字段或对其应用向量函数的计算结果。若不指定，需要置为\\[]；若需要输入多个列变量，需要用元组表示。\n\n**initial** 用于初始化的列字段，作为初始化窗口内元素的输出，初始化窗口为 \\[t0, t0 + *window*)（t0 为第一条数据的时间戳，以时间衡量窗口）。*initial* 可以是输入表中的字段或对其应用向量函数的计算结果。\n\n**window** 正整型或 DURATION 标量，表示初始化窗口和历史窗口的长度。当 *window* 为整数时，其单位与 T 一致。\n\n**func** 无状态函数，为用户自定义函数，其返回值必须是标量。以部分应用的形式传入。*func* 参数个数为 1（历史窗口内的数据）+ *X* 指定的列数，第一个参数对应历史窗口的元素值，之后的参数依次对应 X *指定列的元素值*。除前述参数外，若 *func* 包含其他固定的常量参数，则需以部分应用的形式指定。\n\n**leftClosed** 布尔值，表示历史窗口是否包含左边界的数据，默认为 false。\n\n#### 例子\n\n指定 *leftClosed*=false：\n\n```\n// define a function\ndef myfunc(x, w){ \n     re = sum(x*w)\n     return re\n    }\n\ndateTime = 2021.09.09T09:28:00.000 2021.09.09T09:28:30.000 2021.09.09T09:30:00.000 2021.09.09T09:31:00.000 2021.09.09T09:32:00.000\nsecurityID = `600021`600021`600021`600021`600021\nvolume = 310 280 300 290 240\nprice = 1.5 1.6 1.7 1.6 1.5\nt = table(1:0, `dateTime`securityID`volume`price, [TIMESTAMP, SYMBOL, INT, DOUBLE])\ntableInsert(t, dateTime, securityID, volume, price)\noutput = table(100:0, `securityID`dateTime`factor1, [SYMBOL, TIMESTAMP, DOUBLE])\n\nengine = createReactiveStateEngine(name=\"test\", metrics=[<dateTime>, <genericTStateIterate(dateTime,volume,price,2m,myfunc{,})>], dummyTable=t, outputTable=output, keyColumn=`SecurityID, keepOrder=true)\nengine.append!(t)\ndropAggregator(`test)\n```\n\n| securityID | dateTime                | factor1    |\n| ---------- | ----------------------- | ---------- |\n| 600021     | 2021.09.09T09:28:00.000 | 1.5        |\n| 600021     | 2021.09.09T09:28:30.000 | 1.6        |\n| 600021     | 2021.09.09T09:30:00.000 | 930        |\n| 600021     | 2021.09.09T09:31:00.000 | 270,164    |\n| 600021     | 2021.09.09T09:32:00.000 | 65,062,560 |\n\n上例计算过程如下：\n\n* 由于第 1 条数据的时间戳为 09:28:00.000 窗口为 2 min，因此初始化窗口为 \\[2021.09.09T09:28:00.000, 2021.09.09T09:30:00.000)，前 2 条数据均属于该窗口，因此直接输出 price 的值。\n\n* 第 3 条记录对应的窗口为 (2021.09.09T09:26:30.000, 2021.09.09T09:28:30.000]，该历史窗口内的元素为 \\[1.5, 1.6]，当前 volume 的值为 300，因此调用自定义函数 myfunc(\\[1.5, 1.6], 300) = 930；\n\n* 同理第 4 条记录对应的窗口为 (2021.09.09T09:28:00.000, 2021.09.09T09:30:00.000]，该历史窗口内的元素为 \\[1.6, 930]，当前 volume 的值为 290，因此调用自定义函数 myfunc(\\[1.6, 930], 290) = 270164；\n\n* 以此类推。\n\n指定 *leftClosed*=true:\n\n```\nengine = createReactiveStateEngine(name=\"test\", metrics=[<dateTime>, <genericTStateIterate(dateTime,volume,price,2m,myfunc{,},true)>], dummyTable=t, outputTable=output, keyColumn=`SecurityID, keepOrder=true)\n```\n\n| securityID | dateTime                | factor1    |\n| ---------- | ----------------------- | ---------- |\n| 600021     | 2021.09.09T09:28:00.000 | 1.5        |\n| 600021     | 2021.09.09T09:28:30.000 | 1.6        |\n| 600021     | 2021.09.09T09:30:00.000 | 930        |\n| 600021     | 2021.09.09T09:31:00.000 | 270,599    |\n| 600021     | 2021.09.09T09:32:00.000 | 65,166,960 |\n\n上例计算过程如下：\n\n* 由于第 1 条数据的时间戳为 09:28:00.000 窗口为 2 min，因此初始化窗口为 \\[2021.09.09T09:28:00.000, 2021.09.09T09:30:00.000)，前 2 条数据均属于该窗口，因此直接以 price 的值作为 factor1 的输出。\n\n* 第 3 条记录对应的窗口为 \\[2021.09.09T09:26:30.000, 2021.09.09T09:28:30.000]，该历史窗口内的元素为 \\[1.5, 1.6]，当前 volume 的值为 300，因此调用自定义函数 myfunc(\\[1.5, 1.6], 300) = 930；\n\n* 同理第 4 条记录对应的窗口为 \\[2021.09.09T09:28:00.000, 2021.09.09T09:30:00.000]，该历史窗口内的元素为 \\[1.5, 1.6, 930]，当前 volume 的值为 290，因此调用自定义函数 myfunc(\\[1.5, 1.6, 930], 290) = 270599；\n\n* 以此类推。\n\n相关函数：[genericStateIterate](https://docs.dolphindb.cn/zh/funcs/g/genericStateIterate.html)\n"
    },
    "genOutputColumnsForOBSnapshotEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/genoutputcolumnsforobsnapshotengine.html",
        "signatures": [
            {
                "full": "genOutputColumnsForOBSnapshotEngine([basic=true], [time=true], [depth], [tradeDetail=true], [orderDetail=true], [withdrawDetail=true], [orderBookDetailDepth=0], [prevDetail=true], [seqDetail=false], [residualDetail=false])",
                "name": "genOutputColumnsForOBSnapshotEngine",
                "parameters": [
                    {
                        "full": "[basic=true]",
                        "name": "basic",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[time=true]",
                        "name": "time",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[depth]",
                        "name": "depth",
                        "optional": true
                    },
                    {
                        "full": "[tradeDetail=true]",
                        "name": "tradeDetail",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[orderDetail=true]",
                        "name": "orderDetail",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[withdrawDetail=true]",
                        "name": "withdrawDetail",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[orderBookDetailDepth=0]",
                        "name": "orderBookDetailDepth",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[prevDetail=true]",
                        "name": "prevDetail",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[seqDetail=false]",
                        "name": "seqDetail",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[residualDetail=false]",
                        "name": "residualDetail",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [genOutputColumnsForOBSnapshotEngine](https://docs.dolphindb.cn/zh/funcs/g/genoutputcolumnsforobsnapshotengine.html)\n\n#### 语法\n\ngenOutputColumnsForOBSnapshotEngine(\\[basic=true], \\[time=true], \\[depth], \\[tradeDetail=true], \\[orderDetail=true], \\[withdrawDetail=true], \\[orderBookDetailDepth=0], \\[prevDetail=true], \\[seqDetail=false], \\[residualDetail=false])\n\n#### 详情\n\n该函数用于配合订单簿引擎，简化订单簿引擎的创建过程。\n\n#### 参数\n\n以下参数都用于指定订单簿需要包含的字段，每个参数名都表示一个字段类别，每个类别中包含多个字段。通过 `createOrderBookSnapshotEngine` 函数页的[附录](https://docs.dolphindb.cn/zh/funcs/c/createorderbooksnapshotengine.md#)，查看字段类别及其包含的字段。\n\n**basic** 布尔值。表示是否输出类别 basic 中的字段。默认为 true。\n\n**time** 布尔值。表示是否输出类别 time 中的字段。默认为 true。\n\n**depth** 元组。长度为 2，默认为 (10, true)。\n\n* 第一个元素为整型标量，范围是\\[0, 100]，表示报价/询价的价格和数量的档位。若为 0 则不输出 depth 中的字段；\n\n* 第二个元素为布尔值，决定多档报价/询价的价格和数量的输出形式。若为 false，表示以多列的形式输出；若为 true，以数组向量的形式输出。\n\n**tradeDetail** 布尔值，表示是否输出 tradeDetail 中的字段（不包含tradeBuyOrderTypeList 和 tradeSellOrderTypeList）。默认为 true。\n\n**orderDetail** 布尔值，表示是否输出 orderDetail 中的字段。默认为 true。\n\n**withdrawDetail** 布尔值，表示是否输出 withdrawDetail 中的字段（不包含 withdrawBuyOrderNoList 和withdrawSellOrderNoList）。默认为 true。\n\n**orderbookDetailDepth** 整型标量，用于指定输出订单簿明细的档位（orderbookDetail 类别） \\*。\\*默认值为0，表示不输出。该参数的值必须和 `createOrderBookSnapshotEngine` 的 *orderbookDetailDepth* 参数的值保持一致。\n\n**prevDetail** 布尔值，表示是否输出 prevDetail 中的字段。默认为 true。\n\n**seqDetail** 布尔值，表示是否输出 seqDetail 中的字段。默认为 false。\n\n**residualDetail** 布尔值，表示是否输出剩余委托明细（residualDetail）中的字段（不包含 ResidualBidOrderNoList 和 ResidualAskOrderNoList）。默认为 false。\n\n#### 返回值\n\n返回一个元组，包含2个元素。\n\n* 第一个元素是字符串向量，表示订单簿需要包含的字段，可用于`createOrderBookSnapshotEngine` 的 *outputColMap* 参数。\n\n* 第二个元素是空的内存表，表示订单簿需要具备的表结构，可用于`createOrderBookSnapshotEngine` 的 *outputTable* 参数。\n\n#### 例子\n\n创建订单簿引擎时，需要通过 *outputColMap* 参数指定需要输出的字段；通过 *outputTable* 参数指定输出表。`genOutputColumnsForOBSnapshotEngine`可以简化这两个参数的定义流程。在创建订单簿引擎前，先进行如下操作：\n\n首先，通过 `genOutputColumnsForOBSnapshotEngine` 函数设置需要输出的字段；\n\n然后，指定 *outputColMap* 为 `genOutputColumnsForOBSnapshotEngine` 函数返回值的第一个元素；指定 *outputTable* 为返回值的第二个元素。\n\n运行代码前，先下载 [../data/orderbookDemoInput.zip](https://docs.dolphindb.cn/zh/funcs/data/orderbookDemoInput.zip) 文件。\n\n```\ntry { dropStreamEngine(\"demo\") } catch(ex) { print(ex) }\n\nfilePath = \"./orderbookDemoInput.csv\"\n\n// 创建引擎参数 dummyTable，即指定输入表的表结构\ncolNames = `SecurityID`Date`Time`SecurityIDSource`SecurityType`Index`SourceType`Type`Price`Qty`BSFlag`BuyNo`SellNo`ApplSeqNum`ChannelNo\ncolTypes = [SYMBOL, DATE, TIME, SYMBOL, SYMBOL, LONG, INT, INT, LONG, LONG, INT, LONG, LONG, LONG, INT]\ndummyOrderStream = table(1:0, colNames, colTypes)\n\n// 创建引擎参数 inputColMap，即指定输入表各字段的含义\ninputColMap = dict(`codeColumn`timeColumn`typeColumn`priceColumn`qtyColumn`buyOrderColumn`sellOrderColumn`sideColumn`msgTypeColumn`seqColumn, `SecurityID`Time`Type`Price`Qty`BuyNo`SellNo`BSFlag`SourceType`ApplSeqNum)\n\n// 创建引擎参数 prevClose，即昨日收盘价，prevClose 不影响最终的输出结果中除昨日收盘价以外的其他字段\nprevClose = dict(`000587.SZ`002694.SZ`002822.SZ`000683.SZ`301063.SZ`300459.SZ`300057.SZ`300593.SZ`301035.SZ`300765.SZ, [1.66, 6.56, 6.10, 8.47, 38.10, 5.34, 9.14, 48.81, 60.04, 16.52])\n\n//创建使用 outputColMap 和 outputTableSch 接收 genOutputColumnsForOBSnapshotEngine 的返回值。它们分别用于确定 outputColMap 和 outputTable\noutputColMap, outputTableSch = genOutputColumnsForOBSnapshotEngine(basic=true, time=false, depth=(10, true), tradeDetail=true, orderDetail=false, withdrawDetail=false, orderBookDetailDepth=0, prevDetail=false)\nshare(outputTableSch, `sharedOutputTable)\ngo\n\nengine = createOrderBookSnapshotEngine(name=\"demo\", exchange=\"XSHE\", orderbookDepth=10, intervalInMilli = 1000, date=2022.01.10, startTime=09:15:00.000, prevClose=prevClose, dummyTable=dummyOrderStream, outputTable=outputTableSch, inputColMap=inputColMap, outputColMap=outputColMap, orderBookAsArray=true)\n\n// 10支股票的逐笔数据批量注入快照合成引擎\nengine.append!(select * from loadText(filePath) order by Time)\nselect top 10 * from sharedOutputTable where code=\"300593.SZ\", timestamp between 2022.01.10T13:15:01.000 and 2022.01.10T13:15:10.000\n```\n\n部分结果展示如下：\n\n![](https://docs.dolphindb.cn/zh/images/orderBook1.png)\n\n"
    },
    "genShortGenomeSeq": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/genShortGenomeSeq.html",
        "signatures": [
            {
                "full": "genShortGenomeSeq(X, window)",
                "name": "genShortGenomeSeq",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    }
                ]
            }
        ],
        "markdown": "### [genShortGenomeSeq](https://docs.dolphindb.cn/zh/funcs/g/genShortGenomeSeq.html)\n\n\n\n#### 语法\n\ngenShortGenomeSeq(X, window)\n\n别名：genSGS\n\n#### 详情\n\n对给定长度（以字符个数衡量）的滑动窗口内的 DNA 序列进行编码，不忽略空值。\n\n**Note:**\n\n* 该函数使用向后的窗口，即从当前元素开始向后选取元素。\n\n* 若 *window* 大于 *X* 中所有字符的个数，则返回一个空的整型向量。\n\n#### 参数\n\n**X** STRING 类型标量或 CHAR 类型的向量。\n\n**window** 正整数，范围为\\[2,28]。\n\n#### 返回值\n\n返回一个整型向量，其长度与 *X* 包含的字符个数相同。具体如下：\n\n| window 范围 | 返回值类型                     |\n| --------- | ------------------------- |\n| \\[2,4]    | 短整型向量（FAST SHORT VECTOR）  |\n| \\[5,12]   | 整型向量（FAST INT VECTOR）     |\n| \\[13,28]  | 返回长整型向量（FAST LONG VECTOR） |\n\n#### 例子\n\n```\ngenShortGenomeSeq(\"NNNNNNNNTCGGGGCAT\",3)\n// output\n[,,,,,,,,795,815,831,831,830,824,801,,]\n\ngenShortGenomeSeq(\"TCGGGGCATNGCCCG\",4)\n// output\n[1135,1215,1279,1278,1272,1249,,,,,1258,1195,,,]\n\ngenShortGenomeSeq(\"GCCCGATNNNNN\",6)\n// output\n[396972,395953,,,,,,,,,,]\ngenShortGenomeSeq(\"TCGATCGTCGATCGTCGATCGTCGATCGG\",5)\n// output\n[328113,328390,328475,327789,328118,328411,328556,328113,328390,328475,327789,328118,328411,328556,328113,328390,328475,327789,328118,328411,328556,328113,328390,328475,327791,,,,]\ngenShortGenomeSeq(\"ACTT\",8)\n// output\n[,,,]\n```\n\n相关函数：[encodeShortGenomeSeq](https://docs.dolphindb.cn/zh/funcs/e/encodeShortGenomeSeq.html), [decodeShortGenomeSeq](https://docs.dolphindb.cn/zh/funcs/d/decodeShortGenomeSeq.html)\n"
    },
    "geoWithin": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/geowithin.html",
        "signatures": [
            {
                "full": "geoWithin(X, polygonVertices, [containBoundary=true])",
                "name": "geoWithin",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "polygonVertices",
                        "name": "polygonVertices"
                    },
                    {
                        "full": "[containBoundary=true]",
                        "name": "containBoundary",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [geoWithin](https://docs.dolphindb.cn/zh/funcs/g/geowithin.html)\n\n\n\n#### 语法\n\ngeoWithin(X, polygonVertices, \\[containBoundary=true])\n\n#### 详情\n\n判断点 *X* 是否在多边形 *polygonVertices*中。\n\n#### 参数\n\n**X**是一个 POINT 类型的标量或向量，表示一个或多个点。\n\n**polygonVertices**是一个 POINT 类型向量，表示一个多边形。\n\n**containBoundary**是一个布尔标量，表示是否包含边界上的点，默认值是true。\n\n#### 返回值\n\n布尔标量或向量。\n\n#### 例子\n\n```\npoint1 = point(1,1)\npoint2 = point(2,3)\npoint3 = point(2,1)\npolygon = [point(0,0),point(0,2),point(2,2),point(2,0)]\ngeoWithin([point1,point2],polygon)\n// output:[true,false,true]\ngeoWithin([point1,point2,point3],polygon,false)\n//output:[true,false,false]\n```\n"
    },
    "getAclAuditLog": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getaclauditlog.html",
        "signatures": [
            {
                "full": "getAclAuditLog([userId],[startTime],[endTime],[opType])",
                "name": "getAclAuditLog",
                "parameters": [
                    {
                        "full": "[userId]",
                        "name": "userId",
                        "optional": true
                    },
                    {
                        "full": "[startTime]",
                        "name": "startTime",
                        "optional": true
                    },
                    {
                        "full": "[endTime]",
                        "name": "endTime",
                        "optional": true
                    },
                    {
                        "full": "[opType]",
                        "name": "opType",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [getAclAuditLog](https://docs.dolphindb.cn/zh/funcs/g/getaclauditlog.html)\n\n#### 语法\n\ngetAclAuditLog(\\[userId],\\[startTime],\\[endTime],\\[opType])\n\n#### 详情\n\n查询用户 *userId* 在*startTime* 到 *endTime* 这段时间内完成的，类型为 *opType* 的 ACL 操作记录。\n\n#### 参数\n\n**userId** 可选参数，字符串标量或向量，表示要查询的用户。默认为 NULL，表示查询所有用户的 ACL 操作日志。\n\n**startTime** 可选参数，整型标量或者时间标量，表示查询的起始时间点。时间标量支持 DATE, MONTH, DATETIME, TIMESTAMP, DATEHOUR, NANOTIMESTAMP 类型。默认值为 1970.01.01，表示 1970.01.01零点。\n\n**endTime** 可选参数，整型标量或者时间标量，表示查询的结束时间点。时间标量支持DATE, MONTH, DATETIME, TIMESTAMP, DATEHOUR, NANOTIMESTAMP 类型。默认值为空，表示结束时间为当前时间。*endTime* 必须大于 *startTime*。\n\n**opType** 可选参数，字符串标量或向量，表示查询的操作类型。默认为 NULL，表示查询所有 ACL 操作类型。关于 *opType* 的详细描述参见详情。\n\n#### 返回值\n\n一张表，包含以下字段：\n\n* userId：表示执行操作的用户名称。\n* time：表示操作发生时间。\n* opType：表示操作类型。\n* opDetail：操作细节说明。\n* remoteIp：提交该操作的客户端 IP。\n* remotePort：提交该操作的客户端端口。\n* nodeAlias：接收该操作的节点别名。\n\n*opType* 的所有取值及其对应的 opDetail 示例如下：\n\n| opType                  | opDetail                                           | Description                                                           |\n| ----------------------- | -------------------------------------------------- | --------------------------------------------------------------------- |\n| login                   | login userId=xxx encrypted=true/false              | 用户登录                                                                  |\n| logout                  | logout userId=xxx sessionOnly=true/false           | 用户登出                                                                  |\n| createUser              | userId=xxx groupId=xxx isAdmin=true/false          | 创建用户                                                                  |\n| createGroup             | groupId=xxx userIds=\\[xxx,xxx,…]                   | 创建用户组                                                                 |\n| resetPwd                | userId=xxx                                         | 重置用户密码                                                                |\n| changePwd               |                                                    | 修改用户密码                                                                |\n| deleteUser              | userId=xxx                                         | 删除用户                                                                  |\n| deleteGroup             | groupId=xxx                                        | 删除用户组                                                                 |\n| addGroupMember          | userIds=\\[xxx,xxx,…] groupIds=\\[xxx,xxx,…]         | 把用户添加到群组                                                              |\n| deleteGroupMember       | userIds=\\[xxx,xxx,…] groupIds=\\[xxx,xxx,…]         | 删除用户组的成员                                                              |\n| grant                   | userOrGroupId=xxx accessType=xxx objs=\\[xxx,xxx,…] | 授予权限                                                                  |\n| deny                    | userOrGroupId=xxx accessType=xxx objs=\\[xxx,xxx,…] | 拒绝权限                                                                  |\n| revokeByDFSOperation    | oldObj=xxx newObjs=\\[xxx,xxx,…]                    | 进行 dropDatabase, dropTable 或 dropColumn! 删除操作时，会自动清除所有用户中与被删除内容相关的权限。 |\n| replaceByDFSOperation   | oldObj=xxx newObjs=\\[xxx,xxx,…]                    | 进行 renameTable 和 replaceColumn! 等修改操作时，会同步更新与被修改内容相关的权限信息             |\n| revoke                  | userOrGroupId=xxx accessType=xxx objs=\\[xxx,xxx,…] | 撤回权限                                                                  |\n| createCatalog           | catalog=xxx                                        | 创建 catalog                                                            |\n| dropCatalog             | catalog=xxx                                        | 删除 catalog                                                            |\n| renameCatalog           | catalog=xxx new catalog=xxx                        | 重命名 catalog                                                           |\n| renameSchema            | catalog=xxx schema=xxx new schema=xxx              | 重命名 schema                                                            |\n| createSchema            | catalog=xxx dbUrl=xxx schema=xxx                   | 创建 schema                                                             |\n| dropSchema              | catalog=xxx schema=xxx                             | 删除 schema                                                             |\n| tryDropSchemaByDatabase | dbUrl=xxx                                          | 删除数据库时，从 catalog 里删掉 db 对应的 schema                                    |\n| setMaxJobPriority       | maxJobPriority=xxx                                 | 指定提交作业的最高优先级                                                          |\n| setMaxJobParallelism    | maxJobParallelism=xxx                              | 指定提交的作业最多可以同时并行执行的子任务数量                                               |\n| newConnection           |                                                    | 收到新连接                                                                 |\n| closeConnection         |                                                    | 关闭连接                                                                  |\n| saveClusterNodes        |                                                    | 修改 nodes.cfg                                                          |\n| saveClusterNodesConfigs |                                                    | 修改 cluster.cfg                                                        |\n| saveControllerConfigs   |                                                    | 修改 controller.cfg                                                     |\n| loadClusterNodesConfigs |                                                    | 读取 nodes.cfg                                                          |\n| loadControllerConfigs   |                                                    | 读取 controller.cfg                                                     |\n\n#### 例子\n\n首先配置文件设置 *enableAuditLog*=true。然后通过 `getAclAuditLog` 查询所有 ACL 操作。\n\n```\nlogin(\"admin\",\"123456\")\ncreateUser(\"user1\",\"abcdec\")\ngrant(\"user1\",TABLE_READ,\"*\")\nlogout()\nlogin(\"admin\",\"123456\")\ngetAclAuditLog()\n```\n\n返回：\n\n| userId | time                          | opType        | opDetail                                            | remoteIp      | remotePort | nodeAlias |\n| ------ | ----------------------------- | ------------- | --------------------------------------------------- | ------------- | ---------- | --------- |\n| guest  | 2025.01.02 14:26:52.738224592 | newConnection |                                                     | 192.168.0.130 | 55,428     | datanode1 |\n| guest  | 2025.01.02 14:26:53.049518446 | login         | login userId=admin encrypted=false                  | 192.168.0.130 | 55,428     | datanode1 |\n| admin  | 2025.01.02 14:26:53.059963095 | createUser    | userId=user1 groupIds=\\[] isAdmin=false             | 192.168.0.130 | 55,428     | datanode1 |\n| admin  | 2025.01.02 14:26:53.060387348 | grant         | userOrGroupId=user1 accessType=TABLE\\_READ objs=\\[] | 192.168.0.130 | 55,428     | datanode1 |\n| guest  | 2025.01.02 14:26:53.060426785 | logout        | logout userId=admin sessionOnly=true                | 192.168.0.130 | 55,428     | datanode1 |\n| guest  | 2025.01.02 14:26:53.060576365 | login         | login userId=admin encrypted=false                  | 192.168.0.130 | 55,428     | datanode1 |\n| guest  | 2025.01.08 09:46:49.710254224 | newConnection |                                                     | 192.168.0.130 | 41,746     | datanode1 |\n| guest  | 2025.01.08 09:46:52.124830142 | login         | login userId=admin encrypted=false                  | 192.168.0.130 | 41,746     | datanode1 |\n| admin  | 2025.01.08 09:46:52.127153771 | createUser    | userId=user1 groupIds=\\[] isAdmin=false             | 192.168.0.130 | 41,746     | datanode1 |\n| admin  | 2025.01.08 09:46:52.127752666 | grant         | userOrGroupId=user1 accessType=TABLE\\_READ objs=\\[] | 192.168.0.130 | 41,746     | datanode1 |\n\n"
    },
    "getActiveMaster": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getActiveMaster.html",
        "signatures": [
            {
                "full": "getActiveMaster()",
                "name": "getActiveMaster",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getActiveMaster](https://docs.dolphindb.cn/zh/funcs/g/getActiveMaster.html)\n\n\n\n#### 语法\n\ngetActiveMaster()\n\n#### 详情\n\n对于普通集群，`getActiveMaster` 函数返回控制节点的别名。\n\n对于包含多个控制节点的集群，`getActiveMaster` 函数返回 Leader 控制节点的别名。\n\n**Note:** 该函数只能在控制节点上执行。\n\n#### 参数\n\n无\n\n#### 返回值\n\n字符串标量。\n\n#### 例子\n\n```\ngetActiveMaster();\n// output\ncontroller1\n```\n"
    },
    "getAggregator": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getAggregator.html",
        "signatures": [
            {
                "full": "getStreamEngine(name)",
                "name": "getStreamEngine",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    }
                ]
            }
        ],
        "markdown": "### [getAggregator](https://docs.dolphindb.cn/zh/funcs/g/getAggregator.html)\n\n是 [getStreamEngine](https://docs.dolphindb.cn/zh/funcs/g/getStreamEngine.html) 的别名。\n\n\n以下是 `getStreamEngine` 函数的文档：\n### [getStreamEngine](https://docs.dolphindb.cn/zh/funcs/g/getStreamEngine.html)\n\n\n\n#### 语法\n\ngetStreamEngine(name)\n\n#### 详情\n\n返回流数据引擎的句柄，可以作为 [subscribeTable](https://docs.dolphindb.cn/zh/funcs/s/subscribeTable.html) 函数的 *handler* 参数。\n\n#### 参数\n\n**name** 是一个字符串，表示流数据引擎的名称。它可以包含字母，数字和下划线，但必须以字母开头。\n\n#### 返回值\n\n一个流数据引擎对象。\n\n#### 例子\n\n```\nshare streamTable(1000:0, `time`sym`qty, [TIMESTAMP, SYMBOL, INT]) as trades\noutputTable = table(10000:0, `time`sym`sumQty, [TIMESTAMP, SYMBOL, INT])\ntradesAggregator = createTimeSeriesEngine(\"StreamAggregatorDemo\",3, 3, <[sum(qty)]>, trades, outputTable, `time, false,`sym, 50)\nsubscribeTable(, \"trades\", \"tradesAggregator\", 0, append!{tradesAggregator}, true)\n\ndef writeData(n){\n   timev = 2018.10.08T01:01:01.001 + timestamp(1..n)\n   symv =take(`A`B, n)\n   qtyv = take(1, n)\n   insert into trades values(timev, symv, qtyv)\n}\n\nwriteData(6);\nh = getStreamEngine(\"StreamAggregatorDemo\")\n```\n"
    },
    "getAggregatorStat": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getAggregatorStat.html",
        "signatures": [
            {
                "full": "getStreamEngineStat()",
                "name": "getStreamEngineStat",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getAggregatorStat](https://docs.dolphindb.cn/zh/funcs/g/getAggregatorStat.html)\n\n是 [getStreamEngineStat](https://docs.dolphindb.cn/zh/funcs/g/getStreamEngineStat.html) 的别名。\n\n\n以下是 `getStreamEngineStat` 函数的文档：\n### [getStreamEngineStat](https://docs.dolphindb.cn/zh/funcs/g/getStreamEngineStat.html)\n\n\n\n#### 语法\n\ngetStreamEngineStat()\n\n别名：getAggregatorStat\n\n#### 详情\n\n查询流数据引擎的状态。\n\n#### 参数\n\n无\n\n#### 返回值\n\n返回一个字典，包含以下表：\n\n* 表 TimeSeriesEngine 返回时间序列引擎的状态。它包含以下列：\n\n| 列名                | 含义                              |\n| ----------------- | ------------------------------- |\n| name              | 时间序列引擎的名称                       |\n| user              | 创建时间序列引擎的用户名                    |\n| status            | 时间序列引擎的状态，\"OK\"表示可用，\"FATAL\"表示不可用 |\n| lastErrMsg        | 最后一条错误信息                        |\n| windowTime        | 窗口的长度                           |\n| step              | 计算的时间间隔                         |\n| useSystemTime     | 时间序列引擎中 useSystemTime 参数值       |\n| garbageSize       | 触发内存清理的阈值                       |\n| numGroups         | 时间序列引擎中的分组数                     |\n| numRows           | 时间序列引擎中的记录行数                    |\n| numMetrics        | 时间序列引擎使用的聚合指标的数量                |\n| metrics           | 时间序列引擎使用的聚合指标的元代码               |\n| memoryUsed        | 时间序列引擎所占用内存量，单位为字节              |\n| snapshotDir       | 保存引擎快照的文件目录                     |\n| snapshotInterval  | 每隔多少条数据保存一次引擎快照                 |\n| snapshotMsgId     | 最后一个 snapshot 的 msgId           |\n| snapshotTimestamp | 引擎快照的时间戳                        |\n\n* 表 CrossSectionalEngine 返回横截面聚合引擎的状态。它包含以下列：\n\n| 列名                 | 含义                               |\n| ------------------ | -------------------------------- |\n| name               | 横截面引擎的名称                         |\n| user               | 创建横截面引擎的用户名                      |\n| status             | 横截面引擎的状态，\"OK\" 表示可用，\"FATAL\" 表示不可用 |\n| lastErrMsg         | 最后一条错误信息                         |\n| numRows            | 横截面引擎中的记录行数                      |\n| numMetrics         | 横截面引擎使用的聚合指标的数量                  |\n| metrics            | 横截面引擎使用的聚合指标的元代码                 |\n| triggeringPattern  | 横截面引擎触发计算的方式                     |\n| triggeringInterval | 横截面引擎触发计算的时间间隔                   |\n| memoryUsed         | 横截面引擎所占用内存量，单位为字节                |\n\n* 表 AnomalyDetectionEngine 返回异常检测引擎的状态。它包含以下列：\n\n| 列名               | 含义                                |\n| ---------------- | --------------------------------- |\n| name             | 异常检测引擎的名称                         |\n| user             | 创建异常检测引擎的用户名                      |\n| status           | 异常检测引擎的状态，\"OK\" 表示可用，\"FATAL\" 表示不可用 |\n| lastErrMsg       | 最后一条错误信息                          |\n| numGroups        | 异常检测引擎中的分组数                       |\n| numRows          | 异常检测引擎中的记录行数                      |\n| numMetrics       | 异常指标的数量                           |\n| metrics          | 异常指标的元代码                          |\n| snapshotDir      | 保存引擎快照的文件目录                       |\n| snapshotInterval | 每隔多少条数据保存一次引擎快照                   |\n| snapshotMsgId    | 最后一个 snapshot 的 msgId             |\n| snapshotTimestam | 引擎快照的时间戳                          |\n| garbageSize      | 触发内存清理的阈值                         |\n| memoryUsed       | 异常检测引擎所占用内存量，单位为字节                |\n\n* 表 ReactiveStreamEngine 返回响应式状态引擎的状态。它包含以下列：\n\n| 列名                | 含义                                 |\n| ----------------- | ---------------------------------- |\n| name              | 响应式状态引擎的名称                         |\n| user              | 创建响应式状态引擎的用户名                      |\n| status            | 响应式状态引擎的状态，\"OK\" 表示可用，\"FATAL\" 表示不可用 |\n| lastErrMsg        | 最后一条错误信息                           |\n| numGroups         | 响应式状态引擎中的分组数                       |\n| numRows           | 响应式状态引擎中的记录行数                      |\n| numMetrics        | 指标的数量                              |\n| memoryInUsed      | 响应式状态引擎所占用内存量，单位为字节                |\n| snapshotDir       | 保存引擎快照的文件目录                        |\n| snapshotInterval  | 每隔多少条数据保存一次引擎快照                    |\n| snapshotMsgId     | 最后一个 snapshot 的 msgId              |\n| snapshotTimestamp | 引擎快照的时间戳                           |\n\n* 表 SessionWindowEngine 返回会话窗口引擎的状态。它包含以下列：\n\n| 列名                | 含义                                |\n| ----------------- | --------------------------------- |\n| name              | 会话窗口引擎的名称                         |\n| user              | 创建会话窗口引擎的用户名                      |\n| status            | 会话窗口引擎的状态，\"OK\" 表示可用，\"FATAL\" 表示不可用 |\n| lastErrMsg        | 最后一条错误信息                          |\n| sessionGap        | 每个会话窗口之间的时间间隔                     |\n| useSystemTime     | 会话窗口聚合引擎计算的触发方式                   |\n| numGroups         | 会话窗口引擎中的分组数                       |\n| numRows           | 会话窗口引擎中的记录行数                      |\n| numMetrics        | 指标的数量                             |\n| Metrics           | 会话窗口聚合引擎使用的聚合指标的元代码               |\n| memoryUsed        | 会话窗口引擎所占用内存量，单位为字节                |\n| snapshotDir       | 会话窗口引擎快照保存的文件目录                   |\n| snapshotInterval  | 每隔多少条数据保存一次引擎快照                   |\n| snapshotMsgId     | 最后一个 snapshot 的 msgId             |\n| snapshotTimestamp | 触发保存快照的时间戳                        |\n\n* 表 DailyTimeSeriesEngine 返回日级时间序列引擎的状态。它包含以下列：\n\n| 列名                | 含义                                  |\n| ----------------- | ----------------------------------- |\n| name              | 日级时间序列引擎的名称                         |\n| user              | 创建日级时间序列引擎的用户名                      |\n| status            | 日级时间序列引擎的状态，\"OK\" 表示可用，\"FATAL\" 表示不可用 |\n| lastErrMsg        | 最后一条错误信息                            |\n| windowTime        | 数据窗口的长度                             |\n| step              | 计算的时间间隔                             |\n| useSystemTime     | 日级时间序列引擎中 useSystemTime 参数值         |\n| garbageSize       | 触发内存清理的阈值                           |\n| numGroups         | 日级时间序列引擎中的分组数                       |\n| numRows           | 日级时间序列引擎中的记录行数                      |\n| numMetrics        | 日级时间序列引擎使用的聚合指标的数量                  |\n| metrics           | 日级时间序列引擎使用的聚合指标的元代码                 |\n| memoryUsed        | 日级时间序列引擎所占用内存量，单位为字节                |\n| snapshotDir       | 日级时间序列聚合引擎快照保存的文件目录                 |\n| snapshotInterval  | 每隔多少条数据保存一次引擎快照                     |\n| snapshotMsgId     | 最后一个 snapshot 的 msgId               |\n| snapshotTimestamp | 触发保存快照的时间戳                          |\n\n* 表 TimeBucketEngine 返回时间序列分组引擎的状态。它包含以下列：\n\n| 列名         | 含义                                |\n| ---------- | --------------------------------- |\n| name       | 时间序列分组引擎的名称                       |\n| user       | 创建时间序列分组引擎的用户名                    |\n| status     | 时间序列分组引擎的状态，\"OK\"表示可用，\"FATAL\"表示不可用 |\n| lastErrMsg | 最后一条错误信息                          |\n| numGroups  | 时间序列分组引擎中的分组数                     |\n| numRows    | 时间序列分组引擎中的记录行数                    |\n| numMetrics | 时间序列分组引擎使用的聚合指标的数量                |\n| metrics    | 时间序列分组引擎使用的聚合指标的元代码               |\n| memoryUsed | 时间序列分组引擎所占用内存量，单位为字节              |\n\n* 表 AsofJoinEngine 返回 asof join 引擎的状态。它包含以下列：\n\n| 列名                | 含义                                      |\n| ----------------- | --------------------------------------- |\n| name              | asof join 引擎的名称                         |\n| user              | 创建 asof join 引擎的用户名                     |\n| status            | asof join 引擎的状态，\"OK\" 表示可用，\"FATAL\" 表示不可用 |\n| lastErrMsg        | 最后一条错误信息                                |\n| useSystemTime     | asof join 引擎中 useSystemTime 参数值         |\n| delayedTime       | asof join 引擎中 delayedTime 参数值           |\n| garbageSize       | 触发内存清理的阈值                               |\n| leftTableNumRows  | asof join 引擎左表中的记录行数                    |\n| rightTableNumRows | asof join 引擎右表中的记录行数                    |\n| numMetrics        | asof join 引擎使用的指标的数量                    |\n| metrics           | asof join 引擎使用的指标的元代码                   |\n| memoryUsed        | asof join 引擎所占用内存量，单位为字节                |\n\n* 表 EqualJoinEngine 返回等值连接引擎的状态。它包含以下列：\n\n| 列名                | 含义                                |\n| ----------------- | --------------------------------- |\n| name              | 等值连接引擎的名称                         |\n| user              | 创建等值连接引擎的用户名                      |\n| status            | 等值连接引擎的状态，\"OK\" 表示可用，\"FATAL\" 表示不可用 |\n| lastErrMsg        | 最后一条错误信息                          |\n| garbageSize       | 触发内存清理的阈值                         |\n| leftTableNumRows  | 等值连接引擎左表中的记录行数                    |\n| rightTableNumRows | 等值连接引擎右表中的记录行数                    |\n| numMetrics        | 等值连接引擎使用的指标的数量                    |\n| metrics           | 等值连接引擎使用的指标的元代码                   |\n| memoryUsed        | 等值连接引擎所占用内存量，单位为字节                |\n\n* 表 WindowJoinEngine 返回 window join 引擎的状态。它包含以下列：\n\n| 列名                | 含义                                        |\n| ----------------- | ----------------------------------------- |\n| name              | window join 引擎的名称                         |\n| user              | 创建 window join 引擎的用户名                     |\n| status            | window join 引擎的状态，\"OK\" 表示可用，\"FATAL\" 表示不可用 |\n| lastErrMsg        | 最后一条错误信息                                  |\n| garbageSize       | 触发内存清理的阈值                                 |\n| leftTableNumRows  | window join 引擎左表中的记录行数                    |\n| rightTableNumRows | window join 引擎右表中的记录行数                    |\n| numMetrics        | window join 引擎使用的指标的数量                    |\n| metrics           | window join 引擎使用的指标的元代码                   |\n| memoryUsed        | window join 引擎所占用内存量，单位为字节                |\n| numGroups         | window join 引擎中的分组个数。                     |\n\n* 表 LookupJoinEngine 返回 lookup join 引擎的状态。它包含以下列：\n\n| 列名                | 含义                                        |\n| ----------------- | ----------------------------------------- |\n| name              | lookup join 引擎的名称                         |\n| user              | 创建 lookup join 引擎的用户名                     |\n| status            | lookup join 引擎的状态，\"OK\" 表示可用，\"FATAL\" 表示不可用 |\n| lastErrMsg        | 最后一条错误信息                                  |\n| leftTableNumRows  | lookup join 引擎左表中的记录行数                    |\n| rightTableNumRows | lookup join 引擎右表中的记录行数                    |\n| numMetrics        | lookup join 引擎使用的指标的数量                    |\n| metrics           | lookup join 引擎使用的指标的元代码                   |\n| memoryUsed        | lookup join 引擎所占用内存量，单位为字节                |\n\n* 表 LeftSemiJoinEngine 返回左半等值连接引擎的状态。它包含以下列：\n\n| 列名                | 含义                                  |\n| ----------------- | ----------------------------------- |\n| name              | 左半等值连接引擎的名称                         |\n| user              | 创建左半等值连接引擎的用户名                      |\n| status            | 左半等值连接引擎的状态，\"OK\" 表示可用，\"FATAL\" 表示不可用 |\n| lastErrMsg        | 最后一条错误信息                            |\n| garbageSize       | 触发内存清理的阈值                           |\n| leftTableNumRows  | 左半等值连接引擎左表中的记录行数                    |\n| rightTableNumRows | 左半等值连接引擎右表中的记录行数                    |\n| numMetrics        | 左半等值连接引擎使用的指标的数量                    |\n| metrics           | 左半等值连接引擎使用的指标的元代码                   |\n| memoryUsed        | 左半等值连接引擎所占用内存量，单位为字节                |\n\n* 表 StreamFilter 返回流数据过滤引擎的状态。它包含以下列：\n\n| 列名         | 含义                                 |\n| ---------- | ---------------------------------- |\n| name       | 流数据过滤引擎的名称                         |\n| user       | 创建流数据过滤引擎的用户名                      |\n| status     | 流数据过滤引擎的状态，\"OK\" 表示可用，\"FATAL\" 表示不可用 |\n| lastErrMsg | 最后一条错误信息                           |\n| numRows    | 流数据过滤引擎中的记录行数                      |\n| filters    | 流数据过滤引擎的过滤条件                       |\n\n* 表 StreamDispatchEngine 返回流数据分发引擎的状态。它包含以下列：\n\n| 列名         | 含义                            |\n| ---------- | ----------------------------- |\n| name       | 分发引擎的名称                       |\n| user       | 创建分发引擎的用户名                    |\n| status     | 分发引擎的状态，”OK”表示可用，”FATAL”表示不可用 |\n| lastErrMsg | 最后一条错误信息                      |\n| numRows    | 分发引擎中的记录行数                    |\n| memoryUsed | 分发引擎所占用内存量，单位为字节              |\n\n* 表 DualOwnershipReactiveStreamEngine 返回 Dual Ownership Reactive State Engine 的状态。它包含以下列：\n\n| 列名                | 含义                                       |\n| ----------------- | ---------------------------------------- |\n| name              | Dual Ownership Reactive State Engine 的名称 |\n| user              | 创建引擎的用户名                                 |\n| status            | 引擎的状态，”OK”表示可用，”FATAL”表示不可用              |\n| lastErrMsg        | 最后一条错误信息                                 |\n| numGroups         | 引擎中的分组数                                  |\n| numRows           | 引擎中的记录行数                                 |\n| numMetrics        | 指标的数量                                    |\n| memoryInUsed      | 引擎所占用内存量，单位为字节                           |\n| snapshotDir       | 保存引擎快照的文件目录                              |\n| snapshotInterval  | 每隔多少条数据保存一次引擎快照                          |\n| snapshotMsgId     | 最后一个 snapshot 的 msgId                    |\n| snapshotTimestamp | 引擎快照的时间戳                                 |\n\n* 表 NarrowReactiveStreamEngine 返回生成窄表的响应式状态引擎的状态。它包含以下列：\n\n| 列名                | 含义                          |\n| ----------------- | --------------------------- |\n| name              | 生成窄表的响应式状态引擎的名称             |\n| user              | 创建引擎的用户名                    |\n| status            | 引擎的状态，”OK”表示可用，”FATAL”表示不可用 |\n| lastErrMsg        | 最后一条错误信息                    |\n| numGroups         | 引擎中的分组数                     |\n| numRows           | 引擎中的记录行数                    |\n| numMetrics        | 指标的数量                       |\n| memoryInUsed      | 引擎所占用内存量，单位为字节              |\n| snapshotDir       | 保存引擎快照的文件目录                 |\n| snapshotInterval  | 每隔多少条数据保存一次引擎快照             |\n| snapshotMsgId     | 最后一个 snapshot 的 msgId       |\n| snapshotTimestamp | 引擎快照的时间戳                    |\n\n* 表 SnapshotJoinEngine 返回快照连接引擎的状态。它包含以下列：\n\n| 列名                | 含义                                |\n| ----------------- | --------------------------------- |\n| name              | 快照连接引擎的名称                         |\n| user              | 创建快照连接引擎的用户名                      |\n| status            | 快照连接引擎的状态，\"OK\" 表示可用，\"FATAL\" 表示不可用 |\n| lastErrMsg        | 最后一条错误信息                          |\n| leftTableNumRows  | 快照连接引擎左表中的记录行数                    |\n| rightTableNumRows | 快照连接引擎右表中的记录行数                    |\n| numMetrics        | 快照连接引擎使用的指标的数量                    |\n| metrics           | 快照连接引擎使用的指标的元代码                   |\n| memoryUsed        | 快照连接引擎所占用内存量，单位为字节                |\n\n#### 例子\n\n```\nshare streamTable(10:0,`time`sym`price`qty,[TIMESTAMP,SYMBOL,DOUBLE,INT]) as trades\noutputTable1 = table(10000:0, `time`sym`sumQty, [TIMESTAMP, SYMBOL, INT])\noutputTable2 = table(1:0, `time`avgPrice`sumqty`Total, [TIMESTAMP,DOUBLE,INT,DOUBLE])\ntradesTsAggregator = createTimeSeriesEngine(name=\"TimeSeriesDemo\", windowSize=3, step=3, metrics=<[sum(qty)]>, dummyTable=trades, outputTable=outputTable1, timeColumn=`time, keyColumn=`sym, garbageSize=50)\ntradesCsAggregator=createCrossSectionalEngine(name=\"CrossSectionalDemo\", metrics=<[avg(price), sum(qty), sum(price*qty)]>, dummyTable=trades, outputTable=outputTable2, keyColumn=`sym, triggeringPattern=`perRow)\nsubscribeTable(tableName=\"trades\", actionName=\"tradesTsAggregator\", offset=0, handler=append!{tradesTsAggregator}, msgAsTable=true)\nsubscribeTable(tableName=\"trades\", actionName=\"tradesCsAggregator\", offset=0, handler=append!{tradesCsAggregator}, msgAsTable=true)\n\ndef writeData(n){\n   timev = 2000.10.08T01:01:01.001 + timestamp(1..n)\n   symv =take(`A`B, n)\n   pricev=take(102.1 33.4 73.6 223,n)\n   qtyv = take(60 74 82 59, n)\n   insert into trades values(timev, symv, pricev,qtyv)\n}\n\nwriteData(4);\n\ngetStreamEngineStat().TimeSeriesEngine;\ngetStreamEngineStat().CrossSectionalEngine;\n```\n"
    },
    "getAllCatalogs": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getAllCatalogs.html",
        "signatures": [
            {
                "full": "getAllCatalogs()",
                "name": "getAllCatalogs",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getAllCatalogs](https://docs.dolphindb.cn/zh/funcs/g/getAllCatalogs.html)\n\n\n\n#### 语法\n\ngetAllCatalogs()\n\n#### 详情\n\n检索当前所有可用的 catalog。\n\n#### 参数\n\n无\n\n#### 返回值\n\n返回一个包含 catalog name 的字符串向量。\n\n#### 例子\n\n```\ngetAllCatalogs()\n//Output:[\"catalog1\", \"catalog2\", \"catalog3\"]\n```\n"
    },
    "getAllClusters": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getAllClusters.html",
        "signatures": [
            {
                "full": "getAllClusters()",
                "name": "getAllClusters",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getAllClusters](https://docs.dolphindb.cn/zh/funcs/g/getAllClusters.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\ngetAllClusters()\n\n#### 详情\n\n获取所有集群名称。只能由管理员在 MoM（Master of Master，管理集群）上执行该函数。\n\n#### 参数\n\n无\n\n#### 返回值\n\n一个表，包含以下字段：\n\n* clusterName：集群名称，字符串。\n* clusterType：集群类型，字符串。“momCluster” 代表多集群的管理集群；”memberCluster” 代表普通集群，即被 MoM 管理的集群。\n* status：集群存活状态，整型。 0 代表异常，1 代表存活。\n\n#### 例子\n\n```\ngetAllClusters()\n```\n\n| clusterName        | clusterType   | status |\n| ------------------ | ------------- | ------ |\n| ShangHai\\_cluster2 | memberCluster | 1      |\n| Hangzhou\\_cluster1 | momCluster    | 1      |\n| ShangHai\\_cluster1 | memberCluster | 1      |\n"
    },
    "getAllDBGranularity": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getAllDBGranularity.html",
        "signatures": [
            {
                "full": "getAllDBGranularity()",
                "name": "getAllDBGranularity",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getAllDBGranularity](https://docs.dolphindb.cn/zh/funcs/g/getAllDBGranularity.html)\n\n\n\n#### 语法\n\ngetAllDBGranularity()\n\n#### 详情\n\n该函数只能在数据节点上执行，用于列出该节点上所有数据库的分区粒度。\n\n#### 参数\n\n无\n\n#### 返回值\n\n返回结果是一个字典，其中：\n\n* key：数据库的名称。\n\n* value：分区粒度，结果为 TABLE 或者 DATABASE。详细说明可参考 [database](https://docs.dolphindb.cn/zh/funcs/d/database.html)的参数*chunkGranularity*。\n\n#### 例子\n\n```\ngetAllDBGranularity()\n\n// output: \n/valuedb->TABLE\n```\n"
    },
    "getAllDBs": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getAllDBs.html",
        "signatures": [
            {
                "full": "getAllDBs()",
                "name": "getAllDBs",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getAllDBs](https://docs.dolphindb.cn/zh/funcs/g/getAllDBs.html)\n\n\n\n#### 语法\n\ngetAllDBs()\n\n#### 详情\n\n获取当前节点上的分布式数据库。\n\n注意：在集群环境下，此函数可能不会返回所有数据库。如需获取整个集群的数据库，请使用 [`getClusterDFSDatabases()`](https://docs.dolphindb.cn/zh/funcs/g/getClusterDFSDatabases.html) 函数，或者使用 `[pnodeRun](../p/pnodeRun.md)(getAllDBs)` 获取集群指定节点上的详细数据库信息。\n\n2.00.09 版本起，\n\n* 当该函数由管理员或拥有 DB\\_MANAGE 权限的用户执行时，返回当前节点上所有分布式数据库；\n\n* 否则，仅返回该用户有 DB\\_OWNER 权限的数据库。\n\n#### 参数\n\n无\n\n#### 返回值\n\n返回的结果是字典，key 是数据库名称，不包含 dfs\\://部分，value 是表名，后面的数字分别是该数据库中表的编号（从1开始）和是否已被删除。\n\n#### 例子\n\n```\ngetAllDBs();\n```\n"
    },
    "getAuditLog": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getauditlog.html",
        "signatures": [
            {
                "full": "getAuditLog([userId], [startTime], [endTime], [opType])",
                "name": "getAuditLog",
                "parameters": [
                    {
                        "full": "[userId]",
                        "name": "userId",
                        "optional": true
                    },
                    {
                        "full": "[startTime]",
                        "name": "startTime",
                        "optional": true
                    },
                    {
                        "full": "[endTime]",
                        "name": "endTime",
                        "optional": true
                    },
                    {
                        "full": "[opType]",
                        "name": "opType",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [getAuditLog](https://docs.dolphindb.cn/zh/funcs/g/getauditlog.html)\n\n#### 语法\n\ngetAuditLog(\\[userId], \\[startTime], \\[endTime], \\[opType])\n\n#### 详情\n\n查询用户 userId 在 startTime 到 endTime 这段时间内完成的，类型为 opType 的 DDL 操作记录。\n\nopType 的所有取值及其对应的 opDetail 示例如下：\n\n|           opType           |                      opDetail                     |                     Description                     |\n| :------------------------: | :-----------------------------------------------: | :-------------------------------------------------: |\n|         CREATE\\_DB         |                                                   |                        创建数据库                        |\n|          DROP\\_DB          |                                                   |                        删除数据库                        |\n|        CREATE\\_TABLE       |                                                   |                        创建维度表                        |\n| CREATE\\_PARTITIONED\\_TABLE |                                                   |                        创建分区表                        |\n|         DROP\\_TABLE        |                                                   |                         删除表                         |\n|       DROP\\_PARTITION      |               deletedPartitions=xxx               |                         删除分区                        |\n|        RENAME\\_TABLE       |       tableName=\\[xxx], newTableName=\\[xxx]       |                        给表重命名                        |\n|         SQL\\_DELETE        |           script=\\[xxx], deletedRows=xxx          |                   SQL 语句 delete 数据                  |\n|         SQL\\_UPDATE        |           script=\\[xxx], updatedRows=xxx          |                   SQL 语句 update 数据                  |\n|           UPSERT           |         insertedRows=xxx, updatedRows=xxx         |                  调用函数 upsert! 更新数据                  |\n|         ADD\\_COLUMN        |           colName=\\[xxx], colType=\\[xxx]          |                         增加列                         |\n|    SET\\_COLUMN\\_COMMENT    |         colName=\\[xxx], colComment=\\[xxx]         |                        给列添加注释                       |\n|       TRUNCATE\\_TABLE      |                                                   |                    删除表所有数据并保留表结构                    |\n|       RENAME\\_COLUMN       |         colName=\\[xxx], newColName=\\[xxx]         |                        给列重命名                        |\n|       REPLACE\\_COLUMN      | colName=\\[xxx], colType=\\[xxx], newColType=\\[xxx] |              调用函数 replaceColumn! 替换表中的列             |\n|        DROP\\_COLUMN        |                 columnName=\\[xxx]                 |                         删除列                         |\n|    ADD\\_RANGE\\_PARTITION   |                                                   |         调用 addRangePartitions 增加 RANGE 类型分区         |\n|    ADD\\_VALUE\\_PARTITION   |                                                   |         调用 addValuePartitions 增加 VALUE 类型分区         |\n|           APPEND           |                  appendedRows=xxx                 | 向 atomic='TRANS’ 的库表或向 atomic='CHUNKS’ 的库里的维度表中写入数据 |\n| APPEND\\_CHUNK\\_GRANULARITY |                  appendedRows=xxx                 |            向 atomic='CHUNKS’ 的库里的分区表中写入数据           |\n\n#### 参数\n\n**userId** 字符串标量或向量，表示要查询的用户。默认为 NULL，表示查询所有用户的 DDL 操作日志。\n\n**startTime** 整数标量或者时间标量，时间标量支持DATE, MONTH, DATETIME, TIMESTAMP, DATEHOUR, NANOTIMESTAMP 类型。表示查询的起始时间点。默认值为 1970.01.01 。\n\n**endTime** 整数标量或者时间标量，时间标量支持DATE, MONTH, DATETIME, TIMESTAMP, DATEHOUR, NANOTIMESTAMP 类型。表示查询的结束时间点。默认值为空，表示结束时间为当前时间。endTime 必须大于 startTime。\n\n**opType** 字符串标量或向量，表示查询的操作类型。默认为 NULL，表示查询所有 DDL 操作类型。\n\n**Note:** startTime 和 endTime 规定的是 DDL 操作结束的时间范围。\n\n#### 返回值\n\n返回一个表，其结构如下：\n\n|     列名     |       类型      |      含义      |\n| :--------: | :-----------: | :----------: |\n|   userId   |     STRING    |   执行操作的用户名称  |\n|  startTime | NANOTIMESTAMP |    事务的开始时间   |\n|   endTime  | NANOTIMESTAMP |    事务的结束时间   |\n|   dbName   |     STRING    |     数据库名     |\n|   tbName   |     STRING    |      表名      |\n|   opType   |     STRING    |     操作类型     |\n|  opDetail  |     STRING    |    操作细节说明    |\n|     tid    |      LONG     |     事务ID     |\n|     cid    |      LONG     |   commit ID  |\n|  remoteIp  |     IPADDR    | 提交该操作的客户端 IP |\n| remotePort |      INT      |  提交该操作的客户端端口 |\n|  nodeAlias |     STRING    |  接收该操作的节点别名  |\n\n#### 例子\n\n```\n// 用户 admin 进行一系列 DDL 操作\nlogin(\"admin\",\"123456\")\nn = 3\nid = rand(`st0001`st0002`st0003`st0004`st0005, n)\nsym = rand(`A`B, n)\ntradeDate = take(2022.01.01..2022.01.10, 3)\nval = 1..n\ndummyTb = table(id, sym,tradeDate, val)\n\ndbPath = \"dfs://auditTest\"\nif(existsDatabase(dbPath)){dropDatabase(dbPath)}\ndb = database(directory=dbPath, partitionType=VALUE, partitionScheme=2022.01.01..2022.01.05, engine='TSDB')\npt = createPartitionedTable(dbHandle=db, table=dummyTb, tableName=\"snap\", partitionColumns=`TradeDate, sortColumns=`id`tradeDate, keepDuplicates=ALL)\npt.append!(dummyTb)\n\nrenameTable(db, `snap, `snap_2)\n\n// 查询 DDL 操作记录\ngetAuditLog()\n```\n\n返回：\n\n| userId | startTime                     | endTime                       | dbName           | tbName | opType                     | opDetail                                   | tid | cid | remoteIp      | nodeAlias |\n| ------ | ----------------------------- | ----------------------------- | ---------------- | ------ | -------------------------- | ------------------------------------------ | --- | --- | ------------- | --------- |\n| admin  | 2024.03.26 14:40:43.659196080 | 2024.03.26 14:40:43.676082419 | dfs\\://auditTest |        | CREATE\\_DB                 |                                            | 1   | 1   | 192.168.0.140 | datanode1 |\n| admin  | 2024.03.26 14:40:43.676154581 | 2024.03.26 14:40:43.687319577 | dfs\\://auditTest | snap   | CREATE\\_PARTITIONED\\_TABLE |                                            | 2   | 2   | 192.168.0.140 | datanode1 |\n| admin  | 2024.03.26 14:40:45.135000207 | 2024.03.26 14:40:45.160530442 | dfs\\://auditTest | snap   | RENAME\\_TABLE              | tableName=\\[snap], newTableName=\\[snap\\_2] | 4   | 4   | 192.168.0.14  | datanode1 |\n\n"
    },
    "getAuthenticatedUsers": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getAuthenticatedUsers.html",
        "signatures": [
            {
                "full": "getAuthenticatedUsers()",
                "name": "getAuthenticatedUsers",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getAuthenticatedUsers](https://docs.dolphindb.cn/zh/funcs/g/getAuthenticatedUsers.html)\n\n\n\n#### 语法\n\ngetAuthenticatedUsers()\n\n#### 详情\n\n获取所有节点已经登录的用户信息。\n\n#### 参数\n\n无\n\n#### 返回值\n\n返回一个字符串向量，包含所有已登录用户的名称。\n\n#### 例子\n\n```\ngetAuthenticatedUsers()\n// output\n[\"admin\",\"a1\",\"a3\",\"a2\",\"a4\"]\n```\n"
    },
    "getAuthenticatedUserTicket": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getauthenticateduserticket.html",
        "signatures": [
            {
                "full": "getAuthenticatedUserTicket([expire])",
                "name": "getAuthenticatedUserTicket",
                "parameters": [
                    {
                        "full": "[expire]",
                        "name": "expire",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [getAuthenticatedUserTicket](https://docs.dolphindb.cn/zh/funcs/g/getauthenticateduserticket.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\ngetAuthenticatedUserTicket(\\[expire])\n\n#### 详情\n\n生成当前已登录用户的动态登录口令，并可设置口令过期时间。用户可使用该口令，通过`authenticateByTicket(ticket)`进行免密登录。\n\n#### 参数\n\n**expire** 是一个 DATETIME 标量，表示登录口令的过期时间。\n\n#### 返回值\n\n字符串标量。\n\n#### 例子\n\n```\nlogin(\"user1\", \"123456\")\ngetAuthenticatedUserTicket(2030.12.31T12:00:00)\n/ output: \nVQEpuZYCbwhPDj6qvuyW+zDwdnQI3HiUhfJOpyUW/J5X5XZmponkmE6n5COI1xUP\nxCVr29VHsNYOV00tGZrFkGKPOJhjWJtSt85ok5s8EVYXwZCgdrYjdharJLBk/e04\nu1oBC0/6nD4WdDM68pCbsZgUqDe94+czqG0M21Sy8PA=\n/\n```\n"
    },
    "getBackupList": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getBackupList.html",
        "signatures": [
            {
                "full": "getBackupList(backupDir, dbPath, tableName)",
                "name": "getBackupList",
                "parameters": [
                    {
                        "full": "backupDir",
                        "name": "backupDir"
                    },
                    {
                        "full": "dbPath",
                        "name": "dbPath"
                    },
                    {
                        "full": "tableName",
                        "name": "tableName"
                    }
                ]
            }
        ],
        "markdown": "### [getBackupList](https://docs.dolphindb.cn/zh/funcs/g/getBackupList.html)\n\n\n\n#### 语法\n\ngetBackupList(backupDir, dbPath, tableName)\n\n#### 详情\n\n查看指定分布式表的所有备份信息。\n\n#### 参数\n\n**backupDir** 是字符串，表示存放备份数据的目录。\n\n**dbPath** 是字符串，表示分布式数据库的名称。\n\n**tableName** 是字符串，表示数据库中表的名称。\n\n#### 返回值\n\n返回一个表，包含指定分布式表的备份信息，每个分区对应表中的一行。其中表中各字段的含义如下：\n\n* chunkID：分区的 ID。\n\n* chunkPath：分区的完整路径。\n\n* cid：版本号。\n\n* rows：分区数据包含的行数。\n\n* updateTime：chunk 最后一次更新的时间戳。\n\n#### 例子\n\n```\nif(existsDatabase(\"dfs://valuedb\")){\n   dropDatabase(\"dfs://valuedb\")\n}\nn=3000000\nmonth=take(2000.01M..2000.04M, n);\nx=1..n\nt=table(month,x);\n\n\ndb=database(\"dfs://valuedb\", VALUE, 2000.01M..2000.04M)\npt = db.createPartitionedTable(t, `pt, `month);\npt.append!(t);\nbackup(\"/home/DolphinDB/backup\",\"dfs://valuedb\",tableName=\"pt\");\ngetBackupList(\"/home/DolphinDB/backup\",\"dfs://valuedb\",\"pt\");\n```\n\n| chunkID                              | chunkPath                  | cid    | rows    | updateTime              |\n| ------------------------------------ | -------------------------- | ------ | ------- | ----------------------- |\n| 0061427c-4b24-e3b6-425c-c0e1553d3c35 | dfs\\://valuedb/200001M/b39 | 13,348 | 750,000 | 2022.09.21T15:45:50.931 |\n| dabbd90d-6001-f8a9-4d3e-8000d96eba68 | dfs\\://valuedb/200002M/b39 | 13,348 | 750,000 | 2022.09.21T15:45:50.931 |\n| f5c259b4-4be3-f385-46d4-1a1a2d224e9d | dfs\\://valuedb/200003M/b39 | 13,348 | 750,000 | 2022.09.21T15:45:50.931 |\n| 6ed58eb9-a2ae-6197-4f81-3186ca1e8b20 | dfs\\://valuedb/200004M/b39 | 13,348 | 750,000 | 2022.09.21T15:45:50.931 |\n"
    },
    "getBackupMeta": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getBackupMeta.html",
        "signatures": [
            {
                "full": "getBackupMeta(backupDir, dbPath, partition, tableName)",
                "name": "getBackupMeta",
                "parameters": [
                    {
                        "full": "backupDir",
                        "name": "backupDir"
                    },
                    {
                        "full": "dbPath",
                        "name": "dbPath"
                    },
                    {
                        "full": "partition",
                        "name": "partition"
                    },
                    {
                        "full": "tableName",
                        "name": "tableName"
                    }
                ]
            }
        ],
        "markdown": "### [getBackupMeta](https://docs.dolphindb.cn/zh/funcs/g/getBackupMeta.html)\n\n\n\n#### 语法\n\ngetBackupMeta(backupDir, dbPath, partition, tableName)\n\n#### 详情\n\n查询指定某分布式数据表中某个分区的备份信息。\n\n#### 参数\n\n**backupDir** 是字符串，表示存放备份数据的目录。\n\n**dbPath** 是字符串，表示分布式数据库的名称，例如 `\"dfs://demo\"`。\n\n**partition** 是字符串，表示分区在数据库内的路径，例如 `\"/20190101/GOOG\"`。\n\n请注意：若使用 2.00.4 到 2.00.6 版本 server，对表级分区数据进行备份和恢复时，该参数必须指定路径到物理索引（可通过函数 [listTables](https://docs.dolphindb.cn/zh/funcs/l/listTables.html) 获取），例如分区 `\"/compoDB/20170807/0_50\"` 下表的物理索引为8，则 partition 需指定为 `\"/compoDB/20170807/0_50/8\"`。\n\n**tableName** 是字符串，表示数据库中表的名称。\n\n#### 返回值\n\n返回的结果是一个字典，包含以下 key：\n\n* schema：该数据表的结构。\n\n* dfsPath：该分区的完整路径。\n\n* rows：分区数据包含的行数。\n\n* chunkID：该分区的 ID。\n\n* cid：版本号。\n\n#### 例子\n\n查看数据库 `dfs://valuedb` 中数据表 \"pt\" 在 `\"/200001M\"` 分区的备份信息。\n\n```\ngetBackupMeta(\"/home/DolphinDB/backup\",\"dfs://valuedb\", \"/200001M\",\"pt\")\n// output\nschema->\nname  typeString typeInt extra comment\n----- ---------- ------- ----- -------\nmonth MONTH      7\nx     INT        4\n\ndfsPath->dfs://valuedb/200001M/b39\nrows->750000\nchunkID->0061427c-4b24-e3b6-425c-c0e1553d3c35\ncid->13349\n```\n"
    },
    "getBackupStatus": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getBackupStatus.html",
        "signatures": [
            {
                "full": "getBackupStatus([userName])",
                "name": "getBackupStatus",
                "parameters": [
                    {
                        "full": "[userName]",
                        "name": "userName",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [getBackupStatus](https://docs.dolphindb.cn/zh/funcs/g/getBackupStatus.html)\n\n\n\n#### 语法\n\ngetBackupStatus(\\[userName])\n\n#### 详情\n\n查看指定用户的 backup/restore 任务。\n\n**Note:**\n\n* 一次 backup 执行过程产生的任务数与其备份的分区的个数相同。\n\n* 管理员调用该函数时，若指定了 *userName*，则返回指定用户的 backup/restore 任务；否则返回所有用户的 backup/restore 任务。\n\n* 非管理员调用该函数时，只能返回当前用户的 backup/restore 任务。\n\n#### 参数\n\n**userName** 表示用户名的字符串。\n\n#### 返回值\n\n返回一个表，每一行为一个任务的信息。包含以下字段：\n\n* userName：用户名。\n\n* type：备份或恢复的类型。\n\n  * BACKUP\\_BY\\_SQL/RESTORE\\_BY\\_SQL： 表示使用 SQL 元代码方式的备份/恢复。\n\n  * BACKUP\\_BY\\_COPY\\_FILE/RESTORE\\_BY\\_COPY\\_FILE：表示使用拷贝文件方式的备份/恢复。\n\n* startTime：任务开始的时间。\n\n* dbName：数据库的路径。\n\n* tableName：表的名称。\n\n* totalPartitions：待备份/恢复的分区数量。\n\n* completedPartitions：完成备份/恢复的分区数量。\n\n* percentComplete：任务完成百分比。\n\n* endTime：若任务已完成，则返回任务完成的时间，否则返回预估完成时间。\n\n* completed ：任务完成状态。若全部完成，则为1，否则为0。\n\n#### 例子\n\n```\ngetBackupStatus()\n```\n\n| userName | type                   | startTime               | dbName         | tableName | totalPartitions | completedPartitions | percentComplete | endTime                 | completed |\n| -------- | ---------------------- | ----------------------- | -------------- | --------- | --------------- | ------------------- | --------------- | ----------------------- | --------- |\n| u1       | BACKUP\\_BY\\_COPY\\_FILE | 2022.09.21T17:18:04.264 | dfs\\://valuedb | pt        | 1               | 1                   | 100             | 2022.09.21T17:18:04.269 | 1         |\n| u1       | BACKUP\\_BY\\_SQL        | 2022.09.21T17:13:04.344 | dfs\\://valuedb | pt        | 4               | 4                   | 100             | 2022.09.21T17:13:04.413 | 1         |\n| u1       | BACKUP\\_BY\\_COPY\\_FILE | 2022.09.21T17:18:04.264 | dfs\\://valuedb | pt1       | 1               | 1                   | 100             | 2022.09.21T17:18:04.265 | 1         |\n| admin    | BACKUP\\_BY\\_COPY\\_FILE | 2022.09.21T16:47:42.798 | dfs\\://valuedb | pt        | 4               | 4                   | 100             | 2022.09.21T16:47:42.859 | 1         |\n| admin    | BACKUP\\_BY\\_COPY\\_FILE | 2022.09.21T16:37:33.725 | dfs\\://valuedb | pt        | 4               | 4                   | 100             | 2022.09.21T16:37:33.790 | 1         |\n| admin    | BACKUP\\_BY\\_SQL        | 2022.09.21T15:10:05.016 | dfs\\://compoDB | pt2       | 10              | 10                  | 100             | 2022.09.21T15:10:05.075 | 1         |\n"
    },
    "getCachedSymbolBaseMemSize": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getCachedSymbolBaseMemSize.html",
        "signatures": [
            {
                "full": "getCachedSymbolBaseMemSize()",
                "name": "getCachedSymbolBaseMemSize",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getCachedSymbolBaseMemSize](https://docs.dolphindb.cn/zh/funcs/g/getCachedSymbolBaseMemSize.html)\n\n\n\n#### 语法\n\ngetCachedSymbolBaseMemSize()\n\n#### 详情\n\n获取引擎中 SYMBOL 类型的字典编码的缓存大小，单位是字节。\n\n#### 参数\n\n无\n\n#### 返回值\n\n返回一个长整型标量。\n"
    },
    "getCacheEngineMemSize": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getCacheEngineMemSize.html",
        "signatures": [
            {
                "full": "getCacheEngineMemSize()",
                "name": "getCacheEngineMemSize",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getCacheEngineMemSize](https://docs.dolphindb.cn/zh/funcs/g/getCacheEngineMemSize.html)\n\n\n\n#### 语法\n\ngetCacheEngineMemSize()\n\n#### 详情\n\n查看当前节点下 OLAP 引擎的 Cache Engine 的内存情况，单位为字节。\n\n#### 参数\n\n无\n\n#### 返回值\n\n返回一个 ANY VECTOR：\n\n第1个元素表示 Cache Engine 正在使用的内存量；\n\n第2个元素表示 Cache Engine 保存的列文件占用的内存；\n\n第3个元素表示指向列文件的指针所占用的内存；\n\n第4个元素表示 Cache Engine 允许使用的内存上限。\n\n#### 例子\n\n```\nsetCacheEngineMemSize(0.4)\ngetCacheEngineMemSize()\n// output\n(0,0,0,429496729)\n```\n\n相关函数： [setCacheEngineMemSize](https://docs.dolphindb.cn/zh/funcs/s/setCacheEngineMemSize.html)\n"
    },
    "getCacheEngineStat": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getCacheEngineStat.html",
        "signatures": [
            {
                "full": "getCacheEngineStat()",
                "name": "getCacheEngineStat",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getCacheEngineStat](https://docs.dolphindb.cn/zh/funcs/g/getCacheEngineStat.html)\n\n\n\n#### 语法\n\ngetCacheEngineStat()\n\n#### 详情\n\n获取当前节点下 OLAP 引擎 Cache Engine 的状态信息。该函数只能在数据节点调用。\n\n#### 参数\n\n无\n\n#### 返回值\n\n返回一个表对象，包含以下几列:\n\n* chunkId: chunk 的唯一标识。\n\n* physicalName: chunk 所属表的物理表名。\n\n* timeSinceLastWrite: 距离最后一次写入经过的时间，单位为毫秒。\n\n* cachedRowsOfCompletedTxn: 当前缓存的已完成事务的记录数。\n\n* cachedRowsOfUncompletedTxn: 当前缓存的未完成事务的记录数。注意: 每个 chunk 最多只有最后一个事务是未完成的。\n\n* cachedMemOfCompletedTxn: cachedRowsOfCompletedTxn 占用的内存，单位为字节。\n\n* cachedMemOfUncompletedTxn: cachedRowsOfUncompletedTxn 占用的内存，单位为字节。\n\n* cachedTids: 当前缓存的事务 id 列表。\n\n#### 例子\n\n```\ngetCacheEngineStat()\n```\n\n| chunkId                              | physicalName | timeSinceLastWrite | cachedRowsOfCompletedTxn | cachedRowsOfUncompletedTxn | cachedMemOfCompletedTxn | cachedMemOfUncompletedTxn | cachedTids |\n| ------------------------------------ | ------------ | ------------------ | ------------------------ | -------------------------- | ----------------------- | ------------------------- | ---------- |\n| e4558d3c-fa41-52b5-418b-94e26cb70a75 | pt\\_2        | 1056               | 222,386                  | 0                          | 3,558,176               | 0                         | 2052       |\n"
    },
    "getCacheRulesForComputeGroup": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getcacherulesforcomputegroup.html",
        "signatures": [
            {
                "full": "getCacheRulesForComputeGroup([name])",
                "name": "getCacheRulesForComputeGroup",
                "parameters": [
                    {
                        "full": "[name]",
                        "name": "name",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [getCacheRulesForComputeGroup](https://docs.dolphindb.cn/zh/funcs/g/getcacherulesforcomputegroup.html)\n\n首发版本：3.00.5\n\n\n\n#### 语法\n\ngetCacheRulesForComputeGroup(\\[name])\n\n#### 详情\n\n返回全部或指定计算组中的缓存规则。\n\n#### 参数\n\n**name** 可选参数，字符串标量，指定计算组的名称；不指定则返回全部计算组中的缓存规则。\n\n#### 返回值\n\n一张表，包含以下字段：\n\n* **computeGroup**：计算组的名称。\n* **tableName**：需要在计算组缓存路径中进行缓存的表。\n\n#### 例子\n\n```\ngetCacheRulesForComputeGroup(\"cgroup1\")\n```\n\n| computeGroup | tableName                |\n| ------------ | ------------------------ |\n| cgroup1      | dfs\\://compute\\_test/tb1 |\n\n**相关函数：**[removeCacheRulesForComputeGroup](https://docs.dolphindb.cn/zh/funcs/r/removecacherulesforcomputegroup.html)、[addCacheRulesForComputeGroup](https://docs.dolphindb.cn/zh/funcs/a/addcacherulesforcomputegroup.html)\n"
    },
    "getCatalogsByCluster": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getCatalogsByCluster.html",
        "signatures": [
            {
                "full": "getCatalogsByCluster(clusterName)",
                "name": "getCatalogsByCluster",
                "parameters": [
                    {
                        "full": "clusterName",
                        "name": "clusterName"
                    }
                ]
            }
        ],
        "markdown": "### [getCatalogsByCluster](https://docs.dolphindb.cn/zh/funcs/g/getCatalogsByCluster.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\ngetCatalogsByCluster(clusterName)\n\n#### 详情\n\n查询指定集群所有的数据目录（catalog）。只能由管理员在 MoM（Master of Master，管理集群）上执行该函数。\n\n\\*\\*返回值：\\*\\*字符串向量。\n\n#### 参数\n\n**clusterName** 字符串标量或向量，表示集群名称。\n\n#### 返回值\n\n字符串向量。\n\n#### 例子\n\n```\n// MoMSender 集群：\ncreateCatalog(\"catalog1\")\ncreateCatalog(\"catalog2\")\ncreateCatalog(\"catalog3\")\ncreateCatalog(\"catalog4\")\n\n// MoM 集群：\ngetCatalogsByCluster(\"MoMSender\")\n// Output: [\"catalog1\",\"catalog2\",\"catalog3\",\"catalog4\"] \n```\n"
    },
    "getCEPEngineMonitor": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getCEPEngineMonitor.html",
        "signatures": [
            {
                "full": "getCEPEngineMonitor(engine, subEngineName, [monitorName])",
                "name": "getCEPEngineMonitor",
                "parameters": [
                    {
                        "full": "engine",
                        "name": "engine"
                    },
                    {
                        "full": "subEngineName",
                        "name": "subEngineName"
                    },
                    {
                        "full": "[monitorName]",
                        "name": "monitorName",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [getCEPEngineMonitor](https://docs.dolphindb.cn/zh/funcs/g/getCEPEngineMonitor.html)\n\n\n\n#### 语法\n\ngetCEPEngineMonitor(engine, subEngineName, \\[monitorName])\n\n#### 详情\n\n获取指定 CEP 引擎中指定或所有一级（非 spawn）monitor 实例。\n\n#### 参数\n\n**engine** CEP 引擎句柄或名称。\n\n**subEngineName** 字符串标量，表示 CEP 子引擎名称。\n\n**monitorName** 字符串标量，可选参数，表示 monitor 名称。若不指定，返回所有一级 monitor 实例。\n\n#### 返回值\n\nmonitor 实例，或一个字典（键为 monitor 名称， 值为 monitor 实例）。\n\n#### 例子\n\n```\nclass mainMonitor:CEPMonitor{      \n    ordersTable :: ANY  \n    def mainMonitor(){\n        ordersTable = array(ANY, 0)  \n    }\n    \n    def updateOrders(event) {\n        ordersTable.append!([event.trader, event.market, event.code, event.price, event.qty])\n    }\n   \n    def onload(){\n        addEventListener(updateOrders, 'Orders',,'all') \n    }\n}\n\nclass Orders{\n    eventTime :: TIMESTAMP \n    sym :: STRING\n    val0 :: INT\n    val1 :: FLOAT\n    val2 :: DOUBLE\n    def Orders(s,v0,v1,v2){\n        sym = s\n        val0 = v0\n        val1 = v1\n        val2 = v2\n        eventTime = now()\n    }\n}\n\ndummy = table(array(TIMESTAMP, 0) as eventTime, array(STRING, 0) as eventType, array(BLOB, 0) as blobs)\ntry{dropStreamEngine(\"cep1\")}catch(ex){}\nengine=createCEPEngine(\"cep1\",<mainMonitor()>,dummy,Orders,,'eventTime',,,\"sym\")\n\nappendEvent(`cep1,Orders(\"a000\", 3, 3.0, 30.0))\n\n// 查看 subEngine 的名称\ngetCEPEngineStat('cep1').subEngineStat[\"subEngineName\"]\n\nmonitors = getCEPEngineMonitor('cep1', 'a000', 'mainMonitor')\n```\n"
    },
    "getCEPEngineStat": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getCEPEngineStat%20.html",
        "signatures": [
            {
                "full": "getCEPEngineStat(engine)",
                "name": "getCEPEngineStat",
                "parameters": [
                    {
                        "full": "engine",
                        "name": "engine"
                    }
                ]
            }
        ],
        "markdown": "### [getCEPEngineStat](https://docs.dolphindb.cn/zh/funcs/g/getCEPEngineStat%20.html)\n\n\n\n#### 语法\n\ngetCEPEngineStat(engine)\n\n#### 详情\n\n查看指定 CEP 引擎当前的运行状态，包括 CEP 引擎及其子引擎的状态。\n\n#### 参数\n\n**engine** CEP 引擎的句柄。\n\n#### 返回值\n\n一个字典，包含以下字段：\n\n* EngineStat：一个字典，记录 CEP 引擎的状态，和 `getStreamEngineStat().CEPEngine` 返回的信息一致。\n\n  ```\n  eventsOnOutputQueue->0\n  lastErrorTimestamp->\n  numOfSubEngine->15\n  lastErrorMessage->\n  eventsEmitted->0\n  eventsReceived->15\n  name->test_CEP\n  queueDepth->1024\n  user->admin\n  useSystemTime->true\n  status->OK\n  ```\n\n* eventSchema：记录所有 CEP 引擎中进行反序列化的事件及其结构。\n\n<table id=\"topic_xh3_51v_x1c_table_dst_ch1_ybc\"><thead><tr><th id=\"topic_xh3_51v_x1c_table_dst_ch1_ybc_entry_1\">\n\n列名\n\n</th><th id=\"topic_xh3_51v_x1c_table_dst_ch1_ybc_entry_2\">\n\n含义\n\n</th></tr></thead><tbody><tr><td>\n\neventType\n\n</td><td>\n\n事件类型\n\n</td></tr><tr><td>\n\neventField\n\n</td><td>\n\n事件类型中所声明的字段名。多个字段名之间以逗号（,）分隔\n\n</td></tr><tr><td>\n\nfieldType\n\n</td><td>\n\neventField 中各字段对应的数据类型的名称，多个名称之间以逗号（,）分隔\n\n</td></tr><tr><td>\n\nfieldTypeId\n\n</td><td>\n\neventField 中各字段对应的数据类型的 ID。为整型数组向量\n\n</td></tr><tr><td>\n\nfieldFormId\n\n</td><td>\n\neventField 中各字段对应的数据形式的 ID。整型数组向量，0：标量; 1：向量; 2：数据对; 3：矩阵; 4：集合; 5：字典; 6：表\n\n注意：目前只能指定标量和向量，其他形式需要以 ANY 类型指定，因此这里的返回值只有0和1两种\n\n</td></tr></tbody>\n</table>-   subEngineStat：一个表，记录每个子引擎的详细状态。\n\n```\n|列名|含义|\n|---|---|\n|subEngineName|子引擎的名称|\n|eventsOnInputQueue|当前子引擎的事件队列中待处理的事件数量|\n|monitorNumber|当前 Monitor 数量|\n|listeners|事件监听器的数量|\n|timers|计时器数量，当 `addEventListener` 中指定了以下参数的任意一个都会创建1个计时器：*at*，*wait*，*within*，*exceedTime*|\n|eventsRouted|插入到子引擎事件队列队首的事件数量|\n|eventsSent|插入到子引擎事件队列尾部的事件数量|\n|eventsReceived|从外部收到的事件数量|\n|eventsConsumed|匹配成功的事件数量|\n|lastEventTime|最近收到的事件时间|\n|lastErrorMessage|最近一条错误信息|\n|lastErrorTimestamp|最近一次错误信息的时间戳|\n```\n\n* dataViewEngines：一个表，记录所有 dataView 引擎的状态。\n\n  | 列名                 | 含义                                                |\n  | ------------------ | ------------------------------------------------- |\n  | name               | dataView 引擎的名称                                    |\n  | user               | 创建 dataView 引擎的用户名                                |\n  | status             | dataView 引擎状态                                     |\n  | lastErrorMessage   | 最后一条错误信息                                          |\n  | lastErrorTimestamp | 最后一次错误信息的时间戳                                      |\n  | keyColumns         | 参数 keyColumns 指定的字段。多个字段之间以空格分隔                   |\n  | outputTableName    | 输出表的名称                                            |\n  | useSystemTime      | 是否使用系统时间                                          |\n  | throttle           | 数据输出到 outputTable 的时间间隔。如果未指定 *throttle* 参数，则输出为空 |\n  | numItems           | dataView 引擎中的数据行数                                 |\n  | memoryUsed         | dataView 引擎所占用的内存量，单位为字节                          |\n\n#### 例子\n\n```\nclass Orders{\n    eventTime :: TIMESTAMP \n    sym :: STRING\n    val0 :: INT\n    val1 :: FLOAT\n    val2 :: DOUBLE\n    def Orders(s,v0,v1,v2){\n        sym = s\n        val0 = v0\n        val1 = v1\n        val2 = v2\n        eventTime = now()\n    }\n}\nclass mainMonitor:CEPMonitor {\n    ordersTable :: ANY  // 定义成员变量 ordersTable，不限制数据类型和形式\n    def mainMonitor(){\n        ordersTable = array(ANY, 0)  // 这里确定 ordersTable 为一个元组\n    }    \n\n    def updateOrders(event) {\n        ordersTable.append!([event.sym, event.val0, event.val1, event.val2])\n    }\n    def onload(){\n        addEventListener(updateOrders, 'Orders',,'all') \n    }\n}\ndummy = table(array(TIMESTAMP, 0) as eventTime,array(STRING, 0) as eventType,  array(BLOB, 0) as blobs)\nengine=createCEPEngine(name=\"cep_engine\",monitors=<mainMonitor()>,dummyTable=dummy,eventSchema=Orders,timeColumn='eventTime')\n\nappendEvent(`cep_engine,Orders(\"a000\", 3, 3.0, 30.0))\n\ngetCEPEngineStat(`cep_engine)\n```\n\n**相关函数**：[createCEPEngine](https://docs.dolphindb.cn/zh/funcs/c/createCEPEngine.html), [dropStreamEngine](https://docs.dolphindb.cn/zh/funcs/d/dropStreamEngine.html)\n"
    },
    "getCEPEngineSubMonitor": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getCEPEngineSubMonitor.html",
        "signatures": [
            {
                "full": "getCEPEngineSubMonitor(engine, subEngineName, monitorName)",
                "name": "getCEPEngineSubMonitor",
                "parameters": [
                    {
                        "full": "engine",
                        "name": "engine"
                    },
                    {
                        "full": "subEngineName",
                        "name": "subEngineName"
                    },
                    {
                        "full": "monitorName",
                        "name": "monitorName"
                    }
                ]
            }
        ],
        "markdown": "### [getCEPEngineSubMonitor](https://docs.dolphindb.cn/zh/funcs/g/getCEPEngineSubMonitor.html)\n\n\n\n#### 语法\n\ngetCEPEngineSubMonitor(engine, subEngineName, monitorName)\n\n#### 详情\n\n返回指定 monitor 在指定 CEP 引擎中生成的 subMonitor。如果指定的是一级（非 spawn）monitor，则该函数返回它生成的所有 subMonitor，包括所有嵌套级别。如果指定的是一个 subMonitor，则该函数仅返回它直接生成的监视器（即下一层）。\n\n#### 参数\n\n**engine** CEP 引擎句柄或名称。\n\n**subEngineName** 字符串标量，表示 CEP 子引擎名称。\n\n**monitorName** 字符串标量，表示 monitor 名称。\n\n#### 返回值\n\n一个字典，键为 monitor 名称， 值为 monitor 实例。\n\n#### 例子\n\n```\nclass mainMonitor:CEPMonitor{      \n    ordersTable :: ANY  \n    def mainMonitor(){\n        ordersTable = array(ANY, 0)  \n    }\n    \n    def updateOrders(event) {\n        ordersTable.append!([event.trader, event.market, event.code, event.price, event.qty])\n    }\n   \n    def onload(){\n        addEventListener(updateOrders, 'Orders',,'all') \n    }\n}\n\nclass Orders{\n    eventTime :: TIMESTAMP \n    sym :: STRING\n    val0 :: INT\n    val1 :: FLOAT\n    val2 :: DOUBLE\n    def Orders(s,v0,v1,v2){\n        sym = s\n        val0 = v0\n        val1 = v1\n        val2 = v2\n        eventTime = now()\n    }\n}\n\ndummy = table(array(TIMESTAMP, 0) as eventTime, array(STRING, 0) as eventType, array(BLOB, 0) as blobs)\ntry{dropStreamEngine(\"cep1\")}catch(ex){}\nengine=createCEPEngine(\"cep1\",<mainMonitor()>,dummy,Orders,,'eventTime',,,\"sym\")\n\nappendEvent(`cep1,Orders(\"a000\", 3, 3.0, 30.0))\n\n// 查看 subEngine 的名称\ngetCEPEngineStat('cep1').subEngineStat[\"subEngineName\"]\n\nmonitors = getCEPEngineSubMonitor('cep1', 'a000', 'mainMonitor')\n```\n"
    },
    "getChunkPath": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getChunkPath.html",
        "signatures": [
            {
                "full": "getChunkPath(ds)",
                "name": "getChunkPath",
                "parameters": [
                    {
                        "full": "ds",
                        "name": "ds"
                    }
                ]
            }
        ],
        "markdown": "### [getChunkPath](https://docs.dolphindb.cn/zh/funcs/g/getChunkPath.html)\n\n\n\n#### 语法\n\ngetChunkPath(ds)\n\n#### 详情\n\n返回指定数据源代表数据块的路径。\n\n#### 参数\n\n**ds** 是一个或多个数据源。\n\n#### 返回值\n\n字符串向量。\n\n#### 例子\n\n```\nif(existsDatabase(\"dfs://valuedb\")){\n  dropDatabase(\"dfs://valuedb\")\n}\n\ndb=database(\"dfs://valuedb\", VALUE, 1..10)\nn=1000000\nt=table(rand(1..10, n) as id, rand(100.0, n) as val)\npt=db.createPartitionedTable(t, `pt, `id).append!(t);\nds=sqlDS(<select * from pt where id in 1..3>)\ngetChunkPath(ds);\n\n// output\n[\"/valuedb/1/p\",\"/valuedb/2/p\",\"/valuedb/3/p\"]\n```\n"
    },
    "getChunksMeta": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getChunksMeta.html",
        "signatures": [
            {
                "full": "getChunksMeta([chunkPath], [top = 1024])",
                "name": "getChunksMeta",
                "parameters": [
                    {
                        "full": "[chunkPath]",
                        "name": "chunkPath",
                        "optional": true
                    },
                    {
                        "full": "[top = 1024]",
                        "name": "[top = 1024]"
                    }
                ]
            }
        ],
        "markdown": "### [getChunksMeta](https://docs.dolphindb.cn/zh/funcs/g/getChunksMeta.html)\n\n\n\n#### 语法\n\ngetChunksMeta(\\[chunkPath], \\[top = 1024])\n\n#### 详情\n\n查询当前节点上指定数据库 chunk 的元数据。若不指定 *chunkPath*，返回当前节点上所有数据库 chunk 的元数据。\n\n#### 参数\n\n**chunkPath** 是一个或多个 chunk 的 DFS 路径，支持使用通配符 \\*，% 以及？。\n\n* \\* 用于匹配任意数量的任意字符。比如 \"/testDB/\\*\" 表示匹配以 /testDB/ 开头的所有路径。\n* % 用于匹配 0个、1个或多个任意字符。比如 \"/testDB/%/8\" 表示匹配以 /testDB/ 开头、以 /8结尾的所有路径。\n* ? 用于匹配1个任意字符。比如 \"/testDB/1?/8\" 表示匹配 /testDB/10/8、/testDB/11/8 等路径。\n\n**top** 是一个正整数，指定结果中返回的最大 chunk 数。默认值为1024。若设置 *top*= -1，则不限制返回的 chunk 的数量。\n\n#### 返回值\n\n返回一个表，包含以下列\n\n* site：节点别名\n* chunkId：chunk 的唯一标识\n* path：分区的物理路径\n* dfsPath：分区 DFS 路径\n* type：分区类型。0表示 file chunk；1表示 tablet chunk。\n* flag：删除标志。若 flag=0，表示此 chunk 数据可以正常被查询和访问。若 flag=1，表示此 chunk 数据已在逻辑上被标记为删除，不可被查询，但仍然占用磁盘空间。\n  * 使用 delete 语句删除数据时不会删除对应的 chunk，因此返回结果中对应 chunk 的 flag 依然为 0。\n  * 执行 [dropPartition](https://docs.dolphindb.cn/zh/funcs/d/dropPartition.html)、[dropDatabase](https://docs.dolphindb.cn/zh/funcs/d/dropDatabase.html)、[dropTable](https://docs.dolphindb.cn/zh/funcs/d/dropTable.html) 函数或 [drop](https://docs.dolphindb.cn/zh/progr/sql/drop.html) 语句时，会将对应 chunk 的 flag 会设为 1。但 flag = 1 且删除事务已完成时，则不会返回此 chunk 的元数据，因此通常看不到 flag=1 的结果。要看到 flag=1 的 chunk，只能在删除事务未结束时，执行 `getChunksMeta`。\n* size：表示 file chunk 占用磁盘空间，单位为字节。对于 tablet chunk，返回0，需要使用 [getTabletsMeta](https://docs.dolphindb.cn/zh/funcs/g/getTabletsMeta.html) 函数来查看其占用的磁盘空间。\n* version：版本号\n* state：chunk 的状态。\n  * 0：表示 chunk 的最终状态，即所涉及的事务最终正确完成，或者 rollback。\n  * 1：before commit，提交事务之前，即 chunk 上正在执行事务。比如正在写数据或者删除数据。\n  * 2： after commit，已经 commit 事务。\n  * 3： waiting for recovery，等待恢复的状态，比如发生版本不一致或者数据损坏时，数据节点向控制节点发起 recovery 请求后，等待控制节点发起 recovery 时，则会处于这种状态。\n  * 4： in recovery 状态，在 recovery 状态中，接收到控制节点的 recovery 请求，开始启动 recovery，则处于这个状态。recovery 完成后变为最终状态（0）。\n* versionList：版本链\n* resolved：表示 chunk 的事务是否处于决议（commit）状态。true 表示决议状态，false 表示决议后的最终状态。\n\n#### 例子\n\n```\nif(existsDatabase(\"dfs://testDB\")){\n  dropDatabase(\"dfs://testDB\")\n}\n\ndb=database(\"dfs://testDB\", VALUE, 1..10)\nn=1000000\nt=table(rand(1..10, n) as id, rand(100.0, n) as x)\nn=2000000\nt=table(rand(1..10, n) as id, rand(100.0, n) as x, rand(100, n) as y)\ndb.createPartitionedTable(t, `pt2, `id).append!(t)\ngetChunksMeta(\"/testDB%\");\n```\n\n| site     | chunkId                              | path               | dfsPath         | type | flag | size | version | state | versionList       | resolved |\n| -------- | ------------------------------------ | ------------------ | --------------- | ---- | ---- | ---- | ------- | ----- | ----------------- | -------- |\n| P2-node1 | 092d5e12-e595-6f9e-b049-83cba1716997 | /ssd/ssd5/jzVol... | /testDB/pt2.tbl | 0    | 0    | 49   | 1       | 0     | 2052:49;          | false    |\n| P2-node1 | d31e6b47-18f0-37a6-0146-45bf6e266c56 | /ssd/ssd6/jzVol... | /testDB/7       | 1    | 0    | 0    | 2       | 0     | cid : 2053,pt1... | false    |\n| P2-node1 | cd99d9ef-d864-f3bc-4945-f97017d43bf1 | /ssd/ssd5/jzVol... | /testDB/2       | 1    | 0    | 0    | 2       | 0     | cid : 2053,pt1... | false    |\n| P2-node1 | 8da4bea8-31d0-31b5-784f-67aa6339633d | /ssd/ssd5/jzVol... | /testDB/pt1.tbl | 0    | 0    | 41   | 1       | 0     | 2050:41;          | false    |\n| P2-node1 | dd5fc885-f6a6-bfae-8543-254f9fb92484 | /ssd/ssd6/jzVol... | /testDB/10      | 1    | 0    | 0    | 2       | 0     | cid : 2053,pt1... | false    |\n| P2-node1 | 4b8aaed1-2dd6-acb7-5148-4add878c3b33 | /ssd/ssd6/jzVol... | /testDB/domain  | 0    | 0    | 88   | 1       | 0     | 2049:88;          | false    |\n| P2-node1 | 28cb59ec-185a-0ebf-a849-267e769936af | /ssd/ssd6/jzVol... | /testDB/8       | 1    | 0    | 0    | 2       | 0     | cid : 2053,pt1... | false    |\n| P2-node1 | b2facbd2-e301-428f-f94f-8579023f78af | /ssd/ssd6/jzVol... | /testDB/3       | 1    | 0    | 0    | 2       | 0     | cid : 2053,pt1... | false    |\n| P2-node1 | 8bec6445-bc6d-3693-7f46-d1bcdd350182 | /ssd/ssd6/jzVol... | /testDB/5       | 1    | 0    | 0    | 2       | 0     | cid : 2053,pt1... | false    |\n\n**相关函数**：[getTabletsMeta](https://docs.dolphindb.cn/zh/funcs/g/getTabletsMeta.html)\n"
    },
    "getClusterChunksStatus": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getClusterChunksStatus.html",
        "signatures": [
            {
                "full": "getClusterChunksStatus()",
                "name": "getClusterChunksStatus",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getClusterChunksStatus](https://docs.dolphindb.cn/zh/funcs/g/getClusterChunksStatus.html)\n\n\n\n#### 语法\n\ngetClusterChunksStatus()\n\n#### 详情\n\n应用在控制节点上，返回集群中所有 chunk（包括 file chunk 和 tablet chunk）的元数据信息。可以查看 chunk 在集群中数据节点上的分布。\n\n#### 返回值\n\n返回一个表，包含以下列\n\n* chunkId：chunk 的唯一标识\n\n* file：分区路径\n\n* size：file chunk 占用磁盘空间，单位为 byte。对于 tablet chunk，返回 0，需要使用 getTabletsMeta 来查看它们实际占用的磁盘空间\n\n* version：版本号\n\n* vcLength：版本链长度\n\n* versionChain：版本链\n\n* state：chunk 状态。CONSTRUCTING：正在事务中； RECOVERING：正在 recovery 中；COMPLETE：已经处于事务终止状态\n\n* replicas：副本的分布信息，每个副本的格式为 `nodeAlias:replicaVersion:corrupted:inResolution:timestamp:volumeID`，多个副本之间使用逗号分隔。\n\n* replicaCount：副本数\n\n* lastUpdated：上一次更新的时间戳。请注意，server 从 2.00.1 版本才开始支持该字段，因此获取已经存在的由 2.00.1 之前的 server 创建的 chunk 元数据信息时，该字段将返回空值。\n\n* permission：CHUNK 的权限。CHUNK 的权限分为 READ\\_ONLY 以及 READ\\_WRITE（默认权限）两类。正在进行迁移的分区，或存储在 s3 的分区权限均为 READ\\_ONLY\n\n对于 READ\\_ONLY 权限的分区：\n\n(1) 不能追加或更新数据，并只能通过调用 `drop` 类函数进行删除，且遵从事务的原则。（注意：存储在 s3 的分区不支持事务）。\n\n(2) 不能对其进行 recovery, rebalance 以及 TSDB 引擎的 level file 合并操作。\n\n#### 例子\n\n```\nrpc(getControllerAlias(), getClusterChunksStatus);\n```\n\n| chunkId             | file            | size | version | vcLength | versionChain        | state    | replicas            | replicaCount | lastUpdated             | permission  |\n| ------------------- | --------------- | ---- | ------- | -------- | ------------------- | -------- | ------------------- | ------------ | ----------------------- | ----------- |\n| 092d5e12-e595-6f... | /testDB/pt2.tbl | 49   | 1       | 1        | 2052:49:1 ->        | COMPLETE | P1-node1:1:0,P2-... | 2            | 2022.03.31T18:09:41.138 | READ\\_WRITE |\n| 42936e31-8be0-fa... | /testDB/9/i     | 0    | 2       | 2        | 2053:0:2 -> 2051... | COMPLETE | P3-node1:2:0,P1-... | 2            | 2022.03.31T18:09:41.138 | READ\\_WRITE |\n| d31e6b47-18f0-37... | /testDB/7/i     | 0    | 2       | 2        | 2053:0:2 -> 2051... | COMPLETE | P1-node1:2:0,P2-... | 2            | 2022.03.31T18:09:41.138 | READ\\_WRITE |\n| 647a5fd6-cd85-3b... | /testDB/6/i     | 0    | 2       | 2        | 2053:0:2 -> 2051... | COMPLETE | P1-node1:2:0,P3-... | 2            | 2022.03.31T18:09:41.138 | READ\\_WRITE |\n| 8bec6445-bc6d-36... | /testDB/5/i     | 0    | 2       | 2        | 2053:0:2 -> 2051... | COMPLETE | P2-node1:2:0,P3-... | 2            | 2022.03.31T18:09:41.138 | READ\\_WRITE |\n| ca690ba5-be73-a6... | /testDB/4/i     | 0    | 2       | 2        | 2053:0:2 -> 2051... | COMPLETE | P3-node1:2:0,P1-... | 2            | 2022.03.31T18:09:41.138 | READ\\_WRITE |\n"
    },
    "getClusterDFSDatabases": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getClusterDFSDatabases.html",
        "signatures": [
            {
                "full": "getClusterDFSDatabases([includeSysDb=true])",
                "name": "getClusterDFSDatabases",
                "parameters": [
                    {
                        "full": "[includeSysDb=true]",
                        "name": "includeSysDb",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [getClusterDFSDatabases](https://docs.dolphindb.cn/zh/funcs/g/getClusterDFSDatabases.html)\n\n\n\n#### 语法\n\ngetClusterDFSDatabases(\\[includeSysDb=true])\n\n#### 详情\n\n该函数由管理员执行时，返回当前集群中的分布式数据库；\n\n由其他用户执行时，返回该用户在集群中拥有以下权限的分布式数据库：DB\\_OWNER, DB\\_MANAGE, DB\\_READ, DB\\_INSERT, DB\\_UPDATE, DB\\_DELETE, DBOBJ\\_CREATE, DBOBJ\\_DELETE。\n\n#### 参数\n\n**includeSysDb** 可选参数，布尔值，用于控制返回的结果中是否包含系统库，默认值为 true。该参数仅对管理员用户生效。如果是普通用户，即便将 *includeSysDb* 设置为 true 也无法查看系统库。\n\n#### 返回值\n\n字符串向量。\n\n#### 例子\n\n```\ngetClusterDFSDatabases()\n\n// output: [\"dfs://demohash\",\"dfs://myDataYesDB\",\"dfs://testDB\"]\n```\n"
    },
    "getClusterDFSTables": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getClusterDFSTables.html",
        "signatures": [
            {
                "full": "getClusterDFSTables([includeSysTable=true])",
                "name": "getClusterDFSTables",
                "parameters": [
                    {
                        "full": "[includeSysTable=true]",
                        "name": "includeSysTable",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [getClusterDFSTables](https://docs.dolphindb.cn/zh/funcs/g/getClusterDFSTables.html)\n\n\n\n#### 语法\n\ngetClusterDFSTables(\\[includeSysTable=true])\n\n#### 详情\n\n返回集群中的分布式表。\n\n2.00.9 版本起，\n\n* 管理员可以返回当前集群中任一分布式表；\n\n* 其他用户执行时仅返回：\n\n  （1）拥有 DB\\_OWNER, DB\\_MANAGE, DB\\_READ, DB\\_WRITE, DB\\_INSERT, DB\\_UPDATE, DB\\_DELETE 权限的数据库所对应的分布式表；\n\n  （2）拥有 TABLE\\_READ, TABLE\\_WRITE, TABLE\\_INSERT, TABLE\\_UPDATE, TABLE\\_DELETE 权限的分布式表。\n\n2.00.10.2 版本起，该函数由拥有 DBOBJ\\_CREATE 权限的用户执行时，还会返回其创建的分布式表。\n\n#### 参数\n\n**includeSysTable** 可选参数，布尔值，用于控制返回的结果中是否包含系统表，默认值为 true。该参数仅对管理员用户生效。如果是普通用户，即便将 *includeSysTable* 设置为 true 也无法查看系统表。\n\n#### 返回值\n\n字符串向量。\n\n#### 例子\n\n```\ngetClusterDFSTables()\n```\n\n返回：\\[\"dfs\\://demohash/pt\",\"dfs\\://myDataYesDB/tick\",\"dfs\\://testDB/pt1\",\"dfs\\://testDB/pt2\"]\n"
    },
    "getClusterPerf": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getClusterPerf.html",
        "signatures": [
            {
                "full": "getClusterPerf([includeMaster=false])",
                "name": "getClusterPerf",
                "parameters": [
                    {
                        "full": "[includeMaster=false]",
                        "name": "includeMaster",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [getClusterPerf](https://docs.dolphindb.cn/zh/funcs/g/getClusterPerf.html)\n\n\n\n#### 语法\n\ngetClusterPerf(\\[includeMaster=false])\n\n#### 详情\n\n获取每个节点的多个配置和性能监控度量值。注意：代理节点的 connectionNum 是一个随机值，可以忽略。\n\n#### 参数\n\n**includeMaster** 表示获取的节点信息中是否包含控制节点的信息。\n\n#### 返回值\n\n返回一个表对象，包含以下几列：\n\n* computeGroup：计算节点所属的计算组。\n\n* host：节点的主机名。\n\n* port：节点的端口号。\n\n* site：节点的局域网信息。\n\n* mode：节点的类型。0 表示集群的数据节点，1 表示集群的代理节点，2 表示集群的控制节点，3 表示 single mode 的节点，4 表示计算节点。\n\n* state：节点是否存活。\n\n* agentSite：当前节点的代理节点信息。\n\n* maxConnections：最多可以从多少个外部 GUI ，API 或其它节点连接到本地节点。\n\n* maxMemSize：当前节点的内存空间上限（单位：GB）。\n\n* workerNum：常规作业的工作线程的数量。默认值是 CPU 的内核数。\n\n* executorNum：本地执行线程的数量。默认值是 CPU 内核数减1。\n\n* connectionNum：连接到本地节点的连接数。\n\n* name：节点别名。\n\n* memoryUsed：节点的内存占用量（单位：字节）。\n\n* memoryAlloc：系统已分配给当前节点的内存（单位：字节）。\n\n* cpuUsage：CPU 使用率。\n\n* avgLoad：CPU 平均负载。\n\n* medLast10QueryTime：前 10 个完成的查询执行所耗费时间的中间值（单位：纳秒）。注意：必须指定 perfMonitoring=1 才会返回该字段。\n\n* maxLast10QueryTime：前 10 个完成的查询执行所耗费时间的最大值（单位：纳秒）。注意：必须指定 perfMonitoring=1 才会返回该字段。\n\n* medLast100QueryTime：前 100 个完成的查询执行所耗费时间的中间值（单位：纳秒）。注意：必须指定 perfMonitoring=1 才会返回该字段。\n\n* maxLast100QueryTime：前100个完成的查询执行所耗费时间的最大值（单位：纳秒）。注意：必须指定 perfMonitoring=1 才会返回该字段。\n\n* maxRunningQueryTime：当前正在执行的查询的耗费时间的最大值（单位：纳秒）。\n\n* runningJobs：正在执行中的 Job 个数。\n\n* queuedJobs：队列中的 Job 个数。\n\n* runningTasks：正在执行中的 Task 个数。\n\n* queuedTasks：队列中的 Task 个数。\n\n* jobLoad：作业负载。\n\n* diskCapacity：磁盘容量（单位：字节）。\n\n* diskFreeSpace：磁盘剩余空间（单位：字节）。\n\n* diskFreeSpaceRatio：磁盘可用空间占比。\n\n* diskWriteRate：磁盘写速率 （单位：字节/秒）。\n\n* diskReadRate：磁盘读速率（单位：字节/秒）。\n\n* lastMinuteWriteVolume：前一分钟写磁盘容量（单位：字节）。\n\n* lastMinuteReadVolume：前一分钟读磁盘容量（单位：字节）。\n\n* networkSendRate：网络发送速率（单位：字节/秒）。\n\n* networkRecvRate：网络接收速率（单位：字节/秒）。\n\n* lastMinuteNetworkSend：前一分钟网络发送字节数（单位：字节）。\n\n* lastMinuteNetworkRecv：前一分钟网络接收字节数 （单位：字节）。\n\n* publicName：若为控制节点，且配置了 publicName，则显示 publicName；否则显示控制节点所在服务器的 网卡地址。若为数据节点或代理节点，则显示数据节点或代理节点所在服务器的网卡地址。\n\n* lastMsgLatency：流数据订阅节点最后收到的消息的延时（单位：纳秒）。\n\n* cumMsgLatency：流数据订阅节点所有已接收的消息的平均延时（单位：纳秒）。\n\n* isLeader：是否是 raft 组的 leader，该字段仅在配置了控制节点高可用时才生效。请注意，若 raft 组存在宕机的节点，则该节点的 isLeader 将返回空值。\n\n* zone：数据节点或计算节点所属的区域。\n\n#### 例子\n\n```\ngetClusterPerf()\n```\n"
    },
    "getClusterStatus": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getClusterStatus.html",
        "signatures": [
            {
                "full": "getClusterStatus(clusterName)",
                "name": "getClusterStatus",
                "parameters": [
                    {
                        "full": "clusterName",
                        "name": "clusterName"
                    }
                ]
            }
        ],
        "markdown": "### [getClusterStatus](https://docs.dolphindb.cn/zh/funcs/g/getClusterStatus.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\ngetClusterStatus(clusterName)\n\n#### 详情\n\n查询指定集群当前的状态。只能由管理员在 MoM（Master of Master，管理集群）上执行该函数。\n\n#### 参数\n\n**clusterName** 字符串标量或向量，表示集群名称。\n\n#### 返回值\n\n返回一个表，除 clusterName 和 computeGroup 字段外，其它字段与 [getClusterPerf](https://docs.dolphindb.cn/zh/funcs/g/getClusterPerf.html) 函数的结果一致：\n\n* clusterName：集群名称。\n* computeGroup：计算组名称。若集群中无计算组，则该字段为空。\n\n#### 例子\n\n```\ngetClusterStatus(\"ShangHai_cluster2\")\n```\n\n| clusterName        | computeGroup | host      | port  | site                          | mode | state | agentSite             | maxConnections | maxMemSize | workerNum | executorNum | connectionNum | name           | memoryUsed  | memoryAlloc | cpuUsage           | avgLoad             | medLast10QueryTime | maxLast10QueryTime | medLast100QueryTime | maxLast100QueryTime | maxRunningQueryTime | runningJobs | queuedJobs | runningTasks | queuedTasks | jobLoad | diskCapacity | diskFreeSpace | diskFreeSpaceRatio | diskWriteRate | diskReadRate | lastMinuteWriteVolume | lastMinuteReadVolume | networkSendRate | networkRecvRate | lastMinuteNetworkSend | lastMinuteNetworkRecv | publicName | lastMsgLatency | cumMsgLatency | isLeader |\n| ------------------ | ------------ | --------- | ----- | ----------------------------- | ---- | ----- | --------------------- | -------------- | ---------- | --------- | ----------- | ------------- | -------------- | ----------- | ----------- | ------------------ | ------------------- | ------------------ | ------------------ | ------------------- | ------------------- | ------------------- | ----------- | ---------- | ------------ | ----------- | ------- | ------------ | ------------- | ------------------ | ------------- | ------------ | --------------------- | -------------------- | --------------- | --------------- | --------------------- | --------------------- | ---------- | -------------- | ------------- | -------- |\n| ShangHai\\_cluster2 |              | localhost | 8,921 | localhost:8921:agent1         | 1    | 1     | localhost:8921:agent1 | 32             | 4          | 4         | 0           | 0             | agent1         | 0           | 0           | 0                  | 0                   | 0                  | 0                  | 0                   | 0                   | 0                   | 0           | 0          | 0            | 0           | 0       | 0            | 0             | 0                  | 0             | 0            | 0                     | 0                    | 0               | 0               | 0                     | 0                     |            | 0              | 0             |          |\n| ShangHai\\_cluster2 |              | localhost | 8,923 | localhost:8923:cnode1         | 4    | 0     | localhost:8921:agent1 | 0              | 0          | 0         | 0           | 0             | cnode1         | 0           | 0           | 0                  | 0                   | 0                  | 0                  | 0                   | 0                   | 0                   | 0           | 0          | 0            | 0           | 0       | 0            | 0             | 0                  | 0             | 0            | 0                     | 0                    | 0               | 0               | 0                     | 0                     |            | 0              | 0             |          |\n| ShangHai\\_cluster2 |              | localhost | 8,922 | localhost:8922:dnode1         | 0    | 0     | localhost:8921:agent1 | 0              | 0          | 0         | 0           | 0             | dnode1         | 0           | 0           | 0                  | 0                   | 0                  | 0                  | 0                   | 0                   | 0                   | 0           | 0          | 0            | 0           | 0       | 0            | 0             | 0                  | 0             | 0            | 0                     | 0                    | 0               | 0               | 0                     | 0                     |            | 0              | 0             |          |\n| ShangHai\\_cluster2 |              | localhost | 8,920 | localhost:8920:controller8920 | 2    | 1     |                       | 512            | 8          | 4         | 0           | 2             | controller8920 | 123,862,496 | 127,377,408 | 16.049382716049383 | 0.16049382716049382 | 0                  | 0                  | 0                   | 0                   | 0                   | 0           | 0          | 0            | 0           | 0       | 0            | 0             | 0                  | 148           | 0            | 21,028                | 0                    | 0               | 0               | 0                     | 0                     |            | 0              | 0             |          |\n"
    },
    "getClusterTDEKeys": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getclustertdekeys.html",
        "signatures": [
            {
                "full": "getClusterTDEKeys()",
                "name": "getClusterTDEKeys",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getClusterTDEKeys](https://docs.dolphindb.cn/zh/funcs/g/getclustertdekeys.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\ngetClusterTDEKeys()\n\n#### 详情\n\n获取集群中开启静态加密表的加密信息。仅 Linux 系统支持该功能。\n\n注意：该函数由管理员返回集群中所有的加密表信息。否则，仅返回该用户有访问权限的加密表信息。访问权限包含 DB\\_MANAGE, DBOBJ\\_CREATE, DB\\_OWNER, TABLE\\_READ, TABLE\\_WRITE, TABLE\\_INSERT, TABLE\\_UPDATE, TABLE\\_DELETE, DB\\_READ, DB\\_WRITE, DB\\_INSERT, DB\\_UPDATE, DB\\_DELETE。\n\n#### 参数\n\n无\n\n#### 返回值\n\n返回一个表，包含以下列：\n\n* tableName：加密表表名。\n* mode：建表时指定的加密方式，全大写。\n* version：主密钥版本。\n\n#### 例子\n\n```\ngetClusterTDEKeys()\n```\n\n| **tableName**    | **mode**      | **version**   |\n| ---------------- | ------------- | ------------- |\n| dfs\\://db/table1 | `AES_128_CTR` | 3,698,850,997 |\n| dfs\\://db/table2 | `AES_128_CTR` | 5,768,669,747 |\n"
    },
    "getClusterVolumeUsage": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getClusterVolumeUsage.html",
        "signatures": [
            {
                "full": "getClusterVolumeUsage()",
                "name": "getClusterVolumeUsage",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getClusterVolumeUsage](https://docs.dolphindb.cn/zh/funcs/g/getClusterVolumeUsage.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\ngetClusterVolumeUsage()\n\n#### 详情\n\n检查集群中各节点的磁盘使用情况。该函数只能由管理员调用。\n\n#### 参数\n\n无\n\n#### 返回值\n\n返回一个表，包含以下列：\n\n* node：节点名\n* volumePath：磁盘路径\n* volumeId：磁盘内部 ID\n* usage：当前磁盘占用量（单位字节）\n* capacity：磁盘总容量（单位字节）\n\n#### 例子\n\n```\ngetClusterVolumeUsage()\n```\n\n| **node**  | **volumePath**                 | **volumeId** | **usage**       | **capacity**    |\n| --------- | ------------------------------ | ------------ | --------------- | --------------- |\n| local8999 | /home/server/local8999/storage | 109,993,503  | 138,556,121,088 | 250,438,021,120 |\n"
    },
    "getCompletedQueries": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getCompletedQueries.html",
        "signatures": [
            {
                "full": "getCompletedQueries([top])",
                "name": "getCompletedQueries",
                "parameters": [
                    {
                        "full": "[top]",
                        "name": "top",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [getCompletedQueries](https://docs.dolphindb.cn/zh/funcs/g/getCompletedQueries.html)\n\n\n\n#### 语法\n\ngetCompletedQueries(\\[top])\n\n#### 详情\n\n查询本地节点上最近完成的 *top* 条查询分布式数据库的 SQL 语句的描述信息。\n\n本函数只可由系统管理员执行。在使用该函数之前，必须设定配置参数 *perfMonitoring* = 1 以启动性能监控。\n\n#### 参数\n\n**top** 是一个正整数。可选参数，默认值为 10。\n\n#### 返回值\n\n返回一个表，包含以下字段：\n\n| 参数        | 含义                                                                |\n| --------- | ----------------------------------------------------------------- |\n| userID    | 用户 ID 。                                                           |\n| sessionID | 发起查询的会话 ID。                                                       |\n| jobID     | 系统中查询任务的唯一标识。                                                     |\n| rootID    | 当前任务所属根任务的 jobID。                                                 |\n| level     | 任务的级别。根任务的 level 为 0，其分解的子任务 level 为 1，该子任务分解的子任务 level 为 2，以此类推。 |\n| startTime | 查询任务开始时间，为 NANOTIMESTAMP 类型。                                      |\n| endTime   | 查询任务结束时间，为 NANOTIMESTAMP 类型。                                      |\n| jobDesc   | 查询语句描述。                                                           |\n| errorMsg  | 报错信息。                                                             |\n| remoteIP  | 发起查询的客户端 IP。                                                      |\n\n#### 例子\n\n```\nn=1000000\nID=rand(10, n)\nx=rand(1.0, n)\nt=table(ID, x)\ndb=database(\"dfs://rangedb16\", RANGE,  0 5 10)\npt = db.createPartitionedTable(t, `pt, `ID)\npt.append!(t)\nt1 = select count(x) from pt;\nt2 = select * from pt where ID=1;\nt3 = select * from pt where ID=5;\n\ngetCompletedQueries()\n```\n\n| userID | sessionID  | jobID                                | rootID                               | level | startTime                     | endTime                       | jobDesc                             | errorMsg | remoteIP  |\n| ------ | ---------- | ------------------------------------ | ------------------------------------ | ----- | ----------------------------- | ----------------------------- | ----------------------------------- | -------- | --------- |\n| admin  | 1166953221 | 4be0f403-a62d-7bae-4ded-43938cc2b4e9 | 4be0f403-a62d-7bae-4ded-43938cc2b4e9 | 0     | 2021.06.28T18:05:34.366483000 | 2021.06.28T18:05:34.372467000 | select ID,x from pt where ID == 1   |          | 127.0.0.1 |\n| admin  | 1166953221 | 9e9132c5-60c2-b3ab-41da-039ad2dcb6ff | 4be0f403-a62d-7bae-4ded-43938cc2b4e9 | 0     | 2021.06.28T18:05:34.366483000 | 2021.06.28T18:05:34.372467000 | select ID,x from pt where ID == 5   |          | 127.0.0.1 |\n| admin  | 1166953221 | 98275891-9c9b-948e-425c-6c3083713d84 | 98275891-9c9b-948e-425c-6c3083713d84 | 0     | 2021.06.28T18:05:34.344272000 | 2021.06.28T18:05:34.359201000 | select count(x) as count\\_x from pt |          | 127.0.0.1 |\n\n```\ngetCompletedQueries().keys()\n```\n\n返回：\\[\"userID\",\"sessionID\",\"jobID\",\"rootID\",\"level\",\"startTime\",\"endTime\",\"jobDesc\",\"errorMsg\",\"remoteIP\"]\n\n```\ngetCompletedQueries().ErrorMsg\n```\n\n返回：\\[,,]\n\n```\ngetCompletedQueries().jobDesc\n```\n\n返回：\\[\"select ID,x from pt where ID == 5\",\"select ID,x from pt where ID == 1\",\"select count(x) as count\\_x from pt\"]\n\n**Related information**\n\n[getRunningQueries](https://docs.dolphindb.cn/zh/funcs/g/getRunningQueries.html)\n"
    },
    "getComputeGroupChunksStatus": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getcomputegroupchunksstatus.html",
        "signatures": [
            {
                "full": "getComputeGroupChunksStatus([computeGroup])",
                "name": "getComputeGroupChunksStatus",
                "parameters": [
                    {
                        "full": "[computeGroup]",
                        "name": "computeGroup",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [getComputeGroupChunksStatus](https://docs.dolphindb.cn/zh/funcs/g/getcomputegroupchunksstatus.html)\n\n\n\n#### 语法\n\ngetComputeGroupChunksStatus(\\[computeGroup])\n\n#### 详情\n\n应用于控制节点，获取指定或所有计算组中缓存的所有 chunk （包括 file chunk 和 tablet chunk）的元数据信息。\n\n#### 参数\n\n**computeGroup** 可选参数，字符串标量，表示计算组名称。\n\n#### 返回值\n\n返回一个表，包含以下列：\n\n* chunkId：chunk 的唯一标识\n\n* file：分区路径\n\n* routedTo：计算节点别名，控制节点会将对该分区的查询调度到此计算节点。\n\n* cachedOn：缓存分区的计算节点别名，形式为 alias:\\[version]，例如：orca2:\\[29] 表示名为 orca2 的计算节点缓存了分区版本号为 29 的数据。\n\n* computeGroup：缓存分区的计算组名字。一个分区可能被多个计算组缓存。\n\n* size：file chunk 占用磁盘空间，单位为 byte。对于 tablet chunk，返回 0，需要使用 getTabletsMeta 来查看它们实际占用的磁盘空间。\n\n* version：版本号。\n\n* vcLength：版本链长度。\n\n* versionChain：版本链。\n\n* state：chunk 状态。CONSTRUCTING：正在事务中； RECOVERING：正在 recovery 中；COMPLETE：已经处于事务终止状态。\n\n* dataNodeReplicas：数据节点上副本的分布信息。\n\n* dataNodeReplicaCount：数据节点上副本的数量。\n\n* lastUpdated：上一次更新的时间戳。\n\n* permission：CHUNK 的权限。CHUNK 的权限分为 READ\\_ONLY 以及 READ\\_WRITE（默认权限）两类。正在进行迁移的分区，或存储在 s3 的分区权限均为 READ\\_ONLY。\n\n#### 例子\n\n```\ngetComputeGroupChunksStatus()\n```\n\n| chunkId                              | path                                                 | routedTo | cachedOn      | computeGroup | size | version | vcLength | versionChain     | state    | dataNodeReplicas   | dataNodeReplicaCount | lastUpdated             | permission  |\n| ------------------------------------ | ---------------------------------------------------- | -------- | ------------- | ------------ | ---- | ------- | -------- | ---------------- | -------- | ------------------ | -------------------- | ----------------------- | ----------- |\n| abec288a-49f7-61b9-464e-56bf134c8340 | /Storage\\_compute\\_separation\\_tsdb/20120110/Key19/2 | orca3    | \\[NOT CACHED] | orca         | 0    | 1       | 1        | 1466:0:1:1466 -> | COMPLETE | dnode2:1:0:false:0 | 1                    | 2024.10.12 17:26:51.757 | READ\\_WRITE |\n| fdb95a8e-72f0-21a7-0443-2cbe02feeca2 | /Storage\\_compute\\_separation\\_tsdb/20120229/Key1/2  | orca1    | \\[NOT CACHED] | orca         | 0    | 1       | 1        | 1463:0:1:1463 -> | COMPLETE | dnode3:1:0:false:0 | 1                    | 2024.10.12 17:26:51.708 | READ\\_WRITE |\n| 55020019-8b2c-75a1-3b40-7ad2469abe48 | /Storage\\_compute\\_separation\\_tsdb/20120110/Key13/2 | orca3    | \\[NOT CACHED] | orca         | 0    | 1       | 1        | 1458:0:1:1458 -> | COMPLETE | dnode3:1:0:false:0 | 1                    | 2024.10.12 17:26:51.618 | READ\\_WRITE |\n| 96678f5f-6ae5-2b98-9944-5d4370473dee | /Storage\\_compute\\_separation\\_tsdb/20120110/Key7/2  | orca2    | \\[NOT CACHED] | orca         | 0    | 1       | 1        | 1456:0:1:1456 -> | COMPLETE | dnode1:1:0:false:0 | 1                    | 2024.10.12 17:26:51.583 | READ\\_WRITE |\n"
    },
    "getComputeNodeCacheDetails": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getComputeNodeCacheDetails.html",
        "signatures": [
            {
                "full": "getComputeNodeCacheDetails(granularity)",
                "name": "getComputeNodeCacheDetails",
                "parameters": [
                    {
                        "full": "granularity",
                        "name": "granularity"
                    }
                ]
            }
        ],
        "markdown": "### [getComputeNodeCacheDetails](https://docs.dolphindb.cn/zh/funcs/g/getComputeNodeCacheDetails.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\ngetComputeNodeCacheDetails(granularity)\n\n#### 详情\n\n在存算分离架构中，在计算组中的计算节点上执行该函数，可返回该节点上的具体缓存信息。\n\n区别于`getComputeNodeCacheStat`用于查询当前节点的缓存总使用量和缓存上限；`getComputeNodeCacheDetails` 可查询缓存的具体构成。\n\n用户指定以表或分区为单位，查询对应数据在该节点上的缓存类型、缓存大小等。\n\n关于存算分离架构的详细介绍与相关配置，请参见[存算分离](https://docs.dolphindb.cn/zh/db_distr_comp/db/storage_compute_separation.html)主题页。\n\n#### 参数\n\n**granularity**字符串标量，表示查询的粒度：\n\n* \"CHUNK\"： 以分区为单位查询缓存信息。\n* \"TABLE\"：以表为单位查询信息。若存在大量分区，可选择该项以控制返回表行数。\n\n#### 返回值\n\n* 当以分区为单位（*granularity*=\"CHUNK\"）查询时，返回一张包含以下字段的表：\n  * dbName - 库名\n  * tableName - 表名\n  * dfsPath - 分区的 DFS 路径\n  * cid - 当前缓存对应的的版本标识\n  * cacheType - 缓存类型，\"MEM\" 表示位于内存，\"DISK\" 表示位于磁盘。若存在于两处，则会显示两行\n  * size - 以字节为单位的缓存大小，与缓存类型对应\n* 当以表为单位（*granularity*=\"TABLE\"）查询时，每个分区表对应一条记录，包括 dbName、tableName、partitionCount、cacheType 和 size 字段。其中 partitionCount 表示该表中被缓存的分区数。\n\n#### 例子\n\n```\ngetComputeNodeCacheDetails(\"CHUNK\");\n```\n\n| **dbName**    | **tableName** | **dfsPath**  | **cid** | **cacheType** | **size** |\n| ------------- | ------------- | ------------ | ------- | ------------- | -------- |\n| dfs\\://demo   | pt1           | /demo/43/G6  | 509     | MEM           | 222      |\n| dfs\\://demo   | pt1           | /demo/15/G6  | 509     | MEM           | 184      |\n| dfs\\://test01 | pt01          | /test01/1/8c | 515     | MEM           | 280      |\n| …             |               |              |         |               |          |\n\n```\ngetComputeNodeCacheDetails(\"TABLE\");\n```\n\n| **dbName**  | **tableName** | **partitionCount** | **cacheType** | **size** |\n| ----------- | ------------- | ------------------ | ------------- | -------- |\n| dfs\\://demo | pt1           | 27                 | MEM           | 5804     |\n\n相关函数：[clearComputeNodeCache](https://docs.dolphindb.cn/zh/funcs/c/clearcomputenodecache.html), [clearComputeNodeDiskCache](https://docs.dolphindb.cn/zh/funcs/c/clearcomputenodediskcache.html), [getComputeNodeCacheStat](https://docs.dolphindb.cn/zh/funcs/g/getcomputenodecachestat.html)\n"
    },
    "getComputeNodeCacheStat": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getcomputenodecachestat.html",
        "signatures": [
            {
                "full": "getComputeNodeCacheStat()",
                "name": "getComputeNodeCacheStat",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getComputeNodeCacheStat](https://docs.dolphindb.cn/zh/funcs/g/getcomputenodecachestat.html)\n\n\n\n#### 语法\n\ngetComputeNodeCacheStat()\n\n#### 详情\n\n应用于计算组中的计算节点上，返回该节点的二级缓存信息。\n\n#### 参数\n\n无\n\n#### 返回值\n\n返回一个表，包含以下列：\n\n* memCacheUsage：内存缓存的使用量，单位为 MB。\n\n* memCacheSize：内存缓存的最大容量，单位为 MB。\n\n* diskCacheUsage：磁盘缓存的使用量，单位为 MB。\n\n* diskCacheSize：磁盘缓存的最大容量，单位为 MB。\n\n#### 例子\n\n```\ngetComputeNodeCacheStat()\n```\n\n| memCacheUsage      | memCacheSize | diskCacheUsage | diskCacheSize |\n| ------------------ | ------------ | -------------- | ------------- |\n| 114.51725769042969 | 1,024        | 0              | 65,536        |\n"
    },
    "getComputeNodeCacheWarmupJobStatus": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getcomputenodecachewarmupjobstatus.html",
        "signatures": [
            {
                "full": "getComputeNodeCacheWarmupJobStatus([jobId])",
                "name": "getComputeNodeCacheWarmupJobStatus",
                "parameters": [
                    {
                        "full": "[jobId]",
                        "name": "jobId",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [getComputeNodeCacheWarmupJobStatus](https://docs.dolphindb.cn/zh/funcs/g/getcomputenodecachewarmupjobstatus.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\ngetComputeNodeCacheWarmupJobStatus(\\[jobId])\n\n#### 详情\n\n查询指定 *jobId* 的数据预热任务状态。省略 *jobId*时返回所有预热任务的状态。\n\n#### 参数\n\n**jobId**可选参数，字符串标量或向量，表示预热任务的 jobId。\n\n#### 返回值\n\n返回一个表，包括以下字段：\n\n* jobId：数据预热任务的 jobId。\n\n* tableName：任务对应的库表信息。\n\n* jobStatus：任务状态，包括 Pending（待执行），Running（正在执行），Finished（已完成），Error（发生错误）。\n\n* parallelism：并行度，其中 -1 代表该任务没有并行度限制。\n\n* elapsed：任务的执行时长，单位为 ms。\n\n* errMsg：错误信息。\n\n#### 例子\n\n```\ngetComputeNodeCacheWarmupJobStatus()\n```\n"
    },
    "getComputeNodeCachingDelay": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getcomputenodecachingdelay.html",
        "signatures": [
            {
                "full": "getComputeNodeCachingDelay()",
                "name": "getComputeNodeCachingDelay",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getComputeNodeCachingDelay](https://docs.dolphindb.cn/zh/funcs/g/getcomputenodecachingdelay.html)\n\n\n\n#### 语法\n\ngetComputeNodeCachingDelay()\n\n#### 详情\n\n查看当前节点下配置项 *computeNodeCachingDelay* 的生效值，单位为秒。\n\n#### 参数\n\n无\n\n#### 详情\n\n整型标量。\n\n#### 例子\n\n```\ngetComputeNodeCachingDelay() \n\n// output: 580\n```\n\n相关函数：[setComputeNodeCachingDelay](https://docs.dolphindb.cn/zh/funcs/s/setcomputenodecachingdelay.html)\n"
    },
    "getConfig": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getConfig.html",
        "signatures": [
            {
                "full": "getConfig([key])",
                "name": "getConfig",
                "parameters": [
                    {
                        "full": "[key]",
                        "name": "key",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [getConfig](https://docs.dolphindb.cn/zh/funcs/g/getConfig.html)\n\n\n\n#### 语法\n\ngetConfig(\\[key])\n\n#### 详情\n\n获取系统配置信息。系统内部将配置项按安全级别划分为敏感、标准和不敏感三类。\n\n* 敏感配置项：clusterReplicationExecutionPassword、s3SecretAccessKey、oauthClientSecret、metricsToken。\n* 不敏感配置项：webLoginRequired、webModules、oauth、oauthWebType、oauthAuthUri、oauthRedirectUri、oauthClientId、oauthAllowPasswordLoginNodes。\n* 标准配置项：除上述两类之外的其他配置。\n\n当启用配置访问控制（`enableConfigAccessControl=true`）时，函数仅返回当前用户有权限访问的配置项；若未启用访问控制，则不进行权限验证。\n\n**不同用户权限说明**\n\n<table id=\"table_frf_yhp_1hc\"><thead><tr><th>\n\n用户角色\n\n</th><th>\n\n不敏感配置\n\n</th><th>\n\n标准配置\n\n</th><th>\n\n敏感配置\n\n</th></tr></thead><tbody><tr><td>\n\n未登录用户\n\n</td><td>\n\n可以查看\n\n</td><td>\n\n不能查看\n\n</td><td>\n\n不能查看\n\n</td></tr><tr><td>\n\n普通用户\n\n</td><td>\n\n可以查看\n\n</td><td>\n\n可以查看\n\n</td><td>\n\n不能查看\n\n</td></tr><tr><td>\n\n管理员用户\n\n</td><td>\n\n可以查看\n\n</td><td>\n\n可以查看\n\n</td><td>\n\n不能查看\n\n</td></tr></tbody>\n</table>配置参数详情可查看[参数配置](../../db_distr_comp/cfg/para_cfg.md) 。\n\n#### 参数\n\n**key** 是一个字符串，表示配置参数名称，为可选参数。\n\n#### 返回值\n\n* 若不指定 *key*，返回一个字典，包含当前用户有权限读取的所有配置项及其对应值。\n* 若指定 *key*\n  * 若为有效配置参数且用户具有读取权限，返回字符串标量或向量，表示配置值；\n  * 若不是配置参数，或是有效配置但用户没有读取权限，则返回空值。\n"
    },
    "getConfigure": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getConfigure.html",
        "signatures": [
            {
                "full": "getConfig([key])",
                "name": "getConfig",
                "parameters": [
                    {
                        "full": "[key]",
                        "name": "key",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [getConfigure](https://docs.dolphindb.cn/zh/funcs/g/getConfigure.html)\n\n是 [getConfig](https://docs.dolphindb.cn/zh/funcs/g/getConfig.html) 的别名。\n\n\n以下是 `getConfig` 函数的文档：\n### [getConfig](https://docs.dolphindb.cn/zh/funcs/g/getConfig.html)\n\n\n\n#### 语法\n\ngetConfig(\\[key])\n\n#### 详情\n\n获取系统配置信息。系统内部将配置项按安全级别划分为敏感、标准和不敏感三类。\n\n* 敏感配置项：clusterReplicationExecutionPassword、s3SecretAccessKey、oauthClientSecret、metricsToken。\n* 不敏感配置项：webLoginRequired、webModules、oauth、oauthWebType、oauthAuthUri、oauthRedirectUri、oauthClientId、oauthAllowPasswordLoginNodes。\n* 标准配置项：除上述两类之外的其他配置。\n\n当启用配置访问控制（`enableConfigAccessControl=true`）时，函数仅返回当前用户有权限访问的配置项；若未启用访问控制，则不进行权限验证。\n\n**不同用户权限说明**\n\n<table id=\"table_frf_yhp_1hc\"><thead><tr><th>\n\n用户角色\n\n</th><th>\n\n不敏感配置\n\n</th><th>\n\n标准配置\n\n</th><th>\n\n敏感配置\n\n</th></tr></thead><tbody><tr><td>\n\n未登录用户\n\n</td><td>\n\n可以查看\n\n</td><td>\n\n不能查看\n\n</td><td>\n\n不能查看\n\n</td></tr><tr><td>\n\n普通用户\n\n</td><td>\n\n可以查看\n\n</td><td>\n\n可以查看\n\n</td><td>\n\n不能查看\n\n</td></tr><tr><td>\n\n管理员用户\n\n</td><td>\n\n可以查看\n\n</td><td>\n\n可以查看\n\n</td><td>\n\n不能查看\n\n</td></tr></tbody>\n</table>配置参数详情可查看[参数配置](../../db_distr_comp/cfg/para_cfg.md) 。\n\n#### 参数\n\n**key** 是一个字符串，表示配置参数名称，为可选参数。\n\n#### 返回值\n\n* 若不指定 *key*，返回一个字典，包含当前用户有权限读取的所有配置项及其对应值。\n* 若指定 *key*\n  * 若为有效配置参数且用户具有读取权限，返回字符串标量或向量，表示配置值；\n  * 若不是配置参数，或是有效配置但用户没有读取权限，则返回空值。\n"
    },
    "getConnections": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getConnections.html",
        "signatures": [
            {
                "full": "getConnections()",
                "name": "getConnections",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getConnections](https://docs.dolphindb.cn/zh/funcs/g/getConnections.html)\n\n\n\n#### 语法\n\ngetConnections()\n\n#### 详情\n\n获取当前节点的所有网络连接信息，可以在所有节点上执行。\n\n#### 参数\n\n无\n\n#### 返回值\n\n返回一个表，包含三列，第一列（server）为当前节点自己的 IP 和端口信息，第二列（client）为网络连接对端的 IP 和端口信息，第三列（startTime）为连接建立时间。\n\n#### 例子\n\n```\ngetConnections()\n```\n\n| server         | client          | startTime               |\n| -------------- | --------------- | ----------------------- |\n| localhost:8848 | 127.0.0.1:62546 | 2021.09.02T16:50:57.814 |\n| localhost:8848 | 127.0.0.1:63081 | 2021.09.02T10:50:16.350 |\n| localhost:8848 | 127.0.0.1:57559 | 2021.09.02T16:50:57.736 |\n"
    },
    "getConsoleJobs": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getConsoleJobs.html",
        "signatures": [
            {
                "full": "getConsoleJobs()",
                "name": "getConsoleJobs",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getConsoleJobs](https://docs.dolphindb.cn/zh/funcs/g/getConsoleJobs.html)\n\n\n\n#### 语法\n\ngetConsoleJobs()\n\n#### 详情\n\n查询本地节点上正在执行的交互式任务的描述信息。\n\n#### 参数\n\n无\n\n#### 返回值\n\n返回一个表，包含以下字段：\n\n| 参数                  | 含义                                                                                                                     |\n| ------------------- | ---------------------------------------------------------------------------------------------------------------------- |\n| node                | 本地节点的别名。                                                                                                               |\n| userID              | 用户 ID。                                                                                                                 |\n| rootJobId           | 系统中作业的唯一标识。                                                                                                            |\n| jobType             | 作业类型。                                                                                                                  |\n| desc                | 作业描述。                                                                                                                  |\n| priority            | 作业的优先级，为 0-9 之间的整数。                                                                                                    |\n| parallelism         | 作业的并行度，即分配给该作业的线程数上限。                                                                                                  |\n| receiveTime         | 作业被节点接收的时间。                                                                                                            |\n| sessionId           | 发起作业的会话 ID。                                                                                                            |\n| remoteIP            | 发起作业的客户端 IP。                                                                                                           |\n| remotePort          | 发起作业的客户端的端口号。                                                                                                          |\n| totalTasks          | 作业分解出的总任务数。                                                                                                            |\n| finishedTasks       | 作业分解出的任务中已经完成的任务数。                                                                                                     |\n| runningTask         | 作业分解出的任务中正在执行的任务数。                                                                                                     |\n| firstTaskStartTime  | 第一个任务的开始时间。                                                                                                            |\n| latestTaskStartTime | 最近一个任务的开始时间。                                                                                                           |\n| queue               | 任务队列类型： normal queue（0级 worker 队列），web queue（web 端 worker 队列），local task queue（1\\~5级 worker 队列），batchJob queue（批作业队列）。 |\n\n#### 例子\n\n```\ngetConsoleJobs()\n```\n\n| node     | userID | rootJobId                            | jobType | desc             | priority | parallelism | receiveTime             | sessionId  | remoteIP  | remotePort | totalTasks | finishedTasks | runningTask | firstTaskStartTime      | latestTaskStartTime     | queue        |\n| -------- | ------ | ------------------------------------ | ------- | ---------------- | -------- | ----------- | ----------------------- | ---------- | --------- | ---------- | ---------- | ------------- | ----------- | ----------------------- | ----------------------- | ------------ |\n| P2-node1 | admin  | 26681f9c-f914-81ae-47dd-8b8e6e106c48 | script  | getConsoleJobs() | 4        | 2           | 2022.01.05T11:05:06.778 | 1823289176 | 127.0.0.1 | 50595      | 1          | 0             | 1           | 2022.01.05T11:05:06.778 | 2022.01.05T11:05:06.778 | normal queue |\n"
    },
    "getControllerAlias": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getControllerAlias.html",
        "signatures": [
            {
                "full": "getControllerAlias()",
                "name": "getControllerAlias",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getControllerAlias](https://docs.dolphindb.cn/zh/funcs/g/getControllerAlias.html)\n\n\n\n#### 语法\n\ngetControllerAlias()\n\n#### 详情\n\n获取控制节点的别名。该别名定义在由配置参数 config 配置的文件中。\n\n#### 参数\n\n无\n\n#### 返回值\n\n一个字符串。\n\n#### 例子\n\n```\ngetControllerAlias();\n// output: master\n```\n\n相关函数：[getNodeAlias](https://docs.dolphindb.cn/zh/funcs/g/getNodeAlias.html)\n"
    },
    "getControllerElectionTick": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getControllerElectionTick.html",
        "signatures": [
            {
                "full": "getControllerElectionTick()",
                "name": "getControllerElectionTick",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getControllerElectionTick](https://docs.dolphindb.cn/zh/funcs/g/getControllerElectionTick.html)\n\n\n\n#### 语法\n\ngetControllerElectionTick()\n\n#### 详情\n\n获取控制节点组成的 raft 组的 election tick，即通过 `setRaftElectionTick` 设置的 *tickCount* 或配置项 *raftElectionTick* 的设置值。\n\n#### 参数\n\n无\n\n#### 返回值\n\n整型标量。\n\n相关函数： [setRaftElectionTick](https://docs.dolphindb.cn/zh/funcs/s/setRaftElectionTick.html), [getRaftElectionTick](https://docs.dolphindb.cn/zh/funcs/g/getRaftElectionTick.html)\n"
    },
    "getCurrentCatalog": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getCurrentCatalog.html",
        "signatures": [
            {
                "full": "getCurrentCatalog()",
                "name": "getCurrentCatalog",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getCurrentCatalog](https://docs.dolphindb.cn/zh/funcs/g/getCurrentCatalog.html)\n\n\n\n#### 语法\n\ngetCurrentCatalog()\n\n#### 详情\n\n查看当前 session 位于哪个 catalog 中。返回一个字符串。\n\n#### 参数\n\n无\n\n#### 返回值\n\n一个字符串。\n\n#### 例子\n\n```\nselect * from cat1.db1.table1 // 成功\nselect * from db1.table1 // 报错\n\nuse CATALOG cat1;\n\nselect * from db1.table1 // 成功\ngetCurrentCatalog() // Output:\"cat1\"\n```\n"
    },
    "getCurrentSessionAndUser": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getCurrentSessionAndUser.html",
        "signatures": [
            {
                "full": "getCurrentSessionAndUser()",
                "name": "getCurrentSessionAndUser",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getCurrentSessionAndUser](https://docs.dolphindb.cn/zh/funcs/g/getCurrentSessionAndUser.html)\n\n\n\n#### 语法\n\ngetCurrentSessionAndUser()\n\n#### 详情\n\n获取当前 session 的 session ID、用户名、远程 IP 地址和远程端口号。\n\n#### 参数\n\n无\n\n#### 返回值\n\n返回一个元组，第一个元素为 sessionId，第二个元素为 userId（若未登录，则返回\"guest\")，第三个元素为 remoteIP，第四个元素为 remotePort。\n\n#### 例子\n\n```\ngetCurrentSessionAndUser()  \n\n//Output (2333906441, \"admin\", \"127.0.0.1\", 60302)\n```\n"
    },
    "getCurrentTDEKeyVersion": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getcurrenttdekeyversion.html",
        "signatures": [
            {
                "full": "getCurrentTDEKeyVersion()",
                "name": "getCurrentTDEKeyVersion",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getCurrentTDEKeyVersion](https://docs.dolphindb.cn/zh/funcs/g/getcurrenttdekeyversion.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\ngetCurrentTDEKeyVersion()\n\n#### 详情\n\n获取当前应用的 TDE 密钥版本。仅 Linux 系统支持该功能。\n\n#### 参数\n\n无\n\n#### 返回值\n\nLONG 类型标量。\n\n#### 例子\n\n```\ngetCurrentTDEKeyVersion()\n// output: long(3,698,850,997)\n```\n"
    },
    "getDatabaseClusterReplicationStatus": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getDatabaseClusterReplicationStatus.html",
        "signatures": [
            {
                "full": "getDatabaseClusterReplicationStatus()",
                "name": "getDatabaseClusterReplicationStatus",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getDatabaseClusterReplicationStatus](https://docs.dolphindb.cn/zh/funcs/g/getDatabaseClusterReplicationStatus.html)\n\n\n\n#### 语法\n\ngetDatabaseClusterReplicationStatus()\n\n#### 详情\n\n查看所有数据库是否启用集群间的异步复制。该函数只能由管理员在主集群的数据节点调用。\n\n#### 参数\n\n无\n\n#### 返回值\n\n返回一个表，包含以下字段：\n\n* dbName：数据库的路径。\n\n* enabled：布尔值，表示是否启用集群间的异步复制。\n\n* executionSet：任务所属的执行集ID。\n\n相关函数：[setDatabaseForClusterReplication](https://docs.dolphindb.cn/zh/funcs/s/setDatabaseForClusterReplication.html)\n"
    },
    "getDatabasesByCluster": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getDatabasesByCluster.html",
        "signatures": [
            {
                "full": "getDatabasesByCluster(clusterName)",
                "name": "getDatabasesByCluster",
                "parameters": [
                    {
                        "full": "clusterName",
                        "name": "clusterName"
                    }
                ]
            }
        ],
        "markdown": "### [getDatabasesByCluster](https://docs.dolphindb.cn/zh/funcs/g/getDatabasesByCluster.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\ngetDatabasesByCluster(clusterName)\n\n#### 详情\n\n获取集群下所有数据库。只能由管理员在 MoM（Master of Master，管理集群）上执行该函数。\n\n#### 参数\n\n**clusterName** 字符串标量，表示要查询的集群名称。\n\n#### 返回值\n\n字符串向量。\n\n#### 例子\n\n```\ngetDatabasesByCluster(\"MoMSender\")\n\n// Output:   [\"dfs://db2\",\"dfs://db1\"]\n```\n"
    },
    "getDatanodeRestartInterval": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getDatanodeRestartInterval.html",
        "signatures": [
            {
                "full": "getDatanodeRestartInterval()",
                "name": "getDatanodeRestartInterval",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getDatanodeRestartInterval](https://docs.dolphindb.cn/zh/funcs/g/getDatanodeRestartInterval.html)\n\n\n\n#### 语法\n\ngetDatanodeRestartInterval()\n\n#### 详情\n\n在线获取内存中 DatanodeRestartInterval 的值。该命令只能由管理员在控制节点上调用。\n\n#### 参数\n\n无\n\n#### 返回值\n\n整型标量。\n\n相关函数：[setDatanodeRestartInterval](https://docs.dolphindb.cn/zh/funcs/s/setDatanodeRestartInterval.html)\n"
    },
    "getDataViewEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getDataViewEngine.html",
        "signatures": [
            {
                "full": "getDataViewEngine([CEPEngine], dataViewEngineName)",
                "name": "getDataViewEngine",
                "parameters": [
                    {
                        "full": "[CEPEngine]",
                        "name": "CEPEngine",
                        "optional": true
                    },
                    {
                        "full": "dataViewEngineName",
                        "name": "dataViewEngineName"
                    }
                ]
            }
        ],
        "markdown": "### [getDataViewEngine](https://docs.dolphindb.cn/zh/funcs/g/getDataViewEngine.html)\n\n\n\n#### 语法\n\ngetDataViewEngine(\\[CEPEngine], dataViewEngineName)\n\n#### 详情\n\n获取 DataView 引擎中的数据。\n\n#### 参数\n\n**CEPEngine** CEP 引擎的句柄。\n\n**dataViewEngineName** DataView 引擎的名称。\n\n#### 返回值\n\n一个表。该表记录了每个键值对应的最新记录。\n\n#### 例子\n\n```\nclass trades{\n    trader :: STRING\n    market :: STRING\n    code :: STRING\n    price :: DOUBLE\n    qty :: INT\n    eventTime :: TIMESTAMP\n    def trades(t, m, c, p, q){\n        trader = t\n        market = m\n        code = c\n        price = p\n        qty = q\n        eventTime = now()\n    }\n}\n\nclass mainMonitor:CEPMonitor{\n    tradesTable :: ANY\n    isBusy :: BOOL\n    def mainMonitor(){\n        tradesTable = array(ANY, 0)\n        isBusy = false\n    }\n\n    def updateTrades(event)\n\n    def updateTrades2(event)\n\n    def unOnload(){\n        undef('traderDV', SHARED)\n    }\n\n    def onload(){\n        addEventListener(updateTrades, `trades, , \"all\",,,,,\"trades1\")\n        addEventListener(updateTrades2, `trades, , \"all\",,,,,\"trades2\")\n        traderDV = streamTable(array(STRING, 0) as trader, array(STRING, 0) as market, array(SYMBOL, 0) as code, array(DOUBLE, 0) as price, array(INT, 0) as qty, array(INT, 0) as tradeCount, array(BOOL, 0) as busy, array(DATE, 0) as orderDate, array(TIMESTAMP, 0) as updateTime)\n        share(traderDV, 'traderDV')\n        createDataViewEngine('traderDV', objByName('traderDV'), `trader, `updateTime, true)\n    }\n\n    def updateTrades(event) {\n        tradesTable.append!([event.trader, event.market, event.code, event.price, event.qty])\n        getDataViewEngine('traderDV').append!(table(event.trader as trader, string() as market, string() as code, 0.0 as price, 0 as qty, 0 as tradeCount, false as busy, date(event.eventTime) as orderDate))\n        updateDataViewItems('traderDV', event.trader, ['market', 'code', 'price', 'qty', 'tradeCount'], [event.market, event.code, event.price, event.qty, tradesTable.size()])\n    }\n\n    def updateTrades2(event) {\n        tradesTable.append!([event.trader, event.market, event.code, event.price, event.qty])\n        getDataViewEngine('traderDV').append!(table(event.trader as trader, string() as market, string() as code, 0.0 as price, 0 as qty, 0 as tradeCount, false as busy, date(event.eventTime) as orderDate))\n        updateDataViewItems('traderDV', event.trader, ['market', 'code', 'price', 'qty', 'tradeCount'], [event.market, event.code, event.price, event.qty, tradesTable.size()])\n    }\n}\n\ndummy = table(array(TIMESTAMP, 0) as eventTime, array(STRING, 0) as eventType, array(BLOB, 0) as blobs)\nengineCep = createCEPEngine('cep1', <mainMonitor()>, dummy, [trades], 1, 'eventTime', 10000)\ntrade1 = trades('t1', 'sz', 's001', 11.0, 10)\ngo\nappendEvent(engineCep, trade1)\n// 查看 monitor\nmonitors = getCEPEngineMonitor('cep1',\"cep1\",\"mainMonitor\")\n// 查看 listener\nlisteners = monitors.getEventListener()\nprint(listeners)\n// 终止 listener\nlisteners['trades1'].terminate()\nprint(listeners)\n```\n\n**相关函数**：[createCEPEngine](https://docs.dolphindb.cn/zh/funcs/c/createCEPEngine.html), [createDataViewEngine](https://docs.dolphindb.cn/zh/funcs/c/createDataViewEngine.html), [deleteDataViewItems](https://docs.dolphindb.cn/zh/funcs/d/deleteDataViewItems.html)\n"
    },
    "getDBAccess": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getDBAccess.html",
        "signatures": [
            {
                "full": "getDBAccess(dbUrl)",
                "name": "getDBAccess",
                "parameters": [
                    {
                        "full": "dbUrl",
                        "name": "dbUrl"
                    }
                ]
            }
        ],
        "markdown": "### [getDBAccess](https://docs.dolphindb.cn/zh/funcs/g/getDBAccess.html)\n\n\n\n#### 语法\n\ngetDBAccess(dbUrl)\n\n#### 详情\n\n查看哪些用户和组具有与数据库 *dbUrl* 相关（包括 ALLOW 和 DENY 权限状态）的权限。\n\n该函数仅限 admin 和对数据库 *dbUrl* 具有 DB\\_OWNER 或 DB\\_MANAGE 权限的用户调用。\n\n#### 参数\n\n**dbUrl** 字符串标量，表示分布式数据库的地址。\n\n#### 返回值\n\n返回一个表：\n\n* name 具有相关权限的对象的名称。\n* type 该对象的类型，可选值为 user 和 group，分别对应用户和组。\n* DB\\_READ, DB\\_INSERT, DB\\_UPDATE, DB\\_DELETE, DBOBJ\\_CREATE, DBOBJ\\_DELETE, DB\\_MANAGE 分别指代对应权限，权限状态包括 ALLOW, DENY, NONE。关于用户权限的更多信息可参考[用户权限管理](https://docs.dolphindb.cn/zh/tutorials/ACL_and_Security.html)。\n\n#### 例子\n\n用户 user1 具有 DB\\_OWNER 权限，创建了数据库 `dfs://testDB`，并为用户 user2 授予 DB\\_READ 权限，禁止用户 user3 的 DB\\_INSERT 权限，为组 group1 授予 DBOBJ\\_CREATE 权限。此时，用户 user1 可通过 `getDBAccess` 函数查看哪些用户具有 \"dfs\\://testDB\" 相关的权限。\n\n```\nlogin(`user1, `123456)\ngetDBAccess(\"dfs://testDB\")\n```\n\n| name   | type  | DB\\_READ | DB\\_INSERT | DB\\_UPDATE | DB\\_DELETE | DBOBJ\\_CREATE | DBOBJ\\_DELETE | DB\\_MANAGE |\n| ------ | ----- | -------- | ---------- | ---------- | ---------- | ------------- | ------------- | ---------- |\n| group1 | group | NONE     | NONE       | NONE       | NONE       | ALLOW         | NONE          | NONE       |\n| user3  | user  | NONE     | DENY       | NONE       | NONE       | NONE          | NONE          | NONE       |\n| user2  | user  | ALLOW    | NONE       | NONE       | NONE       | NONE          | NONE          | NONE       |\n| admin  | user  | ALLOW    | ALLOW      | ALLOW      | ALLOW      | ALLOW         | ALLOW         | ALLOW      |\n\n**Related information**\n\n[getTableAccess](https://docs.dolphindb.cn/zh/funcs/g/gettableaccess.html)\n"
    },
    "getDFSDatabasesByOwner": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getdfsdatabasebyowner.html",
        "signatures": [
            {
                "full": "getDFSDatabasesByOwner(user)",
                "name": "getDFSDatabasesByOwner",
                "parameters": [
                    {
                        "full": "user",
                        "name": "user"
                    }
                ]
            }
        ],
        "markdown": "### [getDFSDatabasesByOwner](https://docs.dolphindb.cn/zh/funcs/g/getdfsdatabasebyowner.html)\n\n\n\n#### 语法\n\ngetDFSDatabasesByOwner(user)\n\n#### 详情\n\n该函数仅限管理员用户执行，查询当前集群中所有由用户 *user* 创建的数据库。\n\n#### 参数\n\n**user**STRING 类型标量，表示用户名。\n\n#### 返回值\n\n字符串向量。\n\n#### 例子\n\n```\ngetDFSDatabasesByOwner(user=\"user1\")\n// output:[\"dfs://tsdb1\",\"dfs://tsdb2\"]\n```\n"
    },
    "getDFSDatabases": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getDFSDatabases.html",
        "signatures": [
            {
                "full": "getDFSDatabases()",
                "name": "getDFSDatabases",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getDFSDatabases](https://docs.dolphindb.cn/zh/funcs/g/getDFSDatabases.html)\n\n\n\n#### 语法\n\ngetDFSDatabases()\n\n#### 详情\n\n查询当前节点上的分布式数据库。\n\n2.00.9 版本起，\n\n* 当该函数由管理员或拥有 DB\\_MANAGE 权限的用户执行时，返回当前节点上所有分布式数据库；\n\n* 否则，仅返回该用户有 DB\\_OWNER 权限的数据库。\n\n#### 参数\n\n无\n\n#### 返回值\n\n字符串向量。\n\n#### 例子\n\n```\ngetDFSDatabases()\n```\n"
    },
    "getDfsRebalanceConcurrency": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getDfsRebalanceConcurrency.html",
        "signatures": [
            {
                "full": "getDfsRebalanceConcurrency()",
                "name": "getDfsRebalanceConcurrency",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getDfsRebalanceConcurrency](https://docs.dolphindb.cn/zh/funcs/g/getDfsRebalanceConcurrency.html)\n\n\n\n#### 语法\n\ngetDfsRebalanceConcurrency()\n\n#### 详情\n\n获取控制节点上允许的再平衡任务的最大并发数。此函数只能由管理员在控制节点调用。\n\n#### 参数\n\n无\n\n#### 返回值\n\n整型标量。\n\n#### 例子\n\n```\ngetDfsRebalanceConcurrency()\n```\n\n相关函数：[resetDfsRebalanceConcurrency](https://docs.dolphindb.cn/zh/funcs/r/resetDfsRebalanceConcurrency.html)\n"
    },
    "getDfsRecoveryConcurrency": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getDfsRecoveryConcurrency.html",
        "signatures": [
            {
                "full": "getDfsRecoveryConcurrency()",
                "name": "getDfsRecoveryConcurrency",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getDfsRecoveryConcurrency](https://docs.dolphindb.cn/zh/funcs/g/getDfsRecoveryConcurrency.html)\n\n\n\n#### 语法\n\ngetDfsRecoveryConcurrency()\n\n#### 详情\n\n获取控制节点上允许的分区恢复任务的最大并发数。此函数只能由管理员在控制节点调用。\n\n#### 参数\n\n无\n\n#### 返回值\n\n整型标量。\n\n#### 例子\n\n```\ngetDfsRecoveryConcurrency()\n```\n\n相关函数：[resetDfsRecoveryConcurrency](https://docs.dolphindb.cn/zh/funcs/r/resetDfsRecoveryConcurrency.html)\n"
    },
    "getDFSTablesByDatabase": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getDFSTablesByDatabase.html",
        "signatures": [
            {
                "full": "getDFSTablesByDatabase(directory)",
                "name": "getDFSTablesByDatabase",
                "parameters": [
                    {
                        "full": "directory",
                        "name": "directory"
                    }
                ]
            }
        ],
        "markdown": "### [getDFSTablesByDatabase](https://docs.dolphindb.cn/zh/funcs/g/getDFSTablesByDatabase.html)\n\n\n\n#### 语法\n\ngetDFSTablesByDatabase(directory)\n\n#### 详情\n\n返回分布式数据库中的表。\n\n2.00.9 版本起，\n\n* 管理员可以返回当前节点上任一分布式表；\n* 其他用户执行时仅返回：\n\n  （1）拥有 DB\\_OWNER, DB\\_MANAGE, DB\\_READ, DB\\_WRITE, DB\\_INSERT, DB\\_UPDATE, DB\\_DELETE 权限的数据库所对应的分布式表；\n\n  （2）拥有 TABLE\\_READ, TABLE\\_WRITE, TABLE\\_INSERT, TABLE\\_UPDATE, TABLE\\_DELETE 权限的分布式表。\n\n#### 参数\n\n**directory** 是分布式数据库所在的目录。\n\n#### 返回值\n\n字符串向量。\n\n#### 例子\n\n```\ngetDFSTablesByDatabase(\"dfs://db\")\n// output: [\"dfs://db/dt\", \"dfs://db/dt1\"]\n```\n"
    },
    "getDiskIOStat": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getDiskIOStat.html",
        "signatures": [
            {
                "full": "getDiskIOStat()",
                "name": "getDiskIOStat",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getDiskIOStat](https://docs.dolphindb.cn/zh/funcs/g/getDiskIOStat.html)\n\n\n\n#### 语法\n\ngetDiskIOStat()\n\n#### 详情\n\n获取磁盘 I/O 统计信息。\n\n#### 参数\n\n无\n\n#### 返回值\n\n返回包含两个键值对的字典：\n\n* diskIOQueueDepths 是一个向量，表示每个 IO 队列的深度。在同一个 DolphinDB 实例中的所有 IO 任务都属于同一个 IO 队列。\n\n* diskIOConcurrencyLevel 是一个整数，表示 IO 队列的数量。\n\n#### 例子\n\n```\ngetDiskIOStat()\n\n// output\ndiskIOQueueDepths->[0]\ndiskIOConcurrnecyLevel->1\n```\n"
    },
    "getDynamicConfig": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getdynamicconfig.html",
        "signatures": [
            {
                "full": "getDynamicConfig()",
                "name": "getDynamicConfig",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getDynamicConfig](https://docs.dolphindb.cn/zh/funcs/g/getdynamicconfig.html)\n\n\n\n#### 语法\n\ngetDynamicConfig()\n\n#### 详情\n\n获取动态配置项的名称。\n\n#### 参数\n\n无\n\n#### 返回值\n\n返回一个向量，包含所有可以通过 `setDynamicConfig` 在线修改的配置项名。\n\n#### 例子\n\n```\ngetDynamicConfig();\n// output: [\"TSDBVectorIndexCacheSize\",\"TSDBCacheEngineSize\",\"dfsChunkNodeHeartBeatTimeout\",\"reservedMemSize\",\"recoveryWorkers\",\"OLAPCacheEngineSize\",\"memLimitOfTempResult\",\"maxMemSize\",\"memLimitOfAllTempResults\",\"maxPartitionNumPerQuery\",\"memLimitOfTaskGroupResult\",\"memLimitOfQueryResult\",\"maxConnections\",\"maxBlockSizeForReservedMemory\",\"TSDBBlockCacheSize\",\"logLevel\",\"enableNullSafeJoin\",\"enableMultiThreadMerge\"]\n```\n\n**Related information**\n\n[setDynamicConfig](https://docs.dolphindb.cn/zh/funcs/s/setdynamicconfig.html)\n"
    },
    "getEnableNullSafeJoin": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getenablenullsafejoin.html",
        "signatures": [
            {
                "full": "getEnableNullSafeJoin()",
                "name": "getEnableNullSafeJoin",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getEnableNullSafeJoin](https://docs.dolphindb.cn/zh/funcs/g/getenablenullsafejoin.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\ngetEnableNullSafeJoin()\n\n#### 详情\n\n返回在线修改后的 *enableNullSafeJoin* 的配置值。配置详情请参考文档 [DolphinDB-功能配置](https://docs.dolphindb.cn/zh/db_distr_comp/cfg/function_configuration.html)。\n\n#### 参数\n\n无\n\n#### 返回值\n\nBOOL 类型标量。\n\n#### 例子\n\n```\n// 设置 enableNullSafeJoin 为 true\nsetDynamicConfig(\"enableNullSafeJoin\", true)\n// 查看修改后的配置值\ngetEnableNullSafeJoin()\n// output: true\n```\n"
    },
    "getEnv": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getEnv.html",
        "signatures": [
            {
                "full": "getEnv(name, [default])",
                "name": "getEnv",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "[default]",
                        "name": "default",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [getEnv](https://docs.dolphindb.cn/zh/funcs/g/getEnv.html)\n\n\n\n#### 语法\n\ngetEnv(name, \\[default])\n\n#### 详情\n\n查询指定环境变量的值。如果环境变量不存在，则返回 default 参数。\n\n#### 参数\n\n**name** 是字符串标量，表示环境变量名称。\n\n**default** 是字符串标量，表示不存在对应的环境变量时返回的默认值。如果没有指定 default，默认值为空字符串。\n\n#### 返回值\n\n字符串标量。\n\n#### 例子\n\n```\ngetEnv(\"path\")\n```\n\n返回：`C:\\ProgramData\\DockerDesktop\\version-bin;C:\\Program Files\\Docker\\Docker\\Resources\\bin;`\n\n```\ngetEnv(\"JAVA_HOME\");\n```\n\n返回：`C:\\Program Files\\Java\\jdk1.8.0_191`\n\n```\ngetEnv(\"not_exist\",\"not exist\")\n```\n\n返回：`not exist`\n"
    },
    "getEventListener": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getEventListener.html",
        "signatures": [
            {
                "full": "getEventListener([listenerName])",
                "name": "getEventListener",
                "parameters": [
                    {
                        "full": "[listenerName]",
                        "name": "listenerName",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [getEventListener](https://docs.dolphindb.cn/zh/funcs/g/getEventListener.html)\n\n\n\n#### 语法\n\ngetEventListener(\\[listenerName])\n\n#### 详情\n\n在 CEP 引擎中，`getEventListener` 是 monitor 的一个成员方法，可用于查询当前 monitor 中已注册的事件监听器实例。若指定 *listenerName*，则返回对应的事件监听器实例，否则返回所有事件监听器实例。\n\n#### 参数\n\n**listenerName** 字符串标量，表示事件监听器名称。\n\n#### 返回值\n\n一个 EventListener 实例，或一个字典（键为事件监听器名称， 值为事件监听器实例）。\n\n#### 例子\n\n```\nclass trades{\n    trader :: STRING\n    market :: STRING\n    code :: STRING\n    price :: DOUBLE\n    qty :: INT\n    eventTime :: TIMESTAMP\n    def trades(t, m, c, p, q){\n        trader = t\n        market = m\n        code = c\n        price = p\n        qty = q\n        eventTime = now()\n    }\n}\n\nclass mainMonitor:CEPMonitor{\n    tradesTable :: ANY\n    isBusy :: BOOL\n    def mainMonitor(){\n        tradesTable = array(ANY, 0)\n        isBusy = false\n    }\n\n    def updateTrades(event)\n\n    def updateTrades2(event)\n\n    def unOnload(){\n        undef('traderDV', SHARED)\n    }\n\n    def onload(){\n        addEventListener(updateTrades, `trades, , \"all\",,,,,\"trades1\")\n        addEventListener(updateTrades2, `trades, , \"all\",,,,,\"trades2\")\n        traderDV = streamTable(array(STRING, 0) as trader, array(STRING, 0) as market, array(SYMBOL, 0) as code, array(DOUBLE, 0) as price, array(INT, 0) as qty, array(INT, 0) as tradeCount, array(BOOL, 0) as busy, array(DATE, 0) as orderDate, array(TIMESTAMP, 0) as updateTime)\n        share(traderDV, 'traderDV')\n        createDataViewEngine('traderDV', objByName('traderDV'), `trader, `updateTime, true)\n    }\n\n    def updateTrades(event) {\n        tradesTable.append!([event.trader, event.market, event.code, event.price, event.qty])\n        getDataViewEngine('traderDV').append!(table(event.trader as trader, string() as market, string() as code, 0.0 as price, 0 as qty, 0 as tradeCount, false as busy, date(event.eventTime) as orderDate))\n        updateDataViewItems('traderDV', event.trader, ['market', 'code', 'price', 'qty', 'tradeCount'], [event.market, event.code, event.price, event.qty, tradesTable.size()])\n    }\n\n    def updateTrades2(event) {\n        tradesTable.append!([event.trader, event.market, event.code, event.price, event.qty])\n        getDataViewEngine('traderDV').append!(table(event.trader as trader, string() as market, string() as code, 0.0 as price, 0 as qty, 0 as tradeCount, false as busy, date(event.eventTime) as orderDate))\n        updateDataViewItems('traderDV', event.trader, ['market', 'code', 'price', 'qty', 'tradeCount'], [event.market, event.code, event.price, event.qty, tradesTable.size()])\n    }\n}\n\ndummy = table(array(TIMESTAMP, 0) as eventTime, array(STRING, 0) as eventType, array(BLOB, 0) as blobs)\nengineCep = createCEPEngine('cep1', <mainMonitor()>, dummy, [trades], 1, 'eventTime', 10000)\ntrade1 = trades('t1', 'sz', 's001', 11.0, 10)\ngo\nappendEvent(engineCep, trade1)\n// 查看 monitor\nmonitors = getCEPEngineMonitor('cep1',\"cep1\",\"mainMonitor\")\n// 查看 listener\nlisteners = monitors.getEventListener()\nprint(listeners)\n// 终止 listener\nlisteners['trades1'].terminate()\nprint(listeners)\n```\n\n**相关函数**：[addEventListener](https://docs.dolphindb.cn/zh/funcs/a/addEventListener.html)\n"
    },
    "getExecDir": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getExecDir.html",
        "signatures": [
            {
                "full": "getExecDir()",
                "name": "getExecDir",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getExecDir](https://docs.dolphindb.cn/zh/funcs/g/getExecDir.html)\n\n首发版本：3.00.4，3.00.3.1\n\n\n\n#### 语法\n\ngetExecDir()\n\n#### 详情\n\n获取 dolphindb 可执行文件所在目录的绝对路径。\n\n#### 参数\n\n无\n\n#### 返回值\n\n字符串标量。\n\n#### 例子\n\n```\ngetExecDir()\n// output: /home/dolphindb/server\n```\n"
    },
    "getFunctionViews": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getFunctionViews.html",
        "signatures": [
            {
                "full": "getFunctionViews()",
                "name": "getFunctionViews",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getFunctionViews](https://docs.dolphindb.cn/zh/funcs/g/getFunctionViews.html)\n\n\n\n#### 语法\n\ngetFunctionViews()\n\n#### 详情\n\n管理员执行该函数，返回所有用户创建的函数视图；拥有 VIEW\\_OWNER 权限的用户执行该函数只返回该用户创建的函数视图。\n\n#### 参数\n\n无\n\n#### 返回值\n\n一张表，包含四列：\n\n* name：函数名。\n\n* body：函数体。对于直接通过 dom 模块封装的视图，或使用 use \\<moduleName> 的方式加载 dom 模块后再封装其中函数得到的函数视图，该字段将显示函数名，不会显示其函数体。\n\n* owner：函数视图的创建者。\n\n* createTime：函数视图的创建时间。\n\n#### 例子\n\n```\ndef myFunc(){\n    print \"myFunc\"\n}\n\naddFunctionView(udf=myFunc)\ngetFunctionViews()\n```\n\n| name   | body                            | owner | createTime              |\n| ------ | ------------------------------- | ----- | ----------------------- |\n| myFunc | def myFunc(){ print(\"myFunc\") } | admin | 2026.02.02 11:10:54.114 |\n\n**相关函数**：[addFunctionView](https://docs.dolphindb.cn/zh/funcs/a/addFunctionView.html)\n"
    },
    "getGroupAccess": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getGroupAccess.html",
        "signatures": [
            {
                "full": "getGroupAccess(groupIds)",
                "name": "getGroupAccess",
                "parameters": [
                    {
                        "full": "groupIds",
                        "name": "groupIds"
                    }
                ]
            }
        ],
        "markdown": "### [getGroupAccess](https://docs.dolphindb.cn/zh/funcs/g/getGroupAccess.html)\n\n\n\n#### 语法\n\ngetGroupAccess(groupIds)\n\n#### 详情\n\n查询组的权限。只能由管理员执行该函数。\n\n**Note:**\n\n* 自 3.00.5 版本起，支持获取 Orca 流图、流表权限。\n\n* 自 3.00.2 版本起，支持获取访问计算节点组的权限。\n\n* 自 3.00.0 版本起，支持获取访问 catalog 的相关权限。\n\n#### 参数\n\n**groupIds** 表示组名的字符串标量或向量。\n\n#### 返回值\n\n一个内存表，包含组权限信息。\n\n#### 例子\n\n```\ngetGroupAccess(\"myGroup\")\n```\n"
    },
    "getGroupAccessByCluster": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getGroupAccessByCluster.html",
        "signatures": [
            {
                "full": "getGroupAccessByCluster(groupIds, clusterName)",
                "name": "getGroupAccessByCluster",
                "parameters": [
                    {
                        "full": "groupIds",
                        "name": "groupIds"
                    },
                    {
                        "full": "clusterName",
                        "name": "clusterName"
                    }
                ]
            }
        ],
        "markdown": "### [getGroupAccessByCluster](https://docs.dolphindb.cn/zh/funcs/g/getGroupAccessByCluster.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\ngetGroupAccessByCluster(groupIds, clusterName)\n\n#### 详情\n\n查询指定用户组的权限。只能由管理员在 MoM（Master of Master，管理集群）上执行该函数。\n\n#### 参数\n\n**groupIds** 字符串标量或向量，表示要查询的用户组名称。\n\n**clusterName** 字符串标量，表示用户组所属的集群名称。\n\n#### 返回值\n\n返回一个表， 字段与 `getGroupAccess` 函数的返回结果一致。\n\n#### 例子\n\n```\ngetGroupAccessByCluster([\"group2\"], \"MoMSender\")  \n```\n\n| groupName | users | ACCESS\\_READ | ACCESS\\_INSERT | ACCESS\\_UPDATE | ACCESS\\_DELETE | VIEW\\_EXEC | SCRIPT\\_EXEC | TEST\\_EXEC | DBOBJ\\_CREATE | ... |\n| --------- | ----- | ------------ | -------------- | -------------- | -------------- | ---------- | ------------ | ---------- | ------------- | --- |\n| group2    | user2 | none         | allow          | none           | none           | none       | none         | none       | none          | ... |\n\n相关函数：[getGroupAccess](https://docs.dolphindb.cn/zh/funcs/g/getGroupAccess.html)\n"
    },
    "getGroupList": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getGroupList.html",
        "signatures": [
            {
                "full": "getGroupList()",
                "name": "getGroupList",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getGroupList](https://docs.dolphindb.cn/zh/funcs/g/getGroupList.html)\n\n\n\n#### 语法\n\ngetGroupList()\n\n#### 详情\n\n查询所有用户组。\n\n**Note:** 该函数只能由管理员在控制节点、数据节点和计算节点运行。\n\n#### 参数\n\n无\n\n#### 返回值\n\n字符串向量。\n\n#### 例子\n\n```\ngetGroupList()\n\n// output: [\"MVP\",\"MYMVP\"]\n```\n"
    },
    "getGroupListOfAllClusters": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getGroupListOfAllClusters.html",
        "signatures": [
            {
                "full": "getGroupListOfAllClusters()",
                "name": "getGroupListOfAllClusters",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getGroupListOfAllClusters](https://docs.dolphindb.cn/zh/funcs/g/getGroupListOfAllClusters.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\ngetGroupListOfAllClusters()\n\n#### 详情\n\n查询多集群系统中所有集群的用户组信息。只能由管理员在 MoM（Master of Master，管理集群）上执行该函数。\n\n#### 参数\n\n无\n\n#### 返回值\n\n返回一个字典，其中：\n\n* key：集群名称。\n* value：用户组名称列表。\n\n#### 例子\n\n```\ngetGroupListOfAllClusters()\n      \n/* Output:\nmasterOfMaster->[\"group1\"]\nMoMSender->[\"group2\"]  \n*/  \n```\n"
    },
    "getGroupsByUserId": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getGroupsByUserId.html",
        "signatures": [
            {
                "full": "getGroupsByUserId(userId)",
                "name": "getGroupsByUserId",
                "parameters": [
                    {
                        "full": "userId",
                        "name": "userId"
                    }
                ]
            }
        ],
        "markdown": "### [getGroupsByUserId](https://docs.dolphindb.cn/zh/funcs/g/getGroupsByUserId.html)\n\n\n\n#### 语法\n\ngetGroupsByUserId(userId)\n\n#### 详情\n\n查询用户所在的组。\n\n**Note:** 该函数只能由管理员在控制节点、数据节点和计算节点运行。\n\n#### 参数\n\n**userId** 是表示用户名的字符串。\n\n#### 返回值\n\n字符串向量。\n\n#### 例子\n\n```\ngetGroupsByUserId(\"admin\")\n\n// output: [\"MVP\",\"MYMVP\"]\n```\n"
    },
    "getHaMvccLeader": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getHaMvccLeader.html",
        "signatures": [
            {
                "full": "getHaMvccLeader(groupId)",
                "name": "getHaMvccLeader",
                "parameters": [
                    {
                        "full": "groupId",
                        "name": "groupId"
                    }
                ]
            }
        ],
        "markdown": "### [getHaMvccLeader](https://docs.dolphindb.cn/zh/funcs/g/getHaMvccLeader.html)\n\n首发版本：3.00.5\n\n\n\n#### 语法\n\ngetHaMvccLeader(groupId)\n\n#### 详情\n\n获取指定 MVCC Raft 组的 Leader 节点别名。\n\n#### 参数\n\n**groupId** 是一个整数，表示 MVCC Raft 组 ID。\n\n#### 返回值\n\nSTRING 类型标量。\n\n#### 例子\n\n```\ngetHaMvccLeader(5)\n// output\n\"dnode1\"\n```\n\n**相关函数**：[haMvccTable](https://docs.dolphindb.cn/zh/funcs/h/haMvccTable.html)\n"
    },
    "getHaMvccRaftGroups": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getHaMvccRaftGroups.html",
        "signatures": [
            {
                "full": "getHaMvccRaftGroups()",
                "name": "getHaMvccRaftGroups",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getHaMvccRaftGroups](https://docs.dolphindb.cn/zh/funcs/g/getHaMvccRaftGroups.html)\n\n首发版本：3.00.5\n\n\n\n#### 语法\n\ngetHaMvccRaftGroups()\n\n#### 详情\n\n获取当前节点所在的、与 MVCC 表高可用相关的 Raft 组信息。\n\n#### 返回值\n\n返回一个表，包含以下列：\n\n* id：INT 类型列，表示 MVCC Raft 组 ID。\n\n* sites：STRING 类型列，展示该 Raft 组包含的节点信息。\n\n#### 例子\n\n```\ngetHaMvccRaftGroups()\n```\n\n| id | sites                 |\n| -- | --------------------- |\n| 5  | dnode1,dnonde2,cnode1 |\n\n**相关函数**：[haMvccTable](https://docs.dolphindb.cn/zh/funcs/h/haMvccTable.html)\n"
    },
    "getHaMvccTableInfo": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getHaMvccTableInfo.html",
        "signatures": [
            {
                "full": "getHaMvccTableInfo(groupId)",
                "name": "getHaMvccTableInfo",
                "parameters": [
                    {
                        "full": "groupId",
                        "name": "groupId"
                    }
                ]
            }
        ],
        "markdown": "### [getHaMvccTableInfo](https://docs.dolphindb.cn/zh/funcs/g/getHaMvccTableInfo.html)\n\n首发版本：3.00.5\n\n\n\n#### 语法\n\ngetHaMvccTableInfo(groupId)\n\n#### 详情\n\n获取指定 MVCC Raft 组内所有的元信息。\n\n此函数必须在该 Raft 组的成员节点上执行。\n\n#### 参数\n\n**groupId** 是一个整数，表示 HaMvcc 的 Raft 组 ID。\n\n#### 返回值\n\n返回一个表，包含以下列（列名以实际系统输出为准）：\n\n* `tableName`：STRING 类型，表示表名。\n\n* `rows`：LONG 类型，表示行数。\n\n* `memoryUsed`：LONG 类型，表示内存占用，单位为字节。\n\n* `schema`：STRING 类型，表示表结构。\n\n* `defaultValues`：STRING 类型，表示各列的默认值。\n\n* `allowNull`：STRING 类型，表示各列是否允许值为 NULL。\n\n#### 例子\n\n```\ngetHaMvccTableInfo(5)\n```\n\n| tableName  | rows | memoryUsed | schema                            | defaultValues | allowNull          |\n| ---------- | ---- | ---------- | --------------------------------- | ------------- | ------------------ |\n| demoHaMvcc | 10   | 640        | name:STRING, id:INT, value:DOUBLE | A001, 1, 3.6  | false, true, false |\n\n**相关函数**：[haMvccTable](https://docs.dolphindb.cn/zh/funcs/h/haMvccTable.html)\n"
    },
    "getHomeDir": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getHomeDir.html",
        "signatures": [
            {
                "full": "getHomeDir()",
                "name": "getHomeDir",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getHomeDir](https://docs.dolphindb.cn/zh/funcs/g/getHomeDir.html)\n\n\n\n#### 语法\n\ngetHomeDir()\n\n#### 详情\n\n查询本地节点的主目录。主目录是由配置文件 dolphindb.cfg 定义的。\n\n#### 参数\n\n无\n\n#### 返回值\n\n字符串标量。\n\n#### 例子\n\n```\ngetHomeDir()\n\n// output: /data/ddb/server\n```\n"
    },
    "getInstrumentCalendar": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getinstrumentcalendar.html",
        "signatures": [
            {
                "full": "getInstrumentCalendar(instrument)",
                "name": "getInstrumentCalendar",
                "parameters": [
                    {
                        "full": "instrument",
                        "name": "instrument"
                    }
                ]
            }
        ],
        "markdown": "### [getInstrumentCalendar](https://docs.dolphindb.cn/zh/funcs/g/getinstrumentcalendar.html)\n\n首发版本：3.00.4.1\n\n\n\n#### 语法\n\ngetInstrumentCalendar(instrument)\n\n#### 详情\n\n根据输入的金融工具，获取该工具的交易日历。\n\n#### 参数\n\n**instrument** INSTRUMENT 类型标量或向量，表示金融工具。\n\n#### 返回值\n\nSTRING 类型标量或向量。\n\n#### 例子\n\n```\nswap = {\n    \"productType\": \"Swap\",\n    \"swapType\": \"IrSwap\",\n    \"irSwapType\": \"IrFixedFloatingSwap\",\n    \"start\": 2021.05.15,\n    \"maturity\": 2023.05.15,\n    \"frequency\": \"Quarterly\",\n    \"fixedRate\": 0.02,\n    \"calendar\": \"CFET\", \n    \"fixedDayCountConvention\": \"Actual365\",\n    \"floatingDayCountConvention\": \"Actual360\",\n    \"payReceive\": \"Pay\",\n    \"iborIndex\": \"SHIBOR_3M\",\n    \"spread\": 0.0005,\n    \"notionalCurrency\": \"CNY\",\n    \"notionalAmount\": 1E8\n}\nins = parseInstrument(swap)\ngetInstrumentCalendar(ins)\n\n// output: CFET\n```\n\n**相关函数：**[parseInstrument](https://docs.dolphindb.cn/zh/funcs/p/parseInstrument.html)、[getInstrumentField](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentField.html)、[getInstrumentKeys](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentKeys.html)\n"
    },
    "getInstrumentCoupon": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getInstrumentCoupon.html",
        "signatures": [
            {
                "full": "getInstrumentCoupon(instrument)",
                "name": "getInstrumentCoupon",
                "parameters": [
                    {
                        "full": "instrument",
                        "name": "instrument"
                    }
                ]
            }
        ],
        "markdown": "### [getInstrumentCoupon](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentCoupon.html)\n\n首发版本：3.00.4.1\n\n\n\n#### 语法\n\ngetInstrumentCoupon(instrument)\n\n#### 详情\n\n根据输入的金融工具，获取该工具的票面利率（Coupon Rate）。\n\n#### 参数\n\n**instrument** INSTRUMENT 类型标量或向量，表示金融工具。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\nbond = {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Bond\",\n    \"bondType\": \"FixedRateBond\",\n    \"nominal\": 100,\n    \"instrumentId\": \"0001\",\n    \"start\": 2022.05.15,\n    \"maturity\": 2032.05.15,\n    \"dayCountConvention\": \"ActualActualISDA\",\n    \"coupon\": 0.0276,\n    \"issuePrice\": 100.0,\n    \"frequency\": \"Semiannual\"\n}\nins = parseInstrument(bond)\ngetInstrumentCoupon(ins)\n// output: 0.0276\n```\n\n**相关函数：**[parseInstrument](https://docs.dolphindb.cn/zh/funcs/p/parseInstrument.html)、[getInstrumentField](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentField.html)、[getInstrumentKeys](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentKeys.html)\n"
    },
    "getInstrumentCreditRating": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getinstrumentcreditrating.html",
        "signatures": [
            {
                "full": "getInstrumentCreditRating(instrument)",
                "name": "getInstrumentCreditRating",
                "parameters": [
                    {
                        "full": "instrument",
                        "name": "instrument"
                    }
                ]
            }
        ],
        "markdown": "### [getInstrumentCreditRating](https://docs.dolphindb.cn/zh/funcs/g/getinstrumentcreditrating.html)\n\n首发版本：3.00.4.1\n\n\n\n#### 语法\n\ngetInstrumentCreditRating(instrument)\n\n#### 详情\n\n根据输入的金融工具，获取该工具的信用评级（Credit Rating）。\n\n#### 参数\n\n**instrument** INSTRUMENT 类型标量或向量，表示金融工具。\n\n#### 返回值\n\nSTRING 类型标量或向量。\n\n#### 例子\n\n```\nbond = {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Bond\",\n    \"bondType\": \"ZeroCouponBond\",\n    \"instrumentId\": \"0001\",\n    \"start\": 1996.03.01,\n    \"maturity\": 2032.05.15,\n    \"dayCountConvention\": \"ActualActualISDA\",\n    \"coupon\": 0.0276,\n    \"issuePrice\": 100.0,\n    \"frequency\": \"Semiannual\",\n    \"subType\":\"TREASURY_BOND\",\n    \"creditRating\":\"B\",\n    \"settlement\": 2022.05.15 \n}\nins = parseInstrument(bond)\ngetInstrumentCreditRating(ins)\n// output: B\n```\n\n**相关函数：**[parseInstrument](https://docs.dolphindb.cn/zh/funcs/p/parseInstrument.html)、[getInstrumentField](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentField.html)、[getInstrumentKeys](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentKeys.html)\n"
    },
    "getInstrumentCurrency": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getinstrumentcurrency.html",
        "signatures": [
            {
                "full": "getInstrumentCurrency(instrument)",
                "name": "getInstrumentCurrency",
                "parameters": [
                    {
                        "full": "instrument",
                        "name": "instrument"
                    }
                ]
            }
        ],
        "markdown": "### [getInstrumentCurrency](https://docs.dolphindb.cn/zh/funcs/g/getinstrumentcurrency.html)\n\n首发版本：3.00.4.1\n\n\n\n#### 语法\n\ngetInstrumentCurrency(instrument)\n\n#### 详情\n\n根据输入的金融工具，获取该工具的货币类型。\n\n#### 参数\n\n**instrument** INSTRUMENT 类型标量或向量，表示金融工具。\n\n#### 返回值\n\nSTRING 类型标量或向量。\n\n#### 例子\n\n```\nbond = {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Bond\",\n    \"bondType\": \"FixedRateBond\",\n    \"nominal\": 100,\n    \"instrumentId\": \"0001\",\n    \"start\": 2022.05.15,\n    \"maturity\": 2032.05.15,\n    \"dayCountConvention\": \"ActualActualISDA\",\n    \"coupon\": 0.0276,\n    \"issuePrice\": 100.0,\n    \"frequency\": \"Semiannual\",\n    \"currency\": \"USD\"\n}\nins = parseInstrument(bond)\ngetInstrumentCurrency(ins)\n// output: USD\n```\n\n**相关函数：**[parseInstrument](https://docs.dolphindb.cn/zh/funcs/p/parseInstrument.html)、[getInstrumentField](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentField.html)、[getInstrumentKeys](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentKeys.html)\n"
    },
    "getInstrumentCurrencyPair": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getinstrumentcurrencypair.html",
        "signatures": [
            {
                "full": "getInstrumentCurrencyPair(instrument)",
                "name": "getInstrumentCurrencyPair",
                "parameters": [
                    {
                        "full": "instrument",
                        "name": "instrument"
                    }
                ]
            }
        ],
        "markdown": "### [getInstrumentCurrencyPair](https://docs.dolphindb.cn/zh/funcs/g/getinstrumentcurrencypair.html)\n\n首发版本：3.00.4.1\n\n\n\n#### 语法\n\ngetInstrumentCurrencyPair(instrument)\n\n#### 详情\n\n根据输入的金融工具，获取该工具的货币对。\n\n#### 参数\n\n**instrument** INSTRUMENT 类型标量或向量，表示金融工具。\n\n#### 返回值\n\nSTRING 类型标量或向量。\n\n#### 例子\n\n```\nforward = {\n    \"productType\": \"Forward\",\n    \"forwardType\": \"FxForward\",\n    \"expiry\": 2025.09.24,\n    \"delivery\": 2025.09.26,\n    \"currencyPair\": \"USDCNY\",\n    \"direction\": \"Buy\",\n    \"notionalCurrency\": \"USD\",\n    \"notionalAmount\": 1E8,\n    \"strike\": 7.2\n}\nins = parseInstrument(forward)\ngetInstrumentCurrencyPair(ins)\n// output: USDCNY\n```\n\n**相关函数：**[parseInstrument](https://docs.dolphindb.cn/zh/funcs/p/parseInstrument.html)、[getInstrumentField](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentField.html)、[getInstrumentKeys](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentKeys.html)\n"
    },
    "getInstrumentDayCountConvention": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getInstrumentDayCountConvention.html",
        "signatures": [
            {
                "full": "getInstrumentDayCountConvention(instrument)",
                "name": "getInstrumentDayCountConvention",
                "parameters": [
                    {
                        "full": "instrument",
                        "name": "instrument"
                    }
                ]
            }
        ],
        "markdown": "### [getInstrumentDayCountConvention](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentDayCountConvention.html)\n\n首发版本：3.00.4.1\n\n\n\n#### 语法\n\ngetInstrumentDayCountConvention(instrument)\n\n#### 详情\n\n根据输入的金融工具，获取该工具的计息日规则（Day Count Convention）。\n\n#### 参数\n\n**instrument** INSTRUMENT 类型标量或向量，表示金融工具。\n\n#### 返回值\n\nSTRING 类型标量或向量。\n\n#### 例子\n\n```\nbond = {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Bond\",\n    \"bondType\": \"FixedRateBond\",\n    \"nominal\": 100,\n    \"instrumentId\": \"0001\",\n    \"start\": 2022.05.15,\n    \"maturity\": 2032.05.15,\n    \"dayCountConvention\": \"ActualActualISDA\",\n    \"coupon\": 0.0276,\n    \"issuePrice\": 100.0,\n    \"frequency\": \"Semiannual\"\n}\nins = parseInstrument(bond)\ngetInstrumentDayCountConvention(ins)\n// output: ActualActualISDA\n```\n\n**相关函数：**[parseInstrument](https://docs.dolphindb.cn/zh/funcs/p/parseInstrument.html)、[getInstrumentField](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentField.html)、[getInstrumentKeys](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentKeys.html)\n"
    },
    "getInstrumentDelivery": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getinstrumentdelivery.html",
        "signatures": [
            {
                "full": "getInstrumentDelivery(instrument)",
                "name": "getInstrumentDelivery",
                "parameters": [
                    {
                        "full": "instrument",
                        "name": "instrument"
                    }
                ]
            }
        ],
        "markdown": "### [getInstrumentDelivery](https://docs.dolphindb.cn/zh/funcs/g/getinstrumentdelivery.html)\n\n首发版本：3.00.4.1\n\n\n\n#### 语法\n\ngetInstrumentDelivery(instrument)\n\n#### 详情\n\n根据输入的金融工具，获取该工具的交割日期（Delivery Date）。\n\n#### 参数\n\n**instrument** INSTRUMENT 类型标量或向量，表示金融工具。\n\n#### 返回值\n\nDATE 类型标量或向量。\n\n#### 例子\n\n```\nforward =  {\n   \"productType\": \"Forward\",\n    \"forwardType\": \"FxForward\",\n    \"expiry\": 2025.09.24,\n    \"delivery\": 2025.09.26,\n    \"currencyPair\": \"USDCNY\",\n    \"direction\": \"Buy\",\n    \"notionalCurrency\": \"USD\",\n    \"notionalAmount\": 1E8,\n    \"strike\": 7.2\n}\nins = parseInstrument(forward)\ngetInstrumentDelivery(ins)\n\n// output: 2025.09.26\n```\n\n**相关函数：**[parseInstrument](https://docs.dolphindb.cn/zh/funcs/p/parseInstrument.html)、[getInstrumentField](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentField.html)、[getInstrumentKeys](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentKeys.html)\n"
    },
    "getInstrumentDirection": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getinstrumentdirection.html",
        "signatures": [
            {
                "full": "getInstrumentDirection(instrument)",
                "name": "getInstrumentDirection",
                "parameters": [
                    {
                        "full": "instrument",
                        "name": "instrument"
                    }
                ]
            }
        ],
        "markdown": "### [getInstrumentDirection](https://docs.dolphindb.cn/zh/funcs/g/getinstrumentdirection.html)\n\n首发版本：3.00.4.1\n\n\n\n#### 语法\n\ngetInstrumentDirection(instrument)\n\n#### 详情\n\n根据输入的金融工具，获取该工具的交易方向。\n\n#### 参数\n\n**instrument** INSTRUMENT 类型标量或向量，表示金融工具。\n\n#### 返回值\n\nSTRING 类型标量或向量。\n\n#### 例子\n\n```\nforward = {\n    \"productType\": \"Forward\",\n    \"forwardType\": \"FxForward\",\n    \"expiry\": 2025.09.24,\n    \"delivery\": 2025.09.26,\n    \"currencyPair\": \"USDCNY\",\n    \"direction\": \"Buy\",\n    \"notionalCurrency\": \"USD\",\n    \"notionalAmount\": 1E8,\n    \"strike\": 7.2\n}\nins = parseInstrument(forward)\ngetInstrumentDirection(ins)\n// output: Buy         \n```\n\n**相关函数：**[parseInstrument](https://docs.dolphindb.cn/zh/funcs/p/parseInstrument.html)、[getInstrumentField](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentField.html)、[getInstrumentKeys](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentKeys.html)\n"
    },
    "getInstrumentExpiry": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getinstrumentexpiry.html",
        "signatures": [
            {
                "full": "getInstrumentExpiry(instrument)",
                "name": "getInstrumentExpiry",
                "parameters": [
                    {
                        "full": "instrument",
                        "name": "instrument"
                    }
                ]
            }
        ],
        "markdown": "### [getInstrumentExpiry](https://docs.dolphindb.cn/zh/funcs/g/getinstrumentexpiry.html)\n\n首发版本：3.00.4.1\n\n\n\n#### 语法\n\ngetInstrumentExpiry(instrument)\n\n#### 详情\n\n根据输入的金融工具，获取该工具的到期日（Expiry Date）。\n\n#### 参数\n\n**instrument** INSTRUMENT 类型标量或向量，表示金融工具。\n\n#### 返回值\n\nDATE 类型标量或向量。\n\n#### 例子\n\n```\nforward =  {\n   \"productType\": \"Forward\",\n    \"forwardType\": \"FxForward\",\n    \"expiry\": 2025.09.24,\n    \"delivery\": 2025.09.26,\n    \"currencyPair\": \"USDCNY\",\n    \"direction\": \"Buy\",\n    \"notionalCurrency\": \"USD\",\n    \"notionalAmount\": 1E8,\n    \"strike\": 7.2\n}\nins = parseInstrument(forward)\ngetInstrumentExpiry(ins)\n\n// Output: 2025.09.24\n```\n\n**相关函数：**[parseInstrument](https://docs.dolphindb.cn/zh/funcs/p/parseInstrument.html)、[getInstrumentField](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentField.html)、[getInstrumentKeys](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentKeys.html)\n"
    },
    "getInstrumentFarDelivery": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getinstrumentfardelivery.html",
        "signatures": [
            {
                "full": "getInstrumentFarDelivery(instrument)",
                "name": "getInstrumentFarDelivery",
                "parameters": [
                    {
                        "full": "instrument",
                        "name": "instrument"
                    }
                ]
            }
        ],
        "markdown": "### [getInstrumentFarDelivery](https://docs.dolphindb.cn/zh/funcs/g/getinstrumentfardelivery.html)\n\n首发版本：3.00.4.1\n\n\n\n#### 语法\n\ngetInstrumentFarDelivery(instrument)\n\n#### 详情\n\n根据输入的金融工具，获取该工具的远端交割日期（far delivery date）。\n\n#### 参数\n\n**instrument** INSTRUMENT 类型标量或向量，表示金融工具。\n\n#### 返回值\n\nDATE 类型标量或向量。\n\n#### 例子\n\n```\nswap = {\n    \"productType\": \"Swap\",\n    \"swapType\": \"FxSwap\",\n    \"currencyPair\": \"EURUSD\",\n    \"direction\": \"Buy\",\n    \"notionalCurrency\": \"EUR\",\n    \"notionalAmount\": 1E6,\n    \"nearStrike\": 1.1,\n    \"nearExpiry\": 2025.12.08,\n    \"nearDelivery\": 2025.12.10,\n    \"farStrike\": 1.2,\n    \"farExpiry\": 2026.06.08,\n    \"farDelivery\": 2026.06.10\n}\nins = parseInstrument(swap)\ngetInstrumentFarDelivery(ins)\n\n// output: 2026.06.10\n```\n\n**相关函数：**[parseInstrument](https://docs.dolphindb.cn/zh/funcs/p/parseInstrument.html)、[getInstrumentField](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentField.html)、[getInstrumentKeys](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentKeys.html)\n"
    },
    "getInstrumentFarExpiry": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getinstrumentfarexpiry.html",
        "signatures": [
            {
                "full": "getInstrumentFarExpiry(instrument)",
                "name": "getInstrumentFarExpiry",
                "parameters": [
                    {
                        "full": "instrument",
                        "name": "instrument"
                    }
                ]
            }
        ],
        "markdown": "### [getInstrumentFarExpiry](https://docs.dolphindb.cn/zh/funcs/g/getinstrumentfarexpiry.html)\n\n首发版本：3.00.4.1\n\n\n\n#### 语法\n\ngetInstrumentFarExpiry(instrument)\n\n#### 详情\n\n根据输入的金融工具，获取该工具的远端到期日（far expiry date）。\n\n#### 参数\n\n**instrument** INSTRUMENT 类型标量或向量，表示金融工具。\n\n#### 返回值\n\nDATE 类型标量或向量。\n\n#### 例子\n\n```\nswap = {\n    \"productType\": \"Swap\",\n    \"swapType\": \"FxSwap\",\n    \"currencyPair\": \"EURUSD\",\n    \"direction\": \"Buy\",\n    \"notionalCurrency\": \"EUR\",\n    \"notionalAmount\": 1E6,\n    \"nearStrike\": 1.1,\n    \"nearExpiry\": 2025.12.08,\n    \"nearDelivery\": 2025.12.10,\n    \"farStrike\": 1.2,\n    \"farExpiry\": 2026.06.08,\n    \"farDelivery\": 2026.06.10\n}\nins = parseInstrument(swap)\ngetInstrumentFarExpiry(ins)\n\n// output: 2026.06.08\n```\n\n**相关函数：**[parseInstrument](https://docs.dolphindb.cn/zh/funcs/p/parseInstrument.html)、[getInstrumentField](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentField.html)、[getInstrumentKeys](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentKeys.html)\n"
    },
    "getInstrumentFarStrike": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getInstrumentFarStrike.html",
        "signatures": [
            {
                "full": "getInstrumentFarStrike(instrument)",
                "name": "getInstrumentFarStrike",
                "parameters": [
                    {
                        "full": "instrument",
                        "name": "instrument"
                    }
                ]
            }
        ],
        "markdown": "### [getInstrumentFarStrike](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentFarStrike.html)\n\n首发版本：3.00.4.1\n\n\n\n#### 语法\n\ngetInstrumentFarStrike(instrument)\n\n#### 详情\n\n根据输入的金融工具，获取该工具的远端行权价格。\n\n#### 参数\n\n**instrument** INSTRUMENT 类型标量或向量，表示金融工具。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\nswap = {\n    \"productType\": \"Swap\",\n    \"swapType\": \"FxSwap\",\n    \"currencyPair\": \"EURUSD\",\n    \"direction\": \"Buy\",\n    \"notionalCurrency\": \"EUR\",\n    \"notionalAmount\": 1E6,\n    \"nearStrike\": 1.1,\n    \"nearExpiry\": 2025.12.08,\n    \"nearDelivery\": 2025.12.10,\n    \"farStrike\": 1.2,\n    \"farExpiry\": 2026.06.08,\n    \"farDelivery\": 2026.06.10\n}\ninstrument = parseInstrument(swap)\ngetInstrumentFarStrike(instrument)\n\n// output: 1.2\n```\n\n**相关函数：**[parseInstrument](https://docs.dolphindb.cn/zh/funcs/p/parseInstrument.html)、[getInstrumentField](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentField.html)、[getInstrumentKeys](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentKeys.html)\n"
    },
    "getInstrumentField": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getInstrumentField.html",
        "signatures": [
            {
                "full": "getInstrumentField(instrument, key, [default])",
                "name": "getInstrumentField",
                "parameters": [
                    {
                        "full": "instrument",
                        "name": "instrument"
                    },
                    {
                        "full": "key",
                        "name": "key"
                    },
                    {
                        "full": "[default]",
                        "name": "default",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [getInstrumentField](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentField.html)\n\n首发版本：3.00.4.1\n\n\n\n#### 语法\n\ngetInstrumentField(instrument, key, \\[default])\n\n#### 详情\n\n从金融工具中提取指定字段（*key*）对应的值：\n\n* 未设置 *default* 时，若字段存在有效值，则返回该值，否则返回空值；\n* 设置 *default* 时，若字段存在有效值，则将其类型转为 *default* 的类型返回，否则返回 *default*。\n\n#### 参数\n\n**instrument** INSTRUMENT 类型标量或向量，表示金融工具。\n\n**key** STRING 类型标量，表示金融工具的字段，需与 *instrument* 中定义的字段名一致。\n\n**default** 一个标量，表示 *key* 的默认值。目前支持如下类型：LOGICAL, INTEGRAL（COMPRESSED 除外）, TEMPORAL（DATEHOUR 除外）, FLOATING, LITERAL, DECIMAL。\n\n#### 返回值\n\n* 当 *instrument* 是标量时，返回一个标量。\n* 当 *instrument* 是向量时，返回一个与 *instrument* 等长的向量。\n\n#### 例子\n\n```\nbond = {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Bond\",\n    \"bondType\": \"ZeroCouponBond\",\n    \"instrumentId\": \"0001\",\n    \"start\": 1996.03.01,\n    \"maturity\": 2032.05.15,\n    \"dayCountConvention\": \"ActualActualISDA\",\n    \"coupon\": 0.0276,\n    \"issuePrice\": 100.0,\n    \"frequency\": \"Semiannual\",\n    \"subType\":\"TREASURY_BOND\",\n    \"creditRating\":\"B\",\n    \"settlement\": 2022.05.15 \n}\nins = parseInstrument(bond)\ngetInstrumentField(ins, \"productType\")\n// output: Cash\n```\n\n**相关函数：**[parseInstrument](https://docs.dolphindb.cn/zh/funcs/p/parseInstrument.html)、[getInstrumentKeys](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentKeys.html)\n"
    },
    "getInstrumentFixedDayCountConvention": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getinstrumentfixeddaycountconvention.html",
        "signatures": [
            {
                "full": "getInstrumentFixedDayCountConvention(instrument)",
                "name": "getInstrumentFixedDayCountConvention",
                "parameters": [
                    {
                        "full": "instrument",
                        "name": "instrument"
                    }
                ]
            }
        ],
        "markdown": "### [getInstrumentFixedDayCountConvention](https://docs.dolphindb.cn/zh/funcs/g/getinstrumentfixeddaycountconvention.html)\n\n首发版本：3.00.4.1\n\n\n\n#### 语法\n\ngetInstrumentFixedDayCountConvention(instrument)\n\n#### 详情\n\n根据输入的金融工具，获取该工具的固定端日期计数惯例。\n\n#### 参数\n\n**instrument** INSTRUMENT 类型标量或向量，表示金融工具。\n\n#### 返回值\n\nSTRING 类型标量或向量。\n\n#### 例子\n\n```\nswap =  {\n    \"productType\": \"Swap\",\n    \"swapType\": \"IrSwap\",\n    \"irSwapType\": \"IrFixedFloatingSwap\",\n    \"start\": 2021.05.15,\n    \"maturity\": 2023.05.15,\n    \"frequency\": \"Quarterly\",\n    \"fixedRate\": 0.02,\n    \"calendar\": \"CFET\", \n    \"fixedDayCountConvention\": \"Actual365\",\n    \"floatingDayCountConvention\": \"Actual360\",\n    \"payReceive\": \"Pay\",\n    \"iborIndex\": \"SHIBOR_3M\",\n    \"spread\": 0.0005,\n    \"notionalCurrency\": \"CNY\",\n    \"notionalAmount\": 1E8\n}\ninstrument = parseInstrument(swap)\ngetInstrumentFixedDayCountConvention(instrument)\n\n// output: Actual365\n```\n\n**相关函数：**[parseInstrument](https://docs.dolphindb.cn/zh/funcs/p/parseInstrument.html)、[getInstrumentField](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentField.html)、[getInstrumentKeys](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentKeys.html)\n"
    },
    "getInstrumentFixedRate": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getinstrumentfixedrate.html",
        "signatures": [
            {
                "full": "getInstrumentFixedRate(instrument)",
                "name": "getInstrumentFixedRate",
                "parameters": [
                    {
                        "full": "instrument",
                        "name": "instrument"
                    }
                ]
            }
        ],
        "markdown": "### [getInstrumentFixedRate](https://docs.dolphindb.cn/zh/funcs/g/getinstrumentfixedrate.html)\n\n首发版本：3.00.4.1\n\n\n\n#### 语法\n\ngetInstrumentFixedRate(instrument)\n\n#### 详情\n\n根据输入的金融工具，获取该工具的固定端利率。\n\n#### 参数\n\n**instrument** INSTRUMENT 类型标量或向量，表示金融工具。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\nswap =  {\n    \"productType\": \"Swap\",\n    \"swapType\": \"IrSwap\",\n    \"irSwapType\": \"IrFixedFloatingSwap\",\n    \"start\": 2021.05.15,\n    \"maturity\": 2023.05.15,\n    \"frequency\": \"Quarterly\",\n    \"fixedRate\": 0.02,\n    \"calendar\": \"CFET\", \n    \"fixedDayCountConvention\": \"Actual365\",\n    \"floatingDayCountConvention\": \"Actual360\",\n    \"payReceive\": \"Pay\",\n    \"iborIndex\": \"SHIBOR_3M\",\n    \"spread\": 0.0005,\n    \"notionalCurrency\": \"CNY\",\n    \"notionalAmount\": 1E8\n}\ninstrument = parseInstrument(swap)\ngetInstrumentFixedRate(instrument)\n\n// output: 0.02\n```\n\n**相关函数：**[parseInstrument](https://docs.dolphindb.cn/zh/funcs/p/parseInstrument.html)、[getInstrumentField](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentField.html)、[getInstrumentKeys](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentKeys.html)\n"
    },
    "getInstrumentFloatingDayCountConvention": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getinstrumentfloatingdaycountconvention.html",
        "signatures": [
            {
                "full": "getInstrumentFloatingDayCountConvention(instrument)",
                "name": "getInstrumentFloatingDayCountConvention",
                "parameters": [
                    {
                        "full": "instrument",
                        "name": "instrument"
                    }
                ]
            }
        ],
        "markdown": "### [getInstrumentFloatingDayCountConvention](https://docs.dolphindb.cn/zh/funcs/g/getinstrumentfloatingdaycountconvention.html)\n\n首发版本：3.00.4.1\n\n\n\n#### 语法\n\ngetInstrumentFloatingDayCountConvention(instrument)\n\n#### 详情\n\n根据输入的金融工具，获取该工具的浮动端日期计数惯例。\n\n#### 参数\n\n**instrument** INSTRUMENT 类型标量或向量，表示金融工具。\n\n#### 返回值\n\nSTRING 类型标量或向量。\n\n#### 例子\n\n```\nswap =  {\n    \"productType\": \"Swap\",\n    \"swapType\": \"IrSwap\",\n    \"irSwapType\": \"IrFixedFloatingSwap\",\n    \"start\": 2021.05.15,\n    \"maturity\": 2023.05.15,\n    \"frequency\": \"Quarterly\",\n    \"fixedRate\": 0.02,\n    \"calendar\": \"CFET\", \n    \"fixedDayCountConvention\": \"Actual365\",\n    \"floatingDayCountConvention\": \"Actual360\",\n    \"payReceive\": \"Pay\",\n    \"iborIndex\": \"SHIBOR_3M\",\n    \"spread\": 0.0005,\n    \"notionalCurrency\": \"CNY\",\n    \"notionalAmount\": 1E8\n}\ninstrument = parseInstrument(swap)\ngetInstrumentFloatingDayCountConvention(instrument)\n\n// output: Actual360\n```\n\n**相关函数：**[parseInstrument](https://docs.dolphindb.cn/zh/funcs/p/parseInstrument.html)、[getInstrumentField](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentField.html)、[getInstrumentKeys](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentKeys.html)\n"
    },
    "getInstrumentFrequency": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getinstrumentfrequency.html",
        "signatures": [
            {
                "full": "getInstrumentFrequency(instrument)",
                "name": "getInstrumentFrequency",
                "parameters": [
                    {
                        "full": "instrument",
                        "name": "instrument"
                    }
                ]
            }
        ],
        "markdown": "### [getInstrumentFrequency](https://docs.dolphindb.cn/zh/funcs/g/getinstrumentfrequency.html)\n\n首发版本：3.00.4.1\n\n\n\n#### 语法\n\ngetInstrumentFrequency(instrument)\n\n#### 详情\n\n根据输入的金融工具，获取该工具的付息频率（Coupon Frequency）。\n\n#### 参数\n\n**instrument** INSTRUMENT 类型标量或向量，表示金融工具。\n\n#### 返回值\n\nSTRING 类型标量或向量。\n\n#### 例子\n\n```\nbond = {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Bond\",\n    \"bondType\": \"FixedRateBond\",\n    \"nominal\": 100,\n    \"instrumentId\": \"0001\",\n    \"start\": 2022.05.15,\n    \"maturity\": 2032.05.15,\n    \"dayCountConvention\": \"ActualActualISDA\",\n    \"coupon\": 0.0276,\n    \"issuePrice\": 100.0,\n    \"frequency\": \"Semiannual\"\n}\nins = parseInstrument(bond)\ngetInstrumentFrequency(ins)\n// output: Semiannual\n```\n\n**相关函数：**[parseInstrument](https://docs.dolphindb.cn/zh/funcs/p/parseInstrument.html)、[getInstrumentField](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentField.html)、[getInstrumentKeys](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentKeys.html)\n"
    },
    "getInstrumentIborIndex": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getinstrumentiborindex.html",
        "signatures": [
            {
                "full": "getInstrumentIborIndex(instrument)",
                "name": "getInstrumentIborIndex",
                "parameters": [
                    {
                        "full": "instrument",
                        "name": "instrument"
                    }
                ]
            }
        ],
        "markdown": "### [getInstrumentIborIndex](https://docs.dolphindb.cn/zh/funcs/g/getinstrumentiborindex.html)\n\n首发版本：3.00.4.1\n\n\n\n#### 语法\n\ngetInstrumentIborIndex(instrument)\n\n#### 详情\n\n根据输入的金融工具，获取该工具的浮动端参考利率。\n\n#### 参数\n\n**instrument** INSTRUMENT 类型标量或向量，表示金融工具。\n\n#### 返回值\n\nSTRING 类型标量或向量。\n\n#### 例子\n\n```\nswap = {\n    \"productType\": \"Swap\",\n    \"swapType\": \"IrSwap\",\n    \"irSwapType\": \"IrFixedFloatingSwap\",\n    \"start\": 2021.05.15,\n    \"maturity\": 2023.05.15,\n    \"frequency\": \"Quarterly\",\n    \"fixedRate\": 0.02,\n    \"calendar\": \"CFET\", \n    \"fixedDayCountConvention\": \"Actual365\",\n    \"floatingDayCountConvention\": \"Actual360\",\n    \"payReceive\": \"Pay\",\n    \"iborIndex\": \"SHIBOR_3M\",\n    \"spread\": 0.0005,\n    \"notionalCurrency\": \"CNY\",\n    \"notionalAmount\": 1E8\n}\nins = parseInstrument(swap)\ngetInstrumentIborIndex(ins)\n// output: SHIBOR_3M\n```\n\n**相关函数：**[parseInstrument](https://docs.dolphindb.cn/zh/funcs/p/parseInstrument.html)、[getInstrumentField](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentField.html)、[getInstrumentKeys](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentKeys.html)\n"
    },
    "getInstrumentInstrumentId": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getinstrumentinstrumentid.html",
        "signatures": [
            {
                "full": "getInstrumentInstrumentId(instrument)",
                "name": "getInstrumentInstrumentId",
                "parameters": [
                    {
                        "full": "instrument",
                        "name": "instrument"
                    }
                ]
            }
        ],
        "markdown": "### [getInstrumentInstrumentId](https://docs.dolphindb.cn/zh/funcs/g/getinstrumentinstrumentid.html)\n\n首发版本：3.00.4.1\n\n\n\n#### 语法\n\ngetInstrumentInstrumentId(instrument)\n\n#### 详情\n\n根据输入的金融工具，获取该工具的 ID。\n\n#### 参数\n\n**instrument** INSTRUMENT 类型标量或向量，表示金融工具。\n\n#### 返回值\n\nSTRING 类型标量或向量。\n\n#### 例子\n\n```\nbond = {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Bond\",\n    \"bondType\": \"DiscountBond\",\n    \"instrumentId\": \"259924.IB\",\n    \"start\": 2025.04.17,\n    \"maturity\": 2025.07.17,\n    \"issuePrice\": 99.664,\n    \"dayCountConvention\": \"ActualActualISDA\"\n}\ninstrument = parseInstrument(bond)\ngetInstrumentInstrumentId(instrument)\n\n// output: 259924.IB\n```\n\n**相关函数：**[parseInstrument](https://docs.dolphindb.cn/zh/funcs/p/parseInstrument.html)、[getInstrumentField](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentField.html)、[getInstrumentKeys](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentKeys.html)\n"
    },
    "getInstrumentIssuePrice": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getinstrumentissueprice.html",
        "signatures": [
            {
                "full": "getInstrumentIssuePrice(instrument)",
                "name": "getInstrumentIssuePrice",
                "parameters": [
                    {
                        "full": "instrument",
                        "name": "instrument"
                    }
                ]
            }
        ],
        "markdown": "### [getInstrumentIssuePrice](https://docs.dolphindb.cn/zh/funcs/g/getinstrumentissueprice.html)\n\n首发版本：3.00.4.1\n\n\n\n#### 语法\n\ngetInstrumentIssuePrice(instrument)\n\n#### 详情\n\n根据输入的金融工具，获取该工具的发行价格（Issue Price）。\n\n#### 参数\n\n**instrument** INSTRUMENT 类型标量或向量，表示金融工具。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\nbond = {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Bond\",\n    \"bondType\": \"FixedRateBond\",\n    \"nominal\": 100,\n    \"instrumentId\": \"0001\",\n    \"start\": 2022.05.15,\n    \"maturity\": 2032.05.15,\n    \"dayCountConvention\": \"ActualActualISDA\",\n    \"coupon\": 0.0276,\n    \"issuePrice\": 100.0,\n    \"frequency\": \"Semiannual\"\n}\nins = parseInstrument(bond)\ngetInstrumentIssuePrice(ins)\n// output: 100\n```\n\n**相关函数：**[parseInstrument](https://docs.dolphindb.cn/zh/funcs/p/parseInstrument.html)、[getInstrumentField](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentField.html)、[getInstrumentKeys](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentKeys.html)\n"
    },
    "getInstrumentKeys": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getInstrumentKeys.html",
        "signatures": [
            {
                "full": "getInstrumentKeys(instrument)",
                "name": "getInstrumentKeys",
                "parameters": [
                    {
                        "full": "instrument",
                        "name": "instrument"
                    }
                ]
            }
        ],
        "markdown": "### [getInstrumentKeys](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentKeys.html)\n\n首发版本：3.00.4.1\n\n\n\n#### 语法\n\ngetInstrumentKeys(instrument)\n\n#### 详情\n\n根据输入的金融工具，获取该工具所包含的字段。\n\n#### 参数\n\n**instrument** INSTRUMENT 类型标量或向量，表示金融工具。\n\n#### 返回值\n\n* 当 *instrument* 是标量时，返回 STRING 类型向量。\n* 当 *instrument* 是向量时，返回由 STRING 类型向量组成的元组。\n\n#### 例子\n\n```\nbond = {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Bond\",\n    \"bondType\": \"ZeroCouponBond\",\n    \"instrumentId\": \"0001\",\n    \"start\": 1996.03.01,\n    \"maturity\": 2032.05.15,\n    \"dayCountConvention\": \"ActualActualISDA\",\n    \"coupon\": 0.0276,\n    \"issuePrice\": 100.0,\n    \"frequency\": \"Semiannual\",\n    \"subType\":\"TREASURY_BOND\",\n    \"creditRating\":\"B\",\n    \"settlement\": 2022.05.15 \n}\nins = parseInstrument(bond)\ngetInstrumentKeys(ins)\n// output: [\"coupon\",\"subType\",\"discountCurve\",\"cashflow\",\"currency\",\"calendar\",\"dayCountConvention\",\"start\",\"nominal\",\"instrumentId\",\"creditRating\",\"maturity\",\"bondType\",\"version\",\"spreadCurve\",\"productType\",\"assetType\",\"settlement\",\"frequency\",\"cashFlow\",\"issuePrice\"]\n```\n\n**相关函数：**[parseInstrument](https://docs.dolphindb.cn/zh/funcs/p/parseInstrument.html)、[getInstrumentField](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentField.html)\n"
    },
    "getInstrumentMaturity": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getinstrumentmaturity.html",
        "signatures": [
            {
                "full": "getInstrumentMaturity(instrument)",
                "name": "getInstrumentMaturity",
                "parameters": [
                    {
                        "full": "instrument",
                        "name": "instrument"
                    }
                ]
            }
        ],
        "markdown": "### [getInstrumentMaturity](https://docs.dolphindb.cn/zh/funcs/g/getinstrumentmaturity.html)\n\n首发版本：3.00.4.1\n\n\n\n#### 语法\n\ngetInstrumentMaturity(instrument)\n\n#### 详情\n\n根据输入的金融工具，获取该工具的到期日（Maturity Date）。\n\n#### 参数\n\n**instrument** INSTRUMENT 类型标量或向量，表示金融工具。\n\n#### 返回值\n\nDATE 类型标量或向量。\n\n#### 例子\n\n```\nbond = {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Bond\",\n    \"bondType\": \"ZeroCouponBond\",\n    \"instrumentId\": \"0001\",\n    \"start\": 1996.03.01,\n    \"maturity\": 2032.05.15,\n    \"dayCountConvention\": \"ActualActualISDA\",\n    \"coupon\": 0.0276,\n    \"issuePrice\": 100.0,\n    \"frequency\": \"Semiannual\",\n    \"subType\":\"TREASURY_BOND\",\n    \"creditRating\":\"B\",\n    \"settlement\": 2022.05.15 \n}\nins = parseInstrument(bond)\ngetInstrumentMaturity(ins)\n\n// output: 2032.05.15\n```\n\n**相关函数：**[parseInstrument](https://docs.dolphindb.cn/zh/funcs/p/parseInstrument.html)、[getInstrumentField](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentField.html)、[getInstrumentKeys](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentKeys.html)\n"
    },
    "getInstrumentNearDelivery": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getinstrumentneardelivery.html",
        "signatures": [
            {
                "full": "getInstrumentNearDelivery(instrument)",
                "name": "getInstrumentNearDelivery",
                "parameters": [
                    {
                        "full": "instrument",
                        "name": "instrument"
                    }
                ]
            }
        ],
        "markdown": "### [getInstrumentNearDelivery](https://docs.dolphindb.cn/zh/funcs/g/getinstrumentneardelivery.html)\n\n首发版本：3.00.4.1\n\n\n\n#### 语法\n\ngetInstrumentNearDelivery(instrument)\n\n#### 详情\n\n根据输入的金融工具，获取该工具的近端交割日期（near delivery date）。\n\n#### 参数\n\n**instrument** INSTRUMENT 类型标量或向量，表示金融工具。\n\n#### 返回值\n\nDATE 类型标量或向量。\n\n#### 例子\n\n```\nswap = {\n    \"productType\": \"Swap\",\n    \"swapType\": \"FxSwap\",\n    \"currencyPair\": \"EURUSD\",\n    \"direction\": \"Buy\",\n    \"notionalCurrency\": \"EUR\",\n    \"notionalAmount\": 1E6,\n    \"nearStrike\": 1.1,\n    \"nearExpiry\": 2025.12.08,\n    \"nearDelivery\": 2025.12.10,\n    \"farStrike\": 1.2,\n    \"farExpiry\": 2026.06.08,\n    \"farDelivery\": 2026.06.10\n}\nins = parseInstrument(swap)\ngetInstrumentNearDelivery(ins)\n\n// output: 2025.12.10\n```\n\n**相关函数：**[parseInstrument](https://docs.dolphindb.cn/zh/funcs/p/parseInstrument.html)、[getInstrumentField](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentField.html)、[getInstrumentKeys](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentKeys.html)\n"
    },
    "getInstrumentNearExpiry": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getinstrumentnearexpiry.html",
        "signatures": [
            {
                "full": "getInstrumentNearExpiry(instrument)",
                "name": "getInstrumentNearExpiry",
                "parameters": [
                    {
                        "full": "instrument",
                        "name": "instrument"
                    }
                ]
            }
        ],
        "markdown": "### [getInstrumentNearExpiry](https://docs.dolphindb.cn/zh/funcs/g/getinstrumentnearexpiry.html)\n\n首发版本：3.00.4.1\n\n\n\n#### 语法\n\ngetInstrumentNearExpiry(instrument)\n\n#### 详情\n\n根据输入的金融工具，获取该工具的近端到期日（near expiry date）。\n\n#### 参数\n\n**instrument** INSTRUMENT 类型标量或向量，表示金融工具。\n\n#### 返回值\n\nDATE 类型标量或向量。\n\n#### 例子\n\n```\nswap = {\n    \"productType\": \"Swap\",\n    \"swapType\": \"FxSwap\",\n    \"currencyPair\": \"EURUSD\",\n    \"direction\": \"Buy\",\n    \"notionalCurrency\": \"EUR\",\n    \"notionalAmount\": 1E6,\n    \"nearStrike\": 1.1,\n    \"nearExpiry\": 2025.12.08,\n    \"nearDelivery\": 2025.12.10,\n    \"farStrike\": 1.2,\n    \"farExpiry\": 2026.06.08,\n    \"farDelivery\": 2026.06.10\n}\nins = parseInstrument(swap)\ngetInstrumentNearExpiry(ins)\n\n// output: 2025.12.08\n```\n\n**相关函数：**[parseInstrument](https://docs.dolphindb.cn/zh/funcs/p/parseInstrument.html)、[getInstrumentField](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentField.html)、[getInstrumentKeys](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentKeys.html)\n"
    },
    "getInstrumentNearStrike": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getinstrumentnearstrike.html",
        "signatures": [
            {
                "full": "getInstrumentNearStrike(instrument)",
                "name": "getInstrumentNearStrike",
                "parameters": [
                    {
                        "full": "instrument",
                        "name": "instrument"
                    }
                ]
            }
        ],
        "markdown": "### [getInstrumentNearStrike](https://docs.dolphindb.cn/zh/funcs/g/getinstrumentnearstrike.html)\n\n首发版本：3.00.4.1\n\n\n\n#### 语法\n\ngetInstrumentNearStrike(instrument)\n\n#### 详情\n\n根据输入的金融工具，获取该工具的近端行权价格。\n\n#### 参数\n\n**instrument** INSTRUMENT 类型标量或向量，表示金融工具。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\nswap = {\n    \"productType\": \"Swap\",\n    \"swapType\": \"FxSwap\",\n    \"currencyPair\": \"EURUSD\",\n    \"direction\": \"Buy\",\n    \"notionalCurrency\": \"EUR\",\n    \"notionalAmount\": 1E6,\n    \"nearStrike\": 1.1,\n    \"nearExpiry\": 2025.12.08,\n    \"nearDelivery\": 2025.12.10,\n    \"farStrike\": 1.2,\n    \"farExpiry\": 2026.06.08,\n    \"farDelivery\": 2026.06.10\n}\ninstrument = parseInstrument(swap)\n\ngetInstrumentNearStrike(instrument)\n// output: 1.1\n```\n\n**相关函数：**[parseInstrument](https://docs.dolphindb.cn/zh/funcs/p/parseInstrument.html)、[getInstrumentField](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentField.html)、[getInstrumentKeys](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentKeys.html)\n"
    },
    "getInstrumentNominal": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getinstrumentnominal.html",
        "signatures": [
            {
                "full": "getInstrumentNominal(instrument)",
                "name": "getInstrumentNominal",
                "parameters": [
                    {
                        "full": "instrument",
                        "name": "instrument"
                    }
                ]
            }
        ],
        "markdown": "### [getInstrumentNominal](https://docs.dolphindb.cn/zh/funcs/g/getinstrumentnominal.html)\n\n首发版本：3.00.4.1\n\n\n\n#### 语法\n\ngetInstrumentNominal(instrument)\n\n#### 详情\n\n根据输入的金融工具，获取该工具的名义金额（nominal）。\n\n#### 参数\n\n**instrument** INSTRUMENT 类型标量或向量，表示金融工具。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\ndeposit =  {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Deposit\",\n    \"nominal\":100,\n    \"start\": 2025.05.15,\n    \"maturity\": 2025.08.15,\n    \"rate\": 0.02,\n    \"dayCountConvention\": \"Actual360\",\n    \"notionalCurrency\": \"CNY\",\n    \"notionalAmount\": 1E6,\n    \"payReceive\": \"Receive\"\n}\nins = parseInstrument(deposit)\ngetInstrumentNominal(ins)\n\n// output: 100\n```\n\n**相关函数：**[parseInstrument](https://docs.dolphindb.cn/zh/funcs/p/parseInstrument.html)、[getInstrumentField](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentField.html)、[getInstrumentKeys](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentKeys.html)\n"
    },
    "getInstrumentNominalCouponRate": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getinstrumentnominalcouponrate.html",
        "signatures": [
            {
                "full": "getInstrumentNominalCouponRate(instrument)",
                "name": "getInstrumentNominalCouponRate",
                "parameters": [
                    {
                        "full": "instrument",
                        "name": "instrument"
                    }
                ]
            }
        ],
        "markdown": "### [getInstrumentNominalCouponRate](https://docs.dolphindb.cn/zh/funcs/g/getinstrumentnominalcouponrate.html)\n\n首发版本：3.00.4.1\n\n\n\n#### 语法\n\ngetInstrumentNominalCouponRate(instrument)\n\n#### 详情\n\n根据输入的金融工具，获取该工具的名义票面利率。\n\n#### 参数\n\n**instrument** INSTRUMENT 类型标量或向量，表示金融工具。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\nfutures =  {\n    \"productType\": \"Futures\",\n    \"futuresType\": \"BondFutures\",\n    \"instrumentId\": \"T2509\",  \n    \"nominal\": 100.0,\n    \"maturity\": \"2022.09.09\",\n    \"settlement\": \"2022.09.11\",\n    \"underlying\": bond,\n    \"nominalCouponRate\": 0.03  \n}\ninstrument = parseInstrument(futures)\ngetInstrumentNominalCouponRate(instrument)\n\n// output: 0.03\n```\n\n**相关函数：**[parseInstrument](https://docs.dolphindb.cn/zh/funcs/p/parseInstrument.html)、[getInstrumentField](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentField.html)、[getInstrumentKeys](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentKeys.html)\n"
    },
    "getInstrumentNotionalAmount": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getinstrumentnotionalamount.html",
        "signatures": [
            {
                "full": "getInstrumentNotionalAmount(instrument)",
                "name": "getInstrumentNotionalAmount",
                "parameters": [
                    {
                        "full": "instrument",
                        "name": "instrument"
                    }
                ]
            }
        ],
        "markdown": "### [getInstrumentNotionalAmount](https://docs.dolphindb.cn/zh/funcs/g/getinstrumentnotionalamount.html)\n\n首发版本：3.00.4.3\n\n\n\n#### 语法\n\ngetInstrumentNotionalAmount(instrument)\n\n#### 详情\n\n根据输入的金融工具，获取该工具的名义本金金额。\n\n#### 参数\n\n**instrument** INSTRUMENT 类型标量或向量，表示金融工具。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\ndeposit =  {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Deposit\",\n    \"start\": 2025.05.15,\n    \"maturity\": 2025.08.15,\n    \"rate\": 0.02,\n    \"dayCountConvention\": \"Actual360\",\n    \"notionalAmount\":1E6,\n    \"notionalCurrency\":\"CNY\",\n    \"payReceive\": \"Receive\"\n}\ninstrument = parseInstrument(deposit)\ngetInstrumentNotionalAmount(instrument)\n\n// output: 1000000\n```\n\n**相关函数：**[parseInstrument](https://docs.dolphindb.cn/zh/funcs/p/parseInstrument.html)、[getInstrumentField](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentField.html)、[getInstrumentKeys](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentKeys.html)、[getInstrumentNotionalCurrency](https://docs.dolphindb.cn/zh/funcs/g/getinstrumentnotionalcurrency.html)\n"
    },
    "getInstrumentNotionalCurrency": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getinstrumentnotionalcurrency.html",
        "signatures": [
            {
                "full": "getInstrumentNotionalCurrency(instrument)",
                "name": "getInstrumentNotionalCurrency",
                "parameters": [
                    {
                        "full": "instrument",
                        "name": "instrument"
                    }
                ]
            }
        ],
        "markdown": "### [getInstrumentNotionalCurrency](https://docs.dolphindb.cn/zh/funcs/g/getinstrumentnotionalcurrency.html)\n\n首发版本：3.00.4.3\n\n\n\n#### 语法\n\ngetInstrumentNotionalCurrency(instrument)\n\n#### 详情\n\n根据输入的金融工具，获取该工具的名义本金所使用的货币。\n\n#### 参数\n\n**instrument** INSTRUMENT 类型标量或向量，表示金融工具。\n\n#### 返回值\n\n字符串标量或向量。\n\n#### 例子\n\n```\ndeposit =  {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Deposit\",\n    \"start\": 2025.05.15,\n    \"maturity\": 2025.08.15,\n    \"rate\": 0.02,\n    \"dayCountConvention\": \"Actual360\",\n    \"notionalAmount\":1E6,\n    \"notionalCurrency\":\"CNY\",\n    \"payReceive\": \"Receive\"\n}\ninstrument = parseInstrument(deposit)\ngetInstrumentNotionalCurrency(instrument)\n\n// output: \"CNY\"\n```\n\n**相关函数：**[parseInstrument](https://docs.dolphindb.cn/zh/funcs/p/parseInstrument.html)、[getInstrumentField](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentField.html)、[getInstrumentKeys](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentKeys.html)、[getInstrumentNotionalAmount](https://docs.dolphindb.cn/zh/funcs/g/getinstrumentnotionalamount.html)\n"
    },
    "getInstrumentPayoffType": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getinstrumentpayofftype.html",
        "signatures": [
            {
                "full": "getInstrumentPayoffType(instrument)",
                "name": "getInstrumentPayoffType",
                "parameters": [
                    {
                        "full": "instrument",
                        "name": "instrument"
                    }
                ]
            }
        ],
        "markdown": "### [getInstrumentPayoffType](https://docs.dolphindb.cn/zh/funcs/g/getinstrumentpayofftype.html)\n\n首发版本：3.00.4.1\n\n\n\n#### 语法\n\ngetInstrumentPayoffType(instrument)\n\n#### 详情\n\n根据输入的金融工具，获取该工具的收益类型。\n\n#### 参数\n\n**instrument** INSTRUMENT 类型标量或向量，表示金融工具。\n\n#### 返回值\n\nSTRING 类型标量或向量。\n\n#### 例子\n\n```\noption = {\n    \"productType\": \"Option\",\n    \"optionType\": \"EuropeanOption\",\n    \"assetType\": \"FxEuropeanOption\",\n    \"notionalCurrency\": \"EUR\",\n    \"notionalAmount\": 1000000.0,\n    \"strike\": 1.2,\n    \"maturity\": \"2025.10.08\",\n    \"payoffType\": \"Call\",\n    \"dayCountConvention\": \"Actual365\",\n    \"underlying\": \"EURUSD\"\n}\nins = parseInstrument(option)\ngetInstrumentPayoffType(ins)\n// output: Call   \n```\n\n**相关函数：**[parseInstrument](https://docs.dolphindb.cn/zh/funcs/p/parseInstrument.html)、[getInstrumentField](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentField.html)、[getInstrumentKeys](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentKeys.html)\n"
    },
    "getInstrumentPayReceive": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getinstrumentpayreceive.html",
        "signatures": [
            {
                "full": "getInstrumentPayReceive(instrument)",
                "name": "getInstrumentPayReceive",
                "parameters": [
                    {
                        "full": "instrument",
                        "name": "instrument"
                    }
                ]
            }
        ],
        "markdown": "### [getInstrumentPayReceive](https://docs.dolphindb.cn/zh/funcs/g/getinstrumentpayreceive.html)\n\n首发版本：3.00.4.1\n\n\n\n#### 语法\n\ngetInstrumentPayReceive(instrument)\n\n#### 详情\n\n根据输入的金融工具，获取该工具的收付标识。\n\n#### 参数\n\n**instrument** INSTRUMENT 类型标量或向量，表示金融工具。\n\n#### 返回值\n\nSTRING 类型标量或向量。\n\n#### 例子\n\n```\nswap = {\n    \"productType\": \"Swap\",\n    \"swapType\": \"IrSwap\",\n    \"irSwapType\": \"IrFixedFloatingSwap\",\n    \"start\": 2021.05.15,\n    \"maturity\": 2023.05.15,\n    \"frequency\": \"Quarterly\",\n    \"fixedRate\": 0.02,\n    \"calendar\": \"CFET\", \n    \"fixedDayCountConvention\": \"Actual365\",\n    \"floatingDayCountConvention\": \"Actual360\",\n    \"payReceive\": \"Pay\",\n    \"iborIndex\": \"SHIBOR_3M\",\n    \"spread\": 0.0005,\n    \"notionalCurrency\": \"CNY\",\n    \"notionalAmount\": 1E8\n}\nins = parseInstrument(swap)\ngetInstrumentPayReceive(ins)\n// output: Pay\n```\n\n**相关函数：**[parseInstrument](https://docs.dolphindb.cn/zh/funcs/p/parseInstrument.html)、[getInstrumentField](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentField.html)、[getInstrumentKeys](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentKeys.html)\n"
    },
    "getInstrumentRate": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getinstrumentrate.html",
        "signatures": [
            {
                "full": "getInstrumentRate(instrument)",
                "name": "getInstrumentRate",
                "parameters": [
                    {
                        "full": "instrument",
                        "name": "instrument"
                    }
                ]
            }
        ],
        "markdown": "### [getInstrumentRate](https://docs.dolphindb.cn/zh/funcs/g/getinstrumentrate.html)\n\n首发版本：3.00.4.1\n\n\n\n#### 语法\n\ngetInstrumentRate(instrument)\n\n#### 详情\n\n根据输入的金融工具，获取该工具的存款利率。\n\n#### 参数\n\n**instrument** INSTRUMENT 类型标量或向量，表示金融工具。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\ndeposit =  {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Deposit\",\n    \"start\": 2025.05.15,\n    \"maturity\": 2025.08.15,\n    \"rate\": 0.02,\n    \"dayCountConvention\": \"Actual360\",\n    \"notionalCurrency\": \"CNY\",\n    \"notionalAmount\": 1E6,\n    \"payReceive\": \"Receive\"\n}\ninstrument = parseInstrument(deposit)\ngetInstrumentRate(instrument)\n\n// output: 0.02\n```\n\n**相关函数：**[parseInstrument](https://docs.dolphindb.cn/zh/funcs/p/parseInstrument.html)、[getInstrumentField](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentField.html)、[getInstrumentKeys](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentKeys.html)\n"
    },
    "getInstrumentSettlement": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getinstrumentsettlement.html",
        "signatures": [
            {
                "full": "getInstrumentSettlement(instrument)",
                "name": "getInstrumentSettlement",
                "parameters": [
                    {
                        "full": "instrument",
                        "name": "instrument"
                    }
                ]
            }
        ],
        "markdown": "### [getInstrumentSettlement](https://docs.dolphindb.cn/zh/funcs/g/getinstrumentsettlement.html)\n\n首发版本：3.00.4.1\n\n\n\n#### 语法\n\ngetInstrumentSettlement(instrument)\n\n#### 详情\n\n根据输入的金融工具，获取该工具的结算日（Settlement Date）。\n\n#### 参数\n\n**instrument** INSTRUMENT 类型标量或向量，表示金融工具。\n\n#### 返回值\n\nDATE 类型标量或向量。\n\n#### 例子\n\n```\nbond = {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Bond\",\n    \"bondType\": \"ZeroCouponBond\",\n    \"instrumentId\": \"0001\",\n    \"start\": 1996.03.01,\n    \"maturity\": 2032.05.15,\n    \"dayCountConvention\": \"ActualActualISDA\",\n    \"coupon\": 0.0276,\n    \"issuePrice\": 100.0,\n    \"frequency\": \"Semiannual\",\n    \"subType\":\"TREASURY_BOND\",\n    \"creditRating\":\"B\",\n    \"settlement\": 2022.05.15 \n}\nins = parseInstrument(bond)\ngetInstrumentSettlement(ins)\n// output: 2022.05.15\n```\n\n**相关函数：**[parseInstrument](https://docs.dolphindb.cn/zh/funcs/p/parseInstrument.html)、[getInstrumentField](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentField.html)、[getInstrumentKeys](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentKeys.html)\n"
    },
    "getInstrumentSpread": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getinstrumentspread.html",
        "signatures": [
            {
                "full": "getInstrumentSpread(instrument)",
                "name": "getInstrumentSpread",
                "parameters": [
                    {
                        "full": "instrument",
                        "name": "instrument"
                    }
                ]
            }
        ],
        "markdown": "### [getInstrumentSpread](https://docs.dolphindb.cn/zh/funcs/g/getinstrumentspread.html)\n\n首发版本：3.00.4.1\n\n\n\n#### 语法\n\ngetInstrumentSpread(instrument)\n\n#### 详情\n\n根据输入的金融工具，获取该工具的利差。\n\n#### 参数\n\n**instrument** INSTRUMENT 类型标量或向量，表示金融工具。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\nswap =  {\n    \"productType\": \"Swap\",\n    \"swapType\": \"IrSwap\",\n    \"irSwapType\": \"IrFixedFloatingSwap\",\n    \"start\": 2021.05.15,\n    \"maturity\": 2023.05.15,\n    \"frequency\": \"Quarterly\",\n    \"fixedRate\": 0.02,\n    \"calendar\": \"CFET\", \n    \"fixedDayCountConvention\": \"Actual365\",\n    \"floatingDayCountConvention\": \"Actual360\",\n    \"payReceive\": \"Pay\",\n    \"iborIndex\": \"SHIBOR_3M\",\n    \"spread\": 0.0005,\n    \"notionalCurrency\": \"CNY\",\n    \"notionalAmount\": 1E8\n}\ninstrument = parseInstrument(swap)\n\ngetInstrumentSpread(instrument)\n// output: 0.0005\n```\n\n**相关函数：**[parseInstrument](https://docs.dolphindb.cn/zh/funcs/p/parseInstrument.html)、[getInstrumentField](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentField.html)、[getInstrumentKeys](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentKeys.html)\n"
    },
    "getInstrumentStart": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getinstrumentstart.html",
        "signatures": [
            {
                "full": "getInstrumentStart(instrument)",
                "name": "getInstrumentStart",
                "parameters": [
                    {
                        "full": "instrument",
                        "name": "instrument"
                    }
                ]
            }
        ],
        "markdown": "### [getInstrumentStart](https://docs.dolphindb.cn/zh/funcs/g/getinstrumentstart.html)\n\n首发版本：3.00.4.1\n\n\n\n#### 语法\n\ngetInstrumentStart(instrument)\n\n#### 详情\n\n根据输入的金融工具，获取该工具的起始日（Start Date）。\n\n#### 参数\n\n**instrument** INSTRUMENT 类型标量或向量，表示金融工具。\n\n#### 返回值\n\nDATE 类型标量或向量。\n\n#### 例子\n\n```\nbond = {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Bond\",\n    \"bondType\": \"ZeroCouponBond\",\n    \"instrumentId\": \"0001\",\n    \"start\": 1996.03.01,\n    \"maturity\": 2032.05.15,\n    \"dayCountConvention\": \"ActualActualISDA\",\n    \"coupon\": 0.0276,\n    \"issuePrice\": 100.0,\n    \"frequency\": \"Semiannual\",\n    \"subType\":\"TREASURY_BOND\",\n    \"creditRating\":\"B\",\n    \"settlement\": 2022.05.15 \n}\nins = parseInstrument(bond)\ngetInstrumentStart(ins)\n// output: 1996.03.01\n```\n\n**相关函数：**[parseInstrument](https://docs.dolphindb.cn/zh/funcs/p/parseInstrument.html)、[getInstrumentField](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentField.html)、[getInstrumentKeys](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentKeys.html)\n"
    },
    "getInstrumentStrike": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getinstrumentstrike.html",
        "signatures": [
            {
                "full": "getInstrumentStrike(instrument)",
                "name": "getInstrumentStrike",
                "parameters": [
                    {
                        "full": "instrument",
                        "name": "instrument"
                    }
                ]
            }
        ],
        "markdown": "### [getInstrumentStrike](https://docs.dolphindb.cn/zh/funcs/g/getinstrumentstrike.html)\n\n首发版本：3.00.4.1\n\n\n\n#### 语法\n\ngetInstrumentStrike(instrument)\n\n#### 详情\n\n根据输入的金融工具，获取该工具的执行价格。\n\n#### 参数\n\n**instrument** INSTRUMENT 类型标量或向量，表示金融工具。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\nforward =  {\n   \"productType\": \"Forward\",\n    \"forwardType\": \"FxForward\",\n    \"expiry\": 2025.09.24,\n    \"delivery\": 2025.09.26,\n    \"currencyPair\": \"USDCNY\",\n    \"direction\": \"Buy\",\n    \"notionalCurrency\": \"USD\",\n    \"notionalAmount\": 1E8,\n    \"strike\": 7.2\n}\ninstrument = parseInstrument(forward)\n\ngetInstrumentStrike(instrument)\n// output: 7.2\n```\n\n**相关函数：**[parseInstrument](https://docs.dolphindb.cn/zh/funcs/p/parseInstrument.html)、[getInstrumentField](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentField.html)、[getInstrumentKeys](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentKeys.html)\n"
    },
    "getInstrumentSubType": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getinstrumentsubtype.html",
        "signatures": [
            {
                "full": "getInstrumentSubType(instrument)",
                "name": "getInstrumentSubType",
                "parameters": [
                    {
                        "full": "instrument",
                        "name": "instrument"
                    }
                ]
            }
        ],
        "markdown": "### [getInstrumentSubType](https://docs.dolphindb.cn/zh/funcs/g/getinstrumentsubtype.html)\n\n首发版本：3.00.4.1\n\n\n\n#### 语法\n\ngetInstrumentSubType(instrument)\n\n#### 详情\n\n根据输入的金融工具，获取它的债券子类型。\n\n#### 参数\n\n**instrument** INSTRUMENT 类型标量或向量，表示金融工具。\n\n#### 返回值\n\nSTRING 类型标量或向量。\n\n#### 例子\n\n```\nbond = {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Bond\",\n    \"bondType\": \"ZeroCouponBond\",\n    \"instrumentId\": \"0001\",\n    \"start\": 1996.03.01,\n    \"maturity\": 2032.05.15,\n    \"dayCountConvention\": \"ActualActualISDA\",\n    \"coupon\": 0.0276,\n    \"issuePrice\": 100.0,\n    \"frequency\": \"Semiannual\",\n    \"subType\":\"TREASURY_BOND\",\n    \"creditRating\":\"B\",\n    \"settlement\": 2022.05.15 \n}\nins = parseInstrument(bond)\ngetInstrumentSubType(ins)\n// output: TREASURY_BOND\n```\n\n**相关函数：**[parseInstrument](https://docs.dolphindb.cn/zh/funcs/p/parseInstrument.html)、[getInstrumentField](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentField.html)、[getInstrumentKeys](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentKeys.html)\n"
    },
    "getInstrumentUnderlying": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getinstrumentunderlying.html",
        "signatures": [
            {
                "full": "getInstrumentUnderlying(instrument)",
                "name": "getInstrumentUnderlying",
                "parameters": [
                    {
                        "full": "instrument",
                        "name": "instrument"
                    }
                ]
            }
        ],
        "markdown": "### [getInstrumentUnderlying](https://docs.dolphindb.cn/zh/funcs/g/getinstrumentunderlying.html)\n\n首发版本：3.00.4.1\n\n\n\n#### 语法\n\ngetInstrumentUnderlying(instrument)\n\n#### 详情\n\n根据输入的金融工具，获取该工具的标的资产。\n\n#### 参数\n\n**instrument** INSTRUMENT 类型标量或向量，表示金融工具。\n\n#### 返回值\n\n* 当 *instrument* 为国债期货标量时，返回为 INSTRUMENT 标量；\n* 当 *instrument* 为其他标量时，返回类型为 STRING 标量；\n* 当 *instrument* 为包含国债期货的向量时，返回元组；\n* 当 *instrument* 为不包含国债期货的向量时，返回 STRING 向量。\n\n#### 例子\n\n```\nbond ={\n    \"productType\": \"Cash\",\n    \"assetType\": \"Bond\",\n    \"bondType\": \"FixedRateBond\",\n    \"instrumentId\": \"220010.IB\",\n    \"start\": 2020.12.25,\n    \"maturity\": 2031.12.25,\n    \"issuePrice\": 100.0,\n    \"coupon\": 0.0149,\n    \"frequency\": \"Annual\",\n    \"dayCountConvention\": \"ActualActualISDA\"\n}\n\nfutures =  {\n    \"productType\": \"Futures\",\n    \"futuresType\": \"BondFutures\",\n    \"instrumentId\": \"T2509\",\n    \"nominal\": 100.0,\n    \"maturity\": \"2022.09.09\",\n    \"settlement\": \"2022.09.11\",\n    \"underlying\": bond,\n    \"nominalCouponRate\": 0.03\n}\nins1 = parseInstrument(futures)\n\noption = {\n    \"productType\": \"Option\",\n    \"optionType\": \"EuropeanOption\",\n    \"assetType\": \"FxEuropeanOption\",\n    \"notionalCurrency\": \"EUR\",\n    \"notionalAmount\": 1000000.0,\n    \"strike\": 1.2,\n    \"maturity\": \"2025.10.08\",\n    \"payoffType\": \"Call\",\n    \"dayCountConvention\": \"Actual365\",\n    \"underlying\": \"EURUSD\"\n}\nins2 = parseInstrument(option)\n\nx = getInstrumentUnderlying(ins1)\ny = getInstrumentUnderlying(ins2) //EURUSD\nz = getInstrumentUnderlying([ins1,ins2])\n\ntypestr x // INSTRUMENT\ntypestr y // STRING\ntypestr z // ANY VECTOR\n```\n\n**相关函数：**[parseInstrument](https://docs.dolphindb.cn/zh/funcs/p/parseInstrument.html)、[getInstrumentField](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentField.html)、[getInstrumentKeys](https://docs.dolphindb.cn/zh/funcs/g/getInstrumentKeys.html)\n"
    },
    "getIPBlackList": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getipblacklist.html",
        "signatures": [
            {
                "full": "getIPBlackList()",
                "name": "getIPBlackList",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getIPBlackList](https://docs.dolphindb.cn/zh/funcs/g/getipblacklist.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\ngetIPBlackList()\n\n#### 详情\n\n查看当前集群的 IP 黑名单。\n\n#### 参数\n\n无\n\n#### 返回值\n\n字符串向量。\n\n#### 例子\n\n```\naddIPBlackList([\"1.1.1.1\", \"2.2.2.2\", \"3.3.3.3\"])\nremoveIPBlackList(\"2.2.2.2\")\ngetIPBlackList()\n// output: [\"1.1.1.1\", \"3.3.3.3\"]\n```\n\n相关函数：[addIPBlackList](https://docs.dolphindb.cn/zh/funcs/a/addipblacklist.html)、[removeIPBlackList](https://docs.dolphindb.cn/zh/funcs/r/removeipblacklist.html)\n"
    },
    "getIPConnectionLimit": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getIPConnectionLimit.html",
        "signatures": [
            {
                "full": "getIPConnectionLimit()",
                "name": "getIPConnectionLimit",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getIPConnectionLimit](https://docs.dolphindb.cn/zh/funcs/g/getIPConnectionLimit.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\ngetIPConnectionLimit()\n\n#### 详情\n\n获取当前节点对不同 IP 的连接数限制。该限制适用于 API 连接和 `xdb` 连接，不会限制集群内部节点间的连接（如 `rpc` 等）。\n\n仅支持管理员调用，仅支持 Linux 系统部署的 server。\n\n#### 参数\n\n无。\n\n#### 返回值\n\n返回一个表，包含两列：\n\n* remoteIP：表示 IP 地址。\n* limit：表示该 IP 地址允许的最大连接数。\n\n#### 例子\n\n```\ngetIPConnectionLimit();\n```\n\n| remoteIP     | limit |\n| ------------ | ----- |\n| 192.168.1.56 | 10    |\n| 192.168.1.57 | 20    |\n\n相关函数：[setIPConnectionLimit](https://docs.dolphindb.cn/zh/funcs/s/setIPConnectionLimit.html)\n"
    },
    "getIPWhiteList": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getipwhitelist.html",
        "signatures": [
            {
                "full": "getIPWhiteList()",
                "name": "getIPWhiteList",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getIPWhiteList](https://docs.dolphindb.cn/zh/funcs/g/getipwhitelist.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\ngetIPWhiteList()\n\n#### 详情\n\n查看当前集群的 IP 白名单。\n\n#### 参数\n\n无\n\n#### 返回值\n\n字符串向量。\n\n#### 例子\n\n```\naddIPWhiteList([\"1.1.1.1\", \"2.2.2.2\", \"3.3.3.3\"])\nremoveIPWhiteList(\"2.2.2.2\")\ngetIPWhiteList()\n// output: [\"1.1.1.1\", \"3.3.3.3\"]\n```\n\n相关函数：[addIPWhiteList](https://docs.dolphindb.cn/zh/funcs/a/addipwhitelist.html)、[removeIPWhiteList](https://docs.dolphindb.cn/zh/funcs/r/removeipwhitelist.html)\n"
    },
    "getJobMessage": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getJobMessage.html",
        "signatures": [
            {
                "full": "getJobMessage(jobId)",
                "name": "getJobMessage",
                "parameters": [
                    {
                        "full": "jobId",
                        "name": "jobId"
                    }
                ]
            }
        ],
        "markdown": "### [getJobMessage](https://docs.dolphindb.cn/zh/funcs/g/getJobMessage.html)\n\n\n\n#### 语法\n\ngetJobMessage(jobId)\n\n#### 详情\n\n获得定时作业或批处理任务的中间信息。详情请参考 [BatchJobManagement](https://docs.dolphindb.cn/zh/sys_man/BatchJobManagement.html)。\n\n#### 参数\n\n**jobId** 是作业的 ID，是一个字符串。\n\n#### 返回值\n\n当返回值大小超过 65535 字节（即64 KB）时，返回类型为 BLOB（最大支持 64 MB）；否则返回类型为 STRING（最大支持 64 KB）。\n\n#### 例子\n\n```\ndef f():1+2;\nscheduleJob(jobId=`daily, jobDesc=\"Daily Job 1\", jobFunc=f, scheduleTime=10:22m, startDate=2026.06.16, endDate=2026.06.30, frequency='D');\ngetJobMessage(`daily)\n/* output:\n2026-06-16 10:22:12.342530 Start the job [daily]: Daily Job 1\n2026-06-16 10:22:12.342553 The job is done.\n*/\ndef job1(n){\n   s = 0\n   for (x in 1 : n) {\n       s += sum(sin rand(1.0, 100000000)-0.5)\n       print(\"iteration \" + x + \" \" + s)\n   }\n   return s\n}\njob1_ID=submitJob(\"job1_ID\",\"\", job1, 100);\n```\n\n批处理作业完成后，执行以下命令：\n\n```\ngetJobMessage(job1_ID);\n```\n\n返回：\n\n```\n2025-05-26 14:44:58.090748 Start the job [job1_ID202505260000]: job1\n2025-05-26 14:44:59.394245 iteration 1 -2067.639360414350903\n2025-05-26 14:45:00.571536 iteration 2 -3394.027760215838497\n2025-05-26 14:45:01.728218 iteration 3 -6658.143178910555434\n2025-05-26 14:45:02.955152 iteration 4 -9995.435727637650415\n2025-05-26 14:45:04.362283 iteration 5 -8653.510696739111153\n2025-05-26 14:45:05.542019 iteration 6 -10801.809641761219609\n2025-05-26 14:45:06.702139 iteration 7 -12924.020454809666262\n2025-05-26 14:45:07.850191 iteration 8 -10882.168276451939163\n2025-05-26 14:45:09.060107 iteration 9 -14318.061736551684589\n2025-05-26 14:45:10.428853 iteration 10 -11516.30579954075074\n2025-05-26 14:45:11.570470 iteration 11 -13945.02455184262908\n2025-05-26 14:45:12.706159 iteration 12 -15082.415793091910018\n2025-05-26 14:45:13.845771 iteration 13 -16508.837934508221223\n2025-05-26 14:45:14.980443 iteration 14 -12171.185820641085228\n2025-05-26 14:45:16.133074 iteration 15 -11497.140285110303011\n2025-05-26 14:45:17.305225 iteration 16 -12546.300852946240411\n2025-05-26 14:45:18.469218 iteration 17 -8682.138463782639519\n2025-05-26 14:45:19.636227 iteration 18 -8287.05071118341948\n2025-05-26 14:45:20.797512 iteration 19 -6045.8953755881721\n2025-05-26 14:45:21.989929 iteration 20 -1587.853404830938416\n2025-05-26 14:45:23.366825 iteration 21 -1061.898133246364068\n2025-05-26 14:45:24.509909 iteration 22 -5604.016581881107413\n2025-05-26 14:45:25.658594 iteration 23 -681.276543087000391\n2025-05-26 14:45:26.814315 iteration 24 798.217304283653447\n2025-05-26 14:45:27.967876 iteration 25 -2357.82192257714496\n2025-05-26 14:45:29.122764 iteration 26 1474.997463642485854\n2025-05-26 14:45:30.264584 iteration 27 2351.139591280943477\n2025-05-26 14:45:31.408370 iteration 28 1037.512168873698328\n2025-05-26 14:45:32.548303 iteration 29 3893.945455537286761\n2025-05-26 14:45:33.699278 iteration 30 4148.650282345925006\n2025-05-26 14:45:34.894419 iteration 31 4031.307766634015024\n2025-05-26 14:45:36.285051 iteration 32 4107.605624560140313\n2025-05-26 14:45:37.452961 iteration 33 5929.91120327810222\n2025-05-26 14:45:38.623867 iteration 34 9425.642810558107157\n2025-05-26 14:45:39.791290 iteration 35 13047.809822686220286\n2025-05-26 14:45:40.965689 iteration 36 10245.933230357943102\n2025-05-26 14:45:42.117447 iteration 37 5432.54276188393851\n2025-05-26 14:45:43.253473 iteration 38 5227.81294757969772\n2025-05-26 14:45:44.241254 iteration 39 1356.898505138993641\n2025-05-26 14:45:44.860755 iteration 40 -1671.878041062590909\n2025-05-26 14:45:45.484119 iteration 41 -1021.138518814122107\n2025-05-26 14:45:46.108090 iteration 42 -2321.149447111632525\n2025-05-26 14:45:46.720242 iteration 43 -5246.586195028939982\n2025-05-26 14:45:47.339880 iteration 44 -8492.119388688672188\n2025-05-26 14:45:47.994839 iteration 45 -8663.850570230377343\n2025-05-26 14:45:48.798468 iteration 46 -10024.085162459703497\n2025-05-26 14:45:49.416817 iteration 47 -7627.128519907962072\n2025-05-26 14:45:50.050123 iteration 48 -8859.465736911144631\n2025-05-26 14:45:50.696957 iteration 49 -11600.588771286853443\n2025-05-26 14:45:51.332706 iteration 50 -12023.426188408715461\n2025-05-26 14:45:51.958107 iteration 51 -13738.331148613655386\n2025-05-26 14:45:52.574174 iteration 52 -14245.913822854639875\n2025-05-26 14:45:53.228183 iteration 53 -15609.22655546905662\n2025-05-26 14:45:53.840108 iteration 54 -14109.554485099233716\n2025-05-26 14:45:54.455551 iteration 55 -15457.235974196633833\n2025-05-26 14:45:55.109167 iteration 56 -14926.928231457419315\n2025-05-26 14:45:55.901304 iteration 57 -13535.493685042154538\n2025-05-26 14:45:56.512054 iteration 58 -11137.324502514182313\n2025-05-26 14:45:57.126833 iteration 59 -8467.404657879153091\n2025-05-26 14:45:57.742143 iteration 60 -1746.003070659520744\n2025-05-26 14:45:58.353437 iteration 61 -3325.876159699668278\n2025-05-26 14:45:58.966068 iteration 62 588.700051641846584\n2025-05-26 14:45:59.574346 iteration 63 -5367.267372965314279\n2025-05-26 14:46:00.185607 iteration 64 -5910.796992469990073\n2025-05-26 14:46:00.828945 iteration 65 -3960.193144167483296\n2025-05-26 14:46:01.458748 iteration 66 122.939722062535111\n2025-05-26 14:46:02.128915 iteration 67 -704.828146272833123\n2025-05-26 14:46:02.955747 iteration 68 3864.606686010478824\n2025-05-26 14:46:03.584085 iteration 69 5186.69739255679724\n2025-05-26 14:46:04.210760 iteration 70 5384.310290306410024\n2025-05-26 14:46:04.832343 iteration 71 3535.338795232024494\n2025-05-26 14:46:05.451344 iteration 72 7529.76101041288075\n2025-05-26 14:46:06.070711 iteration 73 5539.502143333455023\n2025-05-26 14:46:06.719013 iteration 74 7597.268444337500113\n2025-05-26 14:46:07.342229 iteration 75 14728.821072668564738\n2025-05-26 14:46:07.979907 iteration 76 18934.636409439837734\n2025-05-26 14:46:08.596204 iteration 77 19498.750036070654459\n2025-05-26 14:46:09.252392 iteration 78 19268.594342755670368\n2025-05-26 14:46:10.059616 iteration 79 20036.702738540243444\n2025-05-26 14:46:10.734090 iteration 80 24399.283123330875241\n2025-05-26 14:46:11.401129 iteration 81 26353.387390017069265\n2025-05-26 14:46:12.020258 iteration 82 25021.36744718257978\n2025-05-26 14:46:12.640379 iteration 83 20515.896296028589858\n2025-05-26 14:46:13.271550 iteration 84 18948.980154855420551\n2025-05-26 14:46:13.888417 iteration 85 22251.157044437986769\n2025-05-26 14:46:14.509057 iteration 86 21076.744112906457303\n2025-05-26 14:46:15.129712 iteration 87 19794.661956942076358\n2025-05-26 14:46:15.750538 iteration 88 20416.494072026296635\n2025-05-26 14:46:16.401382 iteration 89 19871.931658841131138\n2025-05-26 14:46:17.209955 iteration 90 18276.697674308263231\n2025-05-26 14:46:17.828958 iteration 91 19967.525665167577244\n2025-05-26 14:46:18.461022 iteration 92 22098.668749747052061\n2025-05-26 14:46:19.079399 iteration 93 17969.401810196610313\n2025-05-26 14:46:19.711974 iteration 94 18239.368392132648295\n2025-05-26 14:46:20.358000 iteration 95 18944.493373054185212\n2025-05-26 14:46:21.011468 iteration 96 14969.713016859974231\n2025-05-26 14:46:21.648286 iteration 97 12863.562367756972889\n2025-05-26 14:46:22.289103 iteration 98 12659.014405440735572\n2025-05-26 14:46:22.917878 iteration 99 14069.1513439974442\n2025-05-26 14:46:22.917878 The job is done.\n```\n"
    },
    "getJobReturn": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getJobReturn.html",
        "signatures": [
            {
                "full": "getJobReturn(jobId, [blocking=false])",
                "name": "getJobReturn",
                "parameters": [
                    {
                        "full": "jobId",
                        "name": "jobId"
                    },
                    {
                        "full": "[blocking=false]",
                        "name": "blocking",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [getJobReturn](https://docs.dolphindb.cn/zh/funcs/g/getJobReturn.html)\n\n\n\n#### 语法\n\ngetJobReturn(jobId, \\[blocking=false])\n\n#### 详情\n\n获取作业（包括定时作业和批处理作业）返回的对象。详情请参考 [BatchJobManagement](https://docs.dolphindb.cn/zh/sys_man/BatchJobManagement.html)。\n\n#### 参数\n\n**jobId** 是作业的 ID，是一个字符串。\n\n**blocking** 是一个布尔值，表示是否采用阻塞模式。默认值为 false。如果 *blocking* 为 false，在批处理作业没有完成的情况下，函数会抛出异常。如果 *blocking* 为 true，直到批处理作业完成后，函数才会返回值。\n\n#### 返回值\n\n取决于作业自身的返回值。\n\n#### 例子\n\n```\ndef f():1+2;\nscheduleJob(jobId=`daily, jobDesc=\"Daily Job 1\", jobFunc=f, scheduleTime=10:22m, startDate=2026.06.16, endDate=2026.06.30, frequency='D');\ngetJobReturn(`daily)\n// output: 3\n\ndef job1(n){\n   s = 0\n   for (x in 1 : n) {\n       s += sum(sin rand(1.0, 100000000)-0.5)\n       print(\"iteration \" + x + \" \" + s)\n   }\n   return s\n}\n\njob1_ID=submitJob(\"job1_ID\",\"\", job1, 100);\ngetJobReturn(job1_ID);\n```\n\n返回：\n\n```\nThe job [job1_ID20210428] is not complete yet.\n```\n\n批处理作业完成后，重新执行`getJobReturn`：\n\n```\ngetJobReturn(job1_ID);\n```\n\n返回：-13318.181243\n\n如需在工作完成后通过 `getJobReturn` 返回结果，可设置 *blocking* 参数为 true。这在批处理作业中非常有用。\n\n```\njob1_ID = submitJob(\"job1_ID\",\"\", job1, 100)\ngetJobReturn(job1_ID, true);\n```\n\n返回：25,199.851552887143\n"
    },
    "getJobStat": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getJobStat.html",
        "signatures": [
            {
                "full": "getJobStat()",
                "name": "getJobStat",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getJobStat](https://docs.dolphindb.cn/zh/funcs/g/getJobStat.html)\n\n\n\n#### 语法\n\ngetJobStat()\n\n#### 详情\n\n监控正在执行或者队列中的作业和任务的数量。\n\n#### 参数\n\n无\n\n#### 返回值\n\n返回一个字典，其 key 的含义为：\n\n| 参数                | 含义           |\n| ----------------- | ------------ |\n| queuedLocalTasks  | 等待执行的本地任务数。  |\n| runningLocalTasks | 正在执行的本地任务数。  |\n| queuedJobs        | 队列中的作业数。     |\n| runningJobs       | 正在执行的作业数。    |\n| queuedRemoteTasks | 发送到远程执行的任务数。 |\n\n#### 例子\n\n```\ngetJobStat();\n```\n\n返回：\n\n```\nqueuedLocalTasks->0\nrunnningJobs->0\nqueuedRemoteTasks->0\nqueuedJobs->0\nrunningLocalTasks->0\n```\n"
    },
    "getJobStatus": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getJobStatus.html",
        "signatures": [
            {
                "full": "getJobStatus(jobId)",
                "name": "getJobStatus",
                "parameters": [
                    {
                        "full": "jobId",
                        "name": "jobId"
                    }
                ]
            }
        ],
        "markdown": "### [getJobStatus](https://docs.dolphindb.cn/zh/funcs/g/getJobStatus.html)\n\n\n\n#### 语法\n\ngetJobStatus(jobId)\n\n#### 详情\n\n获取指定的定时作业或批处理作业的状态。\n\n#### 参数\n\n**jobId** 是作业的 ID，是一个字符串。详情请参考 [BatchJobManagement](https://docs.dolphindb.cn/zh/sys_man/BatchJobManagement.html)。\n\n#### 返回值\n\n返回一个表，包含以下字段：\n\n| 参数           | 含义                      |\n| ------------ | ----------------------- |\n| node         | 本地节点的别名。                |\n| userID       | 提交作业任务的用户 ID。           |\n| jobId        | 在提交批作业时指定的作业名。          |\n| rootJobId    | 系统中作业的唯一标识。             |\n| jobDesc      | 用于描述作业的字符串。             |\n| priority     | 作业的优先级，为 0-9 之间的整数。     |\n| parallelism  | 作业的并行度，即分配给该作业的线程数上限。   |\n| clientIp     | 发起作业任务的客户端 IP。          |\n| clientPort   | 发起作业任务的客户端端口号。          |\n| receivedTime | 作业接收的时间，为 TIMESTAMP 类型。 |\n| startTime    | 作业开始时间，为 TIMESTAMP 类型。  |\n| endTime      | 作业结束时间，为 TIMESTAMP 类型。  |\n| errorMsg     | 报错信息。                   |\n\n#### 例子\n\n```\ndef job1(n){\n   s = 0\n   for (x in 1 : n) {\n       s += sum(sin rand(1.0, 100000000)-0.5)\n       print(\"iteration \" + x + \" \" + s)\n   }\n   return s\n}\n\njob1_ID=submitJob(\"job1_ID\",\"\", job1, 100);\ngetJobStatus(job1_ID);\n```\n\n返回：\n\n| node        | userID | jobId               | rootJobId                            | jobDesc | priority | parallelism | clientIp       | clientPort | receivedTime            | startTime | endTime | errorMsg |\n| ----------- | ------ | ------------------- | ------------------------------------ | ------- | -------- | ----------- | -------------- | ---------- | ----------------------- | --------- | ------- | -------- |\n| controller2 | guest  | job1\\_ID20210428... | b9263bfd-50b8-70b3-9845-e595f9b0c506 | job1    | 4        | 1           | 115.204.199.28 | 61537      | 2023.12.12T02:50:32.598 |           |         |          |\n\n在作业的状态中，*EndTime* 是空的。这意味着作业还在执行中。作业完成后，就能在状态中看到 EndTime。\n\n```\ngetJobStatus(job1_ID);\n```\n\n| node        | userID | jobId               | rootJobId                            | jobDesc | priority | parallelism | clientIp       | clientPort | receivedTime            | startTime               | endTime                 | errorMsg |\n| ----------- | ------ | ------------------- | ------------------------------------ | ------- | -------- | ----------- | -------------- | ---------- | ----------------------- | ----------------------- | ----------------------- | -------- |\n| controller2 | guest  | job1\\_ID20210428... | b9263bfd-50b8-70b3-9845-e595f9b0c506 | job1    | 4        | 1           | 115.204.199.28 | 61537      | 2023.12.12T02:50:32.598 | 2023.12.12T02:50:32.599 | 2023.12.12T02:52:32.477 |          |\n"
    },
    "getLeftStream": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getLeftStream.html",
        "signatures": [
            {
                "full": "getLeftStream(joinEngine)",
                "name": "getLeftStream",
                "parameters": [
                    {
                        "full": "joinEngine",
                        "name": "joinEngine"
                    }
                ]
            }
        ],
        "markdown": "### [getLeftStream](https://docs.dolphindb.cn/zh/funcs/g/getLeftStream.html)\n\n\n\n#### 语法\n\ngetLeftStream(joinEngine)\n\n#### 详情\n\n返回连接引擎左表的表结构对象。向该对象注入的数据，会注入到 *joinEngine* 中。\n\n通过该函数，可以将一个引擎的计算结果直接注入到连接引擎中，实现引擎间的级联。\n\n#### 参数\n\n**joinEngine** 创建连接引擎返回的对象。目前 DolphinDB 支持的连接引擎有：\n\n* createAsofJoinEngine\n\n* createEquiJoinEngine\n\n* createLookupJoinEngine\n\n* createWindowJoinEngine\n\n* createLeftSemiJoinEngine\n\n#### 返回值\n\n返回一个表。\n\n#### 例子\n\n```\nshare streamTable(1000:0, `time`sym`price, [TIMESTAMP, SYMBOL, DOUBLE]) as trades\n\noutput=table(100:0, `timestamp`sym`price1`price2, [TIMESTAMP, SYMBOL, DOUBLE, DOUBLE])\n\nleftTable=table(1:0, `sym`timestamp`price, [SYMBOL, TIMESTAMP, DOUBLE])\nrightTable=table(1:0, `sym`timestamp`price, [SYMBOL, TIMESTAMP, DOUBLE])\n\najEngine = createAsofJoinEngine(\"asofjoin_engine\", leftTable, rightTable, output, <[leftTable.price, rightTable.price]>, `sym, `timestamp)\n\nleftEngine = createReactiveStateEngine(name=`left_reactive_engine, metrics=<[time,msum(price,3)]>, dummyTable=trades, outputTable=getLeftStream(ajEngine), keyColumn=\"sym\")\nrightEngine = createReactiveStateEngine(name=`right_reactive_engine, metrics=<[time,mfirst(price,3)]>, dummyTable=trades, outputTable=getRightStream(ajEngine), keyColumn=\"sym\")\n\nsubscribeTable(, \"trades\", \"left_reactive_engine\", 0, append!{leftEngine}, true)\nsubscribeTable(, \"trades\", \"right_reactive_engine\", 0, append!{rightEngine}, true)\n\nt = table(2022.01.01 + 1..20 as time, take(`AMZN`IBM`APPL, 20) as sym, rand(100.0, 20) as price)\ntrades.append!(t)\nselect * from output order by timestamp,sym\n```\n\n| timestamp               | sym  | price1   | price2  |\n| ----------------------- | ---- | -------- | ------- |\n| 2022.01.02T00:00:00.000 | AMZN |          |         |\n| 2022.01.03T00:00:00.000 | IBM  |          |         |\n| 2022.01.04T00:00:00.000 | APPL |          |         |\n| 2022.01.05T00:00:00.000 | AMZN |          |         |\n| 2022.01.06T00:00:00.000 | IBM  |          |         |\n| 2022.01.07T00:00:00.000 | APPL |          |         |\n| 2022.01.08T00:00:00.000 | AMZN | 102.192  | 26.2273 |\n| 2022.01.09T00:00:00.000 | IBM  | 152.2704 | 43.6296 |\n| 2022.01.10T00:00:00.000 | APPL | 126.1056 | 74.929  |\n| 2022.01.11T00:00:00.000 | AMZN | 137.4656 | 57.6015 |\n| 2022.01.12T00:00:00.000 | IBM  | 116.7775 | 54.2854 |\n| 2022.01.13T00:00:00.000 | APPL | 58.8909  | 49.3149 |\n| 2022.01.14T00:00:00.000 | AMZN | 148.5405 | 18.3633 |\n| 2022.01.15T00:00:00.000 | IBM  | 141.0848 | 54.3554 |\n| 2022.01.16T00:00:00.000 | APPL | 93.9003  | 1.8618  |\n| 2022.01.17T00:00:00.000 | AMZN | 210.4329 | 61.5008 |\n| 2022.01.18T00:00:00.000 | IBM  | 88.7772  | 8.1367  |\n\n相关函数：[getRightStream](https://docs.dolphindb.cn/zh/funcs/g/getRightStream.html)。\n"
    },
    "getLevelFileIndexCacheStatus": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getLevelFileIndexCacheStats.html",
        "signatures": [
            {
                "full": "getLevelFileIndexCacheStatus()",
                "name": "getLevelFileIndexCacheStatus",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getLevelFileIndexCacheStatus](https://docs.dolphindb.cn/zh/funcs/g/getLevelFileIndexCacheStats.html)\n\n\n\n#### 语法\n\ngetLevelFileIndexCacheStatus()\n\n#### 详情\n\n获取所有 level file 的索引内存占用的情况。\n\n#### 参数\n\n无\n\n#### 返回值\n\n返回一个字典，包含以下 key 值：\n\n* capacity：level file 索引内存占用上限；\n\n* usage：level file 索引使用的内存，单位为字节。\n\n#### 例子\n\n```\ngetLevelFileIndexCacheStatus()\n\n// output\nusage->0\ncapacity->429496729\n```\n"
    },
    "getLicenseExpiration": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getLicenseExpiration.html",
        "signatures": [
            {
                "full": "getLicenseExpiration()",
                "name": "getLicenseExpiration",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getLicenseExpiration](https://docs.dolphindb.cn/zh/funcs/g/getLicenseExpiration.html)\n\n\n\n#### 语法\n\ngetLicenseExpiration()\n\n#### 详情\n\n查看当前节点的 license 过期时间。可用于更新 license 之后，验证新的 license 是否生效。\n\n#### 参数\n\n无\n\n#### 返回值\n\nDATE 类型标量。\n\n#### 例子\n\n```\ngetLicenseExpiration()\n```\n\n输出返回：2021.09.30\n"
    },
    "getLoadedModules": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getloadedmodules.html",
        "signatures": [
            {
                "full": "getLoadedModules()",
                "name": "getLoadedModules",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getLoadedModules](https://docs.dolphindb.cn/zh/funcs/g/getloadedmodules.html)\n\n首发版本：3.00.5，3.00.4.3\n\n\n\n#### 语法\n\ngetLoadedModules()\n\n#### 详情\n\n查询当前会话中已经加载的模块。\n\n**Note:**\n\n如果已通过 *preloadModules* 配置项加载指定模块，则每个会话都默认加载了该模块，所以会在返回结果中展示。\n\n#### 参数\n\n无。\n\n#### 返回值\n\n返回一张表，包含以下字段：\n\n* moduleName：模块名称。\n* moduleVersion：模块版本。\n* isFree：是否为免费模块。\n\n如果是自定义模块，moduleVersion 为空，isFree 为 true。\n\n#### 例子\n\n假设已通过 use 语句加载 alphalens 和 ops 模块：\n\n```\ngetLoadedModules()\n```\n\n返回一张模块信息表，如下所示：\n\n| moduleName | moduleVersion | isFree |\n| ---------- | ------------- | ------ |\n| alphalens  | 1.0.0         | true   |\n| ops        | 1.0.0         | true   |\n\n**相关函数**\n\n[loadModule](https://docs.dolphindb.cn/zh/funcs/l/loadModule.html)\n"
    },
    "getLoadedPlugins": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getloadedplugins.html",
        "signatures": [
            {
                "full": "getLoadedPlugins()",
                "name": "getLoadedPlugins",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getLoadedPlugins](https://docs.dolphindb.cn/zh/funcs/g/getloadedplugins.html)\n\n\n\n#### 语法\n\ngetLoadedPlugins()\n\n#### 详情\n\n获取当前节点已加载的插件列表。\n\n#### 参数\n\n无\n\n#### 返回值\n\n一张表，包含以下字段：\n\n* plugin：STRING，插件名称。\n\n* version：STRING，插件的版本（*PluginXXX.txt* 文件的版本）\n\n* user：STRING，加载该插件的用户名称。\n\n* time：TIMESTAMP，加载该插件的时间。\n\n#### 例子\n\n```\nlogin(\"admin\",\"123456\")\nloadPlugin(\"zip\")\nlogin(\"user1\",\"123456\")\nloadPlugin(\"httpclient\")\n\ngetLoadedPlugins()\n```\n\n返回结果：\n\n| plugin     | version | user  | time                    |\n| ---------- | ------- | ----- | ----------------------- |\n| zip        | 3.00.1  | admin | 2024.09.01T10:00:01.000 |\n| httpClient | 3.00.1  | user1 | 2024.09.01T10:00:02.000 |\n"
    },
    "getLocalIOTDBStaticTable": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getLocalIOTDBStaticTable.html",
        "signatures": [
            {
                "full": "getLocalIOTDBStaticTable(dbUrl, tableName, [dfsPath])",
                "name": "getLocalIOTDBStaticTable",
                "parameters": [
                    {
                        "full": "dbUrl",
                        "name": "dbUrl"
                    },
                    {
                        "full": "tableName",
                        "name": "tableName"
                    },
                    {
                        "full": "[dfsPath]",
                        "name": "dfsPath",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [getLocalIOTDBStaticTable](https://docs.dolphindb.cn/zh/funcs/g/getLocalIOTDBStaticTable.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\ngetLocalIOTDBStaticTable(dbUrl, tableName, \\[dfsPath])\n\n#### 详情\n\n该函数仅支持对该表有 TABLE\\_READ 权限或对该数据库有 DB\\_READ 权限的用户在数据节点调用。\n\n#### 参数\n\n**dbUrl** STRING 类型标量，表示分布式数据库的路径。\n\n**tableName** STRING 类型标量，表示表名。\n\n**dfsPath** STRING 类型标量，表示 chunk 的 DFS 路径。该参数可由 `getChunksMeta` 的返回值 dfsPath 列，去掉时间维度及之后内容获得，例如某 chunk 的 dfsPath 为 `/db/Key1/20250428/gP`，则该参数应设置为 `/db/Key1` 。默认返回当前节点该表的所有静态表。\n\n#### 返回值\n\n返回一个表，包含以下字段：\n\n* innerId: 测点对应的内部 ID。\n* 测点列：列数和列名取决于 sort key，即建表时 sortColumns 中除最后一列以外的列。如果这些列中存在名为 innerId 或 valueType 的列，返回表中将自动重命名为 \\_innerId\\_ 和 \\_valueType\\_。\n* valueType: 测点对应的 IOTANY 列的类型。\n\n#### 例子\n\n```\ngetLocalIOTDBStaticTable(dbUrl=\"dfs://db\", tableName=\"pt\", dfsPath=\"/db/Key1\")\n```\n\n| innerId | deviceId | location | valueType |\n| ------- | -------- | -------- | --------- |\n| 1       | 1        | loc2     | DOUBLE    |\n| 0       | 1        | loc1     | INT       |\n"
    },
    "getMarketCalendar": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getMarketCalendar.html",
        "signatures": [
            {
                "full": "getMarketCalendar(marketName, [startDate], [endDate])",
                "name": "getMarketCalendar",
                "parameters": [
                    {
                        "full": "marketName",
                        "name": "marketName"
                    },
                    {
                        "full": "[startDate]",
                        "name": "startDate",
                        "optional": true
                    },
                    {
                        "full": "[endDate]",
                        "name": "endDate",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [getMarketCalendar](https://docs.dolphindb.cn/zh/funcs/g/getMarketCalendar.html)\n\n\n\n#### 语法\n\ngetMarketCalendar(marketName, \\[startDate], \\[endDate])\n\n#### 详情\n\nDolphinDB 提供国内外超过50个交易所的交易日历信息（对应文件存放于 *marketHolidayDir* 中），通过该函数可以获取由 *startDate* 和 *endDate* 确定的时间范围内的交易日历。\n\n#### 参数\n\n**marketName** 字符串标量，表示交易日历标识，例如：国外交易所的 ISO Code、国内交易所简称或自定义交易日历名称。必须是 *marketHolidayDir* 下存在的文件名，否则会报错。\n\n**startDate** DATE 类型标量。默认为空，表示起始日期为 *marketName* 同名文件中最小年份的1月1日。\n\n**endDate** DATE 类型标量。默认为空，表示结束日期为 *marketName* 同名文件中最大年份的12月31日。\n\n#### 返回值\n\nDATE 类型向量。\n\n#### 例子\n\n```\ngetMarketCalendar(\"CCFX\",2022.01.01, 2022.01.10)\n```\n\n输出返回：\\[2022.01.04,2022.01.06,2022.01.07,2022.01.10]\n\n**Related information**\n\n[addMarketHoliday](https://docs.dolphindb.cn/zh/funcs/a/addMarketHoliday.html)\n\n[updateMarketHoliday](https://docs.dolphindb.cn/zh/funcs/u/updateMarketHoliday.html)\n"
    },
    "getMasterReplicationStatus": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getMasterReplicationStatus.html",
        "signatures": [
            {
                "full": "getMasterReplicationStatus([limit=-1])",
                "name": "getMasterReplicationStatus",
                "parameters": [
                    {
                        "full": "[limit=-1]",
                        "name": "limit",
                        "optional": true,
                        "default": "-1"
                    }
                ]
            }
        ],
        "markdown": "### [getMasterReplicationStatus](https://docs.dolphindb.cn/zh/funcs/g/getMasterReplicationStatus.html)\n\n\n\n#### 语法\n\ngetMasterReplicationStatus(\\[limit=-1])\n\n#### 详情\n\n获取主集群的异步复制状态。已完成的任务排列在前面，未完成的任务排列在后面。\n\n* 如果未指定 *limit*，则返回的任务数量不受限制。\n\n* 如果指定 *limit*，则返回最多 *limit* 个任务列表。\n\n其中，已完成的任务最多显示最近的1万条记录；而未完成的任务只显示从最早时间开始，直到满足指定条数的记录。\n\n该函数只能由管理员在主集群的控制节点调用。\n\n#### 参数\n\n**limit** 一个整数，表示结果中最多可返回的任务数量。\n\n#### 返回值\n\n返回一个表，包含以下字段：\n\n* taskId：异步复制任务 id。\n\n* tid：事务 id。\n\n* groupId：异步复制任务所属的组 id。\n\n* operationType：任务类型，参照异步复制支持性表。\n\n* submitTime：任务提交的时间，类型为 NANOTIMESTAMP。\n\n* dbName：任务对应的数据库的路径。\n\n* tableName：任务对应的表名。\n\n* srcIP：存储写任务数据的数据节点 ip。\n\n* srcPort：存储写任务数据的数据节点 port。\n\n* isTruncated：该任务是否已经完成并从发送队列回收。\n\n#### 例子\n\n```\ngetMasterReplicationStatus();\n```\n\n输出返回：\n\n| taskId | tid | groupId | operationType              | submitTime                    | dbName                          | tableName | srcIP     | srcPort | isTruncated |\n| ------ | --- | ------- | -------------------------- | ----------------------------- | ------------------------------- | --------- | --------- | ------- | ----------- |\n| 1      | 1   | 1       | CREATE\\_DB                 | 2022.11.08T10:50:35.442141722 | db://test\\_dropPartition\\_value |           | 127.0.0.1 | 8002    | true        |\n| 2      | 2   | 2       | CREATE\\_PARTITIONED\\_TABLE | 2022.11.08T10:50:35.447716190 | db://test\\_dropPartition\\_value | pt        | 127.0.0.1 | 8002    | true        |\n| 3      | 3   | 3       | APPEND                     | 2022.11.08T10:50:35.584920262 | db://test\\_dropPartition\\_value | pt        | 127.0.0.1 | 8002    | true        |\n| 4      | 4   | 4       | DROP\\_PARTITION            | 2022.11.08T10:50:35.632575800 |                                 | pt        | 127.0.0.1 | 8002    | false       |\n\n相关函数：[getSlaveReplicationStatus](https://docs.dolphindb.cn/zh/funcs/g/getSlaveReplicationStatus.html)\n"
    },
    "getMCPPrompt": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getMCPPrompt.html",
        "signatures": [
            {
                "full": "getMCPPrompt(name, [args], [published])",
                "name": "getMCPPrompt",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "[args]",
                        "name": "args",
                        "optional": true
                    },
                    {
                        "full": "[published]",
                        "name": "published",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [getMCPPrompt](https://docs.dolphindb.cn/zh/funcs/g/getMCPPrompt.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\ngetMCPPrompt(name, \\[args], \\[published])\n\n#### 详情\n\n调用指定的 MCP Prompt 模板。\n\n#### 参数\n\n**name**STRING 类型标量，表示 prompt 模板的名称。\n\n**args** 可选参数，一个字典，键是 STRING 类型，值是 ANY 或 STRING 类型，表示传入 prompt 模板的参数。\n\n**published** 可选参数，布尔值，表示是否调用已发布的版本。默认为 false，表示调用尚未发布的版本。\n\n#### 返回值\n\n一个字符串，内容是根据模板和传入参数生成的 prompt 文本。\n\n#### 例子\n\n```\n// 定义 prompt 模板并发布\naddMCPPrompt(\n  name = \"stock_summary\",\n  message = \"请用一句话总结 ${stock} 从 ${startDate} 到 ${endDate} 的走势。\",\n  description = \"生成某个股票在一段时间内的自然语言概述\",\n  extraInfo = {title : \"股票走势总结\"}\n)\npublishMCPPrompts(\"stock_summary\")\n\n// 更新模板，不发布\nupdateMCPPrompt(\n  name = \"stock_summary\",\n  message = \"请找出 ${stock} 在 ${startDate} 至 ${endDate} 的最高价和最低价。\",\n  description = \"更新后的 Prompt 描述\"\n)\n\n// 调用发布的 stock_summary\ngetMCPPrompt(name=\"stock_summary\", args={\"stock\":\"000111\", \"startDate\":2025.01.01, \"endDate\":2025.08.01}, published=true)\n// output: 请用一句话总结 000111 从 2025.01.01 到 2025.08.01 的走势。\n\n// 调用更新后未发布的 stock_summary\ngetMCPPrompt(name=\"stock_summary\", args={\"stock\":\"000111\", \"startDate\":2025.01.01, \"endDate\":2025.08.01}, published=false)\n// output:请找出 000111 在 2025.01.01 至 2025.08.01 的最高价和最低价。\n```\n"
    },
    "getMemLimitOfAllTempResults": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getmemlimitofalltempresults.html",
        "signatures": [
            {
                "full": "getMemLimitOfAllTempResults()",
                "name": "getMemLimitOfAllTempResults",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getMemLimitOfAllTempResults](https://docs.dolphindb.cn/zh/funcs/g/getmemlimitofalltempresults.html)\n\n\n\n#### 语法\n\ngetMemLimitOfAllTempResults()\n\n#### 详情\n\n获取分布式查询操作（例如表连接、GROUP BY、CONTEXT BY、PIVOT BY）产生的临时表可以占用的内存上限。\n\n#### 参数\n\n无\n\n#### 返回值\n\nDOUBLE 类型标量。\n\n#### 例子\n\n```\ngetMemLimitOfAllTempResults()\n// output: 3.0\n```\n\n相关函数：[setMemLimitOfAllTempResults](https://docs.dolphindb.cn/zh/funcs/s/setmemlimitofalltempresults.html)\n"
    },
    "getMemLimitOfQueryResult": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getMemLimitOfQueryResult.html",
        "signatures": [
            {
                "full": "getMemLimitOfQueryResult()",
                "name": "getMemLimitOfQueryResult",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getMemLimitOfQueryResult](https://docs.dolphindb.cn/zh/funcs/g/getMemLimitOfQueryResult.html)\n\n\n\n#### 语法\n\ngetMemLimitOfQueryResult()\n\n#### 详情\n\n获取单次查询结果占用的内存上限（单位为字节）。\n\n#### 参数\n\n无\n\n#### 返回值\n\nDOUBLE 类型标量。\n\n#### 例子\n\n```\nsetMemLimitOfQueryResult(0.2)\ngetMemLimitOfQueryResult() / 1024 / 1024 / 1024\n// output: 0.2\n```\n\n相关函数：[setMemLimitOfQueryResult](https://docs.dolphindb.cn/zh/funcs/s/setMemLimitOfQueryResult.html)\n"
    },
    "getMemLimitOfTaskGroupResult": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getMemLimitOfTaskGroupResult.html",
        "signatures": [
            {
                "full": "getMemLimitOfTaskGroupResult()",
                "name": "getMemLimitOfTaskGroupResult",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getMemLimitOfTaskGroupResult](https://docs.dolphindb.cn/zh/funcs/g/getMemLimitOfTaskGroupResult.html)\n\n\n\n#### 语法\n\ngetMemLimitOfTaskGroupResult()\n\n#### 详情\n\n获取当前节点发送的批量子查询占用的内存上限（单位为字节）。\n\n#### 参数\n\n无\n\n#### 返回值\n\nDOUBLE 类型标量。\n\n#### 例子\n\n```\nsetMemLimitOfTaskGroupResult(10)\ngetMemLimitOfTaskGroupResult() / 1024 / 1024 / 1024\n// output: 10\n```\n\n相关函数：[setMemLimitOfTaskGroupResult](https://docs.dolphindb.cn/zh/funcs/s/setMemLimitOfTaskGroupResult.html)\n"
    },
    "getMemoryStat": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getMemoryStat.html",
        "signatures": [
            {
                "full": "getMemoryStat()",
                "name": "getMemoryStat",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getMemoryStat](https://docs.dolphindb.cn/zh/funcs/g/getMemoryStat.html)\n\n\n\n#### 语法\n\ngetMemoryStat()\n\n#### 详情\n\n获取当前节点已分配的内存和未使用的内存。两者之差为已占用内存。\n\n#### 参数\n\n无\n\n#### 返回值\n\n返回一个字典，其 key 值的含义为：\n\n* allocatedBytes：当前节点已分配的内存，单位为字节。\n\n* freeBytes：当前节点已分配但未使用的内存，单位为字节。\n\n#### 例子\n\n```\ngetMemoryStat();\n\n// output\nfreeBytes->6430128\nallocatedBytes->35463168\n```\n"
    },
    "getMktData": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getMktData.html",
        "signatures": [
            {
                "full": "getMktData(dataSet, type, date, name)",
                "name": "getMktData",
                "parameters": [
                    {
                        "full": "dataSet",
                        "name": "dataSet"
                    },
                    {
                        "full": "type",
                        "name": "type"
                    },
                    {
                        "full": "date",
                        "name": "date"
                    },
                    {
                        "full": "name",
                        "name": "name"
                    }
                ]
            }
        ],
        "markdown": "### [getMktData](https://docs.dolphindb.cn/zh/funcs/g/getMktData.html)\n\n\n\n#### 语法\n\ngetMktData(dataSet, type, date, name)\n\n#### 详情\n\n在指定估值日期下，根据市场数据类型和名称，从数据集中获取相应的市场数据。\n\n#### 参数\n\n**dataSet** 市场数据集合，支持以下类型：\n\n* 市场数据构建引擎（由 `createMktDataEngine` 创建）\n\n* 自定义市场数据集合，可以是向量或字典，其数据结构需符合 `instrumentPricer` 所规定的市场数据输入规范。\n\n**type** 字符串标量，表示市场数据类型，支持以下三种类型：\n\n* \"Price\"：价格数据(期权标的价格)\n\n* \"Curve\"：收益率曲线数据\n\n* \"Surface\"：波动率曲面数据\n\n**date**DATE 类型标量，参考日期。\n\n**name**字符串标量，表示市场数据名称（如曲线名称、曲面名称等）。\n\n#### 返回值\n\nMKTDATA 类型标量。\n\n#### 例子\n\n本例通过 `createMktDataEngine` 实时构建三种类型的市场数据：美元兑人民币（USDCNY）、欧元兑美元（EURUSD）和欧元兑人民币（EURCNY），然后通过 `getMktData` 查看引擎构造的即期价格数据。\n\n```\n\ntry{dropStreamEngine(\"MKTDATA_ENGINE\")}catch(ex){}\nreferenceDate = 2025.07.01\n\nconfig1 = {\n    \"name\": \"USDCNY\",\n    \"type\": \"FxSpotRate\"\n}\nconfig2 = {\n    \"name\": \"EURUSD\",\n    \"type\": \"FxSpotRate\"\n}\nconfig3 = {\n    \"name\": \"EURCNY\",\n    \"type\": \"FxSpotRate\"\n}\n\nengine = createMktDataEngine(\"MKTDATA_ENGINE\", referenceDate, [config1, config2, config3])\n\ntypeCol = [\"FxSpot\", \"FxSpot\", \"FxSpot\"]\nnameCol = [\"USDCNY\", \"EURCNY\", \"EURUSD\"]\npriceCol = [7.12, 7.88, 1.10]\n\ndata = table(typeCol as type, nameCol as name, priceCol as price)\n\nengine.append!(data)\nsleep(100)\n\nre = getMktData(engine, \"Price\", referenceDate, \"USDCNY\")\nprint(re)\n```\n\n相关函数：[createMktDataEngine](https://docs.dolphindb.cn/zh/funcs/c/createMktDataEngine.html), [instrumentPricer](https://docs.dolphindb.cn/zh/funcs/i/instrumentPricer.html)\n"
    },
    "getNodeAlias": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getNodeAlias.html",
        "signatures": [
            {
                "full": "getNodeAlias()",
                "name": "getNodeAlias",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getNodeAlias](https://docs.dolphindb.cn/zh/funcs/g/getNodeAlias.html)\n\n\n\n#### 语法\n\ngetNodeAlias()\n\n#### 详情\n\n获取本地节点的别名。该别名为配置参数 *localSite* 中定义的 alias。\n\n#### 参数\n\n无\n\n#### 返回值\n\n字符串标量。\n\n#### 例子\n\n```\ngetNodeAlias();\n\n// output: controller2\n```\n\n相关函数：[getControllerAlias](https://docs.dolphindb.cn/zh/funcs/g/getControllerAlias.html)\n"
    },
    "getNodeHost": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getNodeHost.html",
        "signatures": [
            {
                "full": "getNodeHost()",
                "name": "getNodeHost",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getNodeHost](https://docs.dolphindb.cn/zh/funcs/g/getNodeHost.html)\n\n\n\n#### 语法\n\ngetNodeHost()\n\n#### 详情\n\n获取本地节点的主机名。该主机名为配置参数 *localSite* 中定义的 host。\n\n#### 参数\n\n无\n\n#### 返回值\n\n字符串标量。\n\n#### 例子\n\n```\ngetNodeHost();\n\n// output: 10.6.0.6\n```\n"
    },
    "getNodePort": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getNodePort.html",
        "signatures": [
            {
                "full": "getNodePort()",
                "name": "getNodePort",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getNodePort](https://docs.dolphindb.cn/zh/funcs/g/getNodePort.html)\n\n\n\n#### 语法\n\ngetNodePort()\n\n#### 详情\n\n获取节点使用的端口号。该端口号为配置参数 *localSite* 中定义的 port。\n\n#### 参数\n\n无\n\n#### 返回值\n\nINT 类型标量。\n\n#### 例子\n\n```\ngetNodePort();\n\n// output: 8888\n```\n"
    },
    "getNodeType": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getNodeType.html",
        "signatures": [
            {
                "full": "getNodeType()",
                "name": "getNodeType",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getNodeType](https://docs.dolphindb.cn/zh/funcs/g/getNodeType.html)\n\n\n\n#### 语法\n\ngetNodeType()\n\n#### 详情\n\n查询节点的类型。0表示数据节点；1表示代理节点；2表示控制器节点；3表示单节点模式；4表示计算节点。\n\n#### 参数\n\n无\n\n#### 返回值\n\nINT 类型标量。\n\n#### 例子\n\n```\ngetNodeType();\n\n// output: 2\n```\n"
    },
    "getOauthClientSecret": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getOauthClientSecret.html",
        "signatures": [
            {
                "full": "getOauthClientSecret()",
                "name": "getOauthClientSecret",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getOauthClientSecret](https://docs.dolphindb.cn/zh/funcs/g/getOauthClientSecret.html)\n\n首发版本：3.00.5，3.00.4.1，3.00.3.2\n\n\n\n#### 语法\n\ngetOauthClientSecret()\n\n#### 详情\n\n获取单点登录（SSO）所使用的 *oauthClientSecret* 配置项的值。仅 admin 用户可调用。当启用配置访问控制（`enableConfigAccessControl=true`）时，由于 *oauthClientSecret* 属于敏感配置项，无法通过 `getConfig` 直接读取，管理员可调用此函数安全地获取该配置。\n\n#### 返回值\n\n返回字符串，表示当前系统配置的 *oauthClientSecret* 值。\n"
    },
    "getOLAPCachedSymbolBaseMemSize": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getOLAPCachedSymbolBaseMemSize.html",
        "signatures": [
            {
                "full": "getOLAPCachedSymbolBaseMemSize()",
                "name": "getOLAPCachedSymbolBaseMemSize",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getOLAPCachedSymbolBaseMemSize](https://docs.dolphindb.cn/zh/funcs/g/getOLAPCachedSymbolBaseMemSize.html)\n\n\n\n#### 语法\n\ngetOLAPCachedSymbolBaseMemSize()\n\n#### 详情\n\n获取 OLAP 引擎中 SYMBOL 类型的字典编码的缓存大小，单位是字节。\n\n#### 参数\n\n无\n\n#### 返回值\n\nLONG 类型标量。\n"
    },
    "getOLAPCacheEngineSize": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getOLAPCacheEngineSize.html",
        "signatures": [
            {
                "full": "getOLAPCacheEngineSize()",
                "name": "getOLAPCacheEngineSize",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getOLAPCacheEngineSize](https://docs.dolphindb.cn/zh/funcs/g/getOLAPCacheEngineSize.html)\n\n\n\n#### 语法\n\ngetOLAPCacheEngineSize()\n\n别名：getCacheEngineMemSize\n\n#### 详情\n\n查看当前节点下 OLAP 引擎的 Cache Engine 的内存情况，单位为字节。\n\n#### 参数\n\n无\n\n#### 返回值\n\n返回一个 ANY VECTOR：\n\n第1个元素表示 Cache Engine 正在使用的内存量；\n\n第2个元素表示 Cache Engine 保存的列文件占用的内存；\n\n第3个元素表示指向列文件的指针所占用的内存；\n\n第4个元素表示 Cache Engine 允许使用的内存上限。\n\n#### 例子\n\n```\nsetOLAPCacheEngineSize(0.4)\ngetOLAPCacheEngineSize()\n// output\n(0,0,0,429496729)\n```\n\n相关函数： [setOLAPCacheEngineSize](https://docs.dolphindb.cn/zh/funcs/s/setOLAPCacheEngineSize.html)\n"
    },
    "getOLAPCacheEngineStat": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getOLAPCacheEngineStat.html",
        "signatures": [
            {
                "full": "getOLAPCacheEngineStat()",
                "name": "getOLAPCacheEngineStat",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getOLAPCacheEngineStat](https://docs.dolphindb.cn/zh/funcs/g/getOLAPCacheEngineStat.html)\n\n\n\n#### 语法\n\ngetOLAPCacheEngineStat()\n\n别名：getCacheEngineStat\n\n#### 详情\n\n获取当前节点下 OLAP 引擎 Cache Engine 的状态信息。该函数只能在数据节点调用。\n\n#### 参数\n\n无\n\n#### 返回值\n\n返回一个表，包含以下几列:\n\n* chunkId：chunk 的唯一标识。\n\n* physicalName：chunk 所属表的物理表名。\n\n* timeSinceLastWrite：距离最后一次写入经过的时间，单位为毫秒。\n\n* cachedRowsOfCompletedTxn：当前缓存的已完成事务的记录数。\n\n* cachedRowsOfUncompletedTxn：当前缓存的未完成事务的记录数。注意：每个 chunk 最多只有最后一个事务是未完成的。\n\n* cachedMemOfCompletedTxn：cachedRowsOfCompletedTxn 占用的内存，单位为字节。\n\n* cachedMemOfUncompletedTxn：cachedRowsOfUncompletedTxn 占用的内存，单位为字节。\n\n* cachedTids：当前缓存的事务 id 列表。\n\n#### 例子\n\n```\ngetOLAPCacheEngineStat()\n```\n\n| chunkId                              | physicalName | timeSinceLastWrite | cachedRowsOfCompletedTxn | cachedRowsOfUncompletedTxn | cachedMemOfCompletedTxn | cachedMemOfUncompletedTxn | cachedTids |\n| ------------------------------------ | ------------ | ------------------ | ------------------------ | -------------------------- | ----------------------- | ------------------------- | ---------- |\n| e4558d3c-fa41-52b5-418b-94e26cb70a75 | pt\\_2        | 1056               | 222,386                  | 0                          | 3,558,176               | 0                         | 2052       |\n"
    },
    "getOrcaCheckpointConfig": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getOrcaCheckpointConfig.html",
        "signatures": [
            {
                "full": "getOrcaCheckpointConfig(name)",
                "name": "getOrcaCheckpointConfig",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    }
                ]
            }
        ],
        "markdown": "### [getOrcaCheckpointConfig](https://docs.dolphindb.cn/zh/funcs/g/getOrcaCheckpointConfig.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\ngetOrcaCheckpointConfig(name)\n\n#### 详情\n\n查看指定流图的 Checkpoint 的配置。\n\n#### 参数\n\n**name** 字符串标量，表示流图的名字。可以传入完整的流图全限定名（如 \"catalog\\_name.orca\\_graph.graph\\_name\"），也可以仅提供流图名（如 \"factors\"）；系统会根据当前的 catalog 设置自动补全为对应的全限定名。\n\n#### 返回值\n\n返回一个字典，包含以下字段：\n\n<table id=\"table_vlh_2t3_3fc\"><thead><tr><th align=\"left\">\n\n**key**\n\n</th><th align=\"left\">\n\n**解释**\n\n</th></tr></thead><tbody><tr><td align=\"left\">\n\nenable\n\n</td><td align=\"left\">\n\n是否开启 Checkpoint\n\n</td></tr><tr><td align=\"left\">\n\ncheckpointMod\n\n</td><td align=\"left\">\n\n流图中除 sink 节点以外的一致性级别：-   exactly\\_once：数据精确执行一次\n\n* at\\_least\\_once：数据至少执行一次\n\n</td></tr><tr><td align=\"left\">\n\ninterval\n\n</td><td align=\"left\">\n\n触发 Checkpoint 的时间间隔，单位为毫秒\n\n</td></tr><tr><td align=\"left\">\n\ntimeout\n\n</td><td align=\"left\">\n\nCheckpoint 的超时时间，即在指定时间内无法完成的 Checkpoint 将判定为失败，单位毫秒\n\n</td></tr><tr><td align=\"left\">\n\nalignedTimeout\n\n</td><td align=\"left\">\n\nBarrier 对齐的超时时间，即在指定时间内无法完成 Barrier 对齐的Checkpoint 将被判定为失败，单位毫秒\n\n</td></tr><tr><td align=\"left\">\n\nminIntervalBetweenCkpt\n\n</td><td align=\"left\">\n\n从上一个 Checkpoint 完成到下一个 Checkpoint 发起之间的最小时间间隔\n\n</td></tr><tr><td align=\"left\">\n\nconsecutiveFailures\n\n</td><td align=\"left\">\n\nCheckpoint 最大连续失败次数。超过该次数后会导致整个流图的状态转换为 ERROR。\n\n</td></tr><tr><td align=\"left\">\n\nmaxConcurrentCheckpoints\n\n</td><td align=\"left\">\n\n允许 Checkpoint 并发个数。请注意，允许并发Checkpoint可能会对运行中的流计算任务产生影响。\n\n</td></tr><tr><td align=\"left\">\n\nmaxRetainedCheckpoints\n\n</td><td align=\"left\">\n\n系统会定期清理历史 Checkpoint 的数据，该配置项用于设置最多保留多少个最新的 Checkpoint 数据。\n\n</td></tr></tbody>\n</table>## 例子\n\n```\ngetOrcaCheckpointConfig(\"streamGraph1\") // name 是流图名称\ngetOrcaCheckpointConfig(\"catalog1.orca_graph.streamGraph1\") // name 是全限定名\n```\n"
    },
    "getOrcaCheckpointJobInfo": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getOrcaCheckpointJobInfo.html",
        "signatures": [
            {
                "full": "getOrcaCheckpointJobInfo([name])",
                "name": "getOrcaCheckpointJobInfo",
                "parameters": [
                    {
                        "full": "[name]",
                        "name": "name",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [getOrcaCheckpointJobInfo](https://docs.dolphindb.cn/zh/funcs/g/getOrcaCheckpointJobInfo.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\ngetOrcaCheckpointJobInfo(\\[name])\n\n#### 详情\n\n查看指定流图的 Checkpoint 运行情况。如果未指定 *name*，则返回 Orca 中所有流图的 Checkpoint 运行情况。\n\n#### 参数\n\n**name** 可选参数，字符串标量，表示流图的名字。可以传入完整的流图全限定名（如 \"catalog\\_name.orca\\_graph.graph\\_name\"），也可以仅提供流图名（如 \"factors\"）；系统会根据当前的 catalog 设置自动补全为对应的全限定名。\n\n#### 返回值\n\n返回一个表，包含以下字段：\n\n* checkpointId：Checkpoint id\n* jobId：流图 id\n* createdTimeStamp：Checkpoint 任务的创建时间\n* finishedTimeStamp：Checkpoint 任务完成的时间\n* status：Checkpoint 任务的状态，\n  * RUNNING：正在运行\n  * ERROR：发生一般性错误，后续会重新发起新的 Checkpoint 任务进行重试\n  * FAILED：发生严重错误，无法重试\n  * SUCCESS：Checkpoint 成功，该 Checkpoint 处于可用状态\n  * CANCELED：Checkpoint 任务被系统取消，此状态通产由于一个流图同时有多个 Checkpoint 任务在 RUNNING 状态，当它们中最新的 Checkpoint 成功后，系统会自动取消旧的 Checkpoint。\n  * PURGED：系统默认只保存最近成功的几个 Checkpoint（由配置项 maxRetainedCheckpoints 管理），超出该参数，系统会自动清理旧的 Checkpoint 数据。\n* extra：额外信息，例如 Checkpoint 的错误信息。\n* partitionId：Checkpoint 元信息所在分区的 ID。\n\n#### 例子\n\n```\ngetOrcaCheckpointJobInfo(\"streamGraph1\") // name 是流图名称\ngetOrcaCheckpointJobInfo(\"catalog1.orca_graph.streamGraph1\") // name 是全限定名\n```\n"
    },
    "getOrcaCheckpointSubjobInfo": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getOrcaCheckpointSubjobInfo.html",
        "signatures": [
            {
                "full": "getOrcaCheckpointSubjobInfo([name])",
                "name": "getOrcaCheckpointSubjobInfo",
                "parameters": [
                    {
                        "full": "[name]",
                        "name": "name",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [getOrcaCheckpointSubjobInfo](https://docs.dolphindb.cn/zh/funcs/g/getOrcaCheckpointSubjobInfo.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\ngetOrcaCheckpointSubjobInfo(\\[name])\n\n#### 详情\n\n查看指定流图 Checkpoint 子任务的运行情况。如果未指定 *name*，则返回 Orca 中所有流图的 Checkpoint 运行情况。\n\n#### 参数\n\n**name** 可选参数，字符串标量，表示流图的名字。可以传入完整的流图全限定名（如 \"catalog\\_name.orca\\_graph.graph\\_name\"），也可以仅提供流图名（如 \"factors\"）；系统会根据当前的 catalog 设置自动补全为对应的全限定名。\n\n#### 返回值\n\n返回一个表，包括以下字段：\n\ncheckpointId：Checkpoint id\n\njobId：流图 id\n\nsubjobId：子任务 id\n\nfirstBarrierArrTs：Checkpoint 子任务收到第一个 Barrier 的时刻。\n\nbarrierAlignTs：Checkpoint 子任务的 Barrier 对齐的时刻。\n\nbarrierForwardTs：Checkpoint 子任务向下游转发 Barrier 的时刻。\n\nstatus：Checkpoint 子任务状态，包括 running、success、failed。\n\nsnapshotChannelsId：Checkpoint 子任务的输入端 Channel 的 id。\n\ndownstreamSubscribeOffsets：下游订阅的 offset。\n\nsnapshotMeta：Checkpoint 数据的元信息。\n\nextra：额外信息，例如 Checkpoint 的错误信息\n\n#### 例子\n\n```\ngetOrcaCheckpointSubjobInfo(\"streamGraph1\") // name 是流图名称\ngetOrcaCheckpointSubjobInfo(\"catalog1.orca_graph.streamGraph1\") // name 是全限定名\n```\n"
    },
    "getOrcaDataLineage": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getOrcaDataLineage.html",
        "signatures": [
            {
                "full": "getOrcaDataLineage(name)",
                "name": "getOrcaDataLineage",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    }
                ]
            }
        ],
        "markdown": "### [getOrcaDataLineage](https://docs.dolphindb.cn/zh/funcs/g/getOrcaDataLineage.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\ngetOrcaDataLineage(name)\n\n#### 详情\n\n查询流图中指定公共流表的数据血缘关系，包括当前及曾经存在的历史血缘。\n\n**当*****name*****是一个表名**，返回一个 JSON 对象，包含该数据表所在的每个流图中其上游依赖的节点信息。\n\n每个流图的 key 是流图内部名称，value 是该流图的属性以及上游节点：\n\n* fqn：字符串标量，表示该流图的全限定名。\n\n* isDeleted：布尔值，指示该流图是否已被删除。\n\n* 每个节点的 key 是节点名称，value 是该节点的属性，包括：\n\n  * isRoot：布尔值，指示该节点是否为根节点。\n\n  * parent：字符串向量，包含该节点所有直接父节点名称。若为根节点，则为空数组 `[]`。\n\n  * isTable：布尔值，指示该节点是否为数据表。\n\n  * isEngine：布尔值，指示该节点是否为引擎。\n\n**当*****name*****是一个 TimerEngine 名**，返回一个 JSON 对象，包含以下字段：\n\n* input：引擎 *func* 的输入参数信息，键为参数名，值为数据类型。若无入参，则为 `{}`。\n\n* output：引擎 *func* 的返回值信息，\n\n  * 若返回值是 TABLE 标量，则键为字段名，值为字段类型。\n\n  * 若返回值是其他形式的标量，则键为 \"return\"，值为数据类型。\n\n  * 其他情况，键为 \"return\"，值为数据形式。\n\n#### 参数\n\n**name** STRING 类型标量，表示需要查询的公共流表名称或 timerEngine 名。表名称支持两种格式：\n\n* 完全限定名，例如 `\"catalog_name.orca_table.table_name\"`\n\n* 内部名称格式，例如 `\"public_stream_table_05056f34_92b0_16b2_204e_c3c63e3f8a84\"`\n\n#### 返回值\n\n一个 JSON 对象。\n\n#### 例子\n\n```\n// 创建并提交流图\ncreateCatalog(\"test\")\ngo\nuse catalog test\n\ndef myFunc(x,y,z){\n    return table(x as col1,y as col2,z as col3)\n}\na = [\"aaa\"]\nb = [\"bbb\"]\nc = [\"ccc\"]\nt = table(1..100 as id, 1..100 as value, take(09:29:00.000..13:00:00.000, 100) as timestamp)\n\ng1 = createStreamGraph(\"factor1\")\ng1.source(\"snapshot1\", schema(t).colDefs.name, schema(t).colDefs.typeString)\n  .reactiveStateEngine([<cumsum(value)>, <timestamp>])\n  .setEngineName(\"rse1\")\n  .timerEngine(3, myFunc, a, b, c)\n  .setEngineName(\"myJob\")\n  .buffer(\"end\")\ng1.submit()\n\ng2 = createStreamGraph(\"factor2\")\ng2.source(\"snapshot2\", schema(t).colDefs.name, schema(t).colDefs.typeString)\n  .reactiveStateEngine([<cumsum(value)>, <timestamp>])\n  .setEngineName(\"rse2\")\n  .buffer(\"end\")\ng2.submit()\n\n// 删除流图 factor2\ndropStreamGraph(\"factor2\")\n\n// 查询血缘\ngetOrcaDataLineage(\"test.orca_table.end\")\n/*\n{\n  \"40d12999-f8f3-9cb5-4a49-813bdee46a9f\": {\n    \"fqn\": \"test.orca_graph.factor1\",\n    \"isDeleted\": false,\n    \"test.orca_engine.rse1\": {\n      \"isRoot\": false,\n      \"isTable\": false,\n      \"isEngine\": true,\n      \"parents\": [\n        \"test.orca_table.snapshot1\"\n      ]\n    },\n    \"test.orca_table.end\": {\n      \"isRoot\": false,\n      \"isTable\": true,\n      \"isEngine\": false,\n      \"parents\": [\n        \"test.orca_engine.rse1\"\n      ]\n    },\n    \"test.orca_table.snapshot1\": {\n      \"isRoot\": true,\n      \"isTable\": true,\n      \"isEngine\": false,\n      \"parents\": []\n    }\n  },\n  \"4cee4ed3-007b-f38a-8743-f6776a6172d9\": {\n    \"fqn\": \"test.orca_graph.factor2\",\n    \"isDeleted\": true,\n    \"test.orca_engine.rse2\": {\n      \"isRoot\": false,\n      \"isTable\": false,\n      \"isEngine\": true,\n      \"parents\": [\n        \"test.orca_table.snapshot2\"\n      ]\n    },\n    \"test.orca_table.end\": {\n      \"isRoot\": false,\n      \"isTable\": true,\n      \"isEngine\": false,\n      \"parents\": [\n        \"test.orca_engine.rse2\"\n      ]\n    },\n    \"test.orca_table.snapshot2\": {\n      \"isRoot\": true,\n      \"isTable\": true,\n      \"isEngine\": false,\n      \"parents\": []\n    }\n  }\n}\n*/\n\n// 查看 timerEngine func\ngetOrcaDataLineage(\"test.orca_engine.myJob\")\n/*\n{\n  \"input\": {\n    \"x\": \"STRING\",\n    \"y\": \"STRING\",\n    \"z\": \"STRING\"\n  },\n  \"output\": {\n    \"col1\": \"STRING\",\n    \"col2\": \"STRING\",\n    \"col3\": \"STRING\"\n  }\n}\n*/\n```\n"
    },
    "getOrcaStateMachineEventTaskStatus": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getOrcaStateMachineEventTaskStatus.html",
        "signatures": [
            {
                "full": "getOrcaStateMachineEventTaskStatus()",
                "name": "getOrcaStateMachineEventTaskStatus",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getOrcaStateMachineEventTaskStatus](https://docs.dolphindb.cn/zh/funcs/g/getOrcaStateMachineEventTaskStatus.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\ngetOrcaStateMachineEventTaskStatus()\n\n#### 详情\n\nStreamMaster 会将接受的请求，作为事件加入状态机队列等待执行。该函数用于获取状态机中任务的状态。\n\n#### 返回值\n\n返回一个表，包含以下字段：\n\n* id：事件 id。\n* type：事件类型，可能值包括：\n  * SUBMIT\\_REQUEST：用户的提交流图请求的事件\n  * SUBMIT：流图提交事件\n  * RESUBMIT\\_REQUEST：用户的重新提交流图请求的事件\n  * DROP\\_REQUEST：用户的删除流图请求的事件\n  * DROP\\_CALLBACK：系统内部的删除流图回调的事件\n  * DROP：流图销毁事件\n  * NODE\\_DOWN：节点宕机事件\n  * NODE\\_READY：节点重启事件\n  * RECOVER：恢复任务\n  * INTERNAL：内部事件\n* state：运行状态，包括 pending, running, finished.\n* retries：重试次数。当事件没有被正确处理时，状态机会尝试重试。\n* scheduledTime：调度时间，表示该事件应该在什么时刻被执行。\n* startTime：事件实际开始处理的时间\n* endTime：结束时间\n* detail：展示事件相关的属性\n* errorMessage：事件处理时的异常\n\n#### 例子\n\n```\ngetOrcaStateMachineEventTaskStatus()\n```\n"
    },
    "getOrcaStreamEngineMeta": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getOrcaStreamEngineMeta.html",
        "signatures": [
            {
                "full": "getOrcaStreamEngineMeta(name)",
                "name": "getOrcaStreamEngineMeta",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    }
                ]
            }
        ],
        "markdown": "### [getOrcaStreamEngineMeta](https://docs.dolphindb.cn/zh/funcs/g/getOrcaStreamEngineMeta.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\ngetOrcaStreamEngineMeta(name)\n\n#### 详情\n\n获取指定流图中所有流引擎的元信息。\n\n#### 参数\n\n**name** 字符串标量，表示流图的名字。可以传入完整的流图全限定名（如 \"catalog\\_name.orca\\_graph.graph\\_name\"），也可以仅提供流图名（如 \"factors\"）；系统会根据当前的 catalog 设置自动补全为对应的全限定名。\n\n#### 返回值\n\n返回一个表，包含以下字段：\n\n* taskId：引擎所属的任务 id\n* name：引擎名称\n* type：引擎类型\n* schema：引擎输出表的字段类型\n* fqn：`setEngineName`定义的全限定名。\n\n#### 例子\n\n```\ngetOrcaStreamEngineMeta(\"streamGraph1\") // name 是流图名称\ngetOrcaStreamEngineMeta(\"catalog1.orca_graph.streamGraph1\") // name 是全限定名\n```\n"
    },
    "getOrcaStreamTableMeta": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getOrcaStreamTableMeta.html",
        "signatures": [
            {
                "full": "getOrcaStreamTableMeta([name])",
                "name": "getOrcaStreamTableMeta",
                "parameters": [
                    {
                        "full": "[name]",
                        "name": "name",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [getOrcaStreamTableMeta](https://docs.dolphindb.cn/zh/funcs/g/getOrcaStreamTableMeta.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\ngetOrcaStreamTableMeta(\\[name])\n\n#### 详情\n\n返回 Orca 中指定流表的元信息。如果未指定 *name*，则返回 Orca 中所有流表的元信息。\n\n#### 参数\n\n**name** 可选参数，表示流表的名称。字符串标量，可以传入完整的流表全限定名（如 \"trading.orca\\_table.trades\"）；也可以仅提供流表名（如 \"trades\"），系统会根据当前的 catalog 设置自动补全为对应的全限定名\n\n#### 返回值\n\n返回结果为一个表，包含以下字段：\n\n* id：流表 id\n* fqn：该流表的全限定名\n* site：流表所在节点的名称。\n* graphRefs：引用此流表的所有流图的 id 列表\n* raftGroupId：高可用流表所属的 raft 组 id，非高可用流表返回 0\n\n#### 例子\n\n```\ngetOrcaStreamTableMeta(\"trade1\") // name 是流表名称\ngetOrcaStreamTableMeta(\"catalog1.orca_table.trade1\") // name 是全限定名\n```\n"
    },
    "getOrcaStreamTaskSubscriptionMeta": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getOrcaStreamTaskSubscriptionMeta.html",
        "signatures": [
            {
                "full": "getOrcaStreamTaskSubscriptionMeta(name)",
                "name": "getOrcaStreamTaskSubscriptionMeta",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    }
                ]
            }
        ],
        "markdown": "### [getOrcaStreamTaskSubscriptionMeta](https://docs.dolphindb.cn/zh/funcs/g/getOrcaStreamTaskSubscriptionMeta.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\ngetOrcaStreamTaskSubscriptionMeta(name)\n\n#### 详情\n\n获取指定流图中所有流任务的订阅信息。\n\n#### 参数\n\n**name** 字符串标量，表示流图的名字。可以传入完整的流图全限定名（如 \"catalog\\_name.orca\\_graph.graph\\_name\"），也可以仅提供流图名（如 \"factors\"）；系统会根据当前的 catalog 设置自动补全为对应的全限定名。\n\n#### 返回值\n\n返回一个表，包含以下字段：\n\n* taskId：流任务 id\n* tableName：流表的名称\n* actionName：订阅任务的名称\n\n#### 例子\n\n```\ngetOrcaStreamTaskSubscriptionMeta(\"streamGraph1\") // name 是流图名称\ngetOrcaStreamTaskSubscriptionMeta(\"catalog1.orca_graph.streamGraph1\") // name 是全限定名\n```\n"
    },
    "getOS": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getOS.html",
        "signatures": [
            {
                "full": "getOS()",
                "name": "getOS",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getOS](https://docs.dolphindb.cn/zh/funcs/g/getOS.html)\n\n\n\n#### 语法\n\ngetOS()\n\n#### 详情\n\n查询 DolphinDB server 所在操作系统的类型。\n\n#### 参数\n\n无\n\n#### 返回值\n\n字符串标量。\n\n#### 例子\n\n```\ngetOS();\n\n// output: linux\n```\n"
    },
    "getOSBit": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getOSBit.html",
        "signatures": [
            {
                "full": "getOSBit()",
                "name": "getOSBit",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getOSBit](https://docs.dolphindb.cn/zh/funcs/g/getOSBit.html)\n\n\n\n#### 语法\n\ngetOSBit()\n\n#### 详情\n\n查询 DolphinDB server 所在操作系统的位数。\n\n#### 参数\n\n无\n\n#### 返回值\n\nINT 类型标量。\n\n#### 例子\n\n```\ngetOSBit();\n\n// output: 64\n```\n"
    },
    "getPerf": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getPerf.html",
        "signatures": [
            {
                "full": "getPerf()",
                "name": "getPerf",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getPerf](https://docs.dolphindb.cn/zh/funcs/g/getPerf.html)\n\n\n\n#### 语法\n\ngetPerf()\n\n#### 详情\n\n查询本地节点上的多个性能监控度量值。\n\n#### 参数\n\n无\n\n#### 返回值\n\n返回一个字典，包含以下 key：\n\n* runningJobs：正在执行中的 Job 个数。\n\n* jobLoad：作业负载。\n\n* avgLoad：CPU 平均负载。\n\n* queuedJobs：队列中的 Job 个数。\n\n* lastMinuteNetworkSend：前一分钟网络发送字节数（单位：字节）。\n\n* lastMinuteNetworkRecv：前一分钟网络接收字节数 （单位：字节）。\n\n* lastMinuteReadVolume：前一分钟读磁盘容量（单位：字节）。\n\n* lastMinuteWriteVolume：前一分钟写磁盘容量（单位：字节）。\n\n* lastMsgLatency：前一批消息的延时（单位：纳秒）。\n\n* cumMsgLatency：所有消息的平均延时（单位：纳秒）。\n\n* maxLast10QueryTime：前 10 个完成的查询执行所耗费时间的最大值（单位：纳秒）。\n\n* maxLast100QueryTime：前100个完成的查询执行所耗费时间的最大值（单位：纳秒）。\n\n* medLast10QueryTime：前 10 个完成的查询执行所耗费时间的中间值（单位：纳秒）。\n\n* medLast100QueryTime：前 100 个完成的查询执行所耗费时间的中间值（单位：纳秒）。\n\n* maxRunningQueryTime：当前正在执行的查询的耗费时间的最大值（单位：纳秒）。\n\n* diskFreeSpaceRatio：磁盘可用空间占比。\n\n* diskReadRate：磁盘读速率（单位：字节/秒）。\n\n* diskWriteRate：磁盘写速率（单位：字节/秒）。\n\n* diskFreeSpace：磁盘剩余空间（单位：字节）。\n\n* diskCapacity：磁盘容量（单位：字节）。\n\n* cpuUsage：CPU 使用率。\n\n* memoryAlloc：系统已分配给当前节点的内存（单位：字节）。\n\n* memoryUsed：节点的内存占用量（单位：字节）。\n\n* networkSendRate：网络发送速率（单位：字节/秒）。\n\n* networkRecvRate：网络接收速率（单位：字节/秒）。\n\n* connectionNum：连接到本地节点的连接数。\n\n#### 例子\n\n```\ngetPerf();\n\n// output\ncumMsgLatency->-9.223372036854776E18\nlastMsgLatency->-9.223372036854776E18\nlastMinuteNetworkRecv->2184101\nmaxLast10QueryTime->224829\nlastMinuteNetworkSend->378283\ndiskWriteRate->144\nnetworkSendRate->3924\nmedLast100QueryTime->131965\navgLoad->1.0228125\nrunningJobs->0\nconnectionNum->2\nmedLast10QueryTime->131965\ncpuUsage->0\ndiskFreeSpaceRatio->0.041250206237365\njobLoad->0\nmemoryUsed->7970304\nmemoryAlloc->19513344\nmaxLast100QueryTime->224829\nnetworkRecvRate->32238\nmaxRunningQueryTime->0\ndiskCapacity->1.859747577856E12\nqueuedJobs->0\ndiskFreeSpace->7.6714971136E10\ndiskReadRate->6538\nlastMinuteWriteVolume->1515\nlastMinuteReadVolume->392408\n```\n"
    },
    "getPersistenceMeta": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getPersistenceMeta.html",
        "signatures": [
            {
                "full": "getPersistenceMeta(table)",
                "name": "getPersistenceMeta",
                "parameters": [
                    {
                        "full": "table",
                        "name": "table"
                    }
                ]
            }
        ],
        "markdown": "### [getPersistenceMeta](https://docs.dolphindb.cn/zh/funcs/g/getPersistenceMeta.html)\n\n\n\n#### 语法\n\ngetPersistenceMeta(table)\n\n#### 详情\n\n查询启用了持久化的共享流数据表的元数据。\n\n#### 参数\n\n**table** 是一个表。\n\n#### 返回值\n\n返回一个字典，包含以下 key：\n\n* lastLogSeqNum：最新的 Raft 日志的逻辑序列号\n\n* totalSize：流表生命周期的总记录数\n\n* sizeInMemory：当前内存中保留的记录数\n\n* memoryOffset：内存数据相对于流表起始位置的偏移量，即内存中保留的最早记录在 totalSize 中的位置。memoryOffset = totalSize - sizeInMemory\n\n* sizeOnDisk：当前已经持久化到磁盘的记录数（包括已被清理的部分）\n\n* diskOffset：磁盘数据相对于流表起始位置的偏移量，即磁盘上保留的最早记录在 totalSize 中的位置。表示已被清理的数据量\n\n* asynWrite：持久化是否采用异步的方式\n\n* compress：是否采用压缩存储\n\n* raftGroup：高可用流数据表所属 Raft 组的 ID。对于普通的流数据表，该值为-1\n\n* retentionMinutes：日志文件的保留时间，默认值是1440分钟，即一天\n\n* hashValue：对本表做持久化的工作线程标识，当配置项 persistenceWorkerNum>1时，hashValue 可能不为0\n\n* persistenceDir：持久化路径\n\n* tableId：是高可用流表在 Raft 组内唯一标识。仅在 *table* 为高可用流表时返回。\n\n![](https://docs.dolphindb.cn/zh/funcs/images/getPersistenceMeta.png \"图1 存储偏移量示意图\")\n\n#### 例子\n\n```\ncolName=[\"time\",\"x\"]\ncolType=[\"timestamp\",\"int\"]\nt = streamTable(100:0, colName, colType);\nenableTableShareAndPersistence(table=t, tableName=`st, cacheSize=1200000)\n\ngo;\n\nfor(s in 0:200){\n   n=10000\n   time=2019.01.01T00:00:00.000+s*n+1..n\n   x=rand(10.0, n)\n   insert into st values(time, x)\n}\n\ngetPersistenceMeta(st);\n\n// output\nlastLogSeqNum->-1\nsizeInMemory->800000\nasynWrite->true\ntotalSize->2000000\nraftGroup->-1\ncompress->true\nmemoryOffset->1200000\nretentionMinutes->1440\nsizeOnDisk->2000000\npersistenceDir->/dolphindb/server/streamPersistDir/st\nhashValue->0\ndiskOffset->0\n```\n"
    },
    "getPKEYCompactionTaskStatus": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getpkeycompactiontaskstatus.html",
        "signatures": [
            {
                "full": "getPKEYCompactionTaskStatus([count])",
                "name": "getPKEYCompactionTaskStatus",
                "parameters": [
                    {
                        "full": "[count]",
                        "name": "count",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [getPKEYCompactionTaskStatus](https://docs.dolphindb.cn/zh/funcs/g/getpkeycompactiontaskstatus.html)\n\n\n\n#### 语法\n\ngetPKEYCompactionTaskStatus(\\[count])\n\n#### 详情\n\n查询 PKEY 引擎 level file 合并操作任务的状态。该函数只能在数据节点调用。\n\n#### 参数\n\n**count** 可选参数，非负整数。设置后，将返回配置项 volumes 中的每一个 volume 的最近的 *count* 个已结束的合并任务的记录（包括成功和失败），以及所有正在执行或尚未开始的任务的记录。默认值为 0，表示返回所有合并任务的状态信息。\n\n#### 返回值\n\n返回一个表，包含以下几列：\n\n| 列名           | 含义                                                                        |\n| ------------ | ------------------------------------------------------------------------- |\n| volume       | 发生合并的文件所在的磁盘卷路径。由配置项 *volumes* 进行配置。                                      |\n| level        | STRING 类型，当前合并的 level file 层级。一次合并最多涉及两个层级。如果此列为空，说明该合并任务尚未开始、正在执行，或执行失败。 |\n| chunkId      | 发生合并操作的 chunk 的 ID。                                                       |\n| tableName    | 发生合并操作的数据表的物理表名。                                                          |\n| files        | 参与当前合并任务的 level file。如果此列为空，说明该合并任务尚未开始、正在执行，或执行失败。                       |\n| force        | 是否由 `triggerPKEYCompaction` 强制触发。                                         |\n| receivedTime | 当前合并任务进入任务队列的时间戳。                                                         |\n| startTime    | 当前合并任务开始执行的时间戳。                                                           |\n| endTime      | 当前合并任务执行结束的时间戳。                                                           |\n| errorMessage | 报错信息。如果失败，则显示失败的原因；否则显示空。                                                 |\n\n#### 例子\n\n```\ngetPKEYCompactionTaskStatus()\n```\n\n| volume                                   | level | chunkId                              | tableName | files           | force | receivedTime            | startTime               | endTime                 | errorMessage |\n| ---------------------------------------- | ----- | ------------------------------------ | --------- | --------------- | ----- | ----------------------- | ----------------------- | ----------------------- | ------------ |\n| /home/dolphindb/server/local8848/storage | 2     | ac872f06-abed-339c-8642-ce7dcf415691 | pt1\\_2    | 2-000000046-002 | true  | 2024.09.24 13:52:37.746 | 2024.09.24 13:52:37.746 | 2024.09.24 13:52:37.816 |              |\n| /home/dolphindb/server/local8848/storage | 1     | ac872f06-abed-339c-8642-ce7dcf415691 | pt1\\_2    | 1-000000046-001 | true  | 2024.09.24 13:52:32.431 | 2024.09.24 13:52:32.431 | 2024.09.24 13:52:32.437 |              |\n| /home/dolphindb/server/local8848/storage | 0     | ac872f06-abed-339c-8642-ce7dcf415691 | pt1\\_2    | 0-000000046-000 | true  | 2024.09.24 11:58:42.006 | 2024.09.24 11:58:42.006 | 2024.09.24 11:58:42.011 |              |\n| /home/dolphindb/server/local8848/storage | 0     | 62ab7ebb-03f2-10a5-5445-c537512aee06 | pt1\\_2    | 0-000000045-000 | true  | 2024.09.24 11:57:13.596 | 2024.09.24 11:57:13.596 | 2024.09.24 11:57:13.601 |              |\n"
    },
    "getPKEYMetaData": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getpkeymetadata.html",
        "signatures": [
            {
                "full": "getPKEYMetaData()",
                "name": "getPKEYMetaData",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getPKEYMetaData](https://docs.dolphindb.cn/zh/funcs/g/getpkeymetadata.html)\n\n\n\n#### 语法\n\ngetPKEYMetaData()\n\n#### 详情\n\n获取 PKEY 引擎下所有 chunk 的元数据。该函数只能在数据节点上执行。\n\n#### 参数\n\n无\n\n#### 返回值\n\n返回一个表，包含以下列:\n\n* chunkId：chunk 的唯一标识\n\n* chunkPath：分区的物理路径\n\n* level：数据文件所在的 level 级别\n\n* table：数据表名称\n\n* files：数据文件名称，即 level file 名称\n\n#### 例子\n\n```\ngetPKEYMetaData()\n```\n\n| chunkId                              | chunkPath                                                                     | level | table  | files           |\n| ------------------------------------ | ----------------------------------------------------------------------------- | ----- | ------ | --------------- |\n| a0a7b031-15b8-32be-664b-21b156dc94c0 | /home/dolphindb/server/local8848/storage/CHUNKS/test\\_pkey/20200102/Key94/1B8 | 0     | pt1\\_2 | 0-000000006-000 |\n| b3307046-77cb-bbb4-2244-dc4dcdd4c4e2 | /home/dolphindb/server/local8848/storage/CHUNKS/test\\_pkey/20200104/Key39/1B8 | 0     | pt1\\_2 | 0-000000009-000 |\n| 1b47193f-39a4-8b93-3f44-d1b32b892126 | /home/dolphindb/server/local8848/storage/CHUNKS/test\\_pkey/20200105/Key94/1B8 | 0     | pt1\\_2 | 0-000000007-000 |\n| 65ac20af-e1ea-21a6-254a-0c7a1f4a1bcf | /home/dolphindb/server/local8848/storage/CHUNKS/test\\_pkey/20200102/Key39/1B8 | 0     | pt1\\_2 | 0-000000003-000 |\n| 600e024e-e280-62bb-084d-b440f7ccc349 | /home/dolphindb/server/local8848/storage/CHUNKS/test\\_pkey/20200101/Key94/1B8 | 0     | pt1\\_2 | 0-000000002-000 |\n| 4f33838b-1b90-3f84-6943-e0da5fda3e10 | /home/dolphindb/server/local8848/storage/CHUNKS/test\\_pkey/20200104/Key94/1B8 | 0     | pt1\\_2 | 0-000000005-000 |\n| e625607d-03ce-00bc-ab47-a419ae5af3f3 | /home/dolphindb/server/local8848/storage/CHUNKS/test\\_pkey/20200103/Key94/1B8 | 0     | pt1\\_2 | 0-000000004-000 |\n| 9e0004ea-33b5-b2b4-d947-065c9333709f | /home/dolphindb/server/local8848/storage/CHUNKS/test\\_pkey/20200101/Key39/1B8 | 0     | pt1\\_2 | 0-000000001-000 |\n| 595d1703-88b4-4397-4b46-281eb8014251 | /home/dolphindb/server/local8848/storage/CHUNKS/test\\_pkey/20200103/Key39/1B8 | 0     | pt1\\_2 | 0-000000008-000 |\n| 280b3b44-8006-52a8-694e-1133e8740c07 | /home/dolphindb/server/local8848/storage/CHUNKS/test\\_pkey/20200105/Key39/1B8 | 0     | pt1\\_2 | 0-000000010-000 |\n"
    },
    "getPrefetchComputeNodeData": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getprefetchcomputenodedata.html",
        "signatures": [
            {
                "full": "getPrefetchComputeNodeData()",
                "name": "getPrefetchComputeNodeData",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getPrefetchComputeNodeData](https://docs.dolphindb.cn/zh/funcs/g/getprefetchcomputenodedata.html)\n\n\n\n#### 语法\n\ngetPrefetchComputeNodeData()\n\n#### 详情\n\n当前节点下配置项 *enableComputeNodePrefetchData* 的生效值。\n\n#### 参数\n\n无\n\n#### 返回值\n\n布尔标量。\n\n#### 例子\n\n```\ngetPrefetchComputeNodeData() \n\n// output: false\n```\n\n相关函数：[setPrefetchComputeNodeData](https://docs.dolphindb.cn/zh/funcs/s/setprefetchcomputenodedata.html)\n"
    },
    "getQueryStatus": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getQueryStatus.html",
        "signatures": [
            {
                "full": "getQueryStatus()",
                "name": "getQueryStatus",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getQueryStatus](https://docs.dolphindb.cn/zh/funcs/g/getQueryStatus.html)\n\n\n\n#### 语法\n\ngetQueryStatus()\n\n#### 详情\n\n获取由当前节点发起且正在执行的查询任务状态。该函数只能在任务发起节点上调用。\n\n#### 参数\n\n无\n\n#### 返回值\n\n返回一个表，包含以下几列：\n\n* id：表示到该查询任务为止，系统已执行的查询任务总数。\n\n* sessionId：任务发起会话的 id。请注意，无法获取通过 `submitJob` 提交的查询任务的 sessionId。\n\n* userId：任务发起会话的用户名。\n\n* query：原始查询语句中主要的查询信息。\n\n* startTime：查询任务开始的时间戳。\n\n* elapsedTimeInMs：查询任务已经经过的时间，单位为毫秒。\n\n* memoryUsage：查询过程中变量和结果所占用的内存空间，单位为字节。\n\n* totalTaskCount：查询子任务总数。\n\n* completedTaskCount：已完成的查询子任务数。\n\n* percentComplete：已完成的查询子任务占比。\n\n#### 例子\n\n```\ngetQueryStatus();\n```\n\n| id | sessionId  | userId | query                        | startTime               | elapsedTimeInMs | memoryUsage | totalTaskCount | completedTaskCount | percentComplete |\n| -- | ---------- | ------ | ---------------------------- | ----------------------- | --------------- | ----------- | -------------- | ------------------ | --------------- |\n| 2  | 1166953221 | admin  | select ticker, id, x from pt | 2022.06.14 08:15:00.606 | 1052            | 184550000   | 4              | 1                  | 0.25            |\n"
    },
    "getRaftElectionTick": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getRaftElectionTick.html",
        "signatures": [
            {
                "full": "getRaftElectionTick(groupId)",
                "name": "getRaftElectionTick",
                "parameters": [
                    {
                        "full": "groupId",
                        "name": "groupId"
                    }
                ]
            }
        ],
        "markdown": "### [getRaftElectionTick](https://docs.dolphindb.cn/zh/funcs/g/getRaftElectionTick.html)\n\n\n\n#### 语法\n\ngetRaftElectionTick(groupId)\n\n#### 详情\n\n获取 group ID 对应的 raft 组当前有效的 election tick，即通过 `setRaftElectionTick` 设置的 *tickCount* 或配置项 *raftElectionTick* 的设置值。\n\n#### 参数\n\n**groupId** 是一个正整数，表示 raft 组的 ID，目前只能是1，表示控制节点组成的 raft 组 ID。\n\n#### 返回值\n\n整型标量。\n\n相关函数： [setRaftElectionTick](https://docs.dolphindb.cn/zh/funcs/s/setRaftElectionTick.html), [getControllerElectionTick](https://docs.dolphindb.cn/zh/funcs/g/getControllerElectionTick.html)\n"
    },
    "getRaftLearnersStatus": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getRaftLearnersStatus.html",
        "signatures": [
            {
                "full": "getRaftLearnersStatus(groupId)",
                "name": "getRaftLearnersStatus",
                "parameters": [
                    {
                        "full": "groupId",
                        "name": "groupId"
                    }
                ]
            }
        ],
        "markdown": "### [getRaftLearnersStatus](https://docs.dolphindb.cn/zh/funcs/g/getRaftLearnersStatus.html)\n\n\n\n#### 语法\n\ngetRaftLearnersStatus(groupId)\n\n#### 详情\n\n查询指定 Raft 组中所有 Learner 节点的状态。\n\n#### 参数\n\n**groupId**是一个大于 1 的整数，表示 Raft 组的 ID。\n\n#### 返回值\n\n一个表，包含以下列：\n\n* nodeName：节点名字。\n\n* nodeId：节点的 ID。\n\n* matchIndex：Leader 已确认复制到该 Learner 的最高日志索引。\n\n* nextIndex：Leader 下一次要发送给该 Learner 的日志条目索引。\n\n* replicationLag：​日志复制延迟条数，值越小表示延迟越低。\n\n* lastActiveTime：Leader 与 Learner 之间最近一次成功通信的时间。\n\n* snapshotProgress：快照传输进度，0表示当前没有进行快照传输。\n\n#### 例子\n\n```\ngetRaftLearnersStatus(3)\n```\n\n| nodeName               | nodeId | matchIndex | nextIndex | replicationLag | lastActiveTime          | snapshotProgress |\n| ---------------------- | ------ | ---------- | --------- | -------------- | ----------------------- | ---------------- |\n| datanode8922\\@cluster2 | 256    | 10,004     | 10,005    | 0              | 2025.08.18 14:00:15.349 | 0                |\n"
    },
    "getRawScriptLog": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getRawScriptLog.html",
        "signatures": [
            {
                "full": "getRawScriptLog([userId],[startTime],[endTime])",
                "name": "getRawScriptLog",
                "parameters": [
                    {
                        "full": "[userId]",
                        "name": "userId",
                        "optional": true
                    },
                    {
                        "full": "[startTime]",
                        "name": "startTime",
                        "optional": true
                    },
                    {
                        "full": "[endTime]",
                        "name": "endTime",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [getRawScriptLog](https://docs.dolphindb.cn/zh/funcs/g/getRawScriptLog.html)\n\n首发版本：3.00.4，3.00.3.1\n\n#### 语法\n\ngetRawScriptLog(\\[userId],\\[startTime],\\[endTime])\n\n#### 详情\n\n查询用户原始代码日志。该函数仅支持管理员调用。\n\n**Note:** 每次脚本执行会产生两条记录：\n\n* 第一条在执行开始前写入，记录 startTime 和 script，endTime 和 errorMsg 留空；\n\n* 第二条在执行结束后写入，记录 endTime 和 errorMsg（如果执行报错），script 留空。\n\n#### 参数\n\n**userId** 字符串标量或向量，指定查询哪些用户的原始代码日志。默认为空，表示查询所有用户。\n\n**startTime** 整型或时间类型标量，指定查询的起始时间。默认为 0，表示查询从 1970.01.01 开始的记录。\n\n**endTime** 整型或时间类型标量，指定查询的结束时间。默认为空，表示查询到目前为止的记录。*startTime* 必须小于等于 *endTime*。\n\n#### 返回值\n\n一张表，包含以下字段：\n\n* node：字符串，执行脚本的节点名。\n* username：字符串，执行脚本的用户名。\n* sessionID：LONG 标量，当前会话 ID。\n* rootJobID：字符串，当前 rootJob 的ID。\n* remoteIP：IPADDR 标量，用户 IP。\n* remotePort：INT 标量，用户端口。\n* startTime：NANOTIMESTAMP 标量，脚本执行开始时间。\n* endTime: NANOTIMESTAMP 标量，脚本执行结束时间。\n* script：字符串，完整脚本代码。\n* errorMsg：字符串，如果脚本执行过程报错，记录错误信息，否则为空。\n\n#### 例子\n\n查询用户 user1 的原始代码日志：\n\n```\ngetRawScriptLog(`user1)\n```\n\n"
    },
    "getReactiveMetrics": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getreactivemetrics.html",
        "signatures": [
            {
                "full": "getReactiveMetrics(name)",
                "name": "getReactiveMetrics",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    }
                ]
            }
        ],
        "markdown": "### [getReactiveMetrics](https://docs.dolphindb.cn/zh/funcs/g/getreactivemetrics.html)\n\n\n\n#### 语法\n\ngetReactiveMetrics(name)\n\n##### 详情\n\n获取指定名称的 narrowReactiveStateEngine 的计算指标列。\n\n##### 参数\n\n**name** 字符串，表示 narrowReactiveStateEngine 的名称。\n\n##### 返回值\n\n返回一个表，第一列为 metricName，第二列为 metricCode。\n\n##### 例子\n\n```\ndummy = streamTable(1:0, [\"securityID1\",\"securityID2\",\"securityID3\",\"createTime\",\"updateTime\",\"upToDatePrice\",\"qty\",\"value\"], [STRING,STRING,STRING,TIMESTAMP,TIMESTAMP,DOUBLE,DOUBLE,INT]) \noutputTable = streamTable(1:0,[\"securityID1\",\"securityID2\",\"securityID3\",\"createTime\",\"updateTime\",\"metricNames\",\"factorValue\"], [STRING,STRING,STRING, TIMESTAMP,TIMESTAMP,STRING,DOUBLE])\nfactor = [<createTime>, <updateTime>,<cumsum(qty)>]\nNarrowtest = createNarrowReactiveStateEngine(name=\"narrowtest1\",metrics=factor,metricNames=\"factor1\",dummyTable=dummy,outputTable=outputTable,keyColumn=[\"securityID1\",\"securityID2\",\"securityID3\"])\ngetReactiveMetrics(\"narrowtest1\")\n```\n\n| metricName | metricCode  |\n| ---------- | ----------- |\n| factor1    | cumsum(qty) |\n\n相关函数：[createNarrowReactiveStateEngine](https://docs.dolphindb.cn/zh/funcs/c/createnarrowreactivestateengine.html)，[addReactiveMetrics](https://docs.dolphindb.cn/zh/funcs/a/addreactivemetrics.html)\n"
    },
    "getRecentJobs": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getRecentJobs.html",
        "signatures": [
            {
                "full": "getRecentJobs([n])",
                "name": "getRecentJobs",
                "parameters": [
                    {
                        "full": "[n]",
                        "name": "n",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [getRecentJobs](https://docs.dolphindb.cn/zh/funcs/g/getRecentJobs.html)\n\n\n\n#### 语法\n\ngetRecentJobs(\\[n])\n\n#### 详情\n\n获取本地节点上最近 *n* 个作业（包括定时作业和批处理作业）的状态信息。\n\n#### 参数\n\n**n** 是一个可选参数，为正整数。 无参数时返回所有 Jobs。\n\n#### 返回值\n\n返回一个表，包含以下字段：\n\n| 参数           | 含义                      |\n| ------------ | ----------------------- |\n| node         | 本地节点的别名。                |\n| userID       | 提交作业任务的用户 ID。           |\n| jobId        | 在提交批作业时指定的作业名。          |\n| rootJobId    | 系统中作业的唯一标识。             |\n| jobDesc      | 用于描述作业的字符串。             |\n| priority     | 作业的优先级，为 0-9 之间的整数。     |\n| parallelism  | 作业的并行度，即分配给该作业的线程数上限。   |\n| clientIp     | 发起作业任务的客户端 IP。          |\n| clientPort   | 发起作业任务的客户端端口号。          |\n| receivedTime | 作业接收的时间，为 TIMESTAMP 类型。 |\n| startTime    | 作业开始时间，为 TIMESTAMP 类型。  |\n| endTime      | 作业结束时间，为 TIMESTAMP 类型。  |\n| errorMsg     | 报错信息。                   |\n\n详情参考：[BatchJobManagement](https://docs.dolphindb.cn/zh/sys_man/BatchJobManagement.html)。\n\n#### 例子\n\n```\ndef jobDemo(n){\n   s = 0\n   for (x in 1 : n) {\n       s += sum(sin rand(1.0, 100000000)-0.5)\n       print(\"iteration \" + x + \" \" + s)\n   }\n   return s\n};\n\nsubmitJob(\"jobDemo1\",\"job demo\", jobDemo, 100);\nsubmitJob(\"jobDemo2\",, jobDemo, 10);\n\n// 通过定时作业，定时执行一个函数\ndef f():1+2;\nscheduleJob(jobId=`daily, jobDesc=\"Daily Job 1\", jobFunc=f, scheduleTime=10:22m, startDate=2026.06.16, endDate=2026.06.30, frequency='D');\n\n// 获取最近10条作业的状态\ngetRecentJobs(10);\n```\n\n| node       | userID | jobId    | rootJobId                            | jobDesc     | priority | parallelism | clientIp      | clientPort | receivedTime            | startTime               | endTime                 | errorMsg |\n| ---------- | ------ | -------- | ------------------------------------ | ----------- | -------- | ----------- | ------------- | ---------- | ----------------------- | ----------------------- | ----------------------- | -------- |\n| local11454 | admin  | jobDemo1 | 463f12b1-9530-caa9-f246-5934582eaa24 | job demo    | 4        | 2           | 192.168.1.193 | 63,309     | 2026.06.16 10:21:01.875 | 2026.06.16 10:21:01.875 | 2026.06.16 10:22:05.678 |          |\n| local11454 | admin  | jobDemo2 | b119031d-4d47-3190-e846-f4db8c2a6e35 | jobDemo     | 4        | 2           | 192.168.1.193 | 63,309     | 2026.06.16 10:21:01.875 | 2026.06.16 10:21:01.875 | 2026.06.16 10:21:08.127 |          |\n| local11454 | admin  | daily    | 75311d80-f938-dc9f-5547-778a5c4ff136 | Daily Job 1 | 4        | 2           |               | 0          | 2026.06.16 10:22:12.342 | 2026.06.16 10:22:12.342 | 2026.06.16 10:22:12.342 |          |\n"
    },
    "getRecentSlaveReplicationInfo": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getRecentSlaveReplicationInfo.html",
        "signatures": [
            {
                "full": "getRecentSlaveReplicationInfo()",
                "name": "getRecentSlaveReplicationInfo",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getRecentSlaveReplicationInfo](https://docs.dolphindb.cn/zh/funcs/g/getRecentSlaveReplicationInfo.html)\n\n\n\n#### 语法\n\ngetRecentSlaveReplicationInfo()\n\n#### 详情\n\n查看跨集群异步复制进程中，连接到主集群的各从集群最近一次的任务状态。该函数只能由管理员在主集群的控制节点调用。\n\n#### 参数\n\n无\n\n#### 返回值\n\n返回一个表对象，包含以下字段：\n\n* connectedController：从集群的 controller 的 ip:port。\n\n* allControllersInRaft：若从集群为高可用集群，则将显示 raft 组所有控制节点的 ip:port。\n\n* lastFinishedTaskId：最近一次执行完成的异步复制任务 id。\n\n* lastPullTime：从集群最近一次连接到主集群拉取异步复制任务的时间。\n\n#### 例子\n\n```\ngetRecentSlaveReplicationInfo()\n```\n\n输出返回：\n\n| connectedController | allControllersInRaft                               | lastFinishedTaskId | lastPullTime            |\n| ------------------- | -------------------------------------------------- | ------------------ | ----------------------- |\n| 192.168.2.2:1111    | 192.168.2.2:1111,192.168.2.2:1112,192.168.2.2:1113 | 233                | 2022.11.11T11:11:11.111 |\n"
    },
    "getRecoveryTaskStatus": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getRecoveryTaskStatus.html",
        "signatures": [
            {
                "full": "getRecoveryTaskStatus()",
                "name": "getRecoveryTaskStatus",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getRecoveryTaskStatus](https://docs.dolphindb.cn/zh/funcs/g/getRecoveryTaskStatus.html)\n\n\n\n#### 语法\n\ngetRecoveryTaskStatus()\n\n#### 详情\n\n查询副本恢复任务的状态。该函数只能在控制节点上执行。\n\n#### 参数\n\n无\n\n#### 返回值\n\n返回一个表，包含以下列：\n\n* TaskId：表示恢复副本任务的 ID。\n\n* TaskType：恢复任务的类型，包括 LoadRebalance 和 ChunkRecovery 。\n\n* ChunkId：分区的 ID。\n\n* ChunkPath：分区的 DFS 路径。\n\n* Source：恢复数据的源节点，即正常的数据节点。\n\n* Dest：需要进行数据恢复的节点(目的节点)。\n\n* Status：数据恢复的状态，包括 “Waiting”, “In-Progress”, “Finished”, “Aborted”。\n\n* AttemptCount：恢复任务尝试的次数。\n\n* DeleteSource：是否删除源节点的数据。当 TaskType 是 ChunkRecovery 时，只能返回 false；当 TaskType 是 LoadRebalance 时，可以返回 true 或 false。\n\n* StartTime：创建恢复任务的时间。\n\n* LastDequeueTime：任务最后一次从任务队列出队的时间。\n\n* LastStartTime：最后一次开始执行任务的时间。\n\n* FinishTime：任务结束的时间。\n\n* IsIncrementalRecovery：是否启用增量复制。\n\n* IsAsyncRecovery：是否启用异步复制。\n\n* ChangeFromIncrementalToFull：是否从增量恢复转为全量恢复。系统多次尝试增量恢复失败会自动转换成全量恢复。\n\n* ChangeToSyncTime：节点在线恢复时，从异步恢复阶段转为同步恢复阶段的时刻。\n\n* FailureReason：recovery 任务失败的原因。\n\n#### 例子\n\n```\ngetRecoveryTaskStatus();\n```\n"
    },
    "getRecoveryWorkerNum": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getRecoveryWorkerNum.html",
        "signatures": [
            {
                "full": "getRecoveryWorkerNum()",
                "name": "getRecoveryWorkerNum",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getRecoveryWorkerNum](https://docs.dolphindb.cn/zh/funcs/g/getRecoveryWorkerNum.html)\n\n\n\n#### 语法\n\ngetRecoveryWorkerNum()\n\n#### 详情\n\n获取当前节点用于 chunk 恢复的工作线程数。\n\n#### 参数\n\n无\n\n#### 返回值\n\n整型标量。\n\n#### 例子\n\n```\nresetRecoveryWorkerNum(2)\ngetRecoveryWorkerNum()\n// output: 2\n```\n\n相关函数：[resetRecoveryWorkerNum](https://docs.dolphindb.cn/zh/funcs/r/resetRecoveryWorkerNum.html)\n"
    },
    "getRedoLogGCStat": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getRedoLogGCStat.html",
        "signatures": [
            {
                "full": "getRedoLogGCStat()",
                "name": "getRedoLogGCStat",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getRedoLogGCStat](https://docs.dolphindb.cn/zh/funcs/g/getRedoLogGCStat.html)\n\n\n\n#### 语法\n\ngetRedoLogGCStat()\n\n#### 详情\n\n获取 redo log 垃圾回收的状态。\n\n#### 参数\n\n无\n\n#### 返回值\n\n返回一个表对象，包含以下几列：\n\n* physicalName：物理表名，格式为 \"/数据库名/物理表名\"\n\n* txnCount：redo log 尚未回收的事务数\n\n* numOfTxnPendingGC：等待回收的事务数\n\n* minTidPendingGC：等待回收的事务的最小 tid\n\n* numOfTxnPendingFlush：等待刷盘的事务数\n\n* minTidPendingFlush：等待刷盘的事务的最小 tid\n\n#### 例子\n\n```\ngetRedoLogGCStat();\n```\n\n| physicalName  | txnCount | numOfTxnPendingGC | minTidPendingGC | numOfTxnPendingFlush | minTidPendingFlush |\n| ------------- | -------- | ----------------- | --------------- | -------------------- | ------------------ |\n| /test/pt\\_2   | 2        | 0                 |                 | 2                    | 1031               |\n| /listdb/pt\\_2 | 1        | 1                 | 1033            | 0                    |                    |\n"
    },
    "getRightStream": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getRightStream.html",
        "signatures": [
            {
                "full": "getRightStream(joinEngine)",
                "name": "getRightStream",
                "parameters": [
                    {
                        "full": "joinEngine",
                        "name": "joinEngine"
                    }
                ]
            }
        ],
        "markdown": "### [getRightStream](https://docs.dolphindb.cn/zh/funcs/g/getRightStream.html)\n\n\n\n#### 语法\n\ngetRightStream(joinEngine)\n\n#### 详情\n\n返回连接引擎右表的表结构对象。向该对象注入的数据，会注入到 *joinEngine* 中。\n\n通过该函数，可以将一个引擎的计算结果直接注入到连接引擎中，实现引擎间的级联。\n\n使用案例请参考 [getLeftStream](https://docs.dolphindb.cn/zh/funcs/g/getLeftStream.html)。\n\n#### 参数\n\n**joinEngine** 创建连接引擎返回的对象。目前 DolphinDB 支持的连接引擎有：\n\n* createAsofJoinEngine\n\n* createEquiJoinEngine\n\n* createLookupJoinEngine\n\n* createWindowJoinEngine\n\n* createLeftSemiJoinEngine\n\n#### 返回值\n\n一个表。\n"
    },
    "getRules": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getrules.html",
        "signatures": [
            {
                "full": "getRules([engineName])",
                "name": "getRules",
                "parameters": [
                    {
                        "full": "[engineName]",
                        "name": "engineName",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [getRules](https://docs.dolphindb.cn/zh/funcs/g/getrules.html)\n\n\n\n#### 语法\n\ngetRules(\\[engineName])\n\n#### 详情\n\n查询规则引擎的规则信息，包括规则集、规则检查策略和回调函数等。\n\n#### 参数\n\n**engineName** 字符串向量，代表要查询的规则引擎的名称。该参数省略时，返回当前节点所有规则引擎的规则信息。\n\n#### 返回值\n\n返回一个字典，key 为引擎的名称， value 为字典，包含以下信息：\n\n* ruleSets：该引擎的规则集。类型为一个字典，key 和 value 定义如下：\n\n  * key：规则集的键值。key 为 “Default” 指默认规则。\n\n  * value：规则集中该键值对应的规则。\n\n* policy：指定引擎的规则检查策略。\n\n* callback：指定引擎的回调函数的名称，未配置回调函数时为空字符串。\n\n#### 例子\n\n```\n// 设置规则集\nx = [1, 2, NULL]\ny = [ [ < value > 1 > ], [ < price < 2 >, < price > 6 > ], [ < value*price > 10 > ] ]\nruleSets = dict(x, y)\n\n// 创建规则引擎\nnames = `sym`value`price`quantity\ntypes = [INT, DOUBLE, DOUBLE, DOUBLE]\ndummy = table(1:0, names, types)\noutputNames = `sym`value`price`rule\noutputTypes = [INT, DOUBLE, DOUBLE, BOOL[]]\noutputTable = table(10:0, outputNames, outputTypes)\ntest = createRuleEngine(name=\"ruleEngineTest\", ruleSets=ruleSets, dummyTable=dummy, outputColumns=[\"sym\",\"value\",\"price\"], outputTable=outputTable, policy=\"all\", ruleSetColumn=\"sym\")\ntest2 = createRuleEngine(name=\"ruleEngineTest2\", ruleSets=ruleSets, dummyTable=dummy, outputColumns=[\"sym\",\"value\",\"price\"], outputTable=outputTable, policy=\"all\", ruleSetColumn=\"sym\")\n\n// 查询规则\ngetRules([\"ruleEngineTest\"])\n/*\nruleEngineTest->\n    ruleSets->\n        Default->(value * price > 10)\n        1->(value > 1)\n        2->(price < 2, price > 6)\n\n    policy->all\n    callback->\n*/\n\n// 更新规则\nupdateRule(\"ruleEngineTest\", 1, [<value > 2>])\n\n// 再次查询\ngetRules()\n/*\nruleEngineTest->\n    ruleSets->\n        Default->(value * price > 10)\n        1->(value > 2)\n        2->(price < 2, price > 6)\n\n    policy->all\n    callback->\n*/\n```\n\n相关函数：[createRuleEngine](https://docs.dolphindb.cn/zh/funcs/c/createRuleEngine.html), [updateRule](https://docs.dolphindb.cn/zh/funcs/u/updateRule.html), [deleteRule](https://docs.dolphindb.cn/zh/funcs/d/deleteRule.html)\n"
    },
    "getRunningQueries": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getRunningQueries.html",
        "signatures": [
            {
                "full": "getRunningQueries()",
                "name": "getRunningQueries",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getRunningQueries](https://docs.dolphindb.cn/zh/funcs/g/getRunningQueries.html)\n\n\n\n#### 语法\n\ngetRunningQueries()\n\n#### 详情\n\n获取本地节点上正在执行的查询任务的描述信息。\n\n使用该函数之前，必须设定参数 *perfMonitoring* = 1 来启用性能监控。\n\n#### 参数\n\n无\n\n#### 返回值\n\n返回一张表，包含以下字段：\n\n| 参数        | 含义                                                                |\n| --------- | ----------------------------------------------------------------- |\n| userID    | 用户 ID 。                                                           |\n| sessionID | 发起查询的会话 ID。                                                       |\n| jobID     | 系统中查询任务的唯一标识。                                                     |\n| rootID    | 当前任务所属根任务的 jobID。                                                 |\n| level     | 任务的级别。根任务的 level 为 0，其分解的子任务 level 为 1，该子任务分解的子任务 level 为 2，以此类推。 |\n| startTime | 查询任务开始时间，为 NANOTIMESTAMP 类型。                                      |\n| endTime   | 查询任务结束时间，为 NANOTIMESTAMP 类型。                                      |\n| jobDesc   | 查询语句描述。                                                           |\n| errorMsg  | 报错信息。                                                             |\n| remoteIP  | 发起查询的客户端 IP。                                                      |\n\n#### 例子\n\n```\ngetRunningQueries();\n```\n\n| userID | sessionID | jobID                                | rootID                               | level | startTime                     | endTime | jobDesc                           | errorMsg | remoteIP      |\n| ------ | --------- | ------------------------------------ | ------------------------------------ | ----- | ----------------------------- | ------- | --------------------------------- | -------- | ------------- |\n| admin  | 738481026 | 88e738a8-a749-4dcb-9cfe-740df2d9ce7d | 88e738a8-a749-4dcb-9cfe-740df2d9ce7d | 0     | 2019.02.07T19:02:26.809905612 |         | select count(\\*) as count from pt |          | 192.168.1.106 |\n\n**Related information**\n\n[getCompletedQueries](https://docs.dolphindb.cn/zh/funcs/g/getCompletedQueries.html)\n"
    },
    "getScheduledJobs": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getScheduledJobs.html",
        "signatures": [
            {
                "full": "getScheduledJobs([jobIdPattern])",
                "name": "getScheduledJobs",
                "parameters": [
                    {
                        "full": "[jobIdPattern]",
                        "name": "jobIdPattern",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [getScheduledJobs](https://docs.dolphindb.cn/zh/funcs/g/getScheduledJobs.html)\n\n\n\n#### 语法\n\ngetScheduledJobs(\\[jobIdPattern])\n\n#### 详情\n\n以表格的形式返回定时任务。如果 *jobIdPattern* 没有指定，返回所有已有的定时作业。\n\n#### 参数\n\n**jobIdPattern** 是表示任务 ID 或任务 ID 模式的字符串。它支持通配符“%”和“?”。\n\n#### 返回值\n\n一个表，包含以下字段：\n\n| 参数            | 含义                                 |\n| ------------- | ---------------------------------- |\n| userId        | 用户 ID。                             |\n| jobId         | 在提交定时作业时指定的作业名。                    |\n| jobDesc       | 作业描述。                              |\n| startDate     | 定时作业的开始日期，为 DATE 类型。               |\n| endDate       | 定时作业的结束日期，为 DATE 类型。               |\n| frequency     | 定时作业的执行频率。                         |\n| scheduledTime | 定时作业的执行间隔，为 MINUTE 类型。             |\n| days          | frequency 为 'W' 或 'M' 时，执行定时任务的日期。 |\n\n#### 例子\n\n```\ngetScheduledJobs();\n```\n\n| userId | jobId   | jobDesc     | startDate  | endDate    | frequency | scheduleTime | days |\n| ------ | ------- | ----------- | ---------- | ---------- | --------- | ------------ | ---- |\n| root   | monthly | Monthly Job | 2018.01.01 | 2018.12.31 | M         | 17:00m       | 1    |\n| root   | weekly  | Weekly Job  | 2018.01.01 | 2018.12.31 | W         | 17:30m       | 2    |\n| root   | daily   | Daily Job   | 2018.01.01 | 2018.12.31 | D         | 18:00m       |      |\n"
    },
    "getSchemaByCatalog": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getSchemaByCatalog.html",
        "signatures": [
            {
                "full": "getSchemaByCatalog(catalog)",
                "name": "getSchemaByCatalog",
                "parameters": [
                    {
                        "full": "catalog",
                        "name": "catalog"
                    }
                ]
            }
        ],
        "markdown": "### [getSchemaByCatalog](https://docs.dolphindb.cn/zh/funcs/g/getSchemaByCatalog.html)\n\n\n\n#### 语法\n\ngetSchemaByCatalog(catalog)\n\n#### 详情\n\n检索指定 catalog 中的所有 schema。\n\n#### 参数\n\n**catalog** 字符串标量，表示 catalog 的名称。\n\n#### 返回值\n\n一个 Table，包含 schema 的名称（schema）和对应路径（dbUrl）。\n\n#### 例子\n\n```\ngetSchemaByCatalog(\"catalog1\")\n```\n\n返回：\n\n| schema  | dbUrl      |\n| ------- | ---------- |\n| schema1 | dfs\\://db1 |\n| schema2 | dfs\\://db2 |\n"
    },
    "getSchemasByCluster": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getSchemasByCluster.html",
        "signatures": [
            {
                "full": "getSchemasByCluster(clusterName, catalogName)",
                "name": "getSchemasByCluster",
                "parameters": [
                    {
                        "full": "clusterName",
                        "name": "clusterName"
                    },
                    {
                        "full": "catalogName",
                        "name": "catalogName"
                    }
                ]
            }
        ],
        "markdown": "### [getSchemasByCluster](https://docs.dolphindb.cn/zh/funcs/g/getSchemasByCluster.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\ngetSchemasByCluster(clusterName, catalogName)\n\n#### 详情\n\n查询集群下指定 catalog 的所有的 schema。只能由管理员在 MoM（Master of Master，管理集群）上执行该函数。\n\n#### 参数\n\n**clusterName** 字符串标量，表示要查询的集群名称。\n\n**catalogName** 字符串标量，表示要查询的 catalog 的名称。\n\n#### 返回值\n\n一个表，包含以下字段：\n\n* schema：字符串类型，schema 的名称。\n* dbUrl：字符串类型，数据库路径。\n\n#### 例子\n\n```\n// MoMSender 的数据节点：\ndatabase(directory=\"dfs://db1\", partitionType=RANGE, partitionScheme=0 5 10)\ndatabase(directory=\"dfs://db2\", partitionType=RANGE, partitionScheme=0 5 10)\ncreateSchema(\"catalog1\", \"dfs://db1\", \"schema1\")\ncreateSchema(\"catalog1\", \"dfs://db2\", \"schema2\")\n\n// MOM 节点：\ngetSchemasByCluster(\"MoMSender\", \"catalog1\")\n```\n\n| schema  | dbUrl      |\n| ------- | ---------- |\n| schema1 | dfs\\://db1 |\n| schema2 | dfs\\://db2 |\n"
    },
    "getSessionExpiredTime": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getsessionexpiredtime.html",
        "signatures": [
            {
                "full": "getSessionExpiredTime()",
                "name": "getSessionExpiredTime",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getSessionExpiredTime](https://docs.dolphindb.cn/zh/funcs/g/getsessionexpiredtime.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\ngetSessionExpiredTime()\n\n#### 详情\n\n在启用严格安全策略（参见配置项*strictSecurityPolicy*）时，通过此函数查看会话的过期时间。\n\n#### 参数\n\n无\n\n#### 返回值\n\n空值或 DURATION 类型标量。\n\n#### 例子\n\n```\ngetSessionExpiredTime() // output: 1H\n```\n"
    },
    "getSessionMemoryStat": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getSessionMemoryStat.html",
        "signatures": [
            {
                "full": "getSessionMemoryStat()",
                "name": "getSessionMemoryStat",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getSessionMemoryStat](https://docs.dolphindb.cn/zh/funcs/g/getSessionMemoryStat.html)\n\n\n\n#### 语法\n\ngetSessionMemoryStat()\n\n#### 详情\n\n获取当前节点所有连接会话的内存占用状态。\n\n缓存类型说明:\n\n| 缓存类型                          | 含义                                |\n| ----------------------------- | --------------------------------- |\n| \\_\\_DimensionalTable\\_\\_      | 维度表缓存，单位为字节。                      |\n| \\_\\_SharedTable\\_\\_           | 共享表缓存，单位为字节。                      |\n| \\_\\_OLAPTablet\\_\\_            | OLAP 引擎数据库表的缓存，单位为字节。             |\n| \\_\\_OLAPCacheEngine \\_\\_      | OLAP 引擎 Cache Engine 的内存占用，单位为字节。 |\n| \\_\\_OLAPCachedSymbolBase\\_\\_  | OLAP 引擎 SYMBOL 类型字典编码的缓存，单位为字节。   |\n| \\_\\_DFSMetadata\\_\\_           | 分布式存储的元数据内存占用情况，单位为字节。            |\n| \\_\\_TSDBCacheEngine\\_\\_       | TSDB 引擎 Cache Engine 的内存占用，单位为字节。 |\n| \\_\\_TSDBLevelFileIndex\\_\\_    | TSDB 引擎 level file 索引的缓存，单位为字节。   |\n| \\_\\_TSDBCachedSymbolBase\\_\\_  | TSDB 引擎 SYMBOL 类型字典编码的缓存，单位为字节。   |\n| \\_\\_PKEYCachedSymbolBase\\_\\_  | PKEY 引擎 SYMBOL 类型字典编码的缓存，单位为字节。   |\n| \\_\\_PKEYCacheEngine\\_\\_       | PKEY 引擎 Cache Engine 的内存占用，单位为字节。 |\n| \\_\\_StreamingPubQueue\\_\\_     | 流数据发布队列里未处理的消息数。                  |\n| \\_\\_StreamingSubQueue\\_\\_     | 流数据订阅队列里未处理的消息数。                  |\n| \\_\\_IOTDBStaticTableCache\\_\\_ | 静态表缓存，单位为字节。                      |\n| \\_\\_IOTDBLatestKeyCache\\_\\_   | 最新值表缓存，单位为字节。                     |\n\n**Note:**\n\n* 此函数无法统计到会话中正在执行的任务所占用的内存情况。\n\n* 对于返回表中的 createTime 和 lastActiveTime，2.00.9.4 之前版本的 DolphinDB，返回零时区时间；2.00.9.4 及之后版本的 DolphinDB，返回当前时区的时间。\n\n#### 返回值\n\n返回一张表包含以下字段：\n\n* userId：用户 ID 或缓存类型的标识符（形如：\\_\\_xxx\\_\\_）。\n\n* sessionId：会话 ID。\n\n* memSize：会话所占用的内存，单位为字节。\n\n* remoteIP：发起会话的客户端的 IP。\n\n* remotePort：发起会话的客户端的端口号。\n\n* createTime：会话创建的时间，为 TIMESTAMP 类型。\n\n* lastActiveTime：会话最近一次执行脚本的时间戳。\n\n#### 例子\n\n```\nt = getSessionMemoryStat();\nt;\n```\n\n| userId                       | sessionId  | memSize | remoteIP     | remotePort | createTime              | lastActiveTime          |\n| ---------------------------- | ---------- | ------- | ------------ | ---------- | ----------------------- | ----------------------- |\n| \\_\\_DimensionalTable\\_\\_     |            | 0       | 0.0.0.0      |            |                         |                         |\n| \\_\\_SharedTable\\_\\_          |            | 0       | 0.0.0.0      |            |                         |                         |\n| \\_\\_OLAPTablet\\_\\_           |            | 0       | 0.0.0.0      |            |                         |                         |\n| \\_\\_OLAPCacheEngine\\_\\_      |            | 0       | 0.0.0.0      |            |                         |                         |\n| \\_\\_OLAPCachedSymbolBa...    |            | 0       | 0.0.0.0      |            |                         |                         |\n| \\_\\_DFSMetadata\\_\\_          |            | 2769    | 0.0.0.0      |            |                         |                         |\n| \\_\\_TSDBCacheEngine\\_\\_      |            | 0       | 0.0.0.0      |            |                         |                         |\n| \\_\\_TSDBLevelFileIndex\\_\\_   |            | 0       | 0.0.0.0      |            |                         |                         |\n| \\_\\_TSDBCachedSymbolBa...    |            | 0       | 0.0.0.0      |            |                         |                         |\n| \\_\\_PKEYCachedSymbolBase\\_\\_ |            | 0       | 0.0.0.0      |            |                         |                         |\n| \\_\\_PKEYCacheEngine\\_\\_      |            | 0       | 0.0.0.0      |            |                         |                         |\n| \\_\\_StreamingPubQueue\\_\\_    |            | 0       | 0.0.0.0      |            |                         |                         |\n| \\_\\_StreamingSubQueue\\_\\_    |            | 0       | 0.0.0.0      |            |                         |                         |\n| admin                        | 2882591513 | 1416    | 60.176.105.0 | 20861      | 2023.02.15T02:15:22.384 | 2023.02.15T02:24:16.307 |\n"
    },
    "getSlaveReplicationExecutionStatus": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getslavereplicationexecutionstatus.html",
        "signatures": [
            {
                "full": "getSlaveReplicationExecutionStatus()",
                "name": "getSlaveReplicationExecutionStatus",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getSlaveReplicationExecutionStatus](https://docs.dolphindb.cn/zh/funcs/g/getslavereplicationexecutionstatus.html)\n\n\n\n#### 语法\n\ngetSlaveReplicationExecutionStatus()\n\n#### 详情\n\n由管理员在从集群的数据节点调用，获取该节点上每个线程执行队列的状态。\n\n#### 返回值\n\n返回一个表对象，包含以下字段：\n\n* executionSet：任务所属的执行集 ID。\n* worker：线程 ID。\n* taskId：异步复制任务 ID。\n* state：任务的状态。可能的取值有 TRANSMITTED（数据传输完成等待执行），EXECUTING（正在执行）。\n\n#### 例子\n\n```\ngetSlaveReplicationExecutionStatus()\n```\n\n| executionSet | worker | taskId | state     |\n| ------------ | ------ | ------ | --------- |\n| 0            | 3      | 25     | EXECUTING |\n"
    },
    "getSlaveReplicationQueueStatus": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getslavereplicationqueuestatus.html",
        "signatures": [
            {
                "full": "getSlaveReplicationQueueStatus()",
                "name": "getSlaveReplicationQueueStatus",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getSlaveReplicationQueueStatus](https://docs.dolphindb.cn/zh/funcs/g/getslavereplicationqueuestatus.html)\n\n#### 语法\n\ngetSlaveReplicationQueueStatus()\n\n#### 详情\n\n获取从集群每个执行队列的任务执行状态。该函数只能由管理员在从集群的控制节点调用。\n\n#### 参数\n\n无\n\n#### 返回值\n\n返回一个表，包含以下字段：\n\n* executionSet：任务所属的执行集ID。\n\n* queueId：任务所属队列的编号。\n\n* unifinishedTasks：队列中未执行的任务数量。\n\n* executionGroupId：正在执行任务所属的组号。\n\n* executionNode：执行该 group 的数据节点别名。\n\n* executionTime：当前 group 已经执行的时间。\n\n* status：任务执行状态，包含四种类型： EXECUTING（正在执行）、FAILED（执行失败）、STOPPED（停止执行）、FINISHED（执行完成）\n\n#### 例子\n\n```\ngetSlaveReplicationQueueStatus()\n```\n\n输出返回：\n\n| executionSet | queueId | unfinishedTasks | executionGroupId | executionNode | executionTime | status   |\n| ------------ | ------- | --------------- | ---------------- | ------------- | ------------- | -------- |\n| 0            | 0       | 0               | -1               | dnode1        | 00:00:00.000  | FINISHED |\n| 0            | 1       | 0               | -1               | dnode2        | 00:00:00.000  | FINISHED |\n| 0            | 2       | 0               | -1               | dnode3        | 00:00:00.000  | FINISHED |\n| 1            | 3       | 0               | -1               | dnode1        | 00:00:00.000  | FINISHED |\n| 1            | 4       | 0               | -1               | dnode2        | 00:00:00.000  | FINISHED |\n| 1            | 5       | 0               | -1               | dnode3        | 00:00:00.000  | FINISHED |\n\n"
    },
    "getSlaveReplicationStatus": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getSlaveReplicationStatus.html",
        "signatures": [
            {
                "full": "getSlaveReplicationStatus([limit=-1])",
                "name": "getSlaveReplicationStatus",
                "parameters": [
                    {
                        "full": "[limit=-1]",
                        "name": "limit",
                        "optional": true,
                        "default": "-1"
                    }
                ]
            }
        ],
        "markdown": "### [getSlaveReplicationStatus](https://docs.dolphindb.cn/zh/funcs/g/getSlaveReplicationStatus.html)\n\n\n\n#### 语法\n\ngetSlaveReplicationStatus(\\[limit=-1])\n\n#### 详情\n\n由管理员在从集群的控制节点调用，获取从集群的异步复制状态。若通过 slaveReplicationDBScope 指定了回放数据库的范围，则仅获取该范围内的异步复制情况。其中，已完成的任务排列在前面，未完成的任务排列在后面。\n\n* 如果未指定 *limit*，则返回的任务数量不受限制。\n\n* 如果指定 *limit*，则返回最多 *limit* 个任务列表。\n\n其中，已完成的任务最多显示最近的1万条记录；而未完成的任务只显示从最早时间开始，直到满足指定条数的记录。\n\n#### 参数\n\n**limit** 一个整数，表示结果中最多可返回的任务数量。\n\n#### 返回值\n\n返回一个表，包含以下字段：\n\n* taskId：异步复制任务 id。\n\n* masterTid：该任务对应主集群中的事务 id。\n\n* groupId：异步复制任务所属的组。\n\n* executionSet：任务所属的执行集ID。\n\n* queueId：任务所属执行队列的编号。\n\n* operationType：任务类型，参照异步复制支持性表。\n\n* createTime：从集群从主集群获取任务的时间，类型为 NANOTIMESTAMP。\n\n* dbName：任务对应的数据库的路径。\n\n* tableName：任务对应的表名。\n\n* srcIP：存储写任务数据的数据节点 ip。\n\n* srcPort：存储写任务数据的数据节点 port。\n\n* finishTime：任务的完成时间，类型为 NANOTIMESTAMP。\n\n* executionNode：执行该任务的从集群的数据节点别名。\n\n* state：任务执行状态，包含四种类型： WAITING（等待执行）、EXECUTING（正在执行）、FINISH（执行完成/任务skip）、FAILED（执行失败）。\n\n* details：补充说明。若 state = FAILED，则该列为执行失败的原因；若 state = FINISH，该列用于对该任务进行补充说明。\n\n#### 例子\n\n```\ngetSlaveReplicationStatus();\n```\n\n输出返回：\n\n| taskId | masterTid | groupId | executionSet | queueId | operationType              | createTime                    | dbName                          | tableName | srcIP     | srcPort | finishTime                    | executionNode | state  | details |\n| ------ | --------- | ------- | ------------ | ------- | -------------------------- | ----------------------------- | ------------------------------- | --------- | --------- | ------- | ----------------------------- | ------------- | ------ | ------- |\n| 1      | 1         | 1       | 0            | 0       | CREATE\\_DOMAIN             | 2022.11.08T10:50:37.425056956 | db://test\\_dropPartition\\_value |           | localhost | 8002    | 2022.11.08T10:50:37.452792885 | NODE2         | FINISH |         |\n| 2      | 2         | 2       | 0            | 1       | CREATE\\_PARTITIONED\\_TABLE | 2022.11.08T10:50:37.425056988 | db://test\\_dropPartition\\_value | pt        | localhost | 8002    | 2022.11.08T10:50:37.479906033 | NODE3         | FINISH |         |\n| 3      | 3         | 3       | 0            | 2       | APPEND                     | 2022.11.08T10:50:37.425057012 | db://test\\_dropPartition\\_value | pt        | localhost | 8002    | 2022.11.08T10:50:37.638746819 | NODE1         | FINISH |         |\n| 4      | 4         | 4       | 0            | 3       | DROP\\_PARTITION            | 2022.11.08T10:50:37.425057037 |                                 | pt        | localhost | 8002    | 2022.11.08T10:50:37.869783336 | NODE2         | FINISH |         |\n\n相关函数：[getMasterReplicationStatus](https://docs.dolphindb.cn/zh/funcs/g/getMasterReplicationStatus.html), [getSlaveReplicationQueueStatus](https://docs.dolphindb.cn/zh/funcs/g/getslavereplicationqueuestatus.html)\n"
    },
    "getSnapshotMsgId": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getSnapshotMsgId.html",
        "signatures": [
            {
                "full": "getSnapshotMsgId(engine)",
                "name": "getSnapshotMsgId",
                "parameters": [
                    {
                        "full": "engine",
                        "name": "engine"
                    }
                ]
            }
        ],
        "markdown": "### [getSnapshotMsgId](https://docs.dolphindb.cn/zh/funcs/g/getSnapshotMsgId.html)\n\n\n\n#### 语法\n\ngetSnapshotMsgId(engine)\n\n#### 详情\n\n用于订阅断开后重新订阅时，获取指定流数据引擎的最近一个快照（snapshot）的 msgId。启用 snapshot 后，重订阅时，`subscribeTable` 函数的 *offset* 参数设置为 getSnapshotMsgId(engine)+1，引擎会加载 snapshot，并从 getSnapshotMsgId(engine) 之后一条消息开始重新订阅。\n\n#### 参数\n\n**engine** 是流数据引擎，即 [createReactiveStateEngine](https://docs.dolphindb.cn/zh/funcs/c/createReactiveStateEngine.html) 等函数返回的抽象表对象。\n\n#### 返回值\n\n整型标量。\n"
    },
    "getSparseReactiveMetrics": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getSparseReactiveMetrics.html",
        "signatures": [
            {
                "full": "getSparseReactiveMetrics(name)",
                "name": "getSparseReactiveMetrics",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    }
                ]
            }
        ],
        "markdown": "### [getSparseReactiveMetrics](https://docs.dolphindb.cn/zh/funcs/g/getSparseReactiveMetrics.html)\n\n\n\n#### 语法\n\ngetSparseReactiveMetrics(name)\n\n#### 详情\n\n获取指定稀疏响应式状态引擎当前配置的计算规则。\n\n#### 参数\n\n**name** 字符串标量，表示稀疏响应式状态引擎的名字。\n\n#### 返回值\n\n返回一个表，结构与 `createSparseReactiveStateEngine` 的 *metrics* 参数相同。\n\n#### 例子\n\n```\ngetSparseReactiveMetrics(\"demoengine\")\n```\n\n| deviceID | formula                     | outputMetricKey |\n| -------- | --------------------------- | --------------- |\n| A001     | mavg(value,3)               | A001\\_1         |\n| A002     | mmax(value,3)-mmin(value,3) | A002\\_1         |\n| A002     | msum(value,3)               | A002\\_2         |\n\n**相关函数**：[createSparseReactiveStateEngine](https://docs.dolphindb.cn/zh/funcs/c/createSparseReactiveStateEngine.html), [addSparseReactiveMetrics](https://docs.dolphindb.cn/zh/funcs/a/addSparseReactiveMetrics.html), [deleteSparseReactiveMetric](https://docs.dolphindb.cn/zh/funcs/d/deleteSparseReactiveMetric.html)\n"
    },
    "getStatelessMetrics": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getstatelessmetrics.html",
        "signatures": [
            {
                "full": "getStatelessMetrics(name)",
                "name": "getStatelessMetrics",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    }
                ]
            }
        ],
        "markdown": "### [getStatelessMetrics](https://docs.dolphindb.cn/zh/funcs/g/getstatelessmetrics.html)\n\n\n\n#### 语法\n\ngetStatelessMetrics(name)\n\n#### 详情\n\n获取响应式无状态引擎的计算逻辑。\n\n#### 参数\n\n**name** STRING 类型标量，表示响应式无状态引擎的名字。\n\n#### 返回值\n\n一个表，包含四列： formula， outputMetricKey，triggerOn，filter。\n\n#### 例子\n\n```\ngetStatelessMetrics(\"engine1\")\n```\n\n| formula                           | outputMetricKey | triggerOn | filter                |\n| --------------------------------- | --------------- | --------- | --------------------- |\n| \"factor1\" + \"factor2\" + \"factor3\" | value1          | factor3   | void()                |\n| \"value1\"\\*\"factor3\"               | value2          |           | pair\\<double>(10, 40) |\n| \"factor1\" \\* \"factor2\"            | value3          | factor1   | pair\\<int>(10, 20)    |\n"
    },
    "getStreamEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getStreamEngine.html",
        "signatures": [
            {
                "full": "getStreamEngine(name)",
                "name": "getStreamEngine",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    }
                ]
            }
        ],
        "markdown": "### [getStreamEngine](https://docs.dolphindb.cn/zh/funcs/g/getStreamEngine.html)\n\n\n\n#### 语法\n\ngetStreamEngine(name)\n\n#### 详情\n\n返回流数据引擎的句柄，可以作为 [subscribeTable](https://docs.dolphindb.cn/zh/funcs/s/subscribeTable.html) 函数的 *handler* 参数。\n\n#### 参数\n\n**name** 是一个字符串，表示流数据引擎的名称。它可以包含字母，数字和下划线，但必须以字母开头。\n\n#### 返回值\n\n一个流数据引擎对象。\n\n#### 例子\n\n```\nshare streamTable(1000:0, `time`sym`qty, [TIMESTAMP, SYMBOL, INT]) as trades\noutputTable = table(10000:0, `time`sym`sumQty, [TIMESTAMP, SYMBOL, INT])\ntradesAggregator = createTimeSeriesEngine(\"StreamAggregatorDemo\",3, 3, <[sum(qty)]>, trades, outputTable, `time, false,`sym, 50)\nsubscribeTable(, \"trades\", \"tradesAggregator\", 0, append!{tradesAggregator}, true)\n\ndef writeData(n){\n   timev = 2018.10.08T01:01:01.001 + timestamp(1..n)\n   symv =take(`A`B, n)\n   qtyv = take(1, n)\n   insert into trades values(timev, symv, qtyv)\n}\n\nwriteData(6);\nh = getStreamEngine(\"StreamAggregatorDemo\")\n```\n"
    },
    "getStreamEngineList": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getstreamenginelist.html",
        "signatures": [
            {
                "full": "getStreamEngineList()",
                "name": "getStreamEngineList",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getStreamEngineList](https://docs.dolphindb.cn/zh/funcs/g/getstreamenginelist.html)\n\n\n\n#### 语法\n\ngetStreamEngineList()\n\n#### 详情\n\n获取当前节点上所有流计算引擎的信息。\n\n#### 参数\n\n无\n\n#### 返回值\n\n一个表，包含以下字段：\n\n* engineType：引擎的类型。\n\n* engineName：引擎的名称。\n\n* user：创建引擎的用户名。\n\n#### 例子\n\n假设在当前节点上，admin 用户已创建1个时序引擎和1个 window join 引擎，user1 用户已创建1个响应式状态引擎，则调用 `getStreamEngineList` 后返回可以所有已创建引擎的信息。\n\n```\ngetStreamEngineList()\n```\n\n| engineType           | engineName   | user  |\n| -------------------- | ------------ | ----- |\n| ReactiveStreamEngine | reactiveDemo | user1 |\n| WindowJoinEngine     | test1        | admin |\n| TimeSeriesEngine     | engine1      | admin |\n"
    },
    "getStreamEngineStat": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getStreamEngineStat.html",
        "signatures": [
            {
                "full": "getStreamEngineStat()",
                "name": "getStreamEngineStat",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getStreamEngineStat](https://docs.dolphindb.cn/zh/funcs/g/getStreamEngineStat.html)\n\n\n\n#### 语法\n\ngetStreamEngineStat()\n\n别名：getAggregatorStat\n\n#### 详情\n\n查询流数据引擎的状态。\n\n#### 参数\n\n无\n\n#### 返回值\n\n返回一个字典，包含以下表：\n\n* 表 TimeSeriesEngine 返回时间序列引擎的状态。它包含以下列：\n\n| 列名                | 含义                              |\n| ----------------- | ------------------------------- |\n| name              | 时间序列引擎的名称                       |\n| user              | 创建时间序列引擎的用户名                    |\n| status            | 时间序列引擎的状态，\"OK\"表示可用，\"FATAL\"表示不可用 |\n| lastErrMsg        | 最后一条错误信息                        |\n| windowTime        | 窗口的长度                           |\n| step              | 计算的时间间隔                         |\n| useSystemTime     | 时间序列引擎中 useSystemTime 参数值       |\n| garbageSize       | 触发内存清理的阈值                       |\n| numGroups         | 时间序列引擎中的分组数                     |\n| numRows           | 时间序列引擎中的记录行数                    |\n| numMetrics        | 时间序列引擎使用的聚合指标的数量                |\n| metrics           | 时间序列引擎使用的聚合指标的元代码               |\n| memoryUsed        | 时间序列引擎所占用内存量，单位为字节              |\n| snapshotDir       | 保存引擎快照的文件目录                     |\n| snapshotInterval  | 每隔多少条数据保存一次引擎快照                 |\n| snapshotMsgId     | 最后一个 snapshot 的 msgId           |\n| snapshotTimestamp | 引擎快照的时间戳                        |\n\n* 表 CrossSectionalEngine 返回横截面聚合引擎的状态。它包含以下列：\n\n| 列名                 | 含义                               |\n| ------------------ | -------------------------------- |\n| name               | 横截面引擎的名称                         |\n| user               | 创建横截面引擎的用户名                      |\n| status             | 横截面引擎的状态，\"OK\" 表示可用，\"FATAL\" 表示不可用 |\n| lastErrMsg         | 最后一条错误信息                         |\n| numRows            | 横截面引擎中的记录行数                      |\n| numMetrics         | 横截面引擎使用的聚合指标的数量                  |\n| metrics            | 横截面引擎使用的聚合指标的元代码                 |\n| triggeringPattern  | 横截面引擎触发计算的方式                     |\n| triggeringInterval | 横截面引擎触发计算的时间间隔                   |\n| memoryUsed         | 横截面引擎所占用内存量，单位为字节                |\n\n* 表 AnomalyDetectionEngine 返回异常检测引擎的状态。它包含以下列：\n\n| 列名               | 含义                                |\n| ---------------- | --------------------------------- |\n| name             | 异常检测引擎的名称                         |\n| user             | 创建异常检测引擎的用户名                      |\n| status           | 异常检测引擎的状态，\"OK\" 表示可用，\"FATAL\" 表示不可用 |\n| lastErrMsg       | 最后一条错误信息                          |\n| numGroups        | 异常检测引擎中的分组数                       |\n| numRows          | 异常检测引擎中的记录行数                      |\n| numMetrics       | 异常指标的数量                           |\n| metrics          | 异常指标的元代码                          |\n| snapshotDir      | 保存引擎快照的文件目录                       |\n| snapshotInterval | 每隔多少条数据保存一次引擎快照                   |\n| snapshotMsgId    | 最后一个 snapshot 的 msgId             |\n| snapshotTimestam | 引擎快照的时间戳                          |\n| garbageSize      | 触发内存清理的阈值                         |\n| memoryUsed       | 异常检测引擎所占用内存量，单位为字节                |\n\n* 表 ReactiveStreamEngine 返回响应式状态引擎的状态。它包含以下列：\n\n| 列名                | 含义                                 |\n| ----------------- | ---------------------------------- |\n| name              | 响应式状态引擎的名称                         |\n| user              | 创建响应式状态引擎的用户名                      |\n| status            | 响应式状态引擎的状态，\"OK\" 表示可用，\"FATAL\" 表示不可用 |\n| lastErrMsg        | 最后一条错误信息                           |\n| numGroups         | 响应式状态引擎中的分组数                       |\n| numRows           | 响应式状态引擎中的记录行数                      |\n| numMetrics        | 指标的数量                              |\n| memoryInUsed      | 响应式状态引擎所占用内存量，单位为字节                |\n| snapshotDir       | 保存引擎快照的文件目录                        |\n| snapshotInterval  | 每隔多少条数据保存一次引擎快照                    |\n| snapshotMsgId     | 最后一个 snapshot 的 msgId              |\n| snapshotTimestamp | 引擎快照的时间戳                           |\n\n* 表 SessionWindowEngine 返回会话窗口引擎的状态。它包含以下列：\n\n| 列名                | 含义                                |\n| ----------------- | --------------------------------- |\n| name              | 会话窗口引擎的名称                         |\n| user              | 创建会话窗口引擎的用户名                      |\n| status            | 会话窗口引擎的状态，\"OK\" 表示可用，\"FATAL\" 表示不可用 |\n| lastErrMsg        | 最后一条错误信息                          |\n| sessionGap        | 每个会话窗口之间的时间间隔                     |\n| useSystemTime     | 会话窗口聚合引擎计算的触发方式                   |\n| numGroups         | 会话窗口引擎中的分组数                       |\n| numRows           | 会话窗口引擎中的记录行数                      |\n| numMetrics        | 指标的数量                             |\n| Metrics           | 会话窗口聚合引擎使用的聚合指标的元代码               |\n| memoryUsed        | 会话窗口引擎所占用内存量，单位为字节                |\n| snapshotDir       | 会话窗口引擎快照保存的文件目录                   |\n| snapshotInterval  | 每隔多少条数据保存一次引擎快照                   |\n| snapshotMsgId     | 最后一个 snapshot 的 msgId             |\n| snapshotTimestamp | 触发保存快照的时间戳                        |\n\n* 表 DailyTimeSeriesEngine 返回日级时间序列引擎的状态。它包含以下列：\n\n| 列名                | 含义                                  |\n| ----------------- | ----------------------------------- |\n| name              | 日级时间序列引擎的名称                         |\n| user              | 创建日级时间序列引擎的用户名                      |\n| status            | 日级时间序列引擎的状态，\"OK\" 表示可用，\"FATAL\" 表示不可用 |\n| lastErrMsg        | 最后一条错误信息                            |\n| windowTime        | 数据窗口的长度                             |\n| step              | 计算的时间间隔                             |\n| useSystemTime     | 日级时间序列引擎中 useSystemTime 参数值         |\n| garbageSize       | 触发内存清理的阈值                           |\n| numGroups         | 日级时间序列引擎中的分组数                       |\n| numRows           | 日级时间序列引擎中的记录行数                      |\n| numMetrics        | 日级时间序列引擎使用的聚合指标的数量                  |\n| metrics           | 日级时间序列引擎使用的聚合指标的元代码                 |\n| memoryUsed        | 日级时间序列引擎所占用内存量，单位为字节                |\n| snapshotDir       | 日级时间序列聚合引擎快照保存的文件目录                 |\n| snapshotInterval  | 每隔多少条数据保存一次引擎快照                     |\n| snapshotMsgId     | 最后一个 snapshot 的 msgId               |\n| snapshotTimestamp | 触发保存快照的时间戳                          |\n\n* 表 TimeBucketEngine 返回时间序列分组引擎的状态。它包含以下列：\n\n| 列名         | 含义                                |\n| ---------- | --------------------------------- |\n| name       | 时间序列分组引擎的名称                       |\n| user       | 创建时间序列分组引擎的用户名                    |\n| status     | 时间序列分组引擎的状态，\"OK\"表示可用，\"FATAL\"表示不可用 |\n| lastErrMsg | 最后一条错误信息                          |\n| numGroups  | 时间序列分组引擎中的分组数                     |\n| numRows    | 时间序列分组引擎中的记录行数                    |\n| numMetrics | 时间序列分组引擎使用的聚合指标的数量                |\n| metrics    | 时间序列分组引擎使用的聚合指标的元代码               |\n| memoryUsed | 时间序列分组引擎所占用内存量，单位为字节              |\n\n* 表 AsofJoinEngine 返回 asof join 引擎的状态。它包含以下列：\n\n| 列名                | 含义                                      |\n| ----------------- | --------------------------------------- |\n| name              | asof join 引擎的名称                         |\n| user              | 创建 asof join 引擎的用户名                     |\n| status            | asof join 引擎的状态，\"OK\" 表示可用，\"FATAL\" 表示不可用 |\n| lastErrMsg        | 最后一条错误信息                                |\n| useSystemTime     | asof join 引擎中 useSystemTime 参数值         |\n| delayedTime       | asof join 引擎中 delayedTime 参数值           |\n| garbageSize       | 触发内存清理的阈值                               |\n| leftTableNumRows  | asof join 引擎左表中的记录行数                    |\n| rightTableNumRows | asof join 引擎右表中的记录行数                    |\n| numMetrics        | asof join 引擎使用的指标的数量                    |\n| metrics           | asof join 引擎使用的指标的元代码                   |\n| memoryUsed        | asof join 引擎所占用内存量，单位为字节                |\n\n* 表 EqualJoinEngine 返回等值连接引擎的状态。它包含以下列：\n\n| 列名                | 含义                                |\n| ----------------- | --------------------------------- |\n| name              | 等值连接引擎的名称                         |\n| user              | 创建等值连接引擎的用户名                      |\n| status            | 等值连接引擎的状态，\"OK\" 表示可用，\"FATAL\" 表示不可用 |\n| lastErrMsg        | 最后一条错误信息                          |\n| garbageSize       | 触发内存清理的阈值                         |\n| leftTableNumRows  | 等值连接引擎左表中的记录行数                    |\n| rightTableNumRows | 等值连接引擎右表中的记录行数                    |\n| numMetrics        | 等值连接引擎使用的指标的数量                    |\n| metrics           | 等值连接引擎使用的指标的元代码                   |\n| memoryUsed        | 等值连接引擎所占用内存量，单位为字节                |\n\n* 表 WindowJoinEngine 返回 window join 引擎的状态。它包含以下列：\n\n| 列名                | 含义                                        |\n| ----------------- | ----------------------------------------- |\n| name              | window join 引擎的名称                         |\n| user              | 创建 window join 引擎的用户名                     |\n| status            | window join 引擎的状态，\"OK\" 表示可用，\"FATAL\" 表示不可用 |\n| lastErrMsg        | 最后一条错误信息                                  |\n| garbageSize       | 触发内存清理的阈值                                 |\n| leftTableNumRows  | window join 引擎左表中的记录行数                    |\n| rightTableNumRows | window join 引擎右表中的记录行数                    |\n| numMetrics        | window join 引擎使用的指标的数量                    |\n| metrics           | window join 引擎使用的指标的元代码                   |\n| memoryUsed        | window join 引擎所占用内存量，单位为字节                |\n| numGroups         | window join 引擎中的分组个数。                     |\n\n* 表 LookupJoinEngine 返回 lookup join 引擎的状态。它包含以下列：\n\n| 列名                | 含义                                        |\n| ----------------- | ----------------------------------------- |\n| name              | lookup join 引擎的名称                         |\n| user              | 创建 lookup join 引擎的用户名                     |\n| status            | lookup join 引擎的状态，\"OK\" 表示可用，\"FATAL\" 表示不可用 |\n| lastErrMsg        | 最后一条错误信息                                  |\n| leftTableNumRows  | lookup join 引擎左表中的记录行数                    |\n| rightTableNumRows | lookup join 引擎右表中的记录行数                    |\n| numMetrics        | lookup join 引擎使用的指标的数量                    |\n| metrics           | lookup join 引擎使用的指标的元代码                   |\n| memoryUsed        | lookup join 引擎所占用内存量，单位为字节                |\n\n* 表 LeftSemiJoinEngine 返回左半等值连接引擎的状态。它包含以下列：\n\n| 列名                | 含义                                  |\n| ----------------- | ----------------------------------- |\n| name              | 左半等值连接引擎的名称                         |\n| user              | 创建左半等值连接引擎的用户名                      |\n| status            | 左半等值连接引擎的状态，\"OK\" 表示可用，\"FATAL\" 表示不可用 |\n| lastErrMsg        | 最后一条错误信息                            |\n| garbageSize       | 触发内存清理的阈值                           |\n| leftTableNumRows  | 左半等值连接引擎左表中的记录行数                    |\n| rightTableNumRows | 左半等值连接引擎右表中的记录行数                    |\n| numMetrics        | 左半等值连接引擎使用的指标的数量                    |\n| metrics           | 左半等值连接引擎使用的指标的元代码                   |\n| memoryUsed        | 左半等值连接引擎所占用内存量，单位为字节                |\n\n* 表 StreamFilter 返回流数据过滤引擎的状态。它包含以下列：\n\n| 列名         | 含义                                 |\n| ---------- | ---------------------------------- |\n| name       | 流数据过滤引擎的名称                         |\n| user       | 创建流数据过滤引擎的用户名                      |\n| status     | 流数据过滤引擎的状态，\"OK\" 表示可用，\"FATAL\" 表示不可用 |\n| lastErrMsg | 最后一条错误信息                           |\n| numRows    | 流数据过滤引擎中的记录行数                      |\n| filters    | 流数据过滤引擎的过滤条件                       |\n\n* 表 StreamDispatchEngine 返回流数据分发引擎的状态。它包含以下列：\n\n| 列名         | 含义                            |\n| ---------- | ----------------------------- |\n| name       | 分发引擎的名称                       |\n| user       | 创建分发引擎的用户名                    |\n| status     | 分发引擎的状态，”OK”表示可用，”FATAL”表示不可用 |\n| lastErrMsg | 最后一条错误信息                      |\n| numRows    | 分发引擎中的记录行数                    |\n| memoryUsed | 分发引擎所占用内存量，单位为字节              |\n\n* 表 DualOwnershipReactiveStreamEngine 返回 Dual Ownership Reactive State Engine 的状态。它包含以下列：\n\n| 列名                | 含义                                       |\n| ----------------- | ---------------------------------------- |\n| name              | Dual Ownership Reactive State Engine 的名称 |\n| user              | 创建引擎的用户名                                 |\n| status            | 引擎的状态，”OK”表示可用，”FATAL”表示不可用              |\n| lastErrMsg        | 最后一条错误信息                                 |\n| numGroups         | 引擎中的分组数                                  |\n| numRows           | 引擎中的记录行数                                 |\n| numMetrics        | 指标的数量                                    |\n| memoryInUsed      | 引擎所占用内存量，单位为字节                           |\n| snapshotDir       | 保存引擎快照的文件目录                              |\n| snapshotInterval  | 每隔多少条数据保存一次引擎快照                          |\n| snapshotMsgId     | 最后一个 snapshot 的 msgId                    |\n| snapshotTimestamp | 引擎快照的时间戳                                 |\n\n* 表 NarrowReactiveStreamEngine 返回生成窄表的响应式状态引擎的状态。它包含以下列：\n\n| 列名                | 含义                          |\n| ----------------- | --------------------------- |\n| name              | 生成窄表的响应式状态引擎的名称             |\n| user              | 创建引擎的用户名                    |\n| status            | 引擎的状态，”OK”表示可用，”FATAL”表示不可用 |\n| lastErrMsg        | 最后一条错误信息                    |\n| numGroups         | 引擎中的分组数                     |\n| numRows           | 引擎中的记录行数                    |\n| numMetrics        | 指标的数量                       |\n| memoryInUsed      | 引擎所占用内存量，单位为字节              |\n| snapshotDir       | 保存引擎快照的文件目录                 |\n| snapshotInterval  | 每隔多少条数据保存一次引擎快照             |\n| snapshotMsgId     | 最后一个 snapshot 的 msgId       |\n| snapshotTimestamp | 引擎快照的时间戳                    |\n\n* 表 SnapshotJoinEngine 返回快照连接引擎的状态。它包含以下列：\n\n| 列名                | 含义                                |\n| ----------------- | --------------------------------- |\n| name              | 快照连接引擎的名称                         |\n| user              | 创建快照连接引擎的用户名                      |\n| status            | 快照连接引擎的状态，\"OK\" 表示可用，\"FATAL\" 表示不可用 |\n| lastErrMsg        | 最后一条错误信息                          |\n| leftTableNumRows  | 快照连接引擎左表中的记录行数                    |\n| rightTableNumRows | 快照连接引擎右表中的记录行数                    |\n| numMetrics        | 快照连接引擎使用的指标的数量                    |\n| metrics           | 快照连接引擎使用的指标的元代码                   |\n| memoryUsed        | 快照连接引擎所占用内存量，单位为字节                |\n\n#### 例子\n\n```\nshare streamTable(10:0,`time`sym`price`qty,[TIMESTAMP,SYMBOL,DOUBLE,INT]) as trades\noutputTable1 = table(10000:0, `time`sym`sumQty, [TIMESTAMP, SYMBOL, INT])\noutputTable2 = table(1:0, `time`avgPrice`sumqty`Total, [TIMESTAMP,DOUBLE,INT,DOUBLE])\ntradesTsAggregator = createTimeSeriesEngine(name=\"TimeSeriesDemo\", windowSize=3, step=3, metrics=<[sum(qty)]>, dummyTable=trades, outputTable=outputTable1, timeColumn=`time, keyColumn=`sym, garbageSize=50)\ntradesCsAggregator=createCrossSectionalEngine(name=\"CrossSectionalDemo\", metrics=<[avg(price), sum(qty), sum(price*qty)]>, dummyTable=trades, outputTable=outputTable2, keyColumn=`sym, triggeringPattern=`perRow)\nsubscribeTable(tableName=\"trades\", actionName=\"tradesTsAggregator\", offset=0, handler=append!{tradesTsAggregator}, msgAsTable=true)\nsubscribeTable(tableName=\"trades\", actionName=\"tradesCsAggregator\", offset=0, handler=append!{tradesCsAggregator}, msgAsTable=true)\n\ndef writeData(n){\n   timev = 2000.10.08T01:01:01.001 + timestamp(1..n)\n   symv =take(`A`B, n)\n   pricev=take(102.1 33.4 73.6 223,n)\n   qtyv = take(60 74 82 59, n)\n   insert into trades values(timev, symv, pricev,qtyv)\n}\n\nwriteData(4);\n\ngetStreamEngineStat().TimeSeriesEngine;\ngetStreamEngineStat().CrossSectionalEngine;\n```\n"
    },
    "getStreamingLeader": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getStreamingLeader.html",
        "signatures": [
            {
                "full": "getStreamingLeader(groupId)",
                "name": "getStreamingLeader",
                "parameters": [
                    {
                        "full": "groupId",
                        "name": "groupId"
                    }
                ]
            }
        ],
        "markdown": "### [getStreamingLeader](https://docs.dolphindb.cn/zh/funcs/g/getStreamingLeader.html)\n\n\n\n#### 语法\n\ngetStreamingLeader(groupId)\n\n#### 详情\n\n获取流数据 Raft 组中的 Leader。\n\n#### 参数\n\n**groupId** 是一个整数，表示流数据 Raft 组的 ID\n\n#### 返回值\n\n字符串标量。\n\n#### 例子\n\n```\ngetStreamingLeader(11);\n// output: DFS_NODE2\n```\n"
    },
    "getStreamingRaftGroups": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getStreamingRaftGroups.html",
        "signatures": [
            {
                "full": "getStreamingRaftGroups()",
                "name": "getStreamingRaftGroups",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getStreamingRaftGroups](https://docs.dolphindb.cn/zh/funcs/g/getStreamingRaftGroups.html)\n\n\n\n#### 语法\n\ngetStreamingRaftGroups()\n\n#### 详情\n\n获取当前节点所在的流数据 Raft 组的信息。\n\n#### 参数\n\n无\n\n#### 返回值\n\n一个表，第一列表示 Raft 组的 id，第二列表示 Raft 组包含的数据节点/计算节点信息。\n\n#### 例子\n\n```\ngetStreamingRaftGroups();\n```\n\n| id | sites                                                                         |\n| -- | ----------------------------------------------------------------------------- |\n| 12 | 192.168.1.135:18102:NODE1,192.168.1.135:18103:NODE2,192.168.1.135:18104:NODE3 |\n| 11 | 192.168.1.135:18102:NODE1,192.168.1.135:18103:NODE2,192.168.1.135:18105:NODE4 |\n\n使用以下脚本可以获取当前集群所有流数据 Raft 组的信息。\n\n```\nselect id,sites from pnodeRun(getStreamingRaftGroups) where isDuplicated([id,sites],FIRST)=false;\n```\n"
    },
    "getStreamingSQLStatus": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getStreamingSQLStatus.html",
        "signatures": [
            {
                "full": "getStreamingSQLStatus([queryId])",
                "name": "getStreamingSQLStatus",
                "parameters": [
                    {
                        "full": "[queryId]",
                        "name": "queryId",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [getStreamingSQLStatus](https://docs.dolphindb.cn/zh/funcs/g/getStreamingSQLStatus.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\ngetStreamingSQLStatus(\\[queryId])\n\n#### 详情\n\n查看流式 SQL 查询的运行状态。\n\n* 若指定 *queryId*，则返回该查询的状态。\n* 若不指定 *queryId*，返回当前用户注册的所有流式 SQL 查询的状态。如果调用者是管理员（admin），则返回所有用户注册的流式 SQL 查询的状态。\n\n#### 参数\n\n**queryId** 可选参数，字符串标量，表示已注册的流式 SQL 查询 ID。\n\n#### 返回值\n\n一个表，包含如下字段：\n\n* queryId：流式 SQL 查询的 ID。\n* user：注册该查询的用户名。\n* registerTime：注册该查询的时间。\n* status：当前查询的状态，取值包括：\n  * SQL\\_REGISTERED：已注册，未运行。\n  * SQL\\_RUNNING：正常运行中，结果实时更新。\n  * SQL\\_STOPPED：已暂停。\n  * INTERNAL\\_ERROR：运行异常。\n* sqlQuery：流式 SQL 查询的语句。\n* involvedTables：查询涉及的表。\n* lastErrorMessage：最近一次错误的信息（如有）。\n\n#### 例子\n\n```\nt=table(1..10 as id,rand(100,10) as val)\nshare t as st\ndeclareStreamingSQLTable(st)\nregisterStreamingSQL(\"select avg(val) from st\",\"sql_avg\") \n\n// 查看流式 SQL 查询的状态\ngetStreamingSQLStatus(\"sql_avg\")\n\n```\n\n| queryId  | user  | registerTime            | status          | sqlQuery                | involvedTables | lastErrorMessage |\n| -------- | ----- | ----------------------- | --------------- | ----------------------- | -------------- | ---------------- |\n| sql\\_avg | admin | 2025.08.09 03:33:40.781 | SQL\\_REGISTERED | select avg(val) from st | st             |                  |\n\n**相关函数：**[declareStreamingSQLTable](https://docs.dolphindb.cn/zh/funcs/d/declareStreamingSQLTable.html), [registerStreamingSQL](https://docs.dolphindb.cn/zh/funcs/r/registerStreamingSQL.html)\n"
    },
    "getStreamingSQLSubscriptionInfo": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getstreamingsqlsubscriptioninfo.html",
        "signatures": [
            {
                "full": "getStreamingSQLSubscriptionInfo(queryId)",
                "name": "getStreamingSQLSubscriptionInfo",
                "parameters": [
                    {
                        "full": "queryId",
                        "name": "queryId"
                    }
                ]
            }
        ],
        "markdown": "### [getStreamingSQLSubscriptionInfo](https://docs.dolphindb.cn/zh/funcs/g/getstreamingsqlsubscriptioninfo.html)\n\n首发版本：3.00.5\n\n\n\n#### 语法\n\ngetStreamingSQLSubscriptionInfo(queryId)\n\n#### 详情\n\n查询指定流式 SQL 的元数据信息。\n\n#### 参数\n\n**queryId** 字符串，表示流式 SQL 的 ID。\n\n#### 返回值\n\n一个字典，包含以下键值：\n\n* leadingRecordInsertTime：触发最近一次更新的数据中最早插入行的插入时间。\n\n* lastRecordInsertTime：触发最近一次更新的数据中最晚插入行的插入时间。\n\n* lastUpdateTime：当前结果集的更新时间。\n\n#### 例子\n\n```\n// 声明流式 SQL 输入表\nshare keyedTable(`id, 1:0, `id`value, [INT, DOUBLE]) as leftTable;\nshare keyedTable(`id, 1:0, `id`value, [INT, DOUBLE]) as rightTable;\ngo;\ndeclareStreamingSQLTable(leftTable);\ndeclareStreamingSQLTable(rightTable);\n// 注册流式 SQL\nqueryId = registerStreamingSQL(\"select id, leftTable.value + rightTable.value from leftTable left join rightTable on leftTable.id=rightTable.id\");\n// 订阅流式 SQL 查询结果\nresult = subscribeStreamingSQL(,queryId)\nt = table(1 2 3 4 5 as id, 0.1 0.2 0.3 0.4 0.5 as value);\nleftTable.append!(t);\nt = table(1 2 3 4 5 as id, 0.1 0.2 0.3 0.4 0.5 as value)\nrightTable.append!(t)\n// 查询该流式 SQL 的元信息\ngetStreamingSQLSubscriptionInfo(queryId)\n/*\noutput:\nleadingRecordInsertTime->2026.01.29T17:42:08.297\nlastRecordInsertTime->2026.01.29T17:42:08.297\nlastUpdateTime->2026.01.29T17:42:08.297\n*/\n```\n"
    },
    "getStreamingStat": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getStreamingStat.html",
        "signatures": [
            {
                "full": "getStreamingStat([stat])",
                "name": "getStreamingStat",
                "parameters": [
                    {
                        "full": "[stat]",
                        "name": "stat",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [getStreamingStat](https://docs.dolphindb.cn/zh/funcs/g/getStreamingStat.html)\n\n\n\n#### 语法\n\ngetStreamingStat(\\[stat])\n\n#### 详情\n\n监控流计算任务的运行状态。\n\n#### 参数\n\n**stat** 可选参数，字符串标量或向量，用于指定需要返回的状态表名。可选值包括：pubConns, subConns, pubTables, persistWorkers, subWorkers, udpPubTables。\n\n#### 返回值\n\n* 如果 *stat* 指定了单个表名，则返回对应的状态表。\n\n* 如果 *stat* 指定了多个表名，或未指定 *stat*，返回包含状态表的字典。\n\n状态表包括：\n\n* 表 pubConns 监控本地发布节点和它的所有订阅节点之间的连接状态。每一行表示一个订阅节点。它包含以下列：\n\n  | 列名              | 含义              |\n  | --------------- | --------------- |\n  | client          | 订阅节点的 IP 地址和端口号 |\n  | queueDepthLimit | 发布节点上的消息队列深度的上限 |\n  | queueDepth      | 发布节点上的当前消息队列深度  |\n  | tables          | 发布节点上所有的共享流数据表  |\n\n* 表 subConns 监控本地订阅节点和发布节点之间的连接状态。每一行表示一个发布节点。它包含以下列：\n\n  | 列名             | 含义            |\n  | -------------- | ------------- |\n  | publisher      | 发布节点的别名       |\n  | cumMsgCount    | 已经接收到的消息数量    |\n  | cumMsgLatency  | 所有已接收的消息的平均延迟 |\n  | LastMsgLatency | 最后接收到的消息的延迟   |\n  | lastUpdate     | 最后接收到消息的时间    |\n\n* 表 pubTables 监控流数据表状态。每一行表示一个流数据表的信息。它包含以下列：\n\n  | 列名         | 含义                   |\n  | ---------- | -------------------- |\n  | tableName  | 发布的流数据表名             |\n  | subscriber | 订阅端的 ip 和端口信息        |\n  | msgOffset  | 已经发布的最后一条数据在总数据中的偏移量 |\n  | actions    | 订阅任务的名称              |\n\n  上表中的延迟表示从消息到达发布节点的消息队列开始，到消息到达订阅节点的消息队列所耗费的时间。\n\n* 表 persistWorkers 监控负责持久化流数据表的工作线程的状态。它包含以下列：\n\n  | 列名              | 含义            |\n  | --------------- | ------------- |\n  | workerId        | 线程 ID         |\n  | queueDepthLimit | 持久化的消息队列深度的上限 |\n  | queueDepth      | 持久化的当前消息队列深度  |\n  | tables          | 已经持久化的流数据表    |\n\n* 表 subWorkers 监控订阅节点的工作线程的状态。工作线程状态信息会按照 topic 来展示。它包含以下列：\n\n  | 列名                  | 含义                                                            |\n  | ------------------- | ------------------------------------------------------------- |\n  | workerId            | 线程 ID。若此列为空，代表该订阅尚未收到数据。                                      |\n  | topic               | 订阅主题                                                          |\n  | type                | 当前订阅节点的订阅方式：UDP 组播订阅（udp）或 TCP 订阅（tcp）                        |\n  | queueDepthLimit     | 订阅节点上的消息队列深度的上限                                               |\n  | queueDepth          | 订阅节点上的当前消息队列深度                                                |\n  | processedMsgCount   | 已经处理的消息数                                                      |\n  | lastMsgId           | 最后一条消息的 ID                                                    |\n  | failedMsgCount      | 处理失败的消息数                                                      |\n  | lastFailedMsgId     | 最后一条错误消息的 ID                                                  |\n  | lastFailedTimestamp | 最后一条错误消息发生的时间                                                 |\n  | lastErrMsg          | 最后一条错误消息的信息                                                   |\n  | msgAsTable          | 布尔值，表示订阅的数据是否为表。true 表示订阅的数据为表；false 表示订阅的数据是由列组成的元组。         |\n  | batchSize           | handler 批量处理的消息数                                              |\n  | throttle            | 数值类型，单位为毫秒。表示继上次 handler 处理消息之后，若 batchSize 条件一直未达到，多久后再次处理消息 |\n  | hash                | 非负整数，指定某个订阅线程处理进来的消息                                          |\n  | filter              | 流数据表指定的过滤列                                                    |\n  | persistOffset       | 布尔值，表示是否持久化保存最新一条已经处理的订阅数据的偏移量                                |\n  | timeTrigger         | 布尔值，若为 true，表示即使没有新的消息进入，handler 也会在 throttle 参数所设定的时间间隔被触发   |\n  | handlerNeedMsgId    | 布尔值，默认值为 false。若为 true，handler 必须支持两个参数：msgBody，msgId         |\n  | raftGroup           | 高可用下 Raft 组的 ID                                               |\n\n* 表 udpPubTables 用于监控流数据表进行 UDP 组播发布的状态。它包含以下列：\n\n  | 列名        | 含义                   |\n  | --------- | -------------------- |\n  | tableName | 发布的流数据表名             |\n  | channel   | 发布的 UDP 组播地址         |\n  | msgOffset | 已经发布的最后一条数据在总数据中的偏移量 |\n  | actions   | 订阅该发布表的所有订阅任务名称      |\n  | subNum    | 订阅该发布表的所有订阅数量        |\n\n* 表 CEPEngine 用于监控 CEP 引擎的状态。它包含以下列：\n\n  | 列名                  | 含义              |\n  | ------------------- | --------------- |\n  | name                | CEP 引擎名称        |\n  | user                | 创建 CEP 引擎的用户名   |\n  | status              | CEP 引擎状态        |\n  | lastErrorMessage    | 最后一条错误信息        |\n  | lastErrorTimestamp  | 最后一次错误信息的时间戳    |\n  | useSystemTime       | 是否使用系统时间        |\n  | numOfSubEngine      | 当前子引擎数量         |\n  | queueDepth          | 队列深度            |\n  | eventsReceived      | 从外部收到的事件数量      |\n  | eventsEmitted       | 向外发送的事件数量       |\n  | eventsOnOutputQueue | 向外发送的事件队列中的事件数量 |\n\n#### 例子\n\n```\ngetStreamingStat().pubConns;\ngetStreamingStat().subConns;\ngetStreamingStat().pubTables;\ngetStreamingStat().persistWorkers;\ngetStreamingStat().subWorkers;\ngetStreamingStat\\(\\).udpPubTables\n```\n"
    },
    "getStreamTableCacheOffset": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getstreamtablecacheoffset.html",
        "signatures": [
            {
                "full": "getStreamTableCacheOffset(streamTable)",
                "name": "getStreamTableCacheOffset",
                "parameters": [
                    {
                        "full": "streamTable",
                        "name": "streamTable"
                    }
                ]
            }
        ],
        "markdown": "### [getStreamTableCacheOffset](https://docs.dolphindb.cn/zh/funcs/g/getstreamtablecacheoffset.html)\n\n\n\n#### 语法\n\ngetStreamTableCacheOffset(streamTable)\n\n#### 详情\n\n查看指定的流表在内存中的最旧的记录相较于流表已写入的总记录数的偏移量（offset），即总记录数减去内存中数据行的值。\n\n#### 参数\n\n**streamTable** 是一个自动清理的非持久化流表，即由 `enableTableShareAndCachePurge` 创建的流表，或由 `enableTableCachePurge` 设置后的流表。\n\n#### 返回值\n\n整型标量。\n\n#### 例子\n\n```\nt = streamTable(1000:0, `time`sym`volume, [DATETIME, SYMBOL, INT])\nenableTableShareAndCachePurge(table=t, tableName=`st, cachePurgeTimeColumn=`time,\n cachePurgeInterval=30m, cacheRetentionTime=20m)\n\ntime = datetime(2024.01.01T09:00:00) +1..1000*2\nsym=take(`a`b`c, 1000)\nvolume = rand(10,1000)\n\ninsert into t values([time, sym, volume])\ngetStreamTableCacheOffset(t)\n//0\n\ntime = datetime(2024.01.01T09:35:00) +1..1000*2\nsym=take(`a`b`c, 1000)\nvolume = rand(10,1000)\ninsert into t values([time, sym, volume])\ngetStreamTableCacheOffset(t)\n//999\n```\n"
    },
    "getStreamTableChangelog": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getStreamTableChangelog.html",
        "signatures": [
            {
                "full": "getStreamTableChangelog(streamTable)",
                "name": "getStreamTableChangelog",
                "parameters": [
                    {
                        "full": "streamTable",
                        "name": "streamTable"
                    }
                ]
            }
        ],
        "markdown": "### [getStreamTableChangelog](https://docs.dolphindb.cn/zh/funcs/g/getStreamTableChangelog.html)\n\n首发版本：3.00.5\n\n\n\n#### 语法\n\ngetStreamTableChangelog(streamTable)\n\n#### 详情\n\n返回带状态标识的流表。\n\n#### 参数\n\n**streamTable** 是流数据表。\n\n#### 返回值\n\n一个表。\n\n#### 例子\n\n```\ngetStreamTableChangelog(tickStream)\n```\n\n|   | changelog\\_type | sym       | time                | price              |\n| - | --------------- | --------- | ------------------- | ------------------ |\n| 0 | N               | 000001.SH | 2021.02.08 09:30:01 | 14.666441912917989 |\n| 1 | N               | 000001.SH | 2021.02.08 09:30:02 | 105.60469803298001 |\n| 2 | U               | 000001.SH | 2021.02.08 09:30:01 | 89.723076797026    |\n| 3 | U               | 000001.SH | 2021.02.08 09:30:02 | 69.34098429496888  |\n\n**相关函数**：[changelogStreamTable](https://docs.dolphindb.cn/zh/funcs/c/changelogStreamTable.html)\n"
    },
    "getStreamTableFilterColumn": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getStreamTableFilterColumn.html",
        "signatures": [
            {
                "full": "getStreamTableFilterColumn(streamTable)",
                "name": "getStreamTableFilterColumn",
                "parameters": [
                    {
                        "full": "streamTable",
                        "name": "streamTable"
                    }
                ]
            }
        ],
        "markdown": "### [getStreamTableFilterColumn](https://docs.dolphindb.cn/zh/funcs/g/getStreamTableFilterColumn.html)\n\n\n\n#### 语法\n\ngetStreamTableFilterColumn(streamTable)\n\n#### 详情\n\n返回由函数 [setStreamTableFilterColumn](https://docs.dolphindb.cn/zh/funcs/s/setStreamTableFilterColumn.html) 指定的流数据表中过滤列的名称。\n\n#### 参数\n\n**streamTable** 是流数据表。\n\n#### 返回值\n\n字符串标量。\n\n#### 例子\n\n```\nshare streamTable(10000:0,`time`symbol`price, [TIMESTAMP,SYMBOL,INT]) as trades\nsetStreamTableFilterColumn(trades, `symbol)\ntrades_1=table(10000:0,`time`symbol`price, [TIMESTAMP,SYMBOL,INT])\nfilter=symbol(`IBM`GOOG)\nsubscribeTable(tableName=`trades, actionName=`trades_1, handler=append!{trades_1}, msgAsTable=true, filter=filter);\n\nn=100\ntime=take(2018.01.01T09:30:00.000,n)\nsymbol=take((`IBM`GOOG`AAPL`C`BABA),n)\nprice=1..n\n\nt=table(time,symbol,price)\ntrades.append!(t)\n\n// 获取流数据表trades由setStreamTableFilterColumn函数指定的过滤列名\ngetStreamTableFilterColumn(trades) ;\n// output: symbol\n```\n"
    },
    "getStreamTables": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getstreamtables.html",
        "signatures": [
            {
                "full": "getStreamTables([option=0])",
                "name": "getStreamTables",
                "parameters": [
                    {
                        "full": "[option=0]",
                        "name": "option",
                        "optional": true,
                        "default": "0"
                    }
                ]
            }
        ],
        "markdown": "### [getStreamTables](https://docs.dolphindb.cn/zh/funcs/g/getstreamtables.html)\n\n#### 语法\n\ngetStreamTables(\\[option=0])\n\n#### 详情\n\n获取流数据表的信息。\n\n#### 参数\n\n**option** 整型标量，表示需要获取的流表的类型。可取以下值：\n\n* 0：获取所有流表\n* 1：获取持久化流表\n* 2：获取非持久化流表\n\n#### 返回值\n\n返回一个表，包含如下列：\n\n* name：表的名称。\n* shared：是否为共享表。\n* persisted：是否为持久化表。\n* cachePurgeEnabled：是否为定时清理的非持久化流表。\n* loaded：是否已加载到内存。\n* columns：表所包含的列数。\n* rowsInMemory：内存中的行数。\n* totalRows：写入流表的总行数。\n* memoryUsed：表所占用的内存大小，单位为字节。\n\n**Note:** 若持久化表没被加载到内存时，则只返回 name, persisted 和 loaded 字段，其它字段返回 NULL。\n\n#### 例子\n\n```\nid=`XOM`GS`AAPL;\nx=102.1 33.4 73.6;\n\nrt=streamTable(id, x);\nshare streamTable(10:0,`time`sym`price`volume,[TIMESTAMP,SYMBOL,DOUBLE,INT]) as trades1;\nshare streamTable(10:0,`time`sym`price`volume,[TIMESTAMP,SYMBOL,DOUBLE,INT]) as trades2;\n\ngetStreamTables()\n```\n\n| name    | shared | persisted | cachePurgeEnabled | loaded | columns | rowsInMemory | totalRows | memoryUsed |\n| ------- | ------ | --------- | ----------------- | ------ | ------- | ------------ | --------- | ---------- |\n| rt      | false  | false     | false             | true   | 2       | 3            | 3         | 152        |\n| trades1 | true   | false     | false             | true   | 4       | 0            | 0         | 240        |\n| trades2 | true   | false     | false             | true   | 4       | 0            | 0         | 240        |\n\n"
    },
    "getSubscriptionTopic": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getSubscriptionTopic.html",
        "signatures": [
            {
                "full": "getSubscriptionTopic(tableName, [actionName])",
                "name": "getSubscriptionTopic",
                "parameters": [
                    {
                        "full": "tableName",
                        "name": "tableName"
                    },
                    {
                        "full": "[actionName]",
                        "name": "actionName",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [getSubscriptionTopic](https://docs.dolphindb.cn/zh/funcs/g/getSubscriptionTopic.html)\n\n\n\n#### 语法\n\ngetSubscriptionTopic(tableName, \\[actionName])\n\n#### 详情\n\n查询订阅主题的名称和流数据表的列名。\n\n订阅主题名称是流数据表所在节点的局域网信息（包括内网 IP 地址、端口号和节点别名）、流数据表的名称和订阅任务名称（如果指定了actionName）的组合，它们之间使用\"/\"分隔。例如，如果服务器的局域网信息为是 \"localhost:8848:nodeA\"，流数据表的名称是 \"trades\"，那么主题名称是 \"localhost:8848:nodeA/trades\"；如果订阅任务名称是 \"vwap\"，那么主题名称是 \"localhost:8848:nodeA/trades/vwap\"。\n\n#### 参数\n\n**tableName** 是一个字符串，表示共享的流数据表的名称。\n\n**actionName** 是一个字符串，表示订阅任务的名称。它可以包含字母，数字和下划线。\n\n#### 返回值\n\n返回具有两个元素的元组：分别是订阅主题的名称和流数据表的列名。\n\n#### 例子\n\n在别名为 rh8502 的节点上执行以下脚本，该节点的内网 IP 为192.168.1.135，端口号为8502：\n\n```\nt=streamTable(1000000:0,`date`time`sym`qty`price`exch,[DATE,TIME,SYMBOL,INT,DOUBLE,SYMBOL])\nshare t as trades\ntrades_1=streamTable(1000000:0,`date`time`sym`qty`price`exch,[DATE,TIME,SYMBOL,INT,DOUBLE,SYMBOL])\nsubscribeTable(tableName=`trades, actionName=`vwap, offset=-1, handler=append!{trades_1})\ngetSubscriptionTopic(`trades,`vwap);\n\n// output\n(\"192.168.1.135:8502/rh8502/trades/vwap\",[\"date\",\"time\",\"sym\",\"qty\",\"price\",\"exch\"])\n```\n"
    },
    "getSupportBundle": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getSupportBundle.html",
        "signatures": [
            {
                "full": "getSupportBundle([dir])",
                "name": "getSupportBundle",
                "parameters": [
                    {
                        "full": "[dir]",
                        "name": "dir",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [getSupportBundle](https://docs.dolphindb.cn/zh/funcs/g/getSupportBundle.html)\n\n\n\n#### 语法\n\ngetSupportBundle(\\[dir])\n\n#### 详情\n\n生成一个包含所有配置信息的文件，并返回文件路径。该函数只能在数据节点/计算节点调用。\n\n配置文件包含以下信息：\n\n| 模块名                                           | 含义                                                     | 信息来源                                                                                    |\n| :-------------------------------------------- | :----------------------------------------------------- | :-------------------------------------------------------------------------------------- |\n| VERSION                                       | server 的版本信息。                                          | version()                                                                               |\n| CONFIGS                                       | 配置信息。单机环境下，返回单节点的配置信息；集群环境下，包含集群、控制节点、 和数据节点/计算节点的配置。  | 单机: dolphindb.cfg 集群: cluster.cfg, cluster.nodes, controller.cfg                        |\n| DB AND TABLE SCHEMA                           | 所有数据库和表的结构。                                            | schema                                                                                  |\n| LICENSE AND MACHINE INFO                      | license、机器核数和内存信息。 节点绑定的 CPU 内核绑定和端口信息。                | 许可证: dolphindb.lic                                                                      |\n| OLAP CACHE ENGINE STATUS                      | OLAP 引擎 cache Engine 的状态信息，包含各节点的内存信息以及当前节点的状态表。       | pnodeRun(getOLAPCacheEngineSize) pnodeRun(getOLAPCacheEngineStat)                       |\n| TSDB META                                     | TSDB 引擎下所有 chunk 的元数据。                                 | pnodeRun(getTSDBMetaData)                                                               |\n| REDO LOG GC STATUS                            | 事务 redo log 回收的状态。                                     | pnodeRun(getRedoLogGCStat)                                                              |\n| TRANSACTION STATUS                            | 事务的状态。                                                 | pnodeRun(getTransactionStatus)                                                          |\n| TABLETS META                                  | 集群中行数最多的前100个 chunk 的元数据信息。                            | select top 100 \\* from pnodeRun(getTable tsMeta{“%”,”%”,false,-1}) order by rowNum desc |\n| ANOMALOUS CHUNK STATUS (only in cluster mode) | 处于异常状态的 chunk 信息。异常状态包含处于 recovery 状态，版本号不一致， 副本数不一致等。 | getClusterChunksStatus()                                                                |\n\n#### 参数\n\n**dir** 可选参数，用于指定存储路径。若不指定该参数，单节点环境下默认存储至 \\<HomeDir>（可通过 [getHomeDir](https://docs.dolphindb.cn/zh/funcs/g/getHomeDir.html) 查看 \\<HomeDir>）；集群环境下默认存储至 \\<HomeDir> 同级目录。\n\n#### 返回值\n\n字符串标量。\n\n#### 例子\n\n```\ngetSupportBundle()\n// output\n/home/dolphindb/server/getSupportBundle.1655869793424\n\ngetSupportBundle(\"/home/dolphindb/sup\")\n// output\n/home/dolphindb/sup/getSupportBundle.1655869853178\n```\n"
    },
    "getSystemCpuUsage": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getSystemCpuUsage.html",
        "signatures": [
            {
                "full": "getSystemCpuUsage()",
                "name": "getSystemCpuUsage",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getSystemCpuUsage](https://docs.dolphindb.cn/zh/funcs/g/getSystemCpuUsage.html)\n\n\n\n#### 语法\n\ngetSystemCpuUsage()\n\n#### 详情\n\n返回当前节点上 DolphinDB 进程实时占用 CPU 的百分比。\n\n注意，若 DolphinDB 进程占用多个 CPU，则返回各个 CPU 占用率的总和。\n\n#### 参数\n\n无\n\n#### 返回值\n\nDOUBLE 标量。\n\n#### 例子\n\n```\ngetSystemCpuUsage();\n\n// output: 1.771654\n```\n"
    },
    "getSystemLoadAvg": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getSystemLoadAvg.html",
        "signatures": [
            {
                "full": "getSystemLoadAvg()",
                "name": "getSystemLoadAvg",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getSystemLoadAvg](https://docs.dolphindb.cn/zh/funcs/g/getSystemLoadAvg.html)\n\n\n\n#### 语法\n\ngetSystemLoadAvg()\n\n#### 详情\n\n返回实时系统平均负载。使用该函数前，需要启动性能监控，即在配置文件中把 *perfMonitoring* 设为1。\n\n#### 返回值\n\nDOUBLE 类型标量。\n\n#### 例子\n\n```\ngetSystemLoadAvg();\n\n// output: 5.664062\n```\n"
    },
    "getTableAccess": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/gettableaccess.html",
        "signatures": [
            {
                "full": "getTableAccess(dbUrl, table)",
                "name": "getTableAccess",
                "parameters": [
                    {
                        "full": "dbUrl",
                        "name": "dbUrl"
                    },
                    {
                        "full": "table",
                        "name": "table"
                    }
                ]
            }
        ],
        "markdown": "### [getTableAccess](https://docs.dolphindb.cn/zh/funcs/g/gettableaccess.html)\n\n\n\n#### 语法\n\ngetTableAccess(dbUrl, table)\n\n#### 详情\n\n查看哪些用户和组具有与分布式数据表 *dbUrl/table* 相关（包括 ALLOW 和 DENY 权限状态）的权限。\n\n该函数仅限 admin 和对数据库 *dbUrl* 具有 DB\\_OWNER 或 DB\\_MANAGE 权限的用户调用。\n\n#### 参数\n\n**dbUrl** 字符串标量，表示分布式数据库的地址。\n\n**table** 字符串标量，表示分布式表的表名。\n\n#### 返回值\n\n返回一个表：\n\n* name 具有相关权限的对象的名称。\n* type 该对象的类型，可选值为 user 和 group，分别对应用户和组。\n* TABLE\\_READ, TABLE\\_INSERT, TABLE\\_UPDATE, TABLE\\_DELETE 分别指代对应权限，权限状态包括 ALLOW, DENY, NONE。关于用户权限的更多信息可参考[用户权限管理](https://docs.dolphindb.cn/zh/tutorials/ACL_and_Security.html)。\n\n#### 例子\n\n具有 DB\\_OWNER 权限的用户 user1 创建了分布式表 `dfs://testDB/pt`，并为用户 user2 授予 TABLE\\_READ 权限，禁止用户 user3 的 TABLE\\_INSERT 权限，为组 group1 授予 TABLE\\_DELETE 权限。此时，用户 user1 可通过 `getTableAccess` 函数查看哪些用户具有 \"dfs\\://testDB/pt\" 相关的权限。\n\n```\nlogin(`user1, `123456)\ngetTableAccess(\"dfs://testDB\", \"pt\")\n```\n\n| name   | type  | TABLE\\_READ | TABLE\\_INSERT | TABLE\\_UPDATE | TABLE\\_DELETE |\n| ------ | ----- | ----------- | ------------- | ------------- | ------------- |\n| group1 | group | NONE        | NONE          | NONE          | ALLOW         |\n| user3  | user  | NONE        | DENY          | NONE          | NONE          |\n| user2  | user  | ALLOW       | NONE          | NONE          | NONE          |\n| admin  | user  | ALLOW       | ALLOW         | ALLOW         | ALLOW         |\n\n**Related information**\n\n[getDBAccess](https://docs.dolphindb.cn/zh/funcs/g/getDBAccess.html)\n"
    },
    "getTableAccessByCluster": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getTableAccessByCluster.html",
        "signatures": [
            {
                "full": "getTableAccessByCluster(table)",
                "name": "getTableAccessByCluster",
                "parameters": [
                    {
                        "full": "table",
                        "name": "table"
                    }
                ]
            }
        ],
        "markdown": "### [getTableAccessByCluster](https://docs.dolphindb.cn/zh/funcs/g/getTableAccessByCluster.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\ngetTableAccessByCluster(table)\n\n#### 详情\n\n获取指定表的所有用户权限。只能由管理员在 MoM（Master of Master，管理集群）上执行该函数。\n\n#### 参数\n\n**table** 字符串标量，表示一个表，形如：`{catalog}.{schema}.{pt}@{cluster}`。\n\n#### 返回值\n\n一个表，字段与 `getTableAccess` 函数的返回结果一致。\n\n#### 例子\n\n```\ngetTableAccessByCluster(\"catalog1.schema1.dt@MoMSender\")\n```\n\n| name  | type | TABLE\\_READ | TABLE\\_INSERT | TABLE\\_UPDATE | TABLE\\_DELETE |\n| ----- | ---- | ----------- | ------------- | ------------- | ------------- |\n| admin | user | ALLOW       | ALLOW         | ALLOW         | ALLOW         |\n\n相关函数：[getTableAccess](https://docs.dolphindb.cn/zh/funcs/g/gettableaccess.html)\n"
    },
    "getTables": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getTables.html",
        "signatures": [
            {
                "full": "getTables(dbHandle)",
                "name": "getTables",
                "parameters": [
                    {
                        "full": "dbHandle",
                        "name": "dbHandle"
                    }
                ]
            }
        ],
        "markdown": "### [getTables](https://docs.dolphindb.cn/zh/funcs/g/getTables.html)\n\n\n\n#### 语法\n\ngetTables(dbHandle)\n\n#### 详情\n\n查询指定数据库中的表：\n\n* 管理员可以返回所有分布式表；\n\n* 其他用户执行时仅返回：\n\n  （1）拥有 DB\\_OWNER, DB\\_MANAGE, DB\\_READ, DB\\_WRITE, DB\\_INSERT, DB\\_UPDATE, DB\\_DELETE 权限的数据库所对应的分布式表；\n\n  （2）拥有 TABLE\\_READ, TABLE\\_WRITE, TABLE\\_INSERT, TABLE\\_UPDATE, TABLE\\_DELETE 权限的分布式表。\n\n#### 参数\n\n**dbHandle** 是数据库句柄。\n\n#### 返回值\n\n字符串向量。\n\n#### 例子\n\n```\nn=1000000\nID=rand(10, n)\ndates=2017.08.07..2017.08.11\ndate=rand(dates, n)\nx=rand(10.0, n)\ny=rand(10, n)\nt1=table(ID, date, x)\nt2=table(ID, date, y)\ndb = database(\"dfs://valueDB\", VALUE, 2017.08.07..2017.08.11)\npt1 = db.createPartitionedTable(t1, `pt1, `date)\npt1.append!(t1)\npt2 = db.createPartitionedTable(t2, `pt2, `date)\npt2.append!(t2);\ngetTables(db);\n```\n\n输出返回：\\[\"pt1\",\"pt2\"]\n"
    },
    "getTablesByCluster": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getTablesByCluster.html",
        "signatures": [
            {
                "full": "getTablesByCluster(clusterName, dbUrl)",
                "name": "getTablesByCluster",
                "parameters": [
                    {
                        "full": "clusterName",
                        "name": "clusterName"
                    },
                    {
                        "full": "dbUrl",
                        "name": "dbUrl"
                    }
                ]
            }
        ],
        "markdown": "### [getTablesByCluster](https://docs.dolphindb.cn/zh/funcs/g/getTablesByCluster.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\ngetTablesByCluster(clusterName, dbUrl)\n\n#### 详情\n\n获取集群指定数据库下的所有表。只能由管理员在 MoM（Master of Master，管理集群）上执行该函数。\n\n#### 参数\n\n**clusterName** 字符串标量，表示要查询的集群名称。\n\n**dbUrl** 字符串标量，表示要查询的数据库路径。\n\n#### 返回值\n\n字符串向量。\n\n#### 例子\n\n```\n// MoMSender 集群数据节点:\ndb = database(directory=\"dfs://db1\", partitionType=RANGE, partitionScheme=0 5 10)\ntimestamp = [09:34:07,09:36:42,09:36:51,09:36:59,09:32:47,09:35:26,09:34:16,09:34:26,09:38:12]\nsym = `C`MS`MS`MS`IBM`IBM`C`C`C\nprice= 49.6 29.46 29.52 30.02 174.97 175.23 50.76 50.32 51.29\nqty = 2200 1900 2100 3200 6800 5400 1300 2500 8800\nt = table(timestamp, sym, qty, price);\ndt=db.createDimensionTable(t,`dt).append!(t);\n   \n// MoM 集群:\ngetTablesByCluster(\"MoMSender\", \"dfs://db1\")\n// Output:  [\"dt\"]\n```\n"
    },
    "getTableSchemaByCluster": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getTableSchemaByCluster.html",
        "signatures": [
            {
                "full": "getTableSchemaByCluster(clusterName, dbUrl, table)",
                "name": "getTableSchemaByCluster",
                "parameters": [
                    {
                        "full": "clusterName",
                        "name": "clusterName"
                    },
                    {
                        "full": "dbUrl",
                        "name": "dbUrl"
                    },
                    {
                        "full": "table",
                        "name": "table"
                    }
                ]
            }
        ],
        "markdown": "### [getTableSchemaByCluster](https://docs.dolphindb.cn/zh/funcs/g/getTableSchemaByCluster.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\ngetTableSchemaByCluster(clusterName, dbUrl, table)\n\n#### 详情\n\n获取指定表的 schema。只能由管理员在 MoM（Master of Master，管理集群）上执行该函数。\n\n#### 参数\n\n**clusterName** 字符串标量，表示要查询的集群名称。\n\n**dburl** 字符串标量，表示要查询的数据库路径。\n\n**table** 字符串标量，表示要查询的表名。\n\n#### 返回值\n\n一个字典，与 `schema(table)` 的结果相同。\n\n#### 例子\n\n```\ngetTableSchemaByCluster(\"MoMSender\", \"dfs://db1\", \"dt\")\n  \n/* Output:\n  colDefs->name      typeString typeInt extra comment\n  --------- ---------- ------- ----- -------\ntimestamp SECOND     10                   \n  sym       STRING     18                   \n  qty       INT        4                    \n  price     DOUBLE     16                   \n  chunkPath->\n  partitionColumnIndex->-1\n  \n*/\n```\n\n相关函数：[schema](https://docs.dolphindb.cn/zh/funcs/s/schema.html)\n"
    },
    "getTablesOfAllClusters": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getTablesOfAllClusters.html",
        "signatures": [
            {
                "full": "getTablesOfAllClusters()",
                "name": "getTablesOfAllClusters",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getTablesOfAllClusters](https://docs.dolphindb.cn/zh/funcs/g/getTablesOfAllClusters.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\ngetTablesOfAllClusters()\n\n#### 详情\n\n与 `getClusterDFSTables` 函数类似，但此函数能够获取当前用户在多个集群中拥有访问权限的所有表。\n\n#### 参数\n\n无\n\n#### 返回值\n\n字符串向量。\n\n#### 例子\n\n```\ngetTablesOfAllClusters()\n// Output:   [\"dfs://testDB/pt1\", \"trading.schema.pt@cluster3\"]\n```\n"
    },
    "getTablet": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getTablet.html",
        "signatures": [
            {
                "full": "getTablet(table, partition)",
                "name": "getTablet",
                "parameters": [
                    {
                        "full": "table",
                        "name": "table"
                    },
                    {
                        "full": "partition",
                        "name": "partition"
                    }
                ]
            }
        ],
        "markdown": "### [getTablet](https://docs.dolphindb.cn/zh/funcs/g/getTablet.html)\n\n\n\n#### 语法\n\ngetTablet(table, partition)\n\n#### 详情\n\n查询内存分区表指定分区的子表。\n\n#### 参数\n\n**table** 是一个内存分区表。\n\n**partition** 是一个标量或向量，代表分区。若 *partition* 中某元素属于某个分区的分区列，此元素代表该分区。\n\n#### 返回值\n\n* 如果 *partition* 是标量，返回一个表。\n\n* 如果 *partition* 是向量，返回一个元组，其中每个元素是一个表。\n\n#### 例子\n\n```\ndb=database(partitionType=RANGE, partitionScheme=2012.06.01 2012.06.10 2012.06.20 2012.07.01)\nn=30\nt=table(take(2012.06.01..2012.06.30, n) as date, n..1 as val)\npt=db.createPartitionedTable(table=t, tableName=`pt, partitionColumns=`date).append!(t);\n\ngetTablet(pt, 2012.06.05);\n```\n\n| date       | val |\n| ---------- | --- |\n| 2012.06.01 | 30  |\n| 2012.06.02 | 29  |\n| 2012.06.03 | 28  |\n| 2012.06.04 | 27  |\n| 2012.06.05 | 26  |\n| 2012.06.06 | 25  |\n| 2012.06.07 | 24  |\n| 2012.06.08 | 23  |\n| 2012.06.09 | 22  |\n\n```\nresult=getTablet(pt, 2012.06.22 2012.06.11);\nresult.size();\n\n// output\n2\n\nresult[0];\n```\n\n| date       | val |\n| ---------- | --- |\n| 2012.06.20 | 11  |\n| 2012.06.21 | 10  |\n| 2012.06.22 | 9   |\n| 2012.06.23 | 8   |\n| 2012.06.24 | 7   |\n| 2012.06.25 | 6   |\n| 2012.06.26 | 5   |\n| 2012.06.27 | 4   |\n| 2012.06.28 | 3   |\n| 2012.06.29 | 2   |\n| 2012.06.30 | 1   |\n"
    },
    "getTabletsMeta": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getTabletsMeta.html",
        "signatures": [
            {
                "full": "getTabletsMeta([chunkPath], [tableName], [diskUsage=false], [top=1024])",
                "name": "getTabletsMeta",
                "parameters": [
                    {
                        "full": "[chunkPath]",
                        "name": "chunkPath",
                        "optional": true
                    },
                    {
                        "full": "[tableName]",
                        "name": "tableName",
                        "optional": true
                    },
                    {
                        "full": "[diskUsage=false]",
                        "name": "diskUsage",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[top=1024]",
                        "name": "top",
                        "optional": true,
                        "default": "1024"
                    }
                ]
            }
        ],
        "markdown": "### [getTabletsMeta](https://docs.dolphindb.cn/zh/funcs/g/getTabletsMeta.html)\n\n\n\n#### 语法\n\ngetTabletsMeta(\\[chunkPath], \\[tableName], \\[diskUsage=false], \\[top=1024])\n\n#### 详情\n\n查询当前节点上指定数据表 chunk 的元数据信息。若结合 [pnodeRun](https://docs.dolphindb.cn/zh/funcs/p/pnodeRun.html) 函数使用，可返回所有节点上指定数据表的元数据信息。\n\n**Note:** 该函数不会返回记录条数为 0 的 chunk。如需查看，可使用[getClusterChunksStatus](https://docs.dolphindb.cn/zh/funcs/g/getClusterChunksStatus.html)。\n\n#### 参数\n\n**chunkPath** 是一个或多个 chunk 的 DFS 路径，支持使用通配符“\\*” ，“？”以及“ %”。“\\*” 表示匹配任意数量的任意字符，“?”表示匹配单个字符，“%”表示匹配 0，1 或多个字符。\n\n**tableName** 是字符串，表示数据表名。\n\n**diskUsage** 是一个 Boolean 值，表示结果是否输出磁盘占用。\n\n**top** 是一个正整数，表示结果中返回的 chunk 的个数上限。默认值为1024。若不设上限，需将 *top* 参数设为-1。\n\n#### 返回值\n\n返回一个表，包含以下列：\n\n* chunkId：chunk的唯一标识\n\n* path：分区的物理路径\n\n* dfsPath：分区DFS路径\n\n* tableName：表名\n\n* version：版本号\n\n* rowNum：分区的记录条数\n\n* createCids：update/delete表时创建的版本号\n\n* latestPhysicalDir：最新版本号（cid）对应的存储数据的临时物理路径\n\n* diskUsage：分区占用的磁盘空间，单位为字节。\n\n#### 例子\n\n```\nif(existsDatabase(\"dfs://testDB\")){\n   dropDatabase(\"dfs://testDB\")\n}\ndb=database(\"dfs://testDB\", VALUE, 1..10)\nn=1000000\nt=table(rand(1..10, n) as id, rand(100.0, n) as x)\ndb.createPartitionedTable(t, `pt1, `id).append!(t)\nn=2000000\nt=table(rand(1..10, n) as id, rand(100.0, n) as x, rand(100, n) as y)\ndb.createPartitionedTable(t, `pt2, `id).append!(t)\ngetTabletsMeta(\"/testDB/%\", `pt1, true);\n```\n\n| chunkId                              | path              | dfsPath      | tableName | version | rowNum | createCids | latestPhysicalDir | diskUsage |\n| ------------------------------------ | ----------------- | ------------ | --------- | ------- | ------ | ---------- | ----------------- | --------- |\n| dbfd1767-f9ca-689e-4d5e-643b8506e82d | C:\\Users\\Downl... | /testDB/10/8 | pt1       | 2       | 100155 | \\[2059]    | pt1\\_2\\_2059      | 696295    |\n| d221b457-fa7b-5990-4caa-13c99f56f716 | C:\\Users\\Downl... | /testDB/9/8  | pt1       | 2       | 99703  | \\[2059]    | pt1\\_2\\_2059      | 693026    |\n| 92904d3b-0147-9bb8-4a28-f99525b250e7 | C:\\Users\\Downl... | /testDB/8/8  | pt1       | 2       | 99791  | \\[2059]    | pt1\\_2\\_2059      | 693848    |\n| 7478c15a-0629-c8ab-47ee-a1d12c3c1cd6 | C:\\Users\\Downl... | /testDB/1/8  | pt1       | 2       | 100215 | \\[2059]    | pt1\\_2\\_2059      | 696932    |\n| 8bc48c11-86ca-97ac-4ee4-8f829de92cc8 | C:\\Users\\Downl... | /testDB/5/8  | pt1       | 2       | 100156 | \\[2059]    | pt1\\_2\\_2059      | 696584    |\n| 6b3a0a09-bc64-3bab-4535-344b7316d244 | C:\\Users\\Downl... | /testDB/2/8  | pt1       | 2       | 100121 | \\[2059]    | pt1\\_2\\_2059      | 696303    |\n| a7452c44-5d2b-6f82-4150-7bc48e941d64 | C:\\Users\\Downl... | /testDB/4/8  | pt1       | 2       | 99858  | \\[2059]    | pt1\\_2\\_2059      | 696572    |\n| a1a375cc-b6c0-29b2-485a-330af7447564 | C:\\Users\\Downl... | /testDB/6/8  | pt1       | 2       | 100280 | \\[2059]    | pt1\\_2\\_2059      | 697596    |\n| b04b4c04-6d43-0d8d-4000-6ae88e349eda | C:\\Users\\Downl... | /testDB/3/8  | pt1       | 2       | 99858  | \\[2059]    | pt1\\_2\\_2059      | 694400    |\n| b20df3a7-678b-1cbe-400d-d8e566706682 | C:\\Users\\Downl... | /testDB/7/8  | pt1       | 2       | 99865  | \\[2059]    | pt1\\_2\\_2059      | 6942755   |\n"
    },
    "getTopicProcessedOffset": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getTopicProcessedOffset.html",
        "signatures": [
            {
                "full": "getTopicProcessedOffset(topic)",
                "name": "getTopicProcessedOffset",
                "parameters": [
                    {
                        "full": "topic",
                        "name": "topic"
                    }
                ]
            }
        ],
        "markdown": "### [getTopicProcessedOffset](https://docs.dolphindb.cn/zh/funcs/g/getTopicProcessedOffset.html)\n\n\n\n#### 语法\n\ngetTopicProcessedOffset(topic)\n\n#### 详情\n\n如果 `subscribeTable` 函数的 *persistOffset* 参数为 true，那么该函数返回最新一条已经处理的订阅数据的偏移量；如果 `subscribeTable` 函数的 *persistOffset* 参数为 false，那么该函数返回-1。\n\n#### 参数\n\n**topic** 是 [subscribeTable](https://docs.dolphindb.cn/zh/funcs/s/subscribeTable.html) 函数返回的订阅主题。\n\n#### 返回值\n\n整型标量。\n\n#### 例子\n\n```\nshare streamTable(1000:0, `time`sym`qty, [TIMESTAMP, SYMBOL, INT]) as trades\ntrades_1 = streamTable(1000:0, `time`sym`qty, [TIMESTAMP, SYMBOL, INT])\ntopic=subscribeTable(tableName=\"trades\", actionName=\"trades_1\", offset=0, handler=append!{trades_1}, msgAsTable=true, persistOffset=true)\ndef writeData(n){\n   timev = 2018.10.08T01:01:01.001 + timestamp(1..n)\n   symv =take(`A`B, n)\n   qtyv = take(1, n)\n   insert into trades values(timev, symv, qtyv)\n}\nwriteData(6);\nselect * from trades_1;\n```\n\n| time                    | sym | qty |\n| ----------------------- | --- | --- |\n| 2018.10.08T01:01:01.002 | A   | 1   |\n| 2018.10.08T01:01:01.003 | B   | 1   |\n| 2018.10.08T01:01:01.004 | A   | 1   |\n| 2018.10.08T01:01:01.005 | B   | 1   |\n| 2018.10.08T01:01:01.006 | A   | 1   |\n| 2018.10.08T01:01:01.007 | B   | 1   |\n\n```\ngetTopicProcessedOffset(topic);\n\n// output: 5\n```\n"
    },
    "getTradingCalendarType": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/gettradingcalendartype.html",
        "signatures": [
            {
                "full": "getTradingCalendarType(marketName)",
                "name": "getTradingCalendarType",
                "parameters": [
                    {
                        "full": "marketName",
                        "name": "marketName"
                    }
                ]
            }
        ],
        "markdown": "### [getTradingCalendarType](https://docs.dolphindb.cn/zh/funcs/g/gettradingcalendartype.html)\n\n#### 语法\n\ngetTradingCalendarType(marketName)\n\n#### 详情\n\n获取指定交易所对应的交易日历的类型。返回值是字符串标量，为 \"holidayDate\" 或 \"tradingDate\"。\n\n#### 参数\n\n**marketName** 字符串标量，表示交易日历标识，例如：国外交易所的 ISO Code、国内交易所简称或自定义交易日历名称。\n\n#### 返回值\n\n字符串标量，为 \"holidayDate\" 或 \"tradingDate\"。\n\n#### 例子\n\n运行以下命令获取交易日历类型：\n\n```\ngetTradingCalendarType(\"SZSE\")\n```\n\n返回：holidayDate\n\n\n\n**Related information**\n\n[updateMarketHoliday](https://docs.dolphindb.cn/zh/funcs/u/updateMarketHoliday.html)\n\n[getMarketCalendar](https://docs.dolphindb.cn/zh/funcs/g/getMarketCalendar.html)\n\n[addMarketHoliday](https://docs.dolphindb.cn/zh/funcs/a/addMarketHoliday.html)\n"
    },
    "getTransactionStatus": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getTransactionStatus.html",
        "signatures": [
            {
                "full": "getTransactionStatus()",
                "name": "getTransactionStatus",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getTransactionStatus](https://docs.dolphindb.cn/zh/funcs/g/getTransactionStatus.html)\n\n\n\n#### 语法\n\ngetTransactionStatus()\n\n#### 详情\n\n获取事务的状态，该函数只能在数据节点/计算节点执行。\n\n#### 参数\n\n无\n\n#### 返回值\n\n一个表，包含以下列：\n\n* tid：事务的 id。\n\n* startTime：事务开始的时间。\n\n* type：事务涉及到的操作类型，包括 APPEND, DROP, SQLUPDATE, SQLUPSERT, SQLDELETE, FILEOPERATE 和 UNKNOWN。\n\n* status：事务当前的状态，包括 BEGIN, COMMIT, COMPLETE, ROLLBACK。\n\n* partitionCount：事务涉及到的分区数量。\n\n* endTime：事务结束的时间。\n\n* elapsedTime：事务持续的时间，单位为毫秒。\n\n#### 例子\n\n```\ngetTransactionStatus()\n```\n\n| tid  | startTime               | type   | status | partitionCount | endTime                 | elapsedTime |\n| ---- | ----------------------- | ------ | ------ | -------------- | ----------------------- | ----------- |\n| 3135 | 2022.06.07 16:19:48.477 | APPEND | BEGIN  | 4              |                         | 584         |\n| 3143 | 2022.06.07 16:11:27.489 | APPEND | COMMIT | 4              | 2022.06.07 16:11:33.100 | 484         |\n"
    },
    "getTSDBCachedSymbolBaseMemSize": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getTSDBCachedSymbolBaseMemSize.html",
        "signatures": [
            {
                "full": "getTSDBCachedSymbolBaseMemSize()",
                "name": "getTSDBCachedSymbolBaseMemSize",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getTSDBCachedSymbolBaseMemSize](https://docs.dolphindb.cn/zh/funcs/g/getTSDBCachedSymbolBaseMemSize.html)\n\n\n\n#### 语法\n\ngetTSDBCachedSymbolBaseMemSize()\n\n#### 详情\n\n获取 TSDB 引擎中 SYMBOL 类型的字典编码的缓存大小，单位是字节。\n\n#### 参数\n\n无\n\n#### 返回值\n\nLONG 类型标量。\n"
    },
    "getTSDBCacheEngineSize": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getTSDBCacheEngineSize.html",
        "signatures": [
            {
                "full": "getTSDBCacheEngineSize()",
                "name": "getTSDBCacheEngineSize",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getTSDBCacheEngineSize](https://docs.dolphindb.cn/zh/funcs/g/getTSDBCacheEngineSize.html)\n\n\n\n#### 语法\n\ngetTSDBCacheEngineSize()\n\n#### 详情\n\n查询 TSDB 引擎 Cache Engine 允许使用的内存上限（单位为字节）。\n\n#### 参数\n\n无\n\n#### 返回值\n\n一个 LONG 类型数据。\n\n#### 例子\n\n```\nsetTSDBCacheEngineSize(0.5)\ngetTSDBCacheEngineSize()\n// output: 536870912\n```\n\n相关函数： [setTSDBCacheEngineSize](https://docs.dolphindb.cn/zh/funcs/s/setTSDBCacheEngineSize.html)\n"
    },
    "getTSDBCompactionTaskStatus": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getTSDBCompactionTaskStatus.html",
        "signatures": [
            {
                "full": "getTSDBCompactionTaskStatus([count])",
                "name": "getTSDBCompactionTaskStatus",
                "parameters": [
                    {
                        "full": "[count]",
                        "name": "count",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [getTSDBCompactionTaskStatus](https://docs.dolphindb.cn/zh/funcs/g/getTSDBCompactionTaskStatus.html)\n\n\n\n#### 语法\n\ngetTSDBCompactionTaskStatus(\\[count])\n\n#### 详情\n\n查询 TSDB 引擎 level file 合并操作任务的状态。该函数只能在数据节点调用。\n\n#### 参数\n\n**count** 非负整数。设置后，将返回最近的 *count* 条合并任务的记录。默认值为 0，返回每个 volume 中最新的 256 个已完成的合并任务以及所有未完成的合并任务。\n\n#### 返回值\n\n返回一个表，包含以下几列：\n\n| 列名           | 含义                                   |\n| ------------ | ------------------------------------ |\n| volume       | 发生合并的文件所在的磁盘卷路径。由配置项 *volumes* 进行配置。 |\n| level        | 当前合并的 level file 层级。                 |\n| chunkId      | 发生合并操作的 chunk 的 ID。                  |\n| tableName    | 发生合并操作的数据表的物理表名。                     |\n| files        | 参与当前合并任务的 level file。                |\n| force        | 是否由 `triggerTSDBCompaction` 强制触发。    |\n| receivedTime | 当前合并任务进入任务队列的时间戳。                    |\n| startTime    | 当前合并任务开始执行的时间戳。                      |\n| endTime      | 当前合并任务执行结束的时间戳。                      |\n| errorMessage | 报错信息。如果失败，则显示失败的原因；否则显示空。            |\n\n#### 例子\n\n```\ngetTSDBCompactionTaskStatus()\n```\n\n| volume                                                                            | level | chunkId                              | tableName | files                    | force | receivedTime            | startTime               | endTime                 | errorMessage |\n| --------------------------------------------------------------------------------- | ----- | ------------------------------------ | --------- | ------------------------ | ----- | ----------------------- | ----------------------- | ----------------------- | ------------ |\n| /home/DolphinDB/DolphinDB\\_Linux64\\_V2.00.9/server/clusterDemo/data/node1/storage | 0     | e0e00bc2-b81e-6eb9-4d01-7bb17fb39595 | pt\\_2     | 0\\_00000006,0\\_00000011, | true  | 2023.06.22T12:47:32.009 | 2023.06.22T12:47:32.010 | 2023.06.22T12:47:32.182 |              |\n| /home/DolphinDB/DolphinDB\\_Linux64\\_V2.00.9/server/clusterDemo/data/node1/storage | 1     | a9dfccad-cec1-0786-480a-9ae809481a8b | pt\\_2     | 0\\_00000003,0\\_00000007, | true  | 2023.06.22T12:47:32.010 | 2023.06.22T12:47:32.182 | 2023.06.22T12:47:32.326 |              |\n| /home/DolphinDB/DolphinDB\\_Linux64\\_V2.00.9/server/clusterDemo/data/node1/storage | 1     | 331324ce-b49f-94ac-4da8-a4bcf6c34e1c | pt\\_2     | 0\\_00000004,0\\_00000010, | true  | 2023.06.22T12:47:32.010 | 2023.06.22T12:47:32.326 | 2023.06.22T12:47:32.451 |              |\n| /home/DolphinDB/DolphinDB\\_Linux64\\_V2.00.9/server/clusterDemo/data/node1/storage | 2     | f3597e0f-6ad9-6eb6-45c8-d42adc5c50f7 | pt\\_2     | 0\\_00000002,0\\_00000008, | true  | 2023.06.22T12:47:32.010 | 2023.06.22T12:47:32.451 | 2023.06.22T12:47:32.527 |              |\n| /home/DolphinDB/DolphinDB\\_Linux64\\_V2.00.9/server/clusterDemo/data/node1/storage | 2     | d36ac640-3428-069b-4382-0b9608b94d17 | pt\\_2     | 0\\_00000005,0\\_00000009, | true  | 2023.06.22T12:47:32.010 | 2023.06.22T12:47:32.527 | 2023.06.22T12:47:32.616 |              |\n| /home/DolphinDB/DolphinDB\\_Linux64\\_V2.00.9/server/clusterDemo/data/node1/storage | 2     | e0e00bc2-b81e-6eb9-4d01-7bb17fb39595 | pt\\_2     | 0\\_00000016,0\\_00000021, | true  | 2023.06.22T12:47:33.058 | 2023.06.22T12:47:33.058 | 2023.06.22T12:47:33.151 |              |\n\n相关函数：[triggerTSDBCompaction](https://docs.dolphindb.cn/zh/funcs/t/triggerTSDBCompaction.html)\n"
    },
    "getTSDBDataStat": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/gettsdbdatastat.html",
        "signatures": [
            {
                "full": "getTSDBDataStat([dbName=\"*\"],[tableName=\"*\"],[chunkId])",
                "name": "getTSDBDataStat",
                "parameters": [
                    {
                        "full": "[dbName=\"*\"]",
                        "name": "dbName",
                        "optional": true,
                        "default": "\"*\""
                    },
                    {
                        "full": "[tableName=\"*\"]",
                        "name": "tableName",
                        "optional": true,
                        "default": "\"*\""
                    },
                    {
                        "full": "[chunkId]",
                        "name": "chunkId",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [getTSDBDataStat](https://docs.dolphindb.cn/zh/funcs/g/gettsdbdatastat.html)\n\n\n\n#### 语法\n\ngetTSDBDataStat(\\[dbName=\"\\*\"],\\[tableName=\"\\*\"],\\[chunkId])\n\n#### 详情\n\n获取当前节点上 TSDB 引擎存储的表的所有或指定 chunk 下的 Level File 和 sortKeyEntry 的数量。\n\n结合 pnodeRun 函数，可以查看一个集群内（某个）表的 Level File 和 sortKeyEntry 的数量。\n\n#### 参数\n\n**dbName** 字符串，表示数据库的名称。可以包含通配符(“\\*“, “%”和”?”)。\n\n**tableName** 字符串，表示数据表名。可以包含通配符(“\\*“, “%”和”?”)。\n\n通配符 ”\\*” 表示匹配所有，”?”表示单个字符，”%”表示0，1或多个字符。\n\n**chunkId** 字符串标量或向量，表示 chunk 的 ID。若指定该参数，则 *dbName* 和 *tableName* 必须为空或者 \\*。\n\n#### 返回值\n\n返回一个表，包含以下列：\n\n* dbName：数据库名称。\n* chunkId：chunk ID。\n* tableName：数据表名。\n* levelFileCount：每个分区内表的 Level File 的数量。\n* sortKeyEntryCount：每个分区内所有 Level File 文件里未去重的 sortKeyEntry 数量。\n\n#### 例子\n\n```\nt = table(1 2 1 1 2 2 3 as month, `Rome`Paris`London`Paris`Rome`London`Rome as city, 200 500 100 300 300 400 400 as sold)\ndb_name = \"dfs://window_function\"\nif (existsDatabase(db_name)) {\n    dropDatabase(db_name)\n}\ndb = database(db_name, HASH, [INT, 4], , 'TSDB')\n\npt = db.createPartitionedTable(t, \"pt\", \"month\", ,\"sold\")\npt.append!(t)\n\npt1 = db.createPartitionedTable(t, \"pt1\", \"month\", ,\"sold\")\npt1.append!(t)\n\nflushTSDBCache()\n```\n\n获取以 `dfs://window` 开头的数据库下所有表的 Level File 和 sortKeyEntry 的数量\n\n```\ngetTSDBDataStat(\"dfs://window%\") \n```\n\n| dbName                  | chunkId                              | tableName | levelFileCount | sortKeyEntryCount |\n| ----------------------- | ------------------------------------ | --------- | -------------- | ----------------- |\n| dfs\\://window\\_function | d334ffab-741a-dcbd-174e-42b412058877 | pt1       | 1              | 1                 |\n| dfs\\://window\\_function | c3de728c-4efb-7e8e-024c-cfafd46c506c | pt1       | 1              | 3                 |\n| dfs\\://window\\_function | 572b1660-790e-e3a0-3944-9b81e50f4eb4 | pt1       | 1              | 3                 |\n| dfs\\://window\\_function | e9ea31f6-4e12-2881-b04a-c540dc3947c8 | pt        | 1              | 1                 |\n| dfs\\://window\\_function | 673a7c12-c0d4-72bf-6a42-9c374589e2d6 | pt        | 1              | 3                 |\n| dfs\\://window\\_function | 57ceedc9-4aaf-2aad-aa43-37924da3d32e | pt        | 1              | 3                 |\n\n获取以 `dfs://window` 开头的数据库下表 pt 的 Level File 和 sortKeyEntry 的数量\n\n```\ngetTSDBDataStat(\"dfs://window%\",\"pt\")\n```\n\n| dbName                  | chunkId                              | tableName | levelFileCount | sortKeyEntryCount |\n| ----------------------- | ------------------------------------ | --------- | -------------- | ----------------- |\n| dfs\\://window\\_function | e9ea31f6-4e12-2881-b04a-c540dc3947c8 | pt        | 1              | 1                 |\n| dfs\\://window\\_function | 673a7c12-c0d4-72bf-6a42-9c374589e2d6 | pt        | 1              | 3                 |\n| dfs\\://window\\_function | 57ceedc9-4aaf-2aad-aa43-37924da3d32e | pt        | 1              | 3                 |\n\n获取指定 chunkId 的分区下的 Level File 和 sortKeyEntry 的数量。\n\n```\ngetTSDBDataStat(chunkId=[\"e9ea31f6-4e12-2881-b04a-c540dc3947c8\", \"673a7c12-c0d4-72bf-6a42-9c374589e2d6\"])\n```\n\n| dbName                  | chunkId                              | tableName | levelFileCount | sortKeyEntryCount |\n| ----------------------- | ------------------------------------ | --------- | -------------- | ----------------- |\n| dfs\\://window\\_function | 673a7c12-c0d4-72bf-6a42-9c374589e2d6 | pt        | 1              | 3                 |\n| dfs\\://window\\_function | 57ceedc9-4aaf-2aad-aa43-37924da3d32e | pt        | 1              | 3                 |\n"
    },
    "getTSDBMetaData": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getTSDBMetaData.html",
        "signatures": [
            {
                "full": "getTSDBMetaData()",
                "name": "getTSDBMetaData",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getTSDBMetaData](https://docs.dolphindb.cn/zh/funcs/g/getTSDBMetaData.html)\n\n\n\n#### 语法\n\ngetTSDBMetaData()\n\n#### 详情\n\n获取 TSDB 引擎下所有 chunk 的元数据。该函数只能在数据节点上执行。\n\n#### 参数\n\n无\n\n#### 返回值\n\n返回一个表，包含以下列:\n\n* chunkId：chunk 的唯一标识\n\n* chunkPath：分区的物理路径\n\n* level：数据文件所在的 level 级别\n\n* table：数据表名称\n\n* files：数据文件名称，即 level file 名称\n\n**首发版本**：2.00.4\n\n#### 例子\n\n```\ngetTSDBMetaData()\n```\n\n| chunkId                          | chunkPath           | level | table | files                    |\n| -------------------------------- | ------------------- | ----- | ----- | ------------------------ |\n| 7e0c65ca-5e4a-4594-2948-fa0b5... | /hdd/hdd7/test/v... | 0     | pt\\_2 | 0\\_00211490,0\\_002115580 |\n| 7e0c65ca-5e4a-4594-2948-fa0b5... | /hdd/hdd7/test/v... | 1     | pt\\_2 | 1\\_00013041              |\n"
    },
    "getTSDBSortKeyEntry": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getTSDBSortKeyEntry.html",
        "signatures": [
            {
                "full": "getTSDBSortKeyEntry(chunkId, [tableName])",
                "name": "getTSDBSortKeyEntry",
                "parameters": [
                    {
                        "full": "chunkId",
                        "name": "chunkId"
                    },
                    {
                        "full": "[tableName]",
                        "name": "tableName",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [getTSDBSortKeyEntry](https://docs.dolphindb.cn/zh/funcs/g/getTSDBSortKeyEntry.html)\n\n\n\n#### 语法\n\ngetTSDBSortKeyEntry(chunkId, \\[tableName])\n\n#### 详情\n\n获取 TSDB 引擎已经写入磁盘的每个 chunk 分区的 sort key（详见 [sortColumns](https://docs.dolphindb.cn/zh/funcs/c/createPartitionedTable.html) 参数介绍）信息。\n\n#### 参数\n\n**chunkId** 字符串标量或向量，表示 chunk 的 ID。注意：不可超过 1024。\n\n**tableName** 可选参数，是字符串标量，表示分布表的名称。若不指定该参数，则表示该 chunk 下所包含的所有表。\n\n#### 返回值\n\n返回一个表，包含以下字段：\n\n* chunkId：chunk 的唯一标识。\n\n* chunkPath：chunk 数据所存储的路径。\n\n* tableName：分布式表表名。\n\n* file：level file 文件名。\n\n* key：sort key 的组合值。sort key 之间以下划线 “\\_” 分隔。\n\n* size：当前 sort key 组合值对应的记录数。\n\n**Note:** 该函数不支持查询 Cache Engine 中的分区数据，因此，调用该函数前，需要先调用 [flushTSDBCache](https://docs.dolphindb.cn/zh/funcs/f/flushTSDBCache.html)，将 cacheEngine 中已完成的分区数据写入磁盘。\n\n#### 例子\n\n```\nn = 10000\nSecurityID = rand(`st0001`st0002`st0003`st0004`st0005, n)\nsym = rand(`A`B`C`D`E, n)\nTradeDate = 2022.01.01 + rand(100,n)\nTotalVolumeTrade = rand(1000..3000, n)\nTotalValueTrade = rand(100.0, n)\nschemaTable_snap = table(SecurityID, sym, TradeDate, TotalVolumeTrade, TotalValueTrade).sortBy!(`SecurityID`sym`TradeDate)\n\ndbPath = \"dfs://TSDB_STOCK\"\nif(existsDatabase(dbPath)){dropDatabase(dbPath)}\ndb_snap = database(dbPath, VALUE, 2022.01.01..2022.01.05, engine='TSDB')\n\nsnap=createPartitionedTable(dbHandle=db_snap, table=schemaTable_snap, tableName=\"snap\", partitionColumns=`TradeDate, sortColumns=`SecurityID`sym`TradeDate, keepDuplicates=ALL, sortKeyMappingFunction=[hashBucket{,3}, hashBucket{,2}])\nsnap.append!(schemaTable_snap)\n\nsnap1=createPartitionedTable(dbHandle=db_snap, table=schemaTable_snap, tableName=\"snap1\", partitionColumns=`TradeDate, sortColumns=`SecurityID`sym`TradeDate, keepDuplicates=ALL)\nsnap1.append!(schemaTable_snap)\n\nflushTSDBCache()\n\ngetChunksMeta()\n```\n\n输出返回：\n\n| site        | chunkId                              | path                                                                 | dfsPath                  | type | flag | size | version | state | versionList                   | resolved |\n| ----------- | ------------------------------------ | -------------------------------------------------------------------- | ------------------------ | ---- | ---- | ---- | ------- | ----- | ----------------------------- | -------- |\n| server11352 | fe93077a-5a05-34a8-554c-67467415bf68 | /dolphindb/server/server11352/storage/CHUNKS/TSDB\\_STOCK/20220410/yv | /TSDB\\_STOCK/20220410/yv | 1    | 0    | 0    | 1       | 0     | cid : 2134,snap1=>2134:89; #  | false    |\n| server11352 | 5c30ef71-3e51-c5ac-6b4d-4458feb8454a | /dolphindb/server/server11352/storage/CHUNKS/TSDB\\_STOCK/20220407/yv | /TSDB\\_STOCK/20220407/yv | 1    | 0    | 0    | 1       | 0     | cid : 2134,snap1=>2134:95; #  | false    |\n| server11352 | 4216dbe9-c238-49a9-4d45-66829c98a7b5 | /dolphindb/server/server11352/storage/CHUNKS/TSDB\\_STOCK/20220406/yv | /TSDB\\_STOCK/20220406/yv | 1    | 0    | 0    | 1       | 0     | cid : 2134,snap1=>2134:92; #  | false    |\n| server11352 | 47ea0d35-7ea9-c3b3-cc4b-cc6cd1fe039d | /dolphindb/server/server11352/storage/CHUNKS/TSDB\\_STOCK/20220401/yv | /TSDB\\_STOCK/20220401/yv | 1    | 0    | 0    | 1       | 0     | cid : 2134,snap1=>2134:100; # | false    |\n| server11352 | aafd71c5-a197-63a9-2d4c-b65cbced3d21 | /dolphindb/server/server11352/storage/CHUNKS/TSDB\\_STOCK/20220330/yv | /TSDB\\_STOCK/20220330/yv | 1    | 0    | 0    | 1       | 0     | cid : 2134,snap1=>2134:97; #  | false    |\n\n```\ngetTSDBSortKeyEntry(\"fe93077a-5a05-34a8-554c-67467415bf68\")\n```\n\n输出返回：\n\n| chunkId                              | chunkPath                                                            | tableName | file        | key       | size |\n| ------------------------------------ | -------------------------------------------------------------------- | --------- | ----------- | --------- | ---- |\n| fe93077a-5a05-34a8-554c-67467415bf68 | /dolphindb/server/server11352/storage/CHUNKS/TSDB\\_STOCK/20220410/yv | snap1     | 0\\_00000058 | st0001\\_A | 2    |\n| fe93077a-5a05-34a8-554c-67467415bf68 | /dolphindb/server/server11352/storage/CHUNKS/TSDB\\_STOCK/20220410/yv | snap1     | 0\\_00000058 | st0001\\_B | 3    |\n| fe93077a-5a05-34a8-554c-67467415bf68 | /dolphindb/server/server11352/storage/CHUNKS/TSDB\\_STOCK/20220410/yv | snap1     | 0\\_00000058 | st0001\\_C | 2    |\n| fe93077a-5a05-34a8-554c-67467415bf68 | /dolphindb/server/server11352/storage/CHUNKS/TSDB\\_STOCK/20220410/yv | snap1     | 0\\_00000058 | st0001\\_D | 6    |\n| fe93077a-5a05-34a8-554c-67467415bf68 | /dolphindb/server/server11352/storage/CHUNKS/TSDB\\_STOCK/20220410/yv | snap1     | 0\\_00000058 | st0002\\_A | 4    |\n"
    },
    "getTSDBTableIndexCacheStatus": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/gettsdbtableindexcachestatus.html",
        "signatures": [
            {
                "full": "getTSDBTableIndexCacheStatus()",
                "name": "getTSDBTableIndexCacheStatus",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getTSDBTableIndexCacheStatus](https://docs.dolphindb.cn/zh/funcs/g/gettsdbtableindexcachestatus.html)\n\n#### 语法\n\ngetTSDBTableIndexCacheStatus()\n\n#### 详情\n\nTSDB 引擎在查询 Level File 时，会将其尾部的索引信息（包括 zonemap 等）加载 Level File 时加载到内存中。该函数用于获取已加载的数据库中表的 Level File 索引所占用的内存（单位为字节）。结合 getTSDBDataStat 函数，可以评估内存中的 Level File 对应的表的 sort key 设置是否合理。\n\n#### 参数\n\n无。\n\n#### 返回值\n\n一个表，包含以下字段：\n\n* dbName：数据库名称。\n\n* chunkId：chunk 的唯一标识。\n\n* tableName：chunk 所属的表名称。\n\n* memUsage：Level File 索引占用的内存，单位为字节。\n\n#### 例子\n\n```\nt = table(1 2 1 1 2 2 3 as month, `Rome`Paris`London`Paris`Rome`London`Rome as city, 200 500 100 300 300 400 400 as sold)\ndb_name = \"dfs://tsdb_01\"\nif (existsDatabase(db_name)) {\n    dropDatabase(db_name)\n}\ndb = database(db_name, HASH, [INT, 4], , 'TSDB')\n\npt = db.createPartitionedTable(t, \"pt\", \"month\", ,\"sold\")\npt.append!(t)\n\npt1 = db.createPartitionedTable(t, \"pt1\", \"month\", ,\"sold\")\npt1.append!(t)\n\nflushTSDBCache()\n\ngetTSDBTableIndexCacheStatus()\n```\n\n| dbName          | chunkId                              | tableName | memUsage |\n| --------------- | ------------------------------------ | --------- | -------- |\n| dfs\\://tsdb\\_01 | 01e891fa-f66d-7599-7544-4e0449f4e608 | pt1\\_3    | 680      |\n| dfs\\://tsdb\\_01 | 81c0f8f7-e195-b298-da4a-d007492f4733 | pt1\\_3    | 680      |\n| dfs\\://tsdb\\_01 | 17f8bc0b-946e-f688-374c-955c586faccf | pt\\_2     | 296      |\n| dfs\\://tsdb\\_01 | 1df88c41-bccf-449b-504c-5978df9cc03f | pt\\_2     | 680      |\n| dfs\\://tsdb\\_01 | 10371e0c-685a-51b1-3042-1ba289514bb9 | pt1\\_3    | 296      |\n| dfs\\://tsdb\\_01 | 0be81d1e-1962-108b-274e-3dc2632921bc | pt\\_2     | 680      |\n\n"
    },
    "getUdfEngineVariable": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getUdfEngineVariable.html",
        "signatures": [
            {
                "full": "getUdfEngineVariable(engine, name)",
                "name": "getUdfEngineVariable",
                "parameters": [
                    {
                        "full": "engine",
                        "name": "engine"
                    },
                    {
                        "full": "name",
                        "name": "name"
                    }
                ]
            }
        ],
        "markdown": "### [getUdfEngineVariable](https://docs.dolphindb.cn/zh/funcs/g/getUdfEngineVariable.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\ngetUdfEngineVariable(engine, name)\n\n#### 详情\n\n查询指定 DStream::udfEngine 中指定外部变量的当前值。\n\n#### 参数\n\n**engine**字符串标量，流图中由 DStream::udfEngine 创建的自定义引擎名称。\n\n**name**字符串标量，外部变量名称，需为创建 DStream::udfEngine 时 *variableNames* 中定义的变量之一。\n\n#### 返回值\n\n返回指定变量当前的值，类型和形式取决于变量本身。\n\n#### 例子\n\n```\nif(existsCatalog(\"orcaCatalog\")) dropCatalog(\"orcaCatalog\")\ncreateCatalog(\"orcaCatalog\")\ngo\nuse catalog orcaCatalog\n// 创建流图\ng = createStreamGraph(\"compare\")\ng.sharedKeyedTable(\"history\", \"id\", 1:0, `id`value, [INT, DOUBLE])\ng.source(\"data\", `id`value`time, [INT, DOUBLE, TIMESTAMP])\n  .udfEngine(def(msg) {\n    history = orcaObj(\"history\")\n    diffTable = table(100:0, `id`diff, [INT, DOUBLE])\n    for(i in 0:msg.size()) {\n        idVal = msg.id[i]\n        valueVal = msg.value[i]\n        // 读取历史值\n        old = select value from history where id = idVal\n        // 写入新值\n        newRow = table(idVal as id, valueVal as value)\n        history.append!(newRow)\n        // 计算差值\n        if(old.size() > 0) {\n            diffTable.append!(table(idVal as id, (valueVal - old.value[0]) as diff))\n        }\n    }\n    return diffTable\n  })\n  .sink(\"comparison\")\ng.submit()\n// 生成模拟数据\nmockData = table(1..5 as id, rand(100.0, 5) as value, now() + 1..5 as time)\n// 插入数据\nappendOrcaStreamTable(\"orcaCatalog.orca_table.data\", mockData)\n// 生成id重复的数据\nmockData = table(1..5 as id, rand(100.0, 5) as value, now() + 1..5 as time)\n// 插入数据\nappendOrcaStreamTable(\"orcaCatalog.orca_table.data\", mockData)\n// 等待处理并查看结果\nsleep(1000)\nselect * from orcaCatalog.orca_table.comparison\n```\n\n**相关函数：**[DStream::udfEngine](https://docs.dolphindb.cn/zh/funcs/d/DStream_udfEngine.html)\n"
    },
    "getUnresolvedTxn": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getUnresolvedTxn.html",
        "signatures": [
            {
                "full": "getUnresolvedTxn()",
                "name": "getUnresolvedTxn",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getUnresolvedTxn](https://docs.dolphindb.cn/zh/funcs/g/getUnresolvedTxn.html)\n\n\n\n#### 语法\n\ngetUnresolvedTxn()\n\n#### 详情\n\n获取两阶段提交协议中处于决议状态的节点及其事务。只能由管理员在控制节点执行。\n\n#### 参数\n\n无\n\n#### 返回值\n\n返回一个表，包含以下字段：\n\n* tid：事务 id。\n\n* cid：提交的版本号。\n\n* chunkId：chunk 的唯一标识。\n\n* initiatingNode：事务决议的发起节点。\n\n* firstResolutionAt：事务开始决议的时间。\n\n* lastResolutionAt：若事务发生多次决议，则会显示最后一次决议的时间。\n"
    },
    "getUserAccess": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getUserAccess.html",
        "signatures": [
            {
                "full": "getUserAccess([userIds], [finalAccess=false])",
                "name": "getUserAccess",
                "parameters": [
                    {
                        "full": "[userIds]",
                        "name": "userIds",
                        "optional": true
                    },
                    {
                        "full": "[finalAccess=false]",
                        "name": "finalAccess",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [getUserAccess](https://docs.dolphindb.cn/zh/funcs/g/getUserAccess.html)\n\n\n\n#### 语法\n\ngetUserAccess(\\[userIds], \\[finalAccess=false])\n\n#### 详情\n\n指定 *userId* 时：\n\n* 若 *finalAccess* = false，则返回指定用户所单独被赋予的权限，不包括用户所属组的权限。\n\n* 若 *finalAccess* = true，则返回指定用户及其所属组的权限组合后的最终生效权限。\n\n当没有指定 *userId* 时，返回当前登录用户的权限。\n\n**Note:** 该函数只能由管理员在控制节点、数据节点和计算节点运行。\n\n#### 参数\n\n**userId** 是表示一个或多个用户的字符串标量或向量。\n\n**finalAccess** 为布尔值，表示是否获取用户及其所属组权限叠加的结果。默认值为 false。\n\n#### 返回值\n\n返回一个表，以下分别介绍返回表的各参数的详情：\n\n| 参数                              | 详情                                                           |\n| :------------------------------ | :----------------------------------------------------------- |\n| userId                          | 用户名                                                          |\n| groups                          | 组名                                                           |\n| isAdmin                         | 是否是管理员。                                                      |\n| MAX\\_JOB\\_PRIORITY              | 该用户对应的作业最高优先级，范围是0-8，可以通过 `setMaxJobPriority` 指定。            |\n| MAX\\_PARALLELISM                | 该用户提交的作业最多可以有多少个子任务同时并行执行，可以通过 `setMaxJobParallelism` 指定。    |\n| QUERY\\_RESULT\\_MEM\\_LIMIT       | 该用户单次查询结果的占用内存上限，浮点类型，单位为 GB。可以通过 `grant` 指定，`revoke` 撤销。    |\n| TASK\\_GROUP\\_MEM\\_LIMIT         | 该用户发送的批量子查询占用的内存上限，浮点类型，单位为 GB。可以通过 `grant` 指定，`revoke` 撤销。  |\n| MAX\\_PARTITION\\_NUM\\_PER\\_QUERY | 该用户单次查询的最大分区数。整型标量，-1 表示没有设置该权限。可以通过 `grant` 指定，`revoke` 撤销。 |\n\n以下字段对应权限，其值为 “allow\" / \"none\" / \"deny\" ：\n\n| 权限                     |\n| ---------------------- |\n| ACCESS\\_READ           |\n| ACCESS\\_INSERT         |\n| ACCESS\\_UPDATE         |\n| ACCESS\\_DELETE         |\n| VIEW\\_EXEC             |\n| SCRIPT\\_EXEC           |\n| TEST\\_EXEC             |\n| DBOBJ\\_CREATE          |\n| DBOBJ\\_DELETE          |\n| DB\\_MANAGE             |\n| DB\\_OWNER              |\n| VIEW\\_OWNER            |\n| COMPUTE\\_GROUP\\_EXEC   |\n| TABLE\\_SENSITIVE\\_VIEW |\n| DB\\_SENSITIVE\\_VIEW    |\n| CREATE\\_SHARED\\_VARS   |\n| MCP\\_MANAGE            |\n| MCP\\_DEVELOP           |\n| MCP\\_EXEC              |\n| ORCA\\_MANAGE           |\n| ORCA\\_GRAPH\\_CONTROL   |\n| ORCA\\_GRAPH\\_CREATE    |\n| ORCA\\_GRAPH\\_DROP      |\n| ORCA\\_TABLE\\_READ      |\n| ORCA\\_TABLE\\_WRITE     |\n| ORCA\\_TABLE\\_CREATE    |\n| ORCA\\_TABLE\\_DROP      |\n| ORCA\\_ENGINE\\_MANAGE   |\n\n**注意**：\n\n* 自 3.00.5 版本起，支持获取 Orca 流图、流表权限。\n\n* 自 3.00.2 版本起，支持获取访问计算节点组的权限。\n\n* 自 3.00.0.0 版本起，支持获取访问 catalog 的相关权限。\n\n* 自 2.00.9版本开始，新增了表和数据库的插入更新和删除权限（即对写权限进行拓展），因此旧版本的 TABLE\\_WRITE 字段由 TABLE\\_INSERT，TABLE\\_UPDATE，TALBE\\_DELETE 字段替代。\n\n* 因为具有 DB\\_READ / DB\\_INSERT / DB\\_UPDATE / DB\\_DELETE 权限的用户，可以在该数据库范围内对其下的所有表执行相应的操作，所以在 getUserAccess 函数中，用户对数据库和表的权限会被统一为 ACCESS\\_READ / ACCESS\\_INSERT / ACCESS\\_UPDATE / ACCESS\\_DELETE。可以通过下表来区分上述权限的具体应用对象。\n\n以下几个字段表示权限应用的具体对象：\n\n| 对象                                     |\n| -------------------------------------- |\n| TABLE\\_READ\\_allowed                   |\n| TABLE\\_READ\\_denied                    |\n| TABLE\\_INSERT\\_allowed                 |\n| TABLE\\_INSERT\\_denied                  |\n| TABLE\\_UPDATE\\_allowed                 |\n| TABLE\\_UPDATE\\_denied                  |\n| TABLE\\_DELETE\\_allowed                 |\n| TABLE\\_DELETE\\_denied                  |\n| DB\\_READ\\_allowed                      |\n| DB\\_READ\\_denied                       |\n| DB\\_INSERT\\_allowed                    |\n| DB\\_INSERT\\_denied                     |\n| DB\\_UPDATE\\_allowed                    |\n| DB\\_UPDATE\\_denied                     |\n| DB\\_DELETE\\_allowed                    |\n| DB\\_DELETE\\_denied                     |\n| VIEW\\_EXEC\\_allowed                    |\n| VIEW\\_EXEC\\_denied                     |\n| DBOBJ\\_CREATE\\_allowed                 |\n| DBOBJ\\_CREATE\\_denied                  |\n| DBOBJ\\_DELETE\\_allowed                 |\n| DBOBJ\\_DELETE\\_denied                  |\n| DB\\_OWNER\\_allowed                     |\n| DB\\_MANAGE\\_allowed                    |\n| DB\\_MANAGE\\_denied                     |\n| CATALOG\\_READ\\_allowed                 |\n| CATALOG\\_READ\\_denied                  |\n| CATALOG\\_INSERT\\_allowed               |\n| CATALOG\\_INSERT\\_denied                |\n| CATALOG\\_UPDATE\\_allowed               |\n| CATALOG\\_UPDATE\\_denied                |\n| CATALOG\\_DELETE\\_allowed               |\n| CATALOG\\_DELETE\\_denied                |\n| COMPUTE\\_GROUP\\_EXEC\\_allowed          |\n| COMPUTE\\_GROUP\\_EXEC\\_denied           |\n| TABLE\\_SENSITIVE\\_VIEW\\_allowed        |\n| TABLE\\_SENSITIVE\\_VIEW\\_denied         |\n| DB\\_SENSITIVE\\_VIEW\\_allowed           |\n| DB\\_SENSITIVE\\_VIEW\\_denied            |\n| MCP\\_EXEC\\_allowed                     |\n| MCP\\_EXEC\\_denied                      |\n| ORCA\\_MANAGE\\_allowed                  |\n| ORCA\\_MANAGE\\_denied                   |\n| ORCA\\_CATALOG\\_GRAPH\\_CONTROL\\_allowed |\n| ORCA\\_CATALOG\\_GRAPH\\_CONTROL\\_denied  |\n| ORCA\\_GRAPH\\_CONTROL\\_allowed          |\n| ORCA\\_GRAPH\\_CONTROL\\_denied           |\n| ORCA\\_CATALOG\\_GRAPH\\_CREATE\\_allowed  |\n| ORCA\\_CATALOG\\_GRAPH\\_CREATE\\_denied   |\n| ORCA\\_CATALOG\\_GRAPH\\_DROP\\_allowed    |\n| ORCA\\_CATALOG\\_GRAPH\\_DROP\\_denied     |\n| ORCA\\_CATALOG\\_TABLE\\_READ\\_allowed    |\n| ORCA\\_CATALOG\\_TABLE\\_READ\\_denied     |\n| ORCA\\_TABLE\\_READ\\_allowed             |\n| ORCA\\_TABLE\\_READ\\_denied              |\n| ORCA\\_CATALOG\\_TABLE\\_WRITE\\_allowed   |\n| ORCA\\_CATALOG\\_TABLE\\_WRITE\\_denied    |\n| ORCA\\_TABLE\\_WRITE\\_allowed            |\n| ORCA\\_TABLE\\_WRITE\\_denied             |\n| ORCA\\_CATALOG\\_TABLE\\_CREATE\\_allowed  |\n| ORCA\\_CATALOG\\_TABLE\\_CREATE\\_denied   |\n| ORCA\\_CATALOG\\_TABLE\\_DROP\\_allowed    |\n| ORCA\\_CATALOG\\_TABLE\\_DROP\\_denied     |\n| ORCA\\_CATALOG\\_ENGINE\\_MANAGE\\_allowed |\n| ORCA\\_CATALOG\\_ENGINE\\_MANAGE\\_denied  |\n| ORCA\\_ENGINE\\_MANAGE\\_allowed          |\n| ORCA\\_ENGINE\\_MANAGE\\_denied           |\n"
    },
    "getUserAccessByCluster": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getUserAccessByCluster.html",
        "signatures": [
            {
                "full": "getUserAccessByCluster(users, cluster, finalAccess)",
                "name": "getUserAccessByCluster",
                "parameters": [
                    {
                        "full": "users",
                        "name": "users"
                    },
                    {
                        "full": "cluster",
                        "name": "cluster"
                    },
                    {
                        "full": "finalAccess",
                        "name": "finalAccess"
                    }
                ]
            }
        ],
        "markdown": "### [getUserAccessByCluster](https://docs.dolphindb.cn/zh/funcs/g/getUserAccessByCluster.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\ngetUserAccessByCluster(users, cluster, finalAccess)\n\n#### 详情\n\n查询指定用户在多集群系统中的权限信息。只能由管理员在 MoM（Master of Master，管理集群）上执行该函数。\n\n#### 参数\n\n**users** 字符串向量，表示要查询的用户名称。\n\n**cluster** 字符串标量，表示要查询的用户所在集群的名称。\n\n**finalAccess** 布尔标量，表示是否获取用户及其所属组权限叠加的结果。\n\n#### 返回值\n\n一个表，字段与 `getUserAccess` 函数的返回结果一致。\n\n#### 例子\n\n```\ngetUserAccessByCluster([\"admin\"], \"masterOfMaster\", true)\n```\n\n| userId | groups | isAdmin | ACCESS\\_READ | ACCESS\\_INSERT | ACCESS\\_UPDATE | ACCESS\\_DELETE | VIEW\\_EXEC | SCRIPT\\_EXEC | TEST\\_EXEC | DBOBJ\\_CREATE | ... |\n| ------ | ------ | ------- | ------------ | -------------- | -------------- | -------------- | ---------- | ------------ | ---------- | ------------- | --- |\n| admin  |        | 1       | allow        | allow          | allow          | allow          | allow      | allow        | allow      | allow         | ... |\n\n相关函数：[getUserAccess](https://docs.dolphindb.cn/zh/funcs/g/getUserAccess.html)\n"
    },
    "getUserHardwareUsage": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getUserHardwareUsage.html",
        "signatures": [
            {
                "full": "getUserHardwareUsage([from=0], [to])",
                "name": "getUserHardwareUsage",
                "parameters": [
                    {
                        "full": "[from=0]",
                        "name": "from",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[to]",
                        "name": "to",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [getUserHardwareUsage](https://docs.dolphindb.cn/zh/funcs/g/getUserHardwareUsage.html)\n\n\n\n#### 语法\n\ngetUserHardwareUsage(\\[from=0], \\[to])\n\n#### 详情\n\n从资源使用日志（*\\<HomeDir>/resource/hardware.log*）获取特定时间段内用户的硬件资源使用情况。该函数仅在资源跟踪功能开启时（配置 *resourceSamplingInterval*）调用，且仅限管理员在数据节点上调用。\n\n#### 参数\n\n**from**整型或时间类型，表示查询的起始时间点。默认值为0，表示查询从1970.01.01零点开始的记录。\n\n**to**整型或时间类型，表示查询的结束时间点。默认为空，表示查询到目前时间点为止的记录。\n\n*from* 必须小于等于 *to*。\n\n#### 返回值\n\n返回一个表，包含以下字段：\n\n* timestamp：NANOTIMESTAMP 类型的时间戳。\n\n* userId：用户名。\n\n* cpu：当前用户占用的工作线程数量。\n\n* memory：内存使用量，当前用户使用的所有变量的内存占用大小。单位是字节。\n\n* send：单次采集间隔内发送的数据量。单位是字节。\n\n* recv：单次采集间隔内接收的数据量。单位是字节。需要注意的是，统计的接收数据量可能会有一定误差，最大误差范围在 2KB 以内。\n\n#### 例子\n\n```\nlogin(\"admin\", \"123456\")\nselect sum(send), sum(recv) from pnodeRun(getUserHardwareUsage) group by userId, node\n```\n\n返回：\n\n| userId | node         | sum\\_send | sum\\_recv |\n| ------ | ------------ | --------- | --------- |\n| admin  | datanode8902 | 197,783   | 464       |\n| admin  | datanode8903 | 375,911   | 438       |\n| admin  | datanode8904 | 1,080,171 | 735,817   |\n| guest  | datanode8902 | 2,144     | 216       |\n| guest  | datanode8903 | 120       | 0         |\n| guest  | datanode8904 | 399       | 0         |\n| user1  | datanode8902 | 80,222    | 0         |\n| user1  | datanode8903 | 120       | 0         |\n| user1  | datanode8904 | 83,361    | 328       |\n| user2  | datanode8902 | 80,100    | 0         |\n"
    },
    "getUserList": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getUserList.html",
        "signatures": [
            {
                "full": "getUserList()",
                "name": "getUserList",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getUserList](https://docs.dolphindb.cn/zh/funcs/g/getUserList.html)\n\n\n\n#### 语法\n\ngetUserList()\n\n#### 详情\n\n返回包含除管理员之外的所有用户名称的向量。\n\n**Note:** 该函数只能由管理员在控制节点、数据节点和计算节点运行。\n\n#### 返回值\n\n字符串向量。\n\n#### 例子\n\n```\nlogin(`admin, `123456);\ngetUserList().sort();\n// output: [\"AA\",\"AAA\",\"BB\",\"BBB\",\"CC\",\"DeionSanders\",\"EliManning\",\"JoeFlacco\"]\n```\n"
    },
    "getUserListOfAllClusters": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getUserListOfAllClusters.html",
        "signatures": [
            {
                "full": "getUserListOfAllClusters()",
                "name": "getUserListOfAllClusters",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getUserListOfAllClusters](https://docs.dolphindb.cn/zh/funcs/g/getUserListOfAllClusters.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\ngetUserListOfAllClusters()\n\n#### 详情\n\n查询多集群管理系统中所有集群的用户信息。只能由管理员在 MoM（Master of Master，管理集群）上执行该函数。\n\n#### 参数\n\n无\n\n#### 返回值\n\n一个字典（dictionary），其中：\n\n* key：集群名称。\n* value：该集群下的用户名称列表。\n\n#### 例子\n\n```\ngetUserListOfAllClusters()\n      \n/* Output:\nmasterOfMaster->[\"user1\",\"user2\",\"admin\"]\nMoMSender->[\"admin\",\"user2\"]  \n*/   \n```\n"
    },
    "getUserLockedStatus": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getUserLockedStatus.html",
        "signatures": [
            {
                "full": "getUserLockedStatus()",
                "name": "getUserLockedStatus",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getUserLockedStatus](https://docs.dolphindb.cn/zh/funcs/g/getUserLockedStatus.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\ngetUserLockedStatus()\n\n#### 详情\n\n查看系统中用户的锁定状态。该函数仅限管理员用户调用，调用时须开启配置项 *enhancedSecurityVerification*。\n\n#### 返回值\n\n返回一张表，包含以下字段：\n\n* user：处于锁定状态的用户名。\n\n* IP：用户被锁定的 IP。若该用户由管理员通过 `lockUser` 函数锁定，则该列为 ”\\*“。\n\n* lockTime：锁定的起始时间。\n\n* unlockTime：预期解锁时间，若该用户由管理员通过 `lockUser` 函数锁定，则该列为空。\n\n#### 例子\n\n```\ngetUserLockedStatus()\n```\n\n| user  | IP            | lockTime                | unlockTime              |\n| ----- | ------------- | ----------------------- | ----------------------- |\n| user2 | \\*            | 2025.03.27 11:27:36.597 |                         |\n| user1 | 192.168.0.140 | 2025.03.27 11:27:23.916 | 2025.03.27 11:32:23.916 |\n"
    },
    "getUserPasswordStatus": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getUserPasswordStatus.html",
        "signatures": [
            {
                "full": "getUserPasswordStatus([user])",
                "name": "getUserPasswordStatus",
                "parameters": [
                    {
                        "full": "[user]",
                        "name": "user",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [getUserPasswordStatus](https://docs.dolphindb.cn/zh/funcs/g/getUserPasswordStatus.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\ngetUserPasswordStatus(\\[user])\n\n#### 详情\n\n获取用户 *user*的密码状态，省略参数 *user*时获取集群中除 admin 以外所有用户的密码状态。\n\n#### 参数\n\n**user** 可选参数，STRING 类型标量，表示用户名。\n\n#### 返回值\n\n返回一个表，包含以下字段：\n\n* user：用户名\n* setTime：当前密码的设置时间\n* expireTime：密码的过期时间\n* authMode：密码验证方式，可能的取值包括 \"SHA256\" 和 \"SCRAM”\"\n\n#### 例子\n\n```\ngetUserPasswordStatus(`user1)\n```\n\n| user  | setTime                       | expireTime                    | authMode |\n| ----- | ----------------------------- | ----------------------------- | -------- |\n| user1 | 2025.03.27 11:51:09.154259866 | 2025.04.26 11:51:09.154259866 | SHA256   |\n"
    },
    "getUsersByGroupId": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getUsersByGroupId.html",
        "signatures": [
            {
                "full": "getUsersByGroupId(groupId)",
                "name": "getUsersByGroupId",
                "parameters": [
                    {
                        "full": "groupId",
                        "name": "groupId"
                    }
                ]
            }
        ],
        "markdown": "### [getUsersByGroupId](https://docs.dolphindb.cn/zh/funcs/g/getUsersByGroupId.html)\n\n\n\n#### 语法\n\ngetUsersByGroupId(groupId)\n\n#### 详情\n\n返回属于指定组的用户。\n\n**Note:** 该函数只能由管理员在控制节点、数据节点和计算节点运行。\n\n#### 参数\n\n**groupId** 是表示组名的字符串。\n\n#### 返回值\n\n字符串向量。\n"
    },
    "getUserTableAccessRecords": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getUserTableAccessRecords.html",
        "signatures": [
            {
                "full": "getUserTableAccessRecords([from=0], [to])",
                "name": "getUserTableAccessRecords",
                "parameters": [
                    {
                        "full": "[from=0]",
                        "name": "from",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[to]",
                        "name": "to",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [getUserTableAccessRecords](https://docs.dolphindb.cn/zh/funcs/g/getUserTableAccessRecords.html)\n\n\n\n#### 语法\n\ngetUserTableAccessRecords(\\[from=0], \\[to])\n\n#### 详情\n\n从已保存记录了分布式表查询信息的日志中，提取指定时间段内的查询日志。\n\n#### 参数\n\n**from**整型或时间类型，表示查询的起始时间点。默认值为0，表示查询从1970.01.01零点开始的记录。\n\n**to**整型或时间类型，表示查询的结束时间点。默认为空，表示查询到目前时间点为止的记录。\n\n*from* 必须小于等于 *to*。\n\n#### 返回值\n\n返回一个表。含以下字段：\n\n* timestamp：NANOTIMESTAMP 类型的时间戳。如果 type 是 sql，则这里记录开始执行 SQL 的时间戳；如果 type 是 rowCount 或 memUsage，则这里记录的是读出数据的时间戳。\n\n* rootQueryId：SQL 查询任务的 ID，是分布式 SQL 查询任务的唯一标识符。一个分布式查询会按分区拆分为多个 SQL 子查询。该 ID 为分布式查询及其拆分出的子查询的根 ID。\n\n* userId：用户名。\n\n* database：数据库名。\n\n* table：表名。\n\n* type：记录的信息类型，包括3类：sql, rowCount, memUsage。\n\n* value：\n\n  * 当类型为 sql 时，为 SQL 查询任务的执行次数。该值总是为1。\n\n  * 当类型为 rowCount 时，为 SQL 执行时存储引擎返回的表的行数。\n\n  * 当类型为 memUsage 时，为查询结果占用的内存大小。单位是字节。\n\n* script：当类型为 sql 时，记录 SQL 脚本，其他类型则为空字符串。\n\n该函数仅限管理员在数据节点上调用。\n\n#### 例子\n\n```\ngetUserTableAccessRecords(2023.12.30T09:18:35.894150296,2023.12.30T09:18:35.894538439)\n```\n\n返回：\n\n| timestamp                     | rootQueryId                          | userId | database       | table | type     | value | script                              |\n| ----------------------------- | ------------------------------------ | ------ | -------------- | ----- | -------- | ----- | ----------------------------------- |\n| 2023.12.30T09:18:35.894150296 | e892855b-7843-1492-0140-a85810662006 | admin  | dfs\\://rangedb | pt    | sql      | 1     | select count(x) as count\\_x from pt |\n| 2023.12.30T09:18:35.894497304 | e892855b-7843-1492-0140-a85810662006 | admin  | dfs\\://rangedb | pt    | rowCount | 43    |                                     |\n| 2023.12.30T09:18:35.894501600 | e892855b-7843-1492-0140-a85810662006 | admin  | dfs\\://rangedb | pt    | memUsage | 516   |                                     |\n"
    },
    "getWorkDir": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/getWorkDir.html",
        "signatures": [
            {
                "full": "getWorkDir()",
                "name": "getWorkDir",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [getWorkDir](https://docs.dolphindb.cn/zh/funcs/g/getWorkDir.html)\n\n首发版本：3.00.4，3.00.3.1\n\n\n\n#### 语法\n\ngetWorkDir()\n\n#### 详情\n\n获取启动 dolphindb 进程时所在的工作目录的绝对路径。\n\n#### 参数\n\n无\n\n#### 返回值\n\n字符串标量。\n\n#### 例子\n\n```\ngetWorkDir()\n// output: /home/dolphindb/server/clusterDemo  \n```\n"
    },
    "glm": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/glm.html",
        "signatures": [
            {
                "full": "glm(ds, yColName, xColNames, [family], [link], [tolerance=1e-6], [maxIter=100])",
                "name": "glm",
                "parameters": [
                    {
                        "full": "ds",
                        "name": "ds"
                    },
                    {
                        "full": "yColName",
                        "name": "yColName"
                    },
                    {
                        "full": "xColNames",
                        "name": "xColNames"
                    },
                    {
                        "full": "[family]",
                        "name": "family",
                        "optional": true
                    },
                    {
                        "full": "[link]",
                        "name": "link",
                        "optional": true
                    },
                    {
                        "full": "[tolerance=1e-6]",
                        "name": "tolerance",
                        "optional": true,
                        "default": "1e-6"
                    },
                    {
                        "full": "[maxIter=100]",
                        "name": "maxIter",
                        "optional": true,
                        "default": "100"
                    }
                ]
            }
        ],
        "markdown": "### [glm](https://docs.dolphindb.cn/zh/funcs/g/glm.html)\n\n\n\n#### 语法\n\nglm(ds, yColName, xColNames, \\[family], \\[link], \\[tolerance=1e-6], \\[maxIter=100])\n\n#### 详情\n\n训练广义线性模型。\n\n#### 参数\n\n**ds** 是数据源，通常由 [sqlDS](https://docs.dolphindb.cn/zh/funcs/s/sqlDS.html) 函数生成。\n\n**yColName** 是字符串，表示数据源中作为因变量的列名。\n\n**xColNames** 是字符串标量或向量，表示数据源中作为自变量的列名。\n\n**family** 是字符串标量，表示指数族分布的类型。它的取值可以是 gaussian, poisson, gamma, inverseGaussian, binomial。\n\n**link** 是字符串标量，表示 *link* 函数的类型。对于不同取值的 *family*, *link* 的默认值如下表所示。\n\n**tolerance** 是浮点数，表示迭代中止的边界差值。如果相邻两次迭代的对数似然函数值的差值小于 *tolerance*，则停止迭代。默认值为0.000001。\n\n**maxIter** 是正整数，表示最大的迭代次数。默认值为100。\n\n*family* 参数对 *link* 参数、因变量的限制如下：\n\n| *family* 的取值    | *link* 可选值                              | 默认的 *link* 取值   | 因变量的取值    |\n| --------------- | --------------------------------------- | --------------- | --------- |\n| gaussian        | identity, inverse, log                  | identity        | DOUBLE 类型 |\n| poisson         | log, sqrt, identity                     | log             | 非负整数      |\n| gamma           | inverse, identity, log                  | inverse         | 大于等于0     |\n| inverseGaussian | inverseOfSquare, inverse, identity, log | inverseOfSquare | 大于等于0     |\n| binomial        | logit, probit                           | logit           | 0或1       |\n\n#### 返回值\n\n返回一个字典，包含以下 key：coefficients, link, tolerance, family, xColNames, tolerance, modelName, residualDeviance, iterations 和 dispersion。其中，coefficients 是一张表，包括计算得到的自变量系数值、每个系数的标准误差、t 值、p 值；modelName 为 \"Generalized Linear Model\"；iterations 是实际迭代次数；dispersion 是模型的规范系数。\n\n#### 例子\n\n下面的例子使用模拟数据训练一个广义线性模型：\n\n```\nx1 = rand(100.0, 100)\nx2 = rand(100.0, 100)\nb0 = 6\nb1 = 1\nb2 = -2\nerr = norm(0, 10, 100)\ny = b0 + b1 * x1 + b2 * x2 + err\nt = table(x1, x2, y)\nmodel = glm(sqlDS(<select * from t>), `y, `x1`x2, `gaussian, `identity);\nmodel;\n\n// output\ncoefficients->\n\nbeta     stdError tstat      pvalue\n-------- -------- ---------- --------\n1.027483 0.032631 31.487543  0\n-1.99913 0.03517  -56.842186 0\n5.260677 2.513633 2.092858   0.038972\n\nlink->identity\ntolerance->1.0E-6\nfamily->gaussian\nxColNames->[\"x1\",\"x2\"]\nmodelName->Generalized Linear Model\nresidualDeviance->8873.158697\niterations->5\ndispersion->91.475863\n```\n\n把模型用于预测：\n\n```\npredict(model, t);\n```\n\n把模型保存到磁盘：\n\n```\nsaveModel(model, \"C:/DolphinDB/Data/GLMModel.txt\");\n```\n\n把模型加载到内存中：\n\n```\nloadModel(\"C:/DolphinDB/Data/GLMModel.txt\");\n```\n"
    },
    "gmd5": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/gmd5.html",
        "signatures": [
            {
                "full": "gmd5(X)",
                "name": "gmd5",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [gmd5](https://docs.dolphindb.cn/zh/funcs/g/gmd5.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\ngmd5(X)\n\n#### 详情\n\n根据 MD5 算法，对 X 的所有元素进行哈希。当 X 是元组/数组向量/数据对/矩阵时，对其平铺后计算 MD5 哈希值。\n\n#### 参数\n\n**X** 可以是标量、向量、元组、数组向量、数据对或矩阵。\n\n#### 返回值\n\nINT128 类型标量。\n\n#### 例子\n\n```\ngmd5([1 2 3])\n// output: 2a1dd1e1e59d0a384c26951e316cd7e6\n\ngmd5([[1, 2], 3])\n// 因为构建 MD5 的数据完全一致，所以输出也一致\n// output: 2a1dd1e1e59d0a384c26951e316cd7e6\n\nxs = array(INT[], 0, 10).append!([1 2 3, 4 5, 6 7 8, 9 10])\ngmd5(xs)\n// output: c457b6addd2869161f8a853c0f247aaf\n\nys = [1 2 3, 4 5, 6 7 8, 9 10]\ngmd5(ys)\n// output: c457b6addd2869161f8a853c0f247aaf\n\nm=matrix(1 2 3, 8 7 0)\ngmd5(m)\n// output: 660a82bc074f9dccc5c9fbb806f44f5c\n```\n\n相关函数：[rowGmd5](https://docs.dolphindb.cn/zh/funcs/r/rowgmd5.html)\n"
    },
    "gmm": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/gmm.html",
        "signatures": [
            {
                "full": "gmm(X, k, [maxIter=300], [tolerance=1e-4], [randomSeed], [mean], [sigma])",
                "name": "gmm",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "k",
                        "name": "k"
                    },
                    {
                        "full": "[maxIter=300]",
                        "name": "maxIter",
                        "optional": true,
                        "default": "300"
                    },
                    {
                        "full": "[tolerance=1e-4]",
                        "name": "tolerance",
                        "optional": true,
                        "default": "1e-4"
                    },
                    {
                        "full": "[randomSeed]",
                        "name": "randomSeed",
                        "optional": true
                    },
                    {
                        "full": "[mean]",
                        "name": "mean",
                        "optional": true
                    },
                    {
                        "full": "[sigma]",
                        "name": "sigma",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [gmm](https://docs.dolphindb.cn/zh/funcs/g/gmm.html)\n\n\n\n#### 语法\n\ngmm(X, k, \\[maxIter=300], \\[tolerance=1e-4], \\[randomSeed], \\[mean], \\[sigma])\n\n#### 详情\n\n通过数据集训练 GMM（高斯混合模型）。\n\n#### 参数\n\n**X** 训练数据集。若为一元数据，则 *X* 是一个向量；若为多元数据，则 *X* 是一个矩阵或表，矩阵的每列代表一个样本数据。\n\n**k** 正整数。表示混合模型中子模型的数量。\n\n**maxlter** 正整数，表示最大的迭代次数。默认为 300。\n\n**tolerance** 浮点数，表示 EM 迭代中止的边界差值。如果相邻两次迭代的对数似然函数值的差值小于 *tolerance*，则停止迭代。默认为 1e-4。\n\n**randomSeed** 随机数种子。\n\n**mean** 可选参数，向量/矩阵。表示模型初始化的均值。若 *X* 为一元数据，则 *mean* 是元素个数为 *k* 的向量；若 *X* 为多元数据，则 *mean* 是列数为 *k*，行数与 *X* 的元数相同的矩阵。若不指定，系统随机从 *X* 中选择 *k* 个值作为模型的初始化均值。\n\n**sigma** 可选参数，向量/元组，元素个数为 *k*。若 *X* 为一元数据，表示每个子模型初始化的方差；若 *X* 为多元数据，表示每个子模型初始化的协方差矩阵。若不指定，系统使用 1 作为方差，或单位矩阵作为协方差矩阵。\n\n#### 返回值\n\n返回一个字典，包含以下键值：\n\n* modelName：字符串 \"Gaussian Mixture Model\"。\n\n* prior：观测数据属于各子模型的先验概率。\n\n* mean：训练获得的每个子模型的期望。\n\n* sigma：若 *X* 为 一元数据，表示训练获得的每个子模型的方差；若 *X* 为多元数据，表示训练获得的每个子模型的协方差矩阵。\n\n#### 例子\n\n```\ndataT = 6.8 7.2 5.3 9.4 6.5 11.2 25.6 0.6 8.9 4.3 2.2 1.9 8.7 0.2 1.5\nmean = [2, 2]\nre = gmm(dataT, 2, 300, 1e-4, 42, mean)\nre\n\n// output\nsigma->[36.759822,36.759822]\nmodelName->Gaussian Mixture Model\nprior->[0.5,0.5]\nmean->[6.686667,6.686667]\n\ndataT = transpose(matrix(3.2 1.5 2.6 7.8 6.3 4.2 5.1 8.9 11.2 25.8, 25.6 4.6 8.9 4.3 2.2 1.9 8.7 0.2 1.5 9.3))\nmean = transpose(matrix([1, 0], [0, 1]))\nre = gmm(dataT, 2, 300, 1e-4, 42, mean)\nre\n\n// output\nsigma->(#0        #1\n51.001369 18.273032\n18.273032 9.34789\n,#0       #1\n1.718475 0.629584\n0.629584 67.713701\n)\nmodelName->Gaussian Mixture Model\nprior->[0.558683,0.441317]\nmean->\n#0        #1\n11.152841 3.238262\n3.341493  10.996997\n```\n"
    },
    "gmtime": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/gmtime.html",
        "signatures": [
            {
                "full": "gmtime(X)",
                "name": "gmtime",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [gmtime](https://docs.dolphindb.cn/zh/funcs/g/gmtime.html)\n\n\n\n#### 语法\n\ngmtime(X)\n\n#### 详情\n\n把本地时间 *X* 转换成零时区时间，即格林尼治时间（GMT）。\n\n#### 参数\n\n**X** 可以是 DATETIME, TIMESTAMP, NANOTIMESTAMP 类型的标量或向量。\n\n#### 返回值\n\n与输入的数据类型和形式一致。\n\n#### 例子\n\n以下例子在美国东部时区执行：\n\n```\ngmtime(2018.01.22 10:20:26);\n\n// output: 2018.01.22T15:20:26\n\ngmtime(2017.12.16T13:30:10.008);\n\n// output: 2017.12.16T18:30:10.008\n```\n"
    },
    "gpFit": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/gpfit.html",
        "signatures": [
            {
                "full": "gpFit(engine, [programNum=1], [programCorr=false])",
                "name": "gpFit",
                "parameters": [
                    {
                        "full": "engine",
                        "name": "engine"
                    },
                    {
                        "full": "[programNum=1]",
                        "name": "programNum",
                        "optional": true,
                        "default": "1"
                    },
                    {
                        "full": "[programCorr=false]",
                        "name": "programCorr",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [gpFit](https://docs.dolphindb.cn/zh/funcs/g/gpfit.html)\n\n#### 语法\n\ngpFit(engine, \\[programNum=1], \\[programCorr=false])\n\n**Note:**\n\n社区版 License 暂不支持该函数，如需使用此功能，请联系技术支持。\n\n#### 详情\n\n查看训练生成的公式。\n\n#### 参数\n\n**engine** 通过函数 createGPLearnEngine 创建引擎的返回对象。\n\n**programNum** 整型标量，表示训练完返回的公式数量。\n\n**programCorr** 布尔标量，指示是否返回公式之间的相关性。\n\n#### 返回值\n\n返回一个表：\n\n* 第一列为 program 列，STRING 类型，用于存储得到的公式；\n* 第二列为 fitness 列，DOUBLE 类型，存储公式的适应度；\n* 当 programCorr 为 true 时，第三列为 programCorr 列，是DOUBLE 类型的数组向量，存储公式之间的相关性。\n\n#### 例子\n\n参考：[Shark GPLearn 快速上手](https://docs.dolphindb.cn/zh/tutorials/gplearn.html)。\n\n\n\n**Related information**\n\n[Shark GPLearn 快速上手](https://docs.dolphindb.cn/zh/tutorials/gplearn.html)\n"
    },
    "gpPredict": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/gppredict.html",
        "signatures": [
            {
                "full": "gpPredict(engine, input, [programNum = 1], [groupCol], [deviceId=0])",
                "name": "gpPredict",
                "parameters": [
                    {
                        "full": "engine",
                        "name": "engine"
                    },
                    {
                        "full": "input",
                        "name": "input"
                    },
                    {
                        "full": "[programNum = 1]",
                        "name": "[programNum = 1]"
                    },
                    {
                        "full": "[groupCol]",
                        "name": "groupCol",
                        "optional": true
                    },
                    {
                        "full": "[deviceId=0]",
                        "name": "deviceId",
                        "optional": true,
                        "default": "0"
                    }
                ]
            }
        ],
        "markdown": "### [gpPredict](https://docs.dolphindb.cn/zh/funcs/g/gppredict.html)\n\n#### 语法\n\ngpPredict(engine, input, \\[programNum = 1], \\[groupCol], \\[deviceId=0])\n\n**Note:**\n\n社区版 License 暂不支持该函数，如需使用此功能，请联系技术支持。\n\n#### 详情\n\n采用上次训练得到的适应度函数较小的前 programNum 个公式用于预测。如果指定 groupCol，计算时还会依据 groupCol 分组。\n\n#### 参数\n\n**engine**通过函数 createGPLearnEngine 创建引擎的返回对象。\n\n**input** 浮点型的表，表示需要预测的数据。\n\n**programNum** 整型标量，表示参与预测的公式数量，默认为 1。\n\n**groupCol** 字符型标量，表示进行分组的列名，默认为空。此列不会参与计算。\n\n**deviceId** INT类型的标量或向量。当前机器拥有多卡时，可以指定使用的设备 ID，默认为 0 。\n\n#### 返回值\n\n返回一个表，共 programNum 列，列名为 gpFit 训练得到的公式。\n\n#### 例子\n\n参考：[Shark GPLearn 快速上手](https://docs.dolphindb.cn/zh/tutorials/gplearn.html)。\n\n\n\n**Related information**\n\n[Shark GPLearn 快速上手](https://docs.dolphindb.cn/zh/tutorials/gplearn.html)\n"
    },
    "gram": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/gram.html",
        "signatures": [
            {
                "full": "gram(ds, [colNames], [subMean], [normalize])",
                "name": "gram",
                "parameters": [
                    {
                        "full": "ds",
                        "name": "ds"
                    },
                    {
                        "full": "[colNames]",
                        "name": "colNames",
                        "optional": true
                    },
                    {
                        "full": "[subMean]",
                        "name": "subMean",
                        "optional": true
                    },
                    {
                        "full": "[normalize]",
                        "name": "normalize",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [gram](https://docs.dolphindb.cn/zh/funcs/g/gram.html)\n\n\n\n#### 语法\n\ngram(ds, \\[colNames], \\[subMean], \\[normalize])\n\n#### 详情\n\n计算数据源中对应列的数据的格拉姆矩阵。假设数据对应的矩阵为 A，返回的结果为 A 的转置与其自身的点积，即 A.tranpose() dot A。\n\n#### 参数\n\n**ds** 是一个或多个数据源，通常由 [sqlDS](https://docs.dolphindb.cn/zh/funcs/s/sqlDS.html) 生成。\n\n**colNames** 是字符串标量或向量，表示数据源中用于计算的列名。默认值是数据源中所有列的列名。\n\n**subMean** 是一个布尔值，表示每列是否减去该列的均值。默认值为 true。\n\n**normalize** 是一个布尔值，表示每列是否除以该列的标准差。默认值为 false。\n\n#### 返回值\n\n一个矩阵。\n\n#### 例子\n\n```\nx = [7,1,1,0,5,2]\ny = [0.7, 0.9, 0.01, 0.8, 0.09, 0.23]\nt=table(x, y)\nds = sqlDS(<select * from t>);\ngram(ds);\n```\n\n| #0        | #1      |\n| --------- | ------- |\n| 37.333333 | -0.56   |\n| -0.56     | 0.75895 |\n"
    },
    "gramSchmidt": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/gramSchmidt.html",
        "signatures": [
            {
                "full": "gramSchmidt(X, [normalize = false])",
                "name": "gramSchmidt",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[normalize = false]",
                        "name": "[normalize = false]"
                    }
                ]
            }
        ],
        "markdown": "### [gramSchmidt](https://docs.dolphindb.cn/zh/funcs/g/gramSchmidt.html)\n\n\n\n#### 语法\n\ngramSchmidt(X, \\[normalize = false])\n\n#### 详情\n\n将列满秩矩阵转换为一个列向量正交的矩阵。\n\n#### 参数\n\n**X** 一个列满秩矩阵（每个列向量均线性无关），且不能包含空值。\n\n**normalize** 可选参数，一个布尔值，表示是否输出标准正交矩阵，默认值为 false。\n\n#### 返回值\n\nDOUBLE 类型矩阵。\n\n#### 例子\n\n```\nx = matrix([2 3 5, 3 6 2, 8 3 6]);\ngramSchmidt(x)\n\n// output\ncol1    col2    col3\n2.0000  1.2105  4.7932\n3.0000  3.3157  -2.1968\n5.0000  -2.4736 -0.5991\n\n// 指定 normalize=true，则输出标准正交矩阵。\ngramSchmidt(x, true)\n\n// output\ncol1    col2    col3\n0.3244      0.2808  0.9033\n0.4867      0.7693  -0.414\n0.8111      -0.5739 -0.1129\n\n\n// 矩阵的列向量线性相关时，则会报错\nx = matrix([1 4, 2 5, 3 6]);\ngramSchmidt(x)\n\n// output\nvector set must be linearly independent\n```\n"
    },
    "grant": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/grant.html",
        "signatures": [
            {
                "full": "grant(userId|groupId, accessType, [objs])",
                "name": "grant",
                "parameters": [
                    {
                        "full": "userId|groupId",
                        "name": "userId|groupId"
                    },
                    {
                        "full": "accessType",
                        "name": "accessType"
                    },
                    {
                        "full": "[objs]",
                        "name": "objs",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [grant](https://docs.dolphindb.cn/zh/funcs/g/grant.html)\n\n\n\n#### 语法\n\ngrant(userId|groupId, accessType, \\[objs])\n\n#### 详情\n\n`grant` 函数用于授予某个用户或用户组指定权限，包括：\n\n* 管理员可通过该命令授予用户或用户组所有权限（任意 *accessType*）。\n\n* 普通用户仅在拥有相关对象的 OWNER 权限时，才能授予以下权限：\n\n  TABLE\\_READ, TABLE\\_WRITE, TABLE\\_INSERT, TABLE\\_UPDATE, TABLE\\_DELETE, DB\\_READ, DB\\_WRITE, DB\\_INSERT, DB\\_UPDATE, DB\\_DELETE, DBOBJ\\_DELETE, DBOBJ\\_CREATE, VIEW\\_EXEC。\n\n* *accessType* = DB\\_OWNER 支持通过 *objs* 指定一个或多个数据库名前缀，用于限制用户可创建和管理的数据库。多个前缀规则可通过向量传递。若用户已获得全局 DB\\_OWNER 权限，则该前缀规则无效。规则之间互不覆盖，除非某规则包含另一个。可通过 `getUserAccess` 函数查看用户已授权的前缀规则。\n\n  权限判定逻辑如下：\n\n  * 若用户全局权限被拒绝，则禁止创建和管理数据库操作；\n\n  * 否则，只要数据库名称匹配任一前缀规则，操作即被允许。\n    注意：\n\n  * 前缀规则仅支持通过 `grant` 和 `revoke` 进行授权和撤销，不能用 `deny` 拒绝；\n\n  * DB\\_OWNER 权限仅在全局范围生效，前缀规则覆盖先前定义的规则。\n\n* 查询内存限制权限\n\n  * QUERY\\_RESULT\\_MEM\\_LIMIT：约束用户查询返回结果的内存上限；\n  * TASK\\_GROUP\\_MEM\\_LIMIT：约束用户发送的批量子查询占用的内存上限。\n\n    这两项权限功能等同于 `setMemLimitOfQueryResult` 和 `setMemLimitOfTaskGroupResult`，但仅针对指定用户生效，不支持用户组。\n\n* *accessType* = CREATE\\_SHARED\\_VAR\n\n  该权限用于限制用户创建共享变量的能力，仅在系统参数 *enableSharedVarCreationControl* = true 时生效。该权限为全局权限，不支持通过对象（*objs*）进行细分控制。\n\n  默认情况下：\n\n  * admin 用户具备该权限；\n  * guest 用户及新建用户普通用户不具备，需显式授权；新建的管理员用户也不具备，但可以为自己显式授权。\n    若配置项为 false，系统不启用权限校验，所有用户均可创建共享变量（即权限设置存在但不生效）。\n\n* Orca 流图和流表相关权限：详见 [Orca 实时计算平台 6.3 节](https://docs.dolphindb.cn/zh/stream/orca.md#)。\n\n#### 参数\n\n**userId** | **groupId** 是表示用户名或组名的字符串。\n\n**accessType** 权限类型/内存限制。\n\n**objs** 标量或向量，表示权限类型的应用对象/约束规则。也可以指定为 \\*，表示全局。当 *accessType* 指定为 COMPUTE\\_GROUP\\_EXEC 时，*objs* 必须为对应的计算组名。\n\n**Note:**\n\n* 管理共享内存表、流数据表或流计算引擎的权限时，*objs* 必须为 \"tableName\\@nodeAlias\" 或\"nodeAlias:tableName\"。\n* 管理 IMOLTP 引擎库表权限时，*objs* 必须为 \"oltp\\://database/table\\@nodeAlias\" 或 \"oltp\\://database\\@nodeAlias\"。\n\n*accessType* 和 *objs* 的取值请参照 [用户权限管理](https://docs.dolphindb.cn/zh/tutorials/ACL_and_Security.html) 权限类型表。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n授予组 \"research\" 的所有成员读取所有数据库表的权限：\n\n```\ngrant(`research, TABLE_READ, \"*\")\n```\n\n授予组 \"research\" 的所有成员读写表 `dfs://db1/t1` 的权限：\n\n```\ngrant(`research, TABLE_WRITE, \"dfs://db1/t1\")\n```\n\n授予组 \"research\" 的所有成员在数据库 `dfs://db1` 和 `dfs://db2` 创建表的权限：\n\n```\ngrant(\"research\", DBOBJ_CREATE, [\"dfs://db1\",\"dfs://db2\"])\n```\n\n授予用户 \"AlexSmith\" 删除数据库的权限：\n\n```\ngrant(\"AlexSmith\", DB_MANAGE)\n```\n\n授予用户\"AlexSmith\"执行脚本的权限：\n\n```\ngrant(\"AlexSmith\", SCRIPT_EXEC)\n```\n\n授予用户 \"AlexSmith\" 测试脚本的权限：\n\n```\ngrant(\"AlexSmith\", TEST_EXEC)\n```\n\n授予用户”AlexSmith”命名空间 test1下函数 f1 的执行权限：\n\n```\ngrant(\"AlexSmith\", VIEW_EXEC, \"test1::f1\")\n```\n\n授予用户”AlexSmith”命名空间 test2 下所有函数的执行权限：\n\n```\ngrant(\"AlexSmith\", VIEW_EXEC, \"test2::*\")\n```\n\n命名空间必须是模块级别。例如有一个模块 *test.dos*，所在路径为 `moduleDir/mod1/test.dos`，为用户授权执行模块中所有函数时，应通过以下脚本实现：\n\n```\ngrant(\"AlexSmith\", VIEW_EXEC, \"mod1::test::*\")\n```\n\n不支持写成：\n\n```\ngrant(\"AlexSmith\", VIEW_EXEC, \"mod1::*\")\n```\n\n如果授权了某个命名空间，后来命名空间中的函数视图被通过 `dropFunctionView` 删除，一旦命名空间中的最后一个函数视图被删除，对该命名空间的授权也将自动回收。同理，授权时如果发现该命名空间下没有函数视图，会抛出异常。\n\n对于没有命名空间的函数视图，被认为是全局的。以下两种方式等价：\n\n```\ngrant(\"AlexSmith\", VIEW_EXEC, \"::f\")\ngrant(\"AlexSmith\", VIEW_EXEC, f)\n```\n\n约束用户查询所占用的内存：\n\n指定 *accessType* 为 QUERY\\_RESULT\\_MEM\\_LIMIT，此时 *objs* 表示限制的内存大小，单位为 GB。下述脚本限制用户 \"AlexSmith\" 查询时，查询结果所占用的内存大小不能超过 4 GB。\n\n```\ngrant(\"AlexSmith\", QUERY_RESULT_MEM_LIMIT, 4)\n```\n\n约束用户只能创建指定前缀的数据库：\n\n假设管理员要求限制用户 \"AlexSmith\" 只能创建并管理以 ddb 作为库名前缀的数据库，可以通过以下脚本实现：\n\n```\ngrant(\"AlexSmith\", DB_OWNER, \"dfs://ddb*\")\n```\n\n当指定 `grant` 函数的 *accessType* 为 DB\\_OWNER 时，可以指定 *objs* 为一个规则，目前仅支持约束用户可以创建的库名前缀，便于不同用户管理不同范围的数据库。\n\n当需要指定多个规则时，可以为 objs 传入一个向量，如下脚本所示：\n\n```\ngrant(\"AlexSmith\", DB_OWNER, [\"dfs://ddb_prefix1*\",\"dfs://ddb_prefix2*\"])\n```\n\n授权时，如果当前已有全局授权，则对某一前缀规则的授权将无效。如果前缀规则之间存在包含关系，则这些规则不会相互覆盖。\n\n当用户创建或管理数据库时，如有全局禁止，则禁止执行，否则，用户的权限为所有前缀规则的并集，即如果库名符合已授权的任一前缀规则，则允许执行。已授权的前缀规则可以通过函数 `getUserAccess` 查看。\n\n**Note:** 特定的前缀约束规则，只能通过 `grant` 指定、通过 `revoke` 移除，但不能通过 `deny` 禁止。当 *accessType* 为 DB\\_OWNER 时，`deny` 只能对全局生效，且会覆盖之前已有的前缀约束规则。\n"
    },
    "groups": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/groups.html",
        "signatures": [
            {
                "full": "groups(X, [mode='dict'])",
                "name": "groups",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[mode='dict']",
                        "name": "mode",
                        "optional": true,
                        "default": "'dict'"
                    }
                ]
            }
        ],
        "markdown": "### [groups](https://docs.dolphindb.cn/zh/funcs/g/groups.html)\n\n\n\n#### 语法\n\ngroups(X, \\[mode='dict'])\n\n#### 详情\n\n对 *X* 中每一个独特值，列出其在 *X* 中的所有对应数据的下标。\n\n#### 参数\n\n**X** 是一个向量。\n\n**mode** 可选参数，用于指定 `groups` 返回值的数据形式，默认为 \"dict\"。可指定为以下值：\n\n* \"dict\"：返回一个字典。字典的 key 存储 *X* 中的独特值（unique value）；字典的 value 为一个向量，存储该值在 *X* 中对应的下标。\n\n* \"table\"：返回一个包含两列的表。字段为 \"key\" 和 \"index\"，分别存储 *X* 中的独特值和其在 *X* 中对应的下标。\n\n* \"vector\"：返回一个 array vector，按照 *X* 中独特值升序排列，存储每个独特值在 *X* 中对应的下标。\n\n* \"tuple\"：返回一个 tuple，其存储方式同 *mode*=\"vector\"。\n\n#### 返回值\n\n若 *mode* = 'dict'，返回一个字典；若 *mode* = 'table'，返回一个数据表，其中 index 列表示下标，为数组向量类型。\n\n#### 例子\n\n```\nx=NULL NULL 12 15 12 16 15 14 NULL NULL\ngroups(x);\n\n// output\n16->[5]\n->[0,1,8,9]\n12->[2,4]\n14->[7]\n15->[3,6]\n\ngroups\\(x, \"vector\"\\)\n// output\n\\[\\[0,1,8,9\\],\\[2,4\\],\\[7\\],\\[3,6\\],\\[5\\]\\]\n\ngroups\\(x, \"tuple\"\\)\n// output\n\\(\\[0,1,8,9\\],\\[2,4\\],\\[7\\],\\[3,6\\],\\[5\\]\\)\n\ngroups\\(x, \"table\"\\)\n```\n\n| key | index      |\n| --- | ---------- |\n|     | \\[0,1,8,9] |\n| 2   | \\[2,4]     |\n| 4   | \\[7]       |\n| 5   | \\[3,6]     |\n| 6   | \\[5]       |\n"
    },
    "gt": {
        "url": "https://docs.dolphindb.cn/zh/funcs/g/gt.html",
        "signatures": [
            {
                "full": "gt(X, Y)",
                "name": "gt",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [gt](https://docs.dolphindb.cn/zh/funcs/g/gt.html)\n\n\n\n#### 语法\n\ngt(X, Y)或 X>Y\n\n#### 详情\n\n如果 *X* 和 *Y* 都不是集合，返回逐个元素比较 *X*>*Y* 的结果。\n\n如果 *X* 和 *Y* 都是集合，则检查 *Y* 是否为 *X* 的真子集。\n\n#### 参数\n\n**X** 和 **Y** 可以是标量、数据对、向量、矩阵或集合。如果 *X* 或 *Y* 的其中一个是数据对、向量或矩阵，另一个必须是一个标量，或具有相同长度或维度的数据对、向量或矩阵。\n\n#### 返回值\n\n布尔类型，数据形式由输入参数决定。\n\n#### 例子\n\n```\n1 2 3 > 2;\n// output: [false,false,true]\n\n1 2 3>0 2 4;\n// output: [true,false,false]\n\n2:3>1:6;\n// output\ntrue : false\n\nm1=1..6$2:3;\nm1;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1  | 3  | 5  |\n| 2  | 4  | 6  |\n\n```\nm1 gt 4;\n```\n\n| #0    | #1    | #2   |\n| ----- | ----- | ---- |\n| false | false | true |\n| false | false | true |\n\n```\nm2=6..1$2:3;\nm2;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 6  | 4  | 2  |\n| 5  | 3  | 1  |\n\n```\nm1>m2;\n```\n\n| #0    | #1    | #2   |\n| ----- | ----- | ---- |\n| false | false | true |\n| false | true  | true |\n\n集合操作：如果 *X*>*Y*，则 *Y* 是 *X* 的真子集。\n\n```\nx=set(4 6);\nx;\n\nset(6,4)\n\ny=set(8 9 4 6);\ny;\n\nset(6,4,9,8)\ny>x;\n// output\ntrue\n\nx>y;\n// output: false\n\nx>x;\n// output: false\n// x 不是 x 的真子集\n```\n"
    },
    "kama": {
        "url": "https://docs.dolphindb.cn/zh/funcs/k/kama.html",
        "signatures": [
            {
                "full": "kama(X, window)",
                "name": "kama",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    }
                ]
            }
        ],
        "markdown": "### [kama](https://docs.dolphindb.cn/zh/funcs/k/kama.html)\n\n\n\n#### 语法\n\nkama(X, window)\n\nTA-lib 系列函数参数说明和窗口计算规则请参考：[TA-lib 系列](https://docs.dolphindb.cn/zh/funcs/themes/TAlib.html)\n\n#### 详情\n\n在给定长度（以元素个数衡量）的滑动窗口内，计算 *X* 的考夫曼自适应移动平均值（Kaufman Adaptive Moving Average）。\n\n#### 返回值\n\nDOUBLE 类型，数据形式同 *X*。\n\n#### 例子\n\n```\nx=[51.65, 81.18, 43.37, 11.26, 82.79, 13.4, 81.87, 63.53, 21.28, 94.23]\nkama(x, 5);\n// output\n[,,,,,81.006144,81.009907,80.793626,80.344572,80.456788]\n\nt=table(take(`A`B,10) as sym, rand(100.0,10) as close)\nselect sym, kama(close, 3) as kama from t context by sym;\n```\n\n输出返回：\n\n| sym | kama      |\n| --- | --------- |\n| A   |           |\n| A   |           |\n| A   |           |\n| A   | 66.342572 |\n| A   | 62.500023 |\n| B   |           |\n| B   |           |\n| B   |           |\n| B   | 17.376469 |\n| B   | 42.27882  |\n"
    },
    "kendall": {
        "url": "https://docs.dolphindb.cn/zh/funcs/k/kendall.html",
        "signatures": [
            {
                "full": "kendall(X, Y)",
                "name": "kendall",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [kendall](https://docs.dolphindb.cn/zh/funcs/k/kendall.html)\n\n\n\n#### 语法\n\nkendall(X, Y)\n\n#### 详情\n\n计算 *X* 和 *Y* 的 Kendall 相关性系数。计算时忽略 NULL 值。\n\n若 *X* 或 *Y* 是矩阵，对每一列执行上述计算，返回一个向量。\n\n如果 *X* 或 *Y* 是内存表，则对表中的每个数值列执行上述计算，非数值列将返回空，结果为一个表。\n\n#### 参数\n\n**X** 一个标量/向量/矩阵/内存表。\n\n**Y** 一个标量/向量/矩阵/内存表。\n\n#### 返回值\n\nDOUBLE 类型标量/向量/表。\n\n#### 例子\n\n```\nx = [33,21,46,-11,78,47,18,20,-5,66]\ny = [1,NULL,10,6,10,3,NULL,NULL,5,3]\nkendall(x, y)\n//output\n0.05\n```\n\n如果 *X* 是矩阵，*Y* 可以长度是与 *X* 行数相同的向量，或者是与 *X* 维度相同的矩阵。返回结果是长度与 *X* 列数相同的向量。\n\n```\nm=1..20$10:2\nkendall(m,x)\n//output\n[-0.0222,-0.0222]\n\nn=rand(20,20)$10:2\nkendall(m,n)\n//output\n[0.3865,-0.1591]\n```\n\n如果 *X* 是表，*Y* 可以是长度与 *X* 行数相同的向量，或者是维度与 *X* 相同的表。返回结果是与 *X* 列数相同的表。\n\n```\nt=table(2..11 as id, \"a\"+string(2..11) as name)\nkendall(t,x)\n```\n\n| id      | name |\n| :------ | :--- |\n| -0.0222 |      |\n\n```\nt1=table(x as col1, y as col2)\nkendall(t,t1)\n```\n\n| id      | name |\n| :------ | :--- |\n| -0.0222 |      |\n"
    },
    "kernelRidge": {
        "url": "https://docs.dolphindb.cn/zh/funcs/k/kernelRidge.html",
        "signatures": [
            {
                "full": "kernelRidge(ds, yColName, xColNames, [alpha=1.0], [kernel='linear'], [gamma=0], [degree=3], [coef0=1], [swColName])",
                "name": "kernelRidge",
                "parameters": [
                    {
                        "full": "ds",
                        "name": "ds"
                    },
                    {
                        "full": "yColName",
                        "name": "yColName"
                    },
                    {
                        "full": "xColNames",
                        "name": "xColNames"
                    },
                    {
                        "full": "[alpha=1.0]",
                        "name": "alpha",
                        "optional": true,
                        "default": "1.0"
                    },
                    {
                        "full": "[kernel='linear']",
                        "name": "kernel",
                        "optional": true,
                        "default": "'linear'"
                    },
                    {
                        "full": "[gamma=0]",
                        "name": "gamma",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[degree=3]",
                        "name": "degree",
                        "optional": true,
                        "default": "3"
                    },
                    {
                        "full": "[coef0=1]",
                        "name": "coef0",
                        "optional": true,
                        "default": "1"
                    },
                    {
                        "full": "[swColName]",
                        "name": "swColName",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [kernelRidge](https://docs.dolphindb.cn/zh/funcs/k/kernelRidge.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nkernelRidge(ds, yColName, xColNames, \\[alpha=1.0], \\[kernel='linear'], \\[gamma=0], \\[degree=3], \\[coef0=1], \\[swColName])\n\n#### 详情\n\n该函数基于核函数和岭回归的正则化技术，拟合数据间的复杂非线性关系，输出回归预测模型。\n\n目标函数为：\n\n![](https://docs.dolphindb.cn/zh/funcs/images/kernelRidge.png)\n\n#### 参数\n\n**ds** 是内存表或由 [sqlDS](https://docs.dolphindb.cn/zh/funcs/s/sqlDS.html) 生成的数据源。\n\n**yColName**是字符串，表示数据源中因变量的列名，对应目标函数中的 y 。\n\n**xColNames**是字符串标量或向量，表示数据源中自变量的列名。对应目标函数中的 X。\n\n**alpha**可选参数，是正数，表示正则化强度。默认值为 1.0。 对应目标函数中的 alpha。\n\n**kernel**可选参数，是字符串，表示核函数的类型。对应目标函数中的 `Φ`。支持以下核函数：\n\n* 'linear'：线性核函数 `<x, y>`\n* 'rbf'：径向基函数核（高斯核）`exp(-gamma * ||x - y||²)`\n* 'poly'/'polynomial'：多项式核函数 `(gamma * <x, y> + coef0)^degree`\n* 'sigmoid'：Sigmoid核函数 `tanh(gamma * <x, y> + coef0)`\n* 'laplacian'：拉普拉斯核函数 `exp(-gamma * ||x - y||₁)`\n* 'cosine'：余弦相似度核函数 `<x, y> / (||x|| * ||y||)`\n* 'additive\\_chi2'：加性卡方核函数 `-∑[(x - y)² / (x + y)]`\n* 'chi2'：卡方核函数 `exp(-gamma * ∑[(x - y)² / (x + y)])`\n\n**gamma**可选参数，是数值标量，表示核函数参数。默认值为 0，此时根据特征数自动设置。\n\n**degree**可选参数，是数值标量，表示多项式核函数的次数。默认值为 3 。\n\n**coef0**可选参数，是数值标量，表示核函数中的常数项系数。默认值为 1.0 。\n\n**swColName**可选参数，是字符串，指定 *ds*中的一个列名，将该列作为样本权重。默认所有样本的权重都为 1 。\n\n#### 返回值\n\n返回一个字典，包含以下键：\n\n* modelName: 字符串标量，表示模型名称，即 kernelRidge 方法对应的模型名为 “kernelRidge”。\n* coefficients: 数值向量，表示参数向量，对应目标函数中的 w 向量。\n* xColNames: 字符串向量，表示特征变量列名。\n* xFit: 数值矩阵，用于存储输入数据源中的自变量。\n* alpha: 数值标量，与参数中的 *alpha* 相同。\n* kernel: 字符串标量，与参数中的 *kernel* 相同。\n* gamma: 数值标量，与参数中的 *gamma* 相同。\n* degree: 数值标量，与参数中的 *degree* 相同。\n* coef0: 数值标量，与参数中的 *coef0* 相同。\n* predict: 模型的预测函数。\n\n#### 例子\n\n```\nx1 = [-1.5, 2.3, 4.2, 1.6];\nx2 = [-2.2, 3.9, 2.8, 0.5];\nsw = [2, 5, 8, 1];\ny = [0.0, 0.9, 3.2, 3.1];\nt = table(y, x1, x2, sw);\n\nm = kernelRidge(t, `y, `x1`x2, 1, 'laplacian', 0, 3, 1, `sw);\nm\n/*\nmodelName->kernelRidge\ncoefficients->#0                \n------------------\n-0.061436450468451\n0.09192514209272  \n2.716894143137368 \n1.428547958639275 \n\nxColNames->[\"x1\",\"x2\"]\nxFit->#0                #1  \n----------------- ----\n-1.5              -2.2\n2.3               3.9 \n4.200000000000001 2.8 \n1.6               0.5 \n\nalpha->1\nkernel->laplacian\ngamma->0.5\ndegree->3\ncoef0->1\npredict->kernelRidgePredict\n*/\n\n\n\nx1 = [-1.2, 4.6, 2.4];\nx2 = [-1.0, 2.8, -4.7];\nt_test = table(x1, x2);\npredict(m, t_test);\n/*\n#0               \n-----------------\n0.166070925673076\n2.34188781136904 \n0.095783250622374\n*/\n\n```\n"
    },
    "keyedStreamTable": {
        "url": "https://docs.dolphindb.cn/zh/funcs/k/keyedStreamTable.html",
        "signatures": [
            {
                "full": "keyedStreamTable(keyColumn, X, [X1], [X2], .....)",
                "name": "keyedStreamTable",
                "parameters": [
                    {
                        "full": "keyColumn",
                        "name": "keyColumn"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[X1]",
                        "name": "X1",
                        "optional": true
                    },
                    {
                        "full": "[X2]",
                        "name": "X2",
                        "optional": true
                    },
                    {
                        "full": ".....",
                        "name": "....."
                    }
                ]
            },
            {
                "full": "keyedStreamTable(keyColumn, capacity:size, colNames, colTypes)",
                "name": "keyedStreamTable",
                "parameters": [
                    {
                        "full": "keyColumn",
                        "name": "keyColumn"
                    },
                    {
                        "full": "capacity:size",
                        "name": "capacity:size"
                    },
                    {
                        "full": "colNames",
                        "name": "colNames"
                    },
                    {
                        "full": "colTypes",
                        "name": "colTypes"
                    }
                ]
            }
        ],
        "markdown": "### [keyedStreamTable](https://docs.dolphindb.cn/zh/funcs/k/keyedStreamTable.html)\n\n\n\n#### 语法\n\nkeyedStreamTable(keyColumn, X, \\[X1], \\[X2], .....)\n\n或\n\nkeyedStreamTable(keyColumn, capacity:size, colNames, colTypes)\n\n#### 详情\n\n创建键值流数据表。该表的主键不允许包含重复值。主键支持一个或多个字段。\n\n实际应用中，可能由于网络原因，会出现数据重复提交写入的情况；或者在上游采用了多路高可用的方式写入数据。面对上述场景，键值流数据表可以实现流数据的幂等性写入，即多次写入键值相同的数据，其结果与第一次写入的结果相同，从而避免数据重复写入。\n\n需要注意的是，此处的键值唯一性并非全局唯一，而是指内存中数据的唯一性。为流数据表开启持久化，可以设置内存中保留的数据条数，一旦数据条数超过设定的上限，系统将一半旧的数据持久化至磁盘。这种方案确保了内存中数据键值的唯一性，而不是全局唯一性。尽管如此，已足以解决多路写入或网络延迟导致的重复提交写入的问题。\n\n向表中添加新记录时，系统会自动检查新记录的主键值：\n\n* 如果新记录的主键值与内存中已有记录的主键值重复时，已有的记录不会被更新。\n\n* 一次性批量插入新记录时，若有多条记录具有相同的主键值，且该主键值与已有记录的主键值不同，只有第一条记录能成功插入。\n\n#### 参数\n\n**keyColumn** 是一个字符串或向量，表示主键。主键的数据类型必须属于以下类别：INTEGRAL, TEMPORAL, LITERAL 或 FLOATING。\n\n第一种用法中，**X**, **X1**, **X2** ... 可以是向量、数组向量、矩阵或元组。每个向量、元组、数组向量的长度，以及矩阵中每列长度都必须相同。**当 Xk 是元组时：**\n\n* 若 Xk 的元素是等长的向量，\\*\\*元组的每个元素将作为表的一列。\\*\\*元组的长度必须等于表的行数。\n\n* 若 Xk 包含不同类型或不等长元素，\\*\\*则将单独作为表的一列（列类型为 ANY），其每个元素将作为该列每行的元素值。\\*\\*Xk 的长度仍然必须和表的行数保持一致。\n\n第二种用法中：\n\n* **capacity** 是正整数，表示建表时系统为该表分配的内存（以记录数为单位）。当记录数超过 *capacity* 时，系统首先会分配 *capacity* 1.2\\~2倍的新的内存空间，然后复制数据到新的内存空间，最后释放原来的内存。对于规模较大的表，此类操作的内存占用会很高。因此，建议建表时预先分配一个合理的 *capacity*。\n\n* **size** 是整数，表示该表新建时的行数。若 *size* =0，创建一个空表。 若 *size*>0，则建立一个只包含 size 条记录的表，记录初始值如下：\n\n  * BOOL 类型默认值为 false；\n\n  * 数值类型、时间类型、IPADDR、COMPLEX、POINT 的默认值为 0；\n\n  * Literal, INT128 类型的默认值为 NULL。\n\n  **Note:** 如果 *colTypes* 指定为数组向量， *size* 必须为0。\n\n* **colNames** 是一个向量，表示列名。\n\n* **colTypes** 是一个向量，表示每列的数据类型，允许主键外的其它列指定为数组向量类型或元组（ANY）类型。可使用表示数据类型的系统保留字或相应的字符串。\n\n#### 返回值\n\n一个表。\n\n#### 例子\n\n第一种用法：\n\n```\nid=`A`B`C`D`E\nx=1 2 3 4 5\nt1=keyedStreamTable(`id, id, x)\nt1;\n```\n\n| id | x |\n| -- | - |\n| A  | 1 |\n| B  | 2 |\n| C  | 3 |\n| D  | 4 |\n| E  | 5 |\n\n第二种用法：\n\n```\nt2=keyedStreamTable(`id,100:0,`id`x, [INT,INT])\ninsert into t2 values(1 2 3,10 20 30);\nt2;\n```\n\n| id | x  |\n| -- | -- |\n| 1  | 10 |\n| 2  | 20 |\n| 3  | 30 |\n\n往表 t2 中插入重复主键值的数据：\n\n```\ninsert into t2 values(3 4 5,35 45 55)\nt2;\n```\n\n| id | x  |\n| -- | -- |\n| 1  | 10 |\n| 2  | 20 |\n| 3  | 30 |\n| 4  | 45 |\n| 5  | 55 |\n\n可以看到，id=3 的记录并没有被覆盖。\n\n主键为多个字段：\n\n```\nt=keyedStreamTable(`sym`id,1:0,`sym`id`val,[SYMBOL,INT,DOUBLE])\ninsert into t values(`A`B`C`D`E,5 4 3 2 1,52.1 64.2 25.5 48.8 71.9);\ninsert into t values(`A`B`R`T`Y,5 8 3 2 1,152.3 164.6 125.5 148.8 171.6);\nt;\n```\n\n| sym | id | val   |\n| --- | -- | ----- |\n| A   | 5  | 52.1  |\n| B   | 4  | 64.2  |\n| C   | 3  | 25.5  |\n| D   | 2  | 48.8  |\n| E   | 1  | 71.9  |\n| B   | 8  | 164.6 |\n| R   | 3  | 125.5 |\n| T   | 2  | 148.8 |\n| Y   | 1  | 171.6 |\n"
    },
    "keyedTable": {
        "url": "https://docs.dolphindb.cn/zh/funcs/k/keyedTable.html",
        "signatures": [
            {
                "full": "keyedTable(keyColumns, X, [X1], [X2], .....)",
                "name": "keyedTable",
                "parameters": [
                    {
                        "full": "keyColumns",
                        "name": "keyColumns"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[X1]",
                        "name": "X1",
                        "optional": true
                    },
                    {
                        "full": "[X2]",
                        "name": "X2",
                        "optional": true
                    },
                    {
                        "full": ".....",
                        "name": "....."
                    }
                ]
            },
            {
                "full": "keyedTable(keyColumns, capacity:size, colNames, colTypes)",
                "name": "keyedTable",
                "parameters": [
                    {
                        "full": "keyColumns",
                        "name": "keyColumns"
                    },
                    {
                        "full": "capacity:size",
                        "name": "capacity:size"
                    },
                    {
                        "full": "colNames",
                        "name": "colNames"
                    },
                    {
                        "full": "colTypes",
                        "name": "colTypes"
                    }
                ]
            },
            {
                "full": "keyedTable(keyColumns, table)",
                "name": "keyedTable",
                "parameters": [
                    {
                        "full": "keyColumns",
                        "name": "keyColumns"
                    },
                    {
                        "full": "table",
                        "name": "table"
                    }
                ]
            }
        ],
        "markdown": "### [keyedTable](https://docs.dolphindb.cn/zh/funcs/k/keyedTable.html)\n\n\n\n#### 语法\n\nkeyedTable(keyColumns, X, \\[X1], \\[X2], .....)\n\n或\n\nkeyedTable(keyColumns, capacity:size, colNames, colTypes)\n\n或\n\nkeyedTable(keyColumns, table)\n\n#### 详情\n\n创建键值内存表。一个键值内存表有一个主键。主键可由一个或多个字段组成。键值内存表基于哈希表实现，将主键字段的组合值存成一个键值，每个键值对应表中的一行数据。在查询时，指定主键的所有字段，便可通过键值定位数据，而无需进行全表扫描。\n\n向表中添加新记录时，系统会自动检查新记录的主键值，如果新记录的主键值与已有记录的主键值重复时，系统会更新表中对应的记录，否则向表中添加记录。\n\n键值表对单行的更新和查询效率很高，是数据缓存的理想选择。键值表也可作为时间序列聚合引擎的输出表，用于实时更新输出表的结果。\n\n关于对键值内存表和[索引内存表](https://docs.dolphindb.cn/zh/funcs/i/indexedTable.html)使用怎样的查询语句以及如何进行查询优化，详见下表：\n\n<table id=\"table_fwd_3lx_dcc\"><thead><tr><th>\n\n</th><th>\n\nkeyedTable\n\n</th><th>\n\nindexedTable\n\n</th></tr></thead><tbody><tr><td>\n\n查询优化\n\n</td><td>\n\n* 查询语句必须包含 *keyColumns* 所有列。\n\n* 过滤条件中只能使用 =, in 或 and，且对不同列使用 in 的次数不超过2次；\n\n* 建议调用 [sliceByKey](https://docs.dolphindb.cn/zh/funcs/s/sliceByKey.html) 以提高性能。\n\n</td><td>\n\n* 查询语句必须包含 *keyColumns* 的第 1 列，且该列过滤条件中只能使用 =, in 或 and；\n\n* 除 keyColumns 的第 1 列外，其它列可以通过 between、比较运算符等进行范围查询，且查询效率高于使用 in 谓词。\n\n* 所有过滤条件中，对不同列使用的 in 的次数不超过2次；\n\n* 建议调用 [sliceByKey](https://docs.dolphindb.cn/zh/funcs/s/sliceByKey.html) 以提高性能。\n\n</td></tr><tr><td>\n\n查询语句特点\n\n</td><td>\n\n包含 keyColumns 的所有列。此时查询性能优于 indexedTable。\n\n</td><td>\n\n只需要包含 *keyColumns* 的第 1 列，而无需包含所有列。\n\n</td></tr></tbody>\n</table>## 参数\n\n**keyColumns** 是一个字符串标量或向量，表示主键。主键的数据类型必须属于以下类别： INTEGRAL, TEMPORAL 或 LITERAL。\n\n第一种用法中，**X**, **X1**, **X2** ... 可以是向量、数组向量、矩阵或元组。每个向量、元组、数组向量的长度，以及矩阵中每列长度都必须相同。**当 Xk 是元组时：**\n\n* 若 Xk 的元素是等长的向量，\\*\\*元组的每个元素将作为表的一列。\\*\\*元组的长度必须等于表的行数。\n\n* 若 Xk 包含不同类型或不等长元素，\\*\\*则将单独作为表的一列（列类型为 ANY），其每个元素将作为该列每行的元素值。\\*\\*Xk 的长度仍然必须和表的行数保持一致。\n\n第二种用法中：\n\n* **capacity** 是正整数，表示建表时系统为该表分配的内存（以记录数为单位）。当记录数超过 *capacity* 时，系统首先会分配 *capacity* 1.2\\~2倍的新的内存空间，然后复制数据到新的内存空间，最后释放原来的内存。对于规模较大的表，此类操作的内存占用会很高。因此，建议建表时预先分配一个合理的 *capacity*。\n\n* **size** 是整数，表示该表新建时的行数。若 *size* =0，创建一个空表。 若 *size*>0，则建立一个只包含 size 条记录的表，记录初始值如下：\n\n  * BOOL 类型默认值为 false；\n\n  * 数值类型、时间类型、IPADDR、COMPLEX、POINT 的默认值为 0；\n\n  * Literal, INT128 类型的默认值为 NULL。\n\n  **Note:** 如果 *colTypes* 指定为数组向量， *size* 必须为0。\n\n* **colNames** 是一个向量，表示列名。\n\n* **colTypes** 是一个向量，表示每列的数据类型，允许主键外的其它列指定为数组向量类型或元组（ANY）类型。可使用表示数据类型的系统保留字或相应的字符串。\n\n第三种用法中，`table` 是一个表。注意，*table* 中的 *keyColumns* 不能包含重复值。\n\n#### 返回值\n\n一个表。\n\n#### 例子\n\n例1. 创建键值表\n\n第一种写法：\n\n```\nsym=`A`B`C`D`E\nid=5 4 3 2 1\nval=52 64 25 48 71\nt=keyedTable(`sym`id,sym,id,val)\nt;\n```\n\n| sym | id | val |\n| --- | -- | --- |\n| A   | 5  | 52  |\n| B   | 4  | 64  |\n| C   | 3  | 25  |\n| D   | 2  | 48  |\n| E   | 1  | 71  |\n\n第二种写法：\n\n```\nt=keyedTable(`sym`id,1:0,`sym`id`val,[SYMBOL,INT,INT])\ninsert into t values(`A`B`C`D`E,5 4 3 2 1,52 64 25 48 71);\n```\n\n第三种写法：\n\n```\ntmp=table(sym, id, val)\nt=keyedTable(`sym`id, tmp);\n```\n\n创建键值内存分区表：\n\n```\nsym=`A`B`C`D`E\nid=5 4 3 2 1\nval=52 64 25 48 71\nt=keyedTable(`sym`id,sym,id,val)\ndb=database(\"\",VALUE,sym)\npt=db.createPartitionedTable(t,`pt,`sym).append!(t);\n```\n\n例2. 更新键值表\n\n```\nt=keyedTable(`sym,1:0,`sym`datetime`price`qty,[SYMBOL,DATETIME,DOUBLE,DOUBLE])\ninsert into t values(`APPL`IBM`GOOG,2018.06.08T12:30:00 2018.06.08T12:30:00 2018.06.08T12:30:00,50.3 45.6 58.0,5200 4800 7800)\nt;\n```\n\n| sym  | datetime            | price | qty  |\n| ---- | ------------------- | ----- | ---- |\n| APPL | 2018.06.08T12:30:00 | 50.3  | 5200 |\n| IBM  | 2018.06.08T12:30:00 | 45.6  | 4800 |\n| GOOG | 2018.06.08T12:30:00 | 58    | 7800 |\n\n插入新记录，并且新记录中的主键值与表中主键值重复：\n\n```\ninsert into t values(`APPL`IBM`GOOG,2018.06.08T12:30:01 2018.06.08T12:30:01 2018.06.08T12:30:01,65.8 45.2 78.6,5800 8700 4600)\nt;\n```\n\n| sym  | datetime            | price | qty  |\n| ---- | ------------------- | ----- | ---- |\n| APPL | 2018.06.08T12:30:01 | 65.8  | 5800 |\n| IBM  | 2018.06.08T12:30:01 | 45.2  | 8700 |\n| GOOG | 2018.06.08T12:30:01 | 78.6  | 4600 |\n\n插入新记录，并且新记录中的主键值重复：\n\n```\ninsert into t values(`MSFT`MSFT,2018.06.08T12:30:01 2018.06.08T12:30:01,45.7 56.9,3600 4500)\nt;\n```\n\n| sym  | datetime            | price | qty  |\n| ---- | ------------------- | ----- | ---- |\n| APPL | 2018.06.08T12:30:01 | 65.8  | 5800 |\n| IBM  | 2018.06.08T12:30:01 | 45.2  | 8700 |\n| GOOG | 2018.06.08T12:30:01 | 78.6  | 4600 |\n| MSFT | 2018.06.08T12:30:01 | 56.9  | 4500 |\n\n主键不允许更新：\n\n```\nupdate t set sym=\"C_\"+sym;\n// output: Can't update a key column.\n```\n\n例3. 查询键值内存表\n\n当过滤条件不使用 or，包含所有 *keyColumns*，并且每个条件都使用了等值谓词(=)或 in 谓词，且 in 谓词数量不超过两个时，键值内存表的查询性能优于普通内存表。\n\n以下例子将比较键值内存表和普通内存表的查询性能。首先，分别创建包含100万条记录的普通内存表 t 和键值内存表 kt。\n\n```\nid=shuffle(1..1000000)\ndate=take(2012.06.01..2012.06.10, 1000000)\ntype=rand(9, 1000000)\nval=rand(100.0, 1000000)\nt=table(id, date, type, val)\nkt=keyedTable(`id`date`type, id, date, type, val);\n```\n\n例3.1\n\n```\ntimer(100) select * from t where id=500000, date=2012.06.01, type=0;\n// output: Time elapsed: 161.574 ms\n\ntimer(100) select * from kt where id=500000, date=2012.06.01, type=0;\n// output: Time elapsed: 1.483 ms\n\ntimer(100) sliceByKey(t1, (500000, 2012.06.01, 0))\n// output: Time elapsed: 0.705 ms\n```\n\n例3.2\n\n```\ntimer(100) select * from t where id in [1, 500000], date in 2012.06.01..2012.06.05, type=5;\n// output: Time elapsed: 894.241 ms\n\ntimer(100) select * from kt where id in [1, 500000], date in 2012.06.01..2012.06.05, type=5;\n// output: Time elapsed: 2.322 ms\n```\n\nin 谓词数量超过两个时，键值内存表不会进行查询优化：\n\n例3.3\n\n```\ntimer(100) select * from t where id in [1, 500000], date in 2012.06.01..2012.06.05, type in 1..5;\n// output: Time elapsed: 801.347 ms\n\ntimer(100) select * from kt where id in [1, 500000], date in 2012.06.01..2012.06.05, type in 1..5;\n// output: Time elapsed: 834.184 ms\n```\n\n若过滤条件没有包括所有 *keyColumns*，键值内存表亦不会进行查询优化：\n\n例3.4\n\n```\ntimer(100) select * from t where id=500000, date in 2012.06.01..2012.06.05;\n// output: Time elapsed: 177.113 ms\n\ntimer(100) select * from kt where id=500000, date in 2012.06.01..2012.06.05;\n// output: Time elapsed: 163.265 ms\n```\n\n例4. 使用 `keyedTable` 保留每只股票卖方委托的最新五档报价。\n\n```\nsym=[\"a\",\"b\",\"c \"] \ntime=22:58:52.827 22:58:53.627 22:58:53.827 \nvolume=array(INT[]).append!([[100,110,120,115,125],[200,230,220,225,230],[320,300,310,315,310]])\nprice=array(DOUBLE[]).append!([[10.5,10.6,10.7,10.77,10.85],[8.6,8.7,8.76,8.83,8.9],[6.3,6.37,6.42,6.48,6.52]])\nt=keyedTable(`sym,sym,time,volume,price)\nt\n```\n\n<table id=\"table_lr3_2wt_x1c\"><thead><tr><th>\n\nsym\n\n</th><th>\n\ntime\n\n</th><th>\n\nvolume\n\n</th><th>\n\nprice\n\n</th></tr></thead><tbody><tr><td>\n\na\n\n</td><td>\n\n22:58:52.827\n\n</td><td>\n\n\\[100, 110, 120, 115, 125]\n\n</td><td>\n\n\\[10.5, 10.6, 10.7, 10.77, 10.85]\n\n</td></tr><tr><td>\n\nb\n\n</td><td>\n\n22:58:53.627\n\n</td><td>\n\n\\[200, 230, 220, 225, 230]\n\n</td><td>\n\n\\[8.6, 8.7, 8.76, 8.83, 8.9]\n\n</td></tr><tr><td>\n\nc\n\n</td><td>\n\n22:58:53.827\n\n</td><td>\n\n\\[320, 300, 310, 315, 310]\n\n</td><td>\n\n\\[6.3, 6.37, 6.42, 6.48, 6.52]\n\n</td></tr></tbody>\n</table>```\n//最新的报价数量和价格\nnewVolume=array(INT[]).append!([[130,110,110,115,120]])\nnewPrice= array(DOUBLE[]).append!([[10.55,10.57,10.62,10.68,10.5]])\n//更新名为 a 的股票的最新报价\nupdate t set volume=newVolume, price=newPrice where sym=\"a\"\nt\n```\n\n<table id=\"table_qr3_2wt_x1c\"><thead><tr><th>\n\nsym\n\n</th><th>\n\ntime\n\n</th><th>\n\nvolume\n\n</th><th>\n\nprice\n\n</th></tr></thead><tbody><tr><td>\n\na\n\n</td><td>\n\n22:58:52.827\n\n</td><td>\n\n\\[130, 110, 110, 115, 120]\n\n</td><td>\n\n\\[10.55, 10.57, 10.62, 10.68, 10.5]\n\n</td></tr><tr><td>\n\nb\n\n</td><td>\n\n22:58:53.627\n\n</td><td>\n\n\\[200, 230, 220, 225, 230]\n\n</td><td>\n\n\\[8.6, 8.7, 8.76, 8.83, 8.9]\n\n</td></tr><tr><td>\n\nc\n\n</td><td>\n\n22:58:53.827\n\n</td><td>\n\n\\[320, 300, 310, 315, 310]\n\n</td><td>\n\n\\[6.3, 6.37, 6.42, 6.48, 6.52]\n\n</td></tr></tbody>\n</table>需要注意的是，更新 array vector 列的数据时，新记录中各行向量的元素个数必须和原记录中对应行向量的元素个数相同，否则会出现报错。如下例，新记录向量中有4个元素，而已有记录对应行的向量中有5个元素，数量不相同，出现报错：\n\n```\nnewVolume=array(INT[]).append!([[130,110,110,120]])\nnewPrice= array(DOUBLE[]).append!([[10.55,10.57,10.62,10.5]])\n\nupdate t set volume=newVolume, price=newPrice where sym=\"a\"\n// error: Failed to update column: volume\n```\n\n相关函数：[indexedTable](https://docs.dolphindb.cn/zh/funcs/i/indexedTable.html)\n"
    },
    "keys": {
        "url": "https://docs.dolphindb.cn/zh/funcs/k/keys.html",
        "signatures": [
            {
                "full": "keys(X)",
                "name": "keys",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [keys](https://docs.dolphindb.cn/zh/funcs/k/keys.html)\n\n\n\n#### 语法\n\nkeys(X)\n\n#### 详情\n\n返回一个字典中的所有键作为一个向量，或一个数据表中的列名作为一个向量，或将一个集合转化为一个向量。\n\n#### 参数\n\n**X** 是一个字典、数据表，或集合。\n\n#### 返回值\n\n一个向量，数据类型取决于 *X* 的字典键/表列名/集合元素。\n\n#### 例子\n\n```\nz=dict(INT,DOUBLE)\nz[5]=7.9\nz[3]=6\nz.keys();\n// output\n[3,5]\n\nt = table(1 2 3 as id, 4 5 6 as x, `IBM`MSFT`GOOG as name);\nkeys(t);\n// output\n[\"id\",\"x\",\"name\"]\n\na=set(1 2 4)\na.keys();\n// output\n[4,2,1]\n```\n\n相关函数：[values](https://docs.dolphindb.cn/zh/funcs/v/values.html)\n"
    },
    "kmeans": {
        "url": "https://docs.dolphindb.cn/zh/funcs/k/kmeans.html",
        "signatures": [
            {
                "full": "kmeans(X, k, [maxIter=300], [randomSeed], [init='random'])",
                "name": "kmeans",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "k",
                        "name": "k"
                    },
                    {
                        "full": "[maxIter=300]",
                        "name": "maxIter",
                        "optional": true,
                        "default": "300"
                    },
                    {
                        "full": "[randomSeed]",
                        "name": "randomSeed",
                        "optional": true
                    },
                    {
                        "full": "[init='random']",
                        "name": "init",
                        "optional": true,
                        "default": "'random'"
                    }
                ]
            }
        ],
        "markdown": "### [kmeans](https://docs.dolphindb.cn/zh/funcs/k/kmeans.html)\n\n\n\n#### 语法\n\nkmeans(X, k, \\[maxIter=300], \\[randomSeed], \\[init='random'])\n\n#### 详情\n\n对训练集执行 K-Means 聚类。\n\n#### 参数\n\n**X** 是一个表，表示训练集。\n\n**k** 是一个正整数，表示要生成的聚类数。\n\n**maxIter** 是一个正整数，表示质心更新的最大迭代次数。默认值是300。\n\n**randomSeed** 是一个整数，表示质心初始化时随机算法的种子。默认值为 NULL。\n\n**init** 可以是一个字符串或者一个矩阵，表示初始值的选择方式。默认值是 'random'。\n\n* 若 *init* 是一个字符串，则可选参数为 'random' 或 'k-means++'。'random' 表示根据 *randomSeed* 随机生成，'kmeans++' 表示根据 kmeans++ 算法生成。\n\n* 若 *init* 是一个矩阵，表示自定义的质心。其列数与表 *X* 需保持一致，行数为 *k*。\n\n#### 返回值\n\n返回一个字典，包含以下 key：\n\n* centers：一个 *k* 行 m 列的矩阵（m 是 *X* 的列数），包含各个类的质心坐标。\n\n* predict：一个聚类模型预测函数，数据类型是 FUNCTIONDEF。\n\n* modelName：字符串 'KMeans'。\n\n* model：保存的模型，数据类型为 RESOURCE，用于预测。\n\n* labels：一个向量，表示 *X* 中每一行数据对应的聚类的类标签。\n\n#### 例子\n\n使用模拟数据训练一个 K-Means 模型：\n\n```\nt = table(100:0, `x0`x1, [DOUBLE, DOUBLE])\nx0 = norm(1.0, 1.0, 50)\nx1 = norm(1.0, 1.5, 50)\ninsert into t values (x0, x1)\nx0 = norm(2.0, 1.0, 50)\nx1 = norm(-1.0, 1.5, 50)\ninsert into t values (x0, x1)\nx0 = norm(-1.0, 1.0, 50)\nx1 = norm(-3.0, 1.5, 50)\ninsert into t values (x0, x1);\n\nmodel = kmeans(t, 3);\nmodel;\n\n// output\ncenters->\n\n#0        #1\n--------- ---------\n-1.048027 -3.809539\n1.110899  1.24216\n1.677974  -1.19158\n\npredict->kmeansPredict\nmodelName->KMeans\nmodel->KMeans\nlabels->[2,2,2,2,2,2,3,2,3,2,...]\n```\n"
    },
    "knn": {
        "url": "https://docs.dolphindb.cn/zh/funcs/k/knn.html",
        "signatures": [
            {
                "full": "knn(Y, X, type, nNeighbor, [power=2])",
                "name": "knn",
                "parameters": [
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "type",
                        "name": "type"
                    },
                    {
                        "full": "nNeighbor",
                        "name": "nNeighbor"
                    },
                    {
                        "full": "[power=2]",
                        "name": "power",
                        "optional": true,
                        "default": "2"
                    }
                ]
            }
        ],
        "markdown": "### [knn](https://docs.dolphindb.cn/zh/funcs/k/knn.html)\n\n\n\n#### 语法\n\nknn(Y, X, type, nNeighbor, \\[power=2])\n\n#### 详情\n\n通过 K 邻近算法（暴力搜索法）对表中的数据进行训练。\n\n#### 参数\n\n**Y** 是一个长度与 *X* 的行数相等的向量，表示 *X* 中每个样本对应的标签。\n\n**X** 是一张表，表示训练集。表中的每一行表示一个样本，每一列表示一个特征。\n\n**type** 是一个字符串。它的取值可以是 'regressor' 或 'classifier'。\n\n**nNeighbor** 是一个正整数，表示 K 邻近算法的邻近节点个数。\n\n**power** 是一个正整数，表示闵可夫斯基距离（Minkowski Distance）的参数。默认值是2，表示使用欧几里得距离（Euclidean Distance）。如果 *power*=1，表示使用曼哈顿距离（Manhattan Distance）。\n\n#### 返回值\n\n返回一个字典，包含以下 key：\n\n* nNeighbor：训练时所用的邻近节点个数\n\n* modelName：模型的名称，为字符串 \"KNN\"\n\n* model：内部模型\n\n* power：训练时所用的闵可夫斯基距离\n\n* type：字符串 \"regressor\" 或 \"classifier\"\n\n* predict：模型的预测函数，可用于对新样本进行预测\n\n#### 例子\n\n```\nheight = 158 158 158 160 160 163 163 160 163 165 165 165 168 168 168 170 170 170\nweight = 58 59 63 59 60 60 61 64 64 61 62 65 62 63 66 63 64 68\nt=table(height, weight)\nlabels=take(1,7) join take(2,11)\nmodel = knn(labels,t,\"classifier\", 5);\n```\n"
    },
    "kroghInterpolate": {
        "url": "https://docs.dolphindb.cn/zh/funcs/k/kroghinterpolate.html",
        "signatures": [
            {
                "full": "kroghInterpolate(X, Y, newX, [der=0])",
                "name": "kroghInterpolate",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "newX",
                        "name": "newX"
                    },
                    {
                        "full": "[der=0]",
                        "name": "der",
                        "optional": true,
                        "default": "0"
                    }
                ]
            }
        ],
        "markdown": "### [kroghInterpolate](https://docs.dolphindb.cn/zh/funcs/k/kroghinterpolate.html)\n\n\n\n#### 语法\n\nkroghInterpolate(X, Y, newX, \\[der=0])\n\n#### 详情\n\n对一组点集进行多项式插值，该多项式通过点集中所有的数据点对 (x, y)。返回在 X 点处指定导数阶数的多项式估值。\n\n可以额外指定在每个点 x 处的多个导数值：用户通过重复 xi 值并将导数值指定为连续的 yi 值来实现。\n\n* 当 x 是唯一值时，y 为多项式 f(x) 的值。\n\n* 当 x 出现相同值时，则第一个 y 是 f(x) 的值，第二个为对应的 x 的一阶导数值，第三个为对应的 x 的二阶导数值，依此类推。比如对于输入X = \\[0,0,1,1]，Yi= \\[1,0,2,3]，有 Y\\[0]=f(0)，Y\\[1]=f'(0)，Y\\[2]=f(1)，Y\\[3]=f'(1)。\n\n#### 参数\n\n**X** 数值向量，表示用于插值的点的 x 坐标。必须是递增序列，不能包含 NULL 值。\n\n**Y** 数值向量，与 *Xi* 等长，表示用于插值的点的 y 坐标。不能包含 NULL 值。\n\n**newX** 数值向量，表示需要求值的点的 x 坐标。不能包含 NULL 值。\n\n**der** 可选参数，非负整数，表示返回值的导数阶数。默认值为 0，表示计算多项式函数本身的值。\n\n#### 返回值\n\nDOUBLE 类型向量。\n\n#### 例子\n\n以正弦函数为例进行多项式插值，分别计算 xx 点处的多项式估值和其一阶导数值。\n\n```\ndef linspace(start, end, num, endpoint=true){\n\tif(endpoint) return end$DOUBLE\\(num-1), start + end$DOUBLE\\(num-1)*0..(num-1)\n\telse return start + end$DOUBLE\\(num-1)*0..(num-1)\t\n}\n\nx = 0 1 2 3 4 5\ny = sin(x)\nxx = linspace(0.0, 5.0, 10)[1]\nyy=kroghInterpolate(x,y,xx)\nyy;\n\nyy1=kroghInterpolate(x,y,xx,1)\nyy1;\n```\n\nyy 返回值：\n\n\\[0,0.515119011157387,0.898231239576709,0.998548648650381,0.793484053410063,0.354287125066207,-0.188319604452395,-0.678504737959061,-0.969692008469677,-0.958924274663139]\n\nyy1 返回值：\n\n\\[0.885486080979582,0.875967413938641,0.459031117252456,-0.103633680213926,-0.612193041424271,-0.92866822117116,-0.976935666075988,-0.742727014588963,-0.273629096989106,0.320916064615744]\n"
    },
    "kroghInterpolateFit": {
        "url": "https://docs.dolphindb.cn/zh/funcs/k/kroghinterpolatefit.html",
        "signatures": [
            {
                "full": "kroghInterpolateFit(X, Y, [der=0])",
                "name": "kroghInterpolateFit",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "[der=0]",
                        "name": "der",
                        "optional": true,
                        "default": "0"
                    }
                ]
            }
        ],
        "markdown": "### [kroghInterpolateFit](https://docs.dolphindb.cn/zh/funcs/k/kroghinterpolatefit.html)\n\n\n\n#### 语法\n\nkroghInterpolateFit(X, Y, \\[der=0])\n\n#### 详情\n\n对一组点集进行多项式插值，该多项式通过点集中所有的点对 (X, Y)。并且可以额外指定在每个点 X 处的多个导数值：用户通过重复 X 值并将导数值指定为连续的 Y 值来实现：\n\n* 当 X 只出现一次时，Y 为多项式 f(x) 的值。\n\n* 当 X 出现多次时，则第一个 Y 是 f(X) 的值，第二个为对应的 X 的一阶导数值，第三个为对应的 X 的二阶导数值，依此类推。比如对于输入 X = \\[0,0,1,1], Y= \\[1,0,2,3], 有 Y\\[0]=f(0)，Y\\[1]=f'(0)，Y\\[2]=f(1)，Y\\[3]=f'(1)。\n\n另外，本函数可结合 [predict](https://docs.dolphindb.cn/zh/funcs/p/predict.html) 函数先后使用，针对生成的模型进行预测。\n\n#### 参数\n\n**X** 数值向量，表示用于插值的点的 x 坐标，必须是递增序列。注意：X 中不可包含 NULL 值。\n\n**Y** 数值向量，表示用于插值的点的 y 坐标。注意：Y 和 X 的长度必须一致，且 Y 中不可包含 NULL 值。\n\n**der** 可选参数，非负整数，表示要求的导数阶数。*der*=0 时计算多项式函数本身的值。其默认值为 0。\n\n#### 返回值\n\n返回一个字典，字典有以下成员：\n\n* modelName：字符串类型，表示模型名称，值为“kroghInterpolate”。\n\n* X：数值向量，表示用于插值的点的x坐标，即输入 X。\n\n* der：非负整数，即输入 der。\n\n* coeffs：数值向量，表示根据输入数据点拟合得到的多项式系数。\n\n* predict：模型的预测函数。其使用方法为 `model.predict(X)`，或者通过 [predict](https://docs.dolphindb.cn/zh/funcs/p/predict.html) 函数进行调用：`predict(model, X)`。其参数为：\n\n  * model：字典类型，即 kroghInterpolateFit 的输出。\n\n  * X： 数值向量，表示需要求值的点的 x 坐标，`predict` 函数将返回在 X 点处的多项式估值。\n\n#### 例子\n\n以正弦函数为例进行多项式插值，计算 x 点处的多项式估值。\n\n```\nx = 0 1 2 3 4 5\ny = sin(x)\nmodel = kroghInterpolateFit(x,y)\nmodel\n\n/*\noutput:\nX->[0,1,2,3,4,5]\nder->0\npredict->kroghInterpolateFitPredict\nmodelName->kroghInterpolate\ncoeffs->[0.0,0.841470984807,-0.386822271395,-0.010393219665,0.032025753923,-0.005411092181,0.0]\n*/\n```\n\n根据生成的模型，自定义函数 `linspace`，并传入相关参数，进一步预测模型。\n\n```\ndef linspace(start, end, num, endpoint=true){\n\tif(endpoint) return end$DOUBLE\\(num-1), start + end$DOUBLE\\(num-1)*0..(num-1)\n\telse return start + end$DOUBLE\\(num-1)*0..(num-1)\t\n}\nxx = linspace(0.0, 5.0, 10)[1]\nmodel.predict(xx)\n\n/*\noutput:\n[0,0.515119011157387,0.898231239576709,0.998548648650381,0.793484053410063,0.354287125066207,-0.188319604452395,-0.678504737959061,-0.969692008469677,-0.958924274663139]\n*/\n```\n\n相关函数：[predict,](https://docs.dolphindb.cn/zh/funcs/p/predict.html) [kroghinterpolate](https://docs.dolphindb.cn/zh/funcs/k/kroghinterpolate.html)\n"
    },
    "ksTest": {
        "url": "https://docs.dolphindb.cn/zh/funcs/k/ksTest.html",
        "signatures": [
            {
                "full": "ksTest(X, Y)",
                "name": "ksTest",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [ksTest](https://docs.dolphindb.cn/zh/funcs/k/ksTest.html)\n\n\n\n#### 语法\n\nksTest(X, Y)\n\n#### 详情\n\n对 *X* 和 *Y* 进行 Kolmogorov-Smirnov 检验，检验它们是否符合同一个分布。\n\n#### 参数\n\n**X** 是一个数值向量。\n\n**Y** 是一个数值向量。\n\n#### 返回值\n\n返回一个字典，包含以下 key：\n\n* ksValue：Kolmogorov-Smirnov 统计量\n\n* pValue：p 值\n\n* D：D 统计量\n\n* method：字符串 \"Two-sample Kolmogorov-Smirnov test\"\n\n#### 例子\n\n```\nx = norm(0.0, 1.0, 50)\ny = norm(0.0, 1.0, 20)\nksTest(x, y);\n\n// output\nksValue->0.739301\npValue->0.645199\nD->0.19\nmethod->Two-sample Kolmogorov-Smirnov test\n```\n"
    },
    "kurtosis": {
        "url": "https://docs.dolphindb.cn/zh/funcs/k/kurtosis.html",
        "signatures": [
            {
                "full": "kurtosis(X, [biased=true])",
                "name": "kurtosis",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[biased=true]",
                        "name": "biased",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [kurtosis](https://docs.dolphindb.cn/zh/funcs/k/kurtosis.html)\n\n\n\n#### 语法\n\nkurtosis(X, \\[biased=true])\n\n#### 详情\n\n计算 *X* 的峰度。`kurtosis` 函数在计算时会忽略 NULL 值。\n\n* 若 *biased*=true，表示结果为有偏估计，计算公式为：\n\n![k1](https://docs.dolphindb.cn/zh/images/k1.png)\n\n* 若 *biased*=false，表示结果为无偏估计，计算公式为：\n\n![k0](https://docs.dolphindb.cn/zh/images/k0.png)\n\n* 若 *X* 为矩阵，计算每列的峰度，返回一个向量。\n\n* 若 *X* 为表，计算每列的峰度，返回一个表。\n\n`kurtosis` 函数也支持校正偏差查询分区表和分布式表。\n\nDolphinDB 的 `kurtosis` 默认情况（当 *biased*=true 时）存在偏差，而 pandas 和 Excel 的 kurt 默认为无偏估计，且减去了正态分布的峰度3。参考下面例子，可以使 DolphinDB 的峰度计算结果与 pandas 和 excel 的结果保持一致：\n\n```\npython\nm = [1111, 323, 43, 51]\ndf = pandas.DataFrame(m)\ny = df.kurt()\n// output\n2.504252\n\ndolphindb\nm=matrix(1111 323 43 51)\nkurtosis(m, false) - 3\n// output\n2.5043\n```\n\n#### 参数\n\n**X** 是一个向量、矩阵或表。\n\n**biased** 是一个布尔值，表示是否为有偏估计。默认值为 true，表示为有偏估计。\n\n#### 返回值\n\nDOUBLE 类型标量/向量/表。\n\n#### 例子\n\n下面的例子使用了 [norm](https://docs.dolphindb.cn/zh/funcs/n/norm.html) 函数生成数据，每次生成的数据都会有细微差别，因此每次计算的结果会有所偏差。\n\n```\nx=norm(0, 1, 1000000);\nkurtosis(x);\n// output\n3.000249\n\nx[0]=100;\nkurtosis(x);\n// output\n100.626722\n\nm=matrix(1..10, 1 2 3 4 5 6 7 8 9 100);\nm;\n```\n\n| #0 | #1  |\n| -- | --- |\n| 1  | 1   |\n| 2  | 2   |\n| 3  | 3   |\n| 4  | 4   |\n| 5  | 5   |\n| 6  | 6   |\n| 7  | 7   |\n| 8  | 8   |\n| 9  | 9   |\n| 10 | 100 |\n\n```\nkurtosis(m);\n// output\n[1.775757575757576,7.997552566718839]\n```\n"
    },
    "join!": {
        "url": "https://docs.dolphindb.cn/zh/funcs/j/join!.html",
        "signatures": [
            {
                "full": "join!(X, Y)",
                "name": "join!",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [join!](https://docs.dolphindb.cn/zh/funcs/j/join!.html)\n\n\n\n#### 语法\n\njoin!(X, Y)\n\n#### 详情\n\n把 *Y* 合并到 *X* 中，`join!` 函数会改变 *X* 的值。\n\n#### 参数\n\n**X** 可以是向量、元组、矩阵或表。\n\n**Y** 可以是标量、向量、元组、矩阵或表。\n\n如果 *X* 是向量或元组，*Y* 可以是标量、向量或元组。如果 *X* 是矩阵，*Y* 可以是向量或矩阵。如果 *X* 是表，*Y* 可以是向量或表。\n\n#### 返回值\n\n返回值的形式取决于 *X* 和 *Y*，详情请参考下方的例子。\n\n#### 例子\n\n如果 *X* 是向量，*Y* 可以是标量、向量或数据类型与 X 相同的元组。返回结果是长度更长的向量。\n\n```\nx=[1,2,3]\nx.join!(4)\nx;\n```\n\n输出返回：\\[1,2,3,4]\n\n```\nx.join!(5 6 7)\nx;\n```\n\n输出返回：\\[1,2,3,4,5,6,7]\n\n```\nx.join!((8,9))\nx;\n```\n\n输出返回：\\[1,2,3,4,5,6,7,8,9]\n\n如果 *X* 是元组，*Y* 可以是标量、向量或元组。返回结果是长度更长的元组。\n\n```\nx = (1,\"A\")\nx.join!(2)\nx;\n```\n\n返回：(1,\"A\",2)\n\n```\nx.join!([3,4,5])\nx;\n```\n\n返回：(1,\"A\",2,\\[3,4,5])\n\n如果配置项 appendTupleAsAWhole 设置为 true，运行以下脚本：\n\n```\nx.join!((\"B\",\"C\"))   // 配置参数 appendTupleAsAWhole=true 时\nx;\n```\n\n返回：(1,\"A\",2,\\[3,4,5],(\"B\",\"C\"))\n\n如果配置项 appendTupleAsAWhole 设置为 false，运行以上脚本后，返回：(1,\"A\",2,\\[3,4,5],\"B\",\"C\")\n\n如果 *X* 是矩阵，*Y* 可以是向量或者是与 *X* 行数相同的矩阵。返回结果是与 *X* 行数相同的矩阵。\n\n```\nx=1..6$2:3\njoin!(x, [7,8])\nx;\n```\n\n输出返回：\n\n| #0 | #1 | #2 | #3 |\n| -- | -- | -- | -- |\n| 1  | 3  | 5  | 7  |\n| 2  | 4  | 6  | 8  |\n\n```\nx.join!(9..12$2:2)\nx;\n```\n\n输出返回：\n\n| #0 | #1 | #2 | #3 | #4 | #5 |\n| -- | -- | -- | -- | -- | -- |\n| 1  | 3  | 5  | 7  | 9  | 11 |\n| 2  | 4  | 6  | 8  | 10 | 12 |\n\n如果 *X* 是表，*Y* 必须是和 *X* 行数相同的表或向量。返回结果是与 *X* 行数相同的表。\n\n```\na=table(1..3 as x, 4.5 6.7 8.5 as y);\na;\n```\n\n输出返回：\n\n| x | y   |\n| - | --- |\n| 1 | 4.5 |\n| 2 | 6.7 |\n| 3 | 8.5 |\n\n```\nb=table(700 500 800 as z);\nb;\n```\n\n输出返回：\n\n| z   |\n| --- |\n| 700 |\n| 500 |\n| 800 |\n\n```\njoin!(a,b);\na;\n```\n\n输出返回：\n\n| x | y   | z   |\n| - | --- | --- |\n| 1 | 4.5 | 700 |\n| 2 | 6.7 | 500 |\n| 3 | 8.5 | 800 |\n\n```\na=table(1..3 as x, `IBM`C`AAPL as y);\nb=table(172.3 25 106.5 as z);\na.join!(b);\na;\n```\n\n输出返回：\n\n| x | y    | z     |\n| - | ---- | ----- |\n| 1 | IBM  | 172.3 |\n| 2 | C    | 25    |\n| 3 | AAPL | 106.5 |\n"
    },
    "join": {
        "url": "https://docs.dolphindb.cn/zh/funcs/j/join.html",
        "signatures": [
            {
                "full": "join(X,Y)",
                "name": "join",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [join](https://docs.dolphindb.cn/zh/funcs/j/join.html)\n\n\n\n#### 语法\n\njoin(X,Y) 或 X<-Y\n\n#### 详情\n\n合并 *X* 和 *Y*。\n\n#### 参数\n\n**X** 和 **Y** 可以是标量、向量、元组、矩阵或表。\n\n#### 返回值\n\n返回值的形式取决于 *X* 和 *Y*，详情请参考下方的例子。\n\n#### 例子\n\n如果 *X* 是标量，*Y* 可以是标量或向量，结果是一个向量；*Y* 可以是元组，结果是一个元组\n\n```\n1 <- 3;\n// output\n[1,3]\n\n4<-1 2 3;\n// output\n[4,1,2,3]\n\n1 <- (2,\"A\")\n// 配置参数 appendTupleAsAWhole=true 时\n// output\n(1,(2,\"A\"))\n// 配置参数 appendTupleAsAWhole=false 时\n// output\n(1,2,\"A\")\n```\n\n如果 *X* 是向量，*Y* 可以是标量、向量或元素类型与 X 相同的元组。它将产生一个更长的向量。\n\n```\n[1,2,3] <- 4;\n// output\n[1,2,3,4]\n\n[1,2,3] <- [4,5,6];\n// output\n[1,2,3,4,5,6]\n```\n\n如果 X 是元组，Y可以是标量、向量或元组。它将产生一个更长的元组。\n\n```\nx = (1,\"A\")\ny = 2\nx <- y\n(1,\"A\",2)\n\ny = [2,3]\n(1,\"A\",[2,3])\n\ny = (2,\"B\")\n// 配置参数 appendTupleAsAWhole=true 时\n// output\n(1,\"A\",(2,\"B\"))\n// 配置参数 appendTupleAsAWhole=false 时\n// output\n(1,\"A\",2,\"B\")\n```\n\n如果 *X* 是矩阵，*Y* 必须是和 *X* 具有相同行数的向量或矩阵。结果是一个和 *X* 具有相同行数的矩阵。\n\n```\n1..6$2:3 <- [7,8];\n```\n\n| #0 | #1 | #2 | #3 |\n| -- | -- | -- | -- |\n| 1  | 3  | 5  | 7  |\n| 2  | 4  | 6  | 8  |\n\n```\n(1..6$2:3) <- (7..12$2:3);\n```\n\n| #0 | #1 | #2 | #3 | #4 | #5 |\n| -- | -- | -- | -- | -- | -- |\n| 1  | 3  | 5  | 7  | 9  | 11 |\n| 2  | 4  | 6  | 8  | 10 | 12 |\n\n如果 *X* 是一个表，*Y* 必须是一个和 *X* 具有相同行数的向量或表。结果是一个和 *X* 具有相同行数的表。\n\n```\na=table(1..3 as x, 4.5 6.7 8.5 as y);\na;\n```\n\n| x | y   |\n| - | --- |\n| 1 | 4.5 |\n| 2 | 6.7 |\n| 3 | 8.5 |\n\n```\nb=table(700 500 800 as z);\nb\n```\n\n| z   |\n| --- |\n| 700 |\n| 500 |\n| 800 |\n\n```\nc=join(a,b);\nc;\n```\n\n| x | y   | z   |\n| - | --- | --- |\n| 1 | 4.5 | 700 |\n| 2 | 6.7 | 500 |\n| 3 | 8.5 | 800 |\n\n```\na=table(1..3 as x, `IBM`C`AAPL as y);\nb=table(172.3 25 106.5 as z);\nc=a<-b;\nc\n```\n\n| x | y    | z     |\n| - | ---- | ----- |\n| 1 | IBM  | 172.3 |\n| 2 | C    | 25    |\n| 3 | AAPL | 106.5 |\n\n相关函数：[cj (cross\\_join)](https://docs.dolphindb.cn/zh/funcs/c/cj.html)\n"
    },
    "jsonExtract": {
        "url": "https://docs.dolphindb.cn/zh/funcs/j/jsonextract.html",
        "signatures": [
            {
                "full": "jsonExtract(json, location, type)",
                "name": "jsonExtract",
                "parameters": [
                    {
                        "full": "json",
                        "name": "json"
                    },
                    {
                        "full": "location",
                        "name": "location"
                    },
                    {
                        "full": "type",
                        "name": "type"
                    }
                ]
            }
        ],
        "markdown": "### [jsonExtract](https://docs.dolphindb.cn/zh/funcs/j/jsonextract.html)\n\n\n\n#### 语法\n\njsonExtract(json, location, type)\n\n#### 详情\n\n查询 JSON 对象中指定位置的数据，并按指定类型输出结果。\n\n#### 参数\n\n**json** LITERAL 类型标量或向量，表示符合标准 JSON 字符串。\n\n**location** 标量/向量/元组。每个元素可以是字符串或非零整数，用于指定相应维度的位置。\n\n* 如果为字符串，表示查询指定键对应的元素。\n\n* 如果为整数：表示查询该整数对应位置的元素。正整数表示从头开始查询，负整数表示从尾部开始查询。\n\n**type** 字符串标量，表示返回结果的类型，可选值为 \"long\", \"int\", \"double\", \"string\" 。\n\n#### 返回值\n\n* 当参数 *json*为标量时，返回标量结果；为向量时，返回向量结果。\n* 返回值类型由参数 *type* 指定。\n* 如果参数 *location* 指定的元素不存在，或无法解析为指定的类型，则返回空值 。\n\n#### 例子\n\n例1 基础用法\n\n```\nA = '{\"a\": \"hello\", \"b\": [-100, 200.5, 300], \"c\": { \"b\" : 2} }'\njsonExtract(A, [2, 1], \"int\") \n// output: -100\n\njsonExtract(A, 1, \"int\") \n// output: NULL\n\njsonExtract(A, 999, \"int\") \n// output: NULL\n\njsonExtract(A, [\"b\", 2], \"int\") \n// output: 200\n\njsonExtract(A, [\"c\", \"b\"], \"double\") \n// output: 2\n\nB = '{\"a\": \"hello\", \"b\": [200, 300]}'\njsonExtract([A, B], [\"c\", \"b\"], \"int\") \n// output: [2, NULL]\n\njsonExtract([A, B], [2, -1], \"int\") \n// output: [300, 300]\n```\n\n例2 查询表中 JSON 字符串里指定位置的数据。\n\n```\nA1 = '{\"a\": \"a1\",\"c\": { \"b\" : 2} }'\nA2 = '{\"a\": \"a2\", \"c\": { \"b\" : 3} }'\nB1 = '{\"a\": \"b1\",  \"c\": { \"b\" : 3} }'\nB2 = '{\"a\": \"b2\", \"c\": { \"b\" : 4} }'\nt1 = table([A1, A2] as json, [2,3] as val)\nt2 = table([B1, B2] as json, [3,4] as val)\n\nselect\n    jsonExtract(t1.json, \"a\", \"string\") as json1, \n    jsonExtract(t2.json, \"a\", \"string\") as json2 \nfrom t1 \njoin t2 on t1.val = t2.val\n```\n\n| json1 | json2 |\n| ----- | ----- |\n| a2    | b1    |\n"
    },
    "ifirstHit": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/ifirstHit.html",
        "signatures": [
            {
                "full": "ifirstHit(func, X, target)",
                "name": "ifirstHit",
                "parameters": [
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "target",
                        "name": "target"
                    }
                ]
            }
        ],
        "markdown": "### [ifirstHit](https://docs.dolphindb.cn/zh/funcs/i/ifirstHit.html)\n\n\n\n#### 语法\n\nifirstHit(func, X, target)\n\n#### 详情\n\n返回 *X* 中第一个满足 *X* *func* *target* （例如 *X*>5) 条件的元素的下标。\n\n若 *X* 中无元素满足条件，则返回-1。\n\n通过 `ifirstHit` 查找时，NULL 值会被忽略：\n\n* 如需查找第一个非 NULL 的下标， 可以通过函数 [ifirstNot](https://docs.dolphindb.cn/zh/funcs/i/ifirstNot.html)；\n\n* 如需查找第一个空值的下标，可以通过函数 [find](https://docs.dolphindb.cn/zh/funcs/f/find.html)。\n\n#### 参数\n\n**func** 关系运算符 >, >=, <, <=, !=, <>, ==。\n\n**X** 向量，矩阵或表。\n\n**target** 和 *X* 类型相同的标量，表示与 *X* 比较的对象。\n\n#### 返回值\n\n* *X* 是向量，返回一个整数。\n* *X* 是矩阵，返回一个整型向量。\n* *X* 是表，返回一个表。\n\n#### 例子\n\n```\nX = NULL 3.2 4.5 1.2 NULL 7.8 0.6 9.1\nifirstHit(<, X, 2.5)\n// output: 3\n\n// 若无元素满足查找条件，返回 -1\nifirstHit(>, X, 10.0)\n// output: -1\n\n```\n\n相关函数：[firstHit](https://docs.dolphindb.cn/zh/funcs/f/firstHit.html)\n"
    },
    "ifirstNot": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/ifirstNot.html",
        "signatures": [
            {
                "full": "ifirstNot(X)",
                "name": "ifirstNot",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [ifirstNot](https://docs.dolphindb.cn/zh/funcs/i/ifirstNot.html)\n\n\n\n#### 语法\n\nifirstNot(X)\n\n#### 详情\n\n查找第一个非空元素的下标位置。\n\n#### 参数\n\n**X** 可以是一个向量，也可以是由多个等长向量组成的元组，亦可是一个矩阵或表。\n\n#### 返回值\n\n如果 *X* 是一个向量，返回第一个非空元素的下标。如果 *X* 中的所有元素都为空，返回-1。\n\n如果 *X* 是一个元组，返回第一个所有向量中均不为空的位置的下标。\n\n如果 *X* 是一个矩阵，返回每列中第一个非空元素的下标。返回一个向量。\n\n如果 *X* 是一个表，返回每列中第一个非空元素的下标。返回一个表。\n\n#### 例子\n\n```\nifirstNot(NULL NULL 2 4 8 NULL 1);\n// output: 2\n\nifirstNot(take(int(),5));\n// output: -1\n\nx=NULL NULL 4 7 8 NULL\ny=1 NULL NULL 4 NULL NULL\nifirstNot([x,y]);\n// output: 3\n\nx=NULL NULL 4 7 8 NULL\ny=1 2 NULL NULL NULL 6\nifirstNot([x,y]);\n// output: -1\n\nm=matrix(0 NULL 1 2 3, NULL 2 NULL 0 3);\nm;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 0  |    |\n|    | 2  |\n| 1  |    |\n| 2  | 0  |\n| 3  | 3  |\n\n```\nifirstNot(m);\n// output: [0,1]\n```\n\n相关函数：[ilastNot](https://docs.dolphindb.cn/zh/funcs/i/ilastNot.html), [firstNot](https://docs.dolphindb.cn/zh/funcs/f/firstNot.html), [lastNot](https://docs.dolphindb.cn/zh/funcs/l/lastNot.html)\n"
    },
    "ifNull": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/ifNull.html",
        "signatures": [
            {
                "full": "ifNull(X, Y)",
                "name": "ifNull",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [ifNull](https://docs.dolphindb.cn/zh/funcs/i/ifNull.html)\n\n\n\n#### 语法\n\nifNull(X, Y)\n\n#### 详情\n\n判断 *X* 是否为空。\n\n#### 参数\n\n**X** 可以是标量、数据对、向量或矩阵。\n\n**Y** 可以是标量、数据对、向量或矩阵。\n\n*X* 和 *Y* 必须具有相同的数据类型。\n\n#### 返回值\n\n* 如果 *X* 为 NULL，则返回 *X* 的值\n* 如果 *X* 为非 NULL，则返回 *Y* 的值\n\n#### 例子\n\n```\nx = take(1..5 join NULL 6,7)\ny = 1..7\nifNull(x,y)\n// output: [1,2,3,4,5,,7]\ny1 = int(take(1..5 join int(),6))$2:3\nx1 = int(take(100,6))$2:3\nifNull(x1,y1)\n\n/* output:\n#0 #1 #2\n-- -- --\n1  3  5 \n2  4   \n*/\n```\n\n若 *X* 为向量，*Y* 为 n 行 m 列的矩阵，则 *X* 的长度为 n\\*m\n\n```\nm=int(take(1..4 join NULL 8,6))\nifNull(m,y1)\n// output: [1,2,3,4,,] \n```\n"
    },
    "ifValid": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/ifValid.html",
        "signatures": [
            {
                "full": "ifValid(X,Y)",
                "name": "ifValid",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [ifValid](https://docs.dolphindb.cn/zh/funcs/i/ifValid.html)\n\n\n\n#### 语法\n\nifValid(X,Y)\n\n#### 详情\n\n判断 *X* 是否非空。\n\n#### 参数\n\n**X** 可以是标量、数据对、向量或矩阵。\n\n**Y** 可以是标量、数据对、向量或矩阵。\n\n*X* 和 *Y* 必须具有相同的数据类型。\n\n#### 返回值\n\n* 如果 *X* 为非 NULL，则返回 *X* 的值\n* 如果 *X* 为 NULL，则返回 *Y* 的值\n\n#### 例子\n\n```\nx = take(1..5 join NULL 6,7)\ny = 1..7\nifValid(x,y)\n// output\n[1,2,3,4,5,6,6]\nx1 = int(take(1..5 join int(),6))$2:3\ny1 = int(take(100,6))$2:3\nifValid(x1,y1)\n```\n\n| col1 | col2 | col3 |\n| ---- | ---- | ---- |\n| 1    | 3    | 5    |\n| 2    | 4    | 100  |\n\n若 *X* 为向量，*Y* 为 n 行 m 列的矩阵，则 *X* 的长度为 n\\*m\n\n```\nm=int(take(1..4 join NULL 8,6))\nifValid(m,y1)\n// output\n[1,2,3,4,100,8]\n```\n"
    },
    "iif": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/iif.html",
        "signatures": [
            {
                "full": "iif(cond, trueResult, falseResult)",
                "name": "iif",
                "parameters": [
                    {
                        "full": "cond",
                        "name": "cond"
                    },
                    {
                        "full": "trueResult",
                        "name": "trueResult"
                    },
                    {
                        "full": "falseResult",
                        "name": "falseResult"
                    }
                ]
            }
        ],
        "markdown": "### [iif](https://docs.dolphindb.cn/zh/funcs/i/iif.html)\n\n\n\n#### 语法\n\niif(cond, trueResult, falseResult)\n\n#### 详情\n\n`iif` 是元素级的条件运算符。它逐元素判断给定的条件，并根据每个元素的条件结果从 *trueResult* 或 *falseResult* 中返回相应位置的元素。具体来说，如果 cond\\[i] 为 true，它返回 *trueResult* 的第 i 个元素；否则返回 *falseResult* 的第 i 个元素。 当 cond\\[i] 为空值时，则返回空值。\n\n**Note:** 此函数会首先执行其中的三个参数，然后根据 *cond* 的结果决定返回 *trueResult* 或 *falseResult*。\n\n#### 参数\n\n**cond** 是布尔标量、向量或矩阵。可为产生布尔标量、向量或矩阵的表达式。\n\n**trueResult** 和 **falseResult** 可以是标量、与 *cond* 等长的向量/元组、或元素个数与 *cond* 相同的矩阵。二者的数据类型必须相同。\n\n#### 返回值\n\n返回值的数据类型与 *trueResult* 和 *falseResult* 的数据类型相同。\n\n* 当输入参数为标量时，返回标量。\n* 当输入参数为向量时，返回向量，与输入向量长度相同。\n* 当输入参数为矩阵时，返回矩阵，与输入矩阵维度相同。\n\n#### 例子\n\n```\niif(true true true false false false, 1..6, 6..1);\n// output: [1,2,3,3,2,1]\n\niif(1..6==3, 1, 2);\n// output: [2,2,1,2,2,2]\n\nx=9 6 8;\niif(x<=8, 10*x, 20*x-80);\n// output: [100,60,80]\n\na = 1..10\niif(isNull(a.prev()), a.cut(1), a.prev().cut(1))\n// output: (1,1,2,3,4,5,6,7,8,9)\n\nt=table(1..5 as id, 11..15 as x);\nt1=table(take(12,5) as a, take(14,5) as b);\nt;\n```\n\n| id | x  |\n| -- | -- |\n| 1  | 11 |\n| 2  | 12 |\n| 3  | 13 |\n| 4  | 14 |\n| 5  | 15 |\n\n```\nt1;\n```\n\n| a  | b  |\n| -- | -- |\n| 12 | 14 |\n| 12 | 14 |\n| 12 | 14 |\n| 12 | 14 |\n| 12 | 14 |\n\n```\nupdate t set x=iif(x<t1.a, t1.a, iif(x>t1.b,t1.b, x));\nt;\n```\n\n| id | x  |\n| -- | -- |\n| 1  | 12 |\n| 2  | 12 |\n| 3  | 13 |\n| 4  | 14 |\n| 5  | 14 |\n\n当配置了 *nullAsMinValueForComparison*=true时，在比较运算中，NULL 元素取相应数据类型的最小值。使用 [nullCompare](https://docs.dolphindb.cn/zh/funcs/ho_funcs/nullCompare.html) 可以保持 `iif` 条件语句里的 NULL 值。\n\n```\na = NULL 1 -3 5\niif(a > 0, a, 0)\n// output: [0, 1, 0, 5]\niif(nullCompare(>,a,0), a, 0)\n// output: [ , 1, 0, 5]\n```\n\n```\nm1=1..6$3:2\nm2=6..1$3:2\niif(m1>m2, m1, m2);\n```\n\n| col1 | col2 |\n| ---- | ---- |\n| 6    | 4    |\n| 5    | 5    |\n| 4    | 6    |\n"
    },
    "ilastNot": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/ilastNot.html",
        "signatures": [
            {
                "full": "ilastNot(X)",
                "name": "ilastNot",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [ilastNot](https://docs.dolphindb.cn/zh/funcs/i/ilastNot.html)\n\n\n\n#### 语法\n\nilastNot(X)\n\n#### 详情\n\n查找最后一个非空元素的下标位置。\n\n如果 *X* 是一个向量，返回最后一个非空元素的下标。如果 *X* 中的所有元素都为空，返回-1。\n\n如果 *X* 是一个元组，返回最后一个所有向量中均不为空的位置的下标。\n\n如果 *X* 是一个矩阵，返回每列中最后一个非空元素的下标。返回一个向量。\n\n如果 *X* 是一个表，返回每列中最后一个非空元素的下标。返回一个表。\n\n#### 参数\n\n**X** 可以是一个向量，也可以是由多个等长向量组成的元组，亦可是一个矩阵或表。\n\n#### 返回值\n\n* 当 X 是向量或元组时，返回 INT 类型标量。\n* 当 X 是矩阵时，返回 INT 类型向量。\n* 当 X 是表时，返回表。\n\n#### 例子\n\n```\nilastNot(NULL NULL 2 4 8 1 NULL);\n// output: 5\n\nilastNot(take(int(),5));\n// output: -1\n\nx=NULL NULL 4 7 8 NULL\ny=1 NULL NULL 4 NULL NULL\nilastNot([x,y]);\n// output: 3\n\nx=NULL NULL 4 7 8 NULL\ny=1 2 NULL NULL NULL 6\nilastNot([x,y]);\n// output: -1\n\nm=matrix(2 NULL 1 0 NULL, NULL 2 NULL 6 0);\nm;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 2  |    |\n|    | 2  |\n| 1  |    |\n| 0  | 6  |\n|    | 0  |\n\n```\nilastNot(m);\n// output: [3,4]\n```\n\n相关函数：[ifirstNot](https://docs.dolphindb.cn/zh/funcs/i/ifirstNot.html), [lastNot](https://docs.dolphindb.cn/zh/funcs/l/lastNot.html), [firstNot](https://docs.dolphindb.cn/zh/funcs/f/firstNot.html)\n"
    },
    "ilike": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/ilike.html",
        "signatures": [
            {
                "full": "ilike(X, pattern)",
                "name": "ilike",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "pattern",
                        "name": "pattern"
                    }
                ]
            }
        ],
        "markdown": "### [ilike](https://docs.dolphindb.cn/zh/funcs/i/ilike.html)\n\n\n\n#### 语法\n\nilike(X, pattern)\n\n#### 详情\n\n判断字符串 *X* 中是否包含字符串 *pattern*。和函数 [like](https://docs.dolphindb.cn/zh/funcs/l/like.html) 不同，比较是不区分大小写的。\n\n#### 参数\n\n**X** 可以是标量、向量或矩阵。\n\n**pattern** 是一个字符串，通常包含类似 \"%\" 的通配符。\n\n#### 返回值\n\n布尔标量、向量、矩阵。\n\n#### 例子\n\n```\nilike(`ABCDEFG, `de);\n// output\n0\n\nilike(`ABCDEFG, \"%de%\");\n// output\n1\n\na=`IBM`ibm`MSFT`Goog`YHOO`ORCL;\na ilike  \"%OO%\";\n// output\n[0,0,0,1,1,0]\n\na[a ilike  \"%OO%\"];\n// output\n[\"Goog\",\"YHOO\"]\n```\n\n相关函数：[like](https://docs.dolphindb.cn/zh/funcs/l/like.html)\n"
    },
    "imax": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/imax.html",
        "signatures": [
            {
                "full": "imax(X)",
                "name": "imax",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [imax](https://docs.dolphindb.cn/zh/funcs/i/imax.html)\n\n\n\n#### 语法\n\nimax(X)\n\n#### 详情\n\n查找数据中最大值的位置索引，如果有多个相同的最大值，返回第一个（最左）的位置。位置索引从 0 开始计数。空向量返回 -1。\n\n#### 参数\n\n**X** 可以是标量、向量、矩阵或表。\n\n#### 返回值\n\n* 若 *X* 是标量或向量，返回一个整型标量。\n\n* 若 *X* 为矩阵，返回一个向量。\n\n* 若 *X* 为表，返回一个表。\n\n#### 例子\n\n```\nx = 1.2 2 NULL 6 -1 6;\nimax(x);\n// 输出：3\n\nx = 5 3 1 6 4 6 $ 3:2;\nimax(x);\n// 输出：(0,0)\n\nx=array(INT,0);\nx;\n// 输出：[]\n\nimax(x);\n// 输出：-1\n// 对于一个空向量，imax 返回 -1\n\nm=matrix(1 2 3, 6 5 4);\nm;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 6  |\n| 2  | 5  |\n| 3  | 4  |\n\n```\nimax(m);\n// 输出：[2,0]\n```\n\n相关函数：[imaxLast](https://docs.dolphindb.cn/zh/funcs/i/imaxlast.html)\n"
    },
    "imaxLast": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/imaxlast.html",
        "signatures": [
            {
                "full": "imaxLast(X)",
                "name": "imaxLast",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [imaxLast](https://docs.dolphindb.cn/zh/funcs/i/imaxlast.html)\n\n\n\n#### 语法\n\nimaxLast(X)\n\n#### 详情\n\n返回最大值的位置。如果有多个相同的最大值，返回右起第一个最大值的位置。位置索引从 0 开始计数。空向量返回 -1。\n\n#### 参数\n\n**X** 可以是标量、向量、矩阵或表。\n\n#### 返回值\n\n* 若 *X* 是标量或向量，返回一个整型标量。\n\n* 若 *X* 为矩阵，返回一个向量。\n\n* 若 *X* 为表，返回一个表。\n\n#### 例子\n\n```\nx = 1.2 2 NULL -1 6 -1\nimaxLast(x);\n// output: 4\n\nm=matrix(3 2 4 4 2, 1 4 2 4 3);\nimaxLast(m) \n// output: [3,3]\n\nt=table(3 3 2 as c1, 1 4 4 as c2)\nimaxLast(t)\n/* output:\nc1       c2\n0\t2\n*/\n```\n\n相关函数：[imax](https://docs.dolphindb.cn/zh/funcs/i/imax.html)\n"
    },
    "imin": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/imin.html",
        "signatures": [
            {
                "full": "imin(X)",
                "name": "imin",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [imin](https://docs.dolphindb.cn/zh/funcs/i/imin.html)\n\n\n\n#### 语法\n\nimin(X)\n\n#### 详情\n\n返回最小元素的位置。如果有多个相同的最小值，返回左起第一个最小值的位置。与所有其它聚合函数一致，计算时忽略 NULL 值。\n\n#### 参数\n\n**X** 可以是标量、向量、矩阵或表。\n\n#### 返回值\n\n* 若 *X* 是标量或向量，返回一个整型标量。\n\n* 若 *X* 为矩阵，返回一个向量。\n\n* 若 *X* 为表，返回一个表。\n\n#### 例子\n\n```\nx = 1.2 2 NULL -1 6 -1\nimin(x);\n// output\n3\n\nx = 5 3 1 6 4 1 $ 3:2\nimin(x);\n// output\n[2,2]\n```\n\n```\nm=matrix(1 3 2 4, 4 2 3 1);\nm;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 4  |\n| 3  | 2  |\n| 2  | 3  |\n| 4  | 1  |\n\n```\nimin(m);\n// output\n[0,3]\n```\n\n相关函数：[iminLast](https://docs.dolphindb.cn/zh/funcs/i/iminlast.html)\n"
    },
    "iminLast": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/iminlast.html",
        "signatures": [
            {
                "full": "iminLast(X)",
                "name": "iminLast",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [iminLast](https://docs.dolphindb.cn/zh/funcs/i/iminlast.html)\n\n\n\n#### 语法\n\niminLast(X)\n\n#### 详情\n\n返回最小元素的位置。如果有多个相同的最小值，返回右起第一个最小值的位置。与所有其它聚合函数一致，计算时忽略 NULL 值。\n\n#### 参数\n\n**X** 可以是标量、向量、矩阵或表。\n\n#### 返回值\n\n* 若 *X* 是标量或向量，返回一个整型标量。\n\n* 若 *X* 为矩阵，返回一个向量。\n\n* 若 *X* 为表，返回一个表。\n\n#### 例子\n\n```\nx = 1.2 2 NULL -1 6 -1\niminLast(x);\n// output: 5\n\nm=matrix(3 2 2 4 2, 1 4 2 1 3);\niminLast(m) \n// output: [4,3]\n\nt=table(3 2 2 as c1, 1 1 4 as c2)\niminLast(t)\n/* output:\nc1       c2\n2\t1\n*/\n```\n\n相关函数：[imin](https://docs.dolphindb.cn/zh/funcs/i/imin.html)\n"
    },
    "imr": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/imr.html",
        "signatures": [
            {
                "full": "imr(ds, initValue, mapFunc, [reduceFunc], [finalFunc], terminateFunc, [carryover=false])",
                "name": "imr",
                "parameters": [
                    {
                        "full": "ds",
                        "name": "ds"
                    },
                    {
                        "full": "initValue",
                        "name": "initValue"
                    },
                    {
                        "full": "mapFunc",
                        "name": "mapFunc"
                    },
                    {
                        "full": "[reduceFunc]",
                        "name": "reduceFunc",
                        "optional": true
                    },
                    {
                        "full": "[finalFunc]",
                        "name": "finalFunc",
                        "optional": true
                    },
                    {
                        "full": "terminateFunc",
                        "name": "terminateFunc"
                    },
                    {
                        "full": "[carryover=false]",
                        "name": "carryover",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [imr](https://docs.dolphindb.cn/zh/funcs/i/imr.html)\n\n\n\n#### 语法\n\nimr(ds, initValue, mapFunc, \\[reduceFunc], \\[finalFunc], terminateFunc, \\[carryover=false])\n\n#### 详情\n\nDolphinDB 提供了基于 map-reduce 方法的迭代计算函数 `imr`。每次迭代使用上一次迭代的结果和输入数据集。每次迭代的输入数据集不变，因此可以被缓存。迭代计算需要模型参数的初始值和终止标准。\n\n#### 参数\n\n**ds** 数据源列表。它必须是每个元素作为数据源对象的元组。即使只有一个数据源，我们仍然需要一个元组来包装数据源。在迭代计算中，数据源自动缓存，缓存将在最后一次迭代后被清除。\n\n**initValue** 模型参数估计的初始值。初始值的格式必须与最终函数的输出相同。\n\n**mapFunc** map函数。它有两个参数。第一个参数是由相应数据源表示的数据实体。第二个参数是前一次迭代中最终函数的输出，这是对模型参数的更新估算。对于第一次迭代，它是用户给出的初始值。\n\n**reduceFunc** 二元 reduce 函数组合了两个 map 函数调用结果。如果有 M 个 map 调用，reduce 函数将被调用 M-1 次。在大多数情况下，reduce 功能是不重要的。一个例子是加法函数。reduce 函数是可选的。\n\n**finalFunc** 每次迭代的最终函数。它接受两个参数。第一个参数是前一次迭代中最终函数的输出。对于第一次迭代，它是用户给出的初始值。第二个参数是 reduce 函数调用的输出。如果没有指定 reduce 函数，则各个 map 调用结果的集合的元组将是第二个参数。\n\n**terminateFunc** 这是一个确定计算是否继续的函数，或是指定次数的迭代。终止函数接受两个参数。第一个是前一次迭代中 reduce 函数的输出，第二个是当前迭代中 reduce 函数的输出。如果函数返回 true，迭代将结束。\n\n**carryover** 布尔值，表示 map 函数调用是否生成一个传递给下一次 map 函数调用的对象。默认值为 false。如果 *carryover* 为 true，那么 map 函数有3个参数并且最后一个参数为携带的对象，同时 map 函数的输出结果是一个元组，最后一个元素为携带的对象。在第一次迭代中，携带的对象为 NULL。\n\n#### 例子\n\n现在我们使用分布式中位数计算的例子来说明函数 `imr`。假设数据分散在多个节点上，我们想计算所有节点之间的变量的中位数。首先，对于每个数据源，将数据放入桶中，并使用 map 函数对每个数据桶中的数据点数进行计数。然后使用 reduce 函数来合并来自多个数据源的计数。找到包含中位数的桶。在下一次迭代中，所选择的桶分为更小的桶。当所选择的桶的长度不超过指定的数量时，迭代就完成了。\n\n```\ndef medMap(data, range, colName){\n return bucketCount(data[colName], double(range), 1024, true)\n}\n\ndef medFinal(range, result){\n   x= result.cumsum()\n   index = x.asof(x[1025]/2.0)\n   ranges = range[1] - range[0]\n   if(index == -1)\n      return (range[0] - ranges*32):range[1]\n   else if(index == 1024)\n      return range[0]:(range[1] + ranges*32)\n   else{\n      interval = ranges / 1024.0\n      startValue = range[0] + (index - 1) * interval\n      return startValue : (startValue + interval)\n   }\n}\n\ndef medEx(ds, colName, range, precision){\n   termFunc = def(prev, cur): cur[1] - cur[0] <= precision\n   return imr(ds, range, medMap{,,colName}, +, medFinal, termFunc).avg()\n}\n```\n"
    },
    "imtForceGCRedolog": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/imtForceGCRedolog.html",
        "signatures": [
            {
                "full": "imtForceGCRedolog(tid)",
                "name": "imtForceGCRedolog",
                "parameters": [
                    {
                        "full": "tid",
                        "name": "tid"
                    }
                ]
            }
        ],
        "markdown": "### [imtForceGCRedolog](https://docs.dolphindb.cn/zh/funcs/i/imtForceGCRedolog.html)\n\n\n\n#### 语法\n\nimtForceGCRedolog(tid)\n\n#### 详情\n\n系统会自动将已完成（处于 COMPLETE 状态）事务的 redo log 将放入待回收列表。并根据此列表中事务 tid 的大小，顺序对成功落盘的事务进行回收。\n\n若回收过程中出现某个编号为 tid 的事务尚未刷盘，在该事务被成功刷盘前，无法对编号大于 *tid* 且成功刷盘事务的 redo log 进行回收。此时调用该命令，可以取消等待编号为 *tid* 事务的回收，继续对后续满足回收条件的事务进行回收。\n\n该函数建议搭配 [getRedoLogGCStat](https://docs.dolphindb.cn/zh/funcs/g/getRedoLogGCStat.html) 函数使用。\n\n#### 参数\n\n**tid** 事务的 id。\n\n#### 返回值\n\n无。\n"
    },
    "imtUpdateChunkVersionOnDataNode": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/imtUpdateChunkVersionOnDataNode.html",
        "signatures": [
            {
                "full": "imtUpdateChunkVersionOnDataNode(chunkId, version)",
                "name": "imtUpdateChunkVersionOnDataNode",
                "parameters": [
                    {
                        "full": "chunkId",
                        "name": "chunkId"
                    },
                    {
                        "full": "version",
                        "name": "version"
                    }
                ]
            }
        ],
        "markdown": "### [imtUpdateChunkVersionOnDataNode](https://docs.dolphindb.cn/zh/funcs/i/imtUpdateChunkVersionOnDataNode.html)\n\n\n\n#### 语法\n\nimtUpdateChunkVersionOnDataNode(chunkId, version)\n\n#### 详情\n\n修改数据节点上对应 *chunkId* 的版本号，以维护集群中多副本数据之间，或数据节点与控制节点之间的版本一致性。\n\n该函数只能在数据节点执行。\n\n#### 参数\n\n**chunkId** 字符串标量或向量，表示 chunk 的 ID。\n\n**version** 整型数字，表示版本号。\n\n#### 返回值\n\n无。\n\n#### 相关函数\n\n控制节点可调用函数 [getClusterChunksStatus](https://docs.dolphindb.cn/zh/funcs/g/getClusterChunksStatus.html) 查询所有节点上 chunk 对应的版本号。\n\n数据节点可调用函数 [getChunksMeta](https://docs.dolphindb.cn/zh/funcs/g/getChunksMeta.html) 查询当前数据节点上 chunk 对应的版本号。\n"
    },
    "in": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/in.html",
        "signatures": [
            {
                "full": "in(X, Y)",
                "name": "in",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [in](https://docs.dolphindb.cn/zh/funcs/i/in.html)\n\n\n\n#### 语法\n\nin(X, Y)\n\n#### 详情\n\n* 若 *Y* 是非时间类型的标量，检查 *X* 和 *Y* 是否相等；若 *Y* 是时间类型的标量，则会检查 *X* 中的每个元素是否在 *Y* 中。当 *Y* 是 NULL 值时，无论 *X* 为何值都返回 false。\n\n* 若 *Y* 是向量，检查 *X* 中的每一个元素是否在 *Y* 中。\n\n* 若 *Y* 是字典，检查 *X* 中的每一个元素是否是 *Y* 中的键。\n\n* 若 *Y* 是单列内存表，检查 *X* 中的每一个元素是否是 *Y* 唯一列中的值。\n\n  **Note:** 表中单列的类型不能是数组向量。\n\n* 若 *Y* 是键值表或索引内存表，检查 *X* 中的每一个元素是否为 *Y* 中的主键。*X* 中元素的个数必须与 *Y* 中主键列的个数一致。\n\n**Note:** *X* 和 *Y* 的数据类型需保持一致。若类型不一致，但属于同一分类，系统会将 *X* 强制转换为与 *Y* 一致的类型。\n\n#### 参数\n\n**X** 可以是标量、向量、元组、矩阵、数组向量、字典、表。\n\n**Y** 可以是标量、向量、字典、单列内存表、键值内存表或索引内存表。\n\n#### 返回值\n\n布尔标量或向量。\n\n#### 例子\n\n```\nin(3 3 5 2, 2 3);\n// output: [true,true,false,true]\n\nx=dict(INT,DOUBLE);\nx[1, 2, 3]=[4.5, 6.6, 3.2];\nx;\n// output\n3->3.2\n1->4.5\n2->6.6\n\nin(1..6, x);\n// output: [true,true,true,false,false,false]\n\nt = table(1 3 5 7 9 as id)\n2 3 in t\n// output: [false,true]\n\nkt = keyedTable(`name`id,1000:0,`name`id`age`department,[STRING,INT,INT,STRING])\ninsert into kt values(`Tom`Sam`Cindy`Emma`Nick, 1 2 3 4 5, 30 35 32 25 30, `IT`Finance`HR`HR`IT)\nin((`Tom`Cindy, 1 3), kt);\n// output: [true,true]\n\nt1 = indexedTable(`sym`side, 10000:0, `sym`side`price`qty, [SYMBOL,CHAR,DOUBLE,INT])\ninsert into t1 values(`IBM`MSFT`GOOG, ['B','S','B'], 10.01 10.02 10.03, 10 10 20)\nin((`IBM`MSFT, ['S','S']), t1);\n// output: [false,true]\n\n```\n\n*X* 为浮点型，*Y* 为整型，数据类型不一致，会将 *X* 转换为与 *Y* 一致的类型进行比较。\n\n```\nin(10, NULL)\n// output: false\n\nin('a', 97)\n// output: true\n\nin(1, 1.1 1.2 1.3)\n// output: false\n\nin(float(1.1 2.2 3.3 4.4 5.5 6.6 7.7 8.8), 1..9)\n// output: [true,true,true,true,true,true,true,true]\n```\n\n`in` 可以搭配 `select` 使用，用于限定条件的筛选的范围：\n\n```\nselect * from kt where name in [`Tom, `Cindy];\n```\n\n| name  | id | age | department |\n| ----- | -- | --- | ---------- |\n| Tom   | 1  | 30  | IT         |\n| Cindy | 3  | 32  | HR         |\n\n相关函数：[find](https://docs.dolphindb.cn/zh/funcs/f/find.html), [binsrch](https://docs.dolphindb.cn/zh/funcs/b/binsrch.html)。\n"
    },
    "indexedSeries": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/indexedSeries.html",
        "signatures": [
            {
                "full": "indexedSeries(index, value)",
                "name": "indexedSeries",
                "parameters": [
                    {
                        "full": "index",
                        "name": "index"
                    },
                    {
                        "full": "value",
                        "name": "value"
                    }
                ]
            }
        ],
        "markdown": "### [indexedSeries](https://docs.dolphindb.cn/zh/funcs/i/indexedSeries.html)\n\n\n\n#### 语法\n\nindexedSeries(index, value)\n\n#### 详情\n\n创建一个有索引的序列。\n\n索引序列支持面板数据对齐运算。普通矩阵或向量进行二元运算时，按照对应元素分别进行计算，需要保持维度（shape）一致。而索引序列之间，索引序列与索引矩阵之间，进行二元运算时，根据行列标签（index）自动对齐，对维度没有硬性要求。\n\n支持的二元操作包括：\n\n(1) 算术运算符和函数：+, -, \\*, /(整除), (ratio), %(mod), pow\n\n(2) 逻辑运算符和函数：<, <=, >, >=, ==, !=, <>, &&, ||, &, |, ^\n\n(3) 滑动窗口函数：mwavg, mwsum, mbeta, mcorr, mcovar\n\n(4) 累计窗口函数：cumwavg, cumwsum, cumbeta, cumcorr, cumcovar\n\n(5) 聚合函数：wavg, wsum, beta, corr, covar\n\n#### 参数\n\n**index** 与 **value** 为等长向量。*index* 须严格递增，无重复项。\n\n#### 返回值\n\n数值型矩阵，表示索引序列。\n\n#### 例子\n\n例1. 索引序列之间的运算，长度可以相等或者不等，根据索引对齐。\n\n```\ns1 = indexedSeries(2012.01.01..2012.01.04, [10, 20, 30, 40])\ns2 = indexedSeries(2011.12.30..2012.01.01, [50, 60, 70])\nres = s1 + s2\n```\n\n|            | col1 |\n| ---------- | ---- |\n| 2011.12.30 |      |\n| 2011.12.31 |      |\n| 2012.01.01 | 80   |\n| 2012.01.02 |      |\n| 2012.01.03 |      |\n| 2012.01.04 |      |\n\n例2. 索引序列和向量之间运算，长度必须相等。\n\n```\ns1 = indexedSeries(2012.01.01..2012.01.04, [10, 20, 30, 40])\nv = [1,2,3,4]\nres = s1+v\n```\n\n|            | col1 |\n| ---------- | ---- |\n| 2012.01.01 | 11   |\n| 2012.01.02 | 22   |\n| 2012.01.03 | 33   |\n| 2012.01.04 | 44   |\n\n例3. 索引序列和索引矩阵进行运算时，根据索引对齐。\n\n```\ns1 = indexedSeries(2012.01.01 2012.01.03 2012.01.04 2012.01.06, [10, 20, 30, 40])\nm = matrix(1..6, 11..16).rename!(2012.01.01..2012.01.06,`x`y).setIndexedMatrix!()\ns1 + m\n```\n\n|            | IBM | MSFT |\n| ---------- | --- | ---- |\n| 2012.01.01 | 11  | 21   |\n| 2012.01.02 |     |      |\n| 2012.01.03 | 23  | 33   |\n| 2012.01.04 | 34  | 44   |\n| 2012.01.05 |     |      |\n| 2012.01.06 | 46  | 56   |\n\n例4. 索引序列与没有设置索引的矩阵进行运算，长度必须相等。\n\n```\ns1 = indexedSeries(2012.01.01..2012.01.04, [10, 20, 30, 40])\nm = matrix([1,1,1,1], [2,2,2,2])\nres = s1 pow m\n```\n\n| col1 | col2  |\n| ---- | ----- |\n| 10   | 100   |\n| 20   | 400   |\n| 30   | 900   |\n| 40   | 1,600 |\n"
    },
    "indexedTable": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/indexedTable.html",
        "signatures": [
            {
                "full": "indexedTable(keyColumns, X, [X1], [X2], .....)",
                "name": "indexedTable",
                "parameters": [
                    {
                        "full": "keyColumns",
                        "name": "keyColumns"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[X1]",
                        "name": "X1",
                        "optional": true
                    },
                    {
                        "full": "[X2]",
                        "name": "X2",
                        "optional": true
                    },
                    {
                        "full": ".....",
                        "name": "....."
                    }
                ]
            },
            {
                "full": "indexedTable(keyColumns, capacity:size, colNames, colTypes)",
                "name": "indexedTable",
                "parameters": [
                    {
                        "full": "keyColumns",
                        "name": "keyColumns"
                    },
                    {
                        "full": "capacity:size",
                        "name": "capacity:size"
                    },
                    {
                        "full": "colNames",
                        "name": "colNames"
                    },
                    {
                        "full": "colTypes",
                        "name": "colTypes"
                    }
                ]
            },
            {
                "full": "indexedTable(keyColumns, table)",
                "name": "indexedTable",
                "parameters": [
                    {
                        "full": "keyColumns",
                        "name": "keyColumns"
                    },
                    {
                        "full": "table",
                        "name": "table"
                    }
                ]
            }
        ],
        "markdown": "### [indexedTable](https://docs.dolphindb.cn/zh/funcs/i/indexedTable.html)\n\n\n\n#### 语法\n\nindexedTable(keyColumns, X, \\[X1], \\[X2], .....)\n\n或\n\nindexedTable(keyColumns, capacity:size, colNames, colTypes)\n\n或\n\nindexedTable(keyColumns, table)\n\n#### 详情\n\n创建索引内存表（indexed table）。一个索引内存表有一个主键。主键可由一个或多个字段组成。索引内存表使用红黑树存储主键索引。在查询时，只要查询条件中包含主键的第1个列字段，便可通过索引定位数据，而无需进行全表扫描。\n\n向表中添加新记录时，系统会检查新记录的主键值。如果新记录的主键值与已有记录的主键值重复，系统会更新表中对应的记录；否则，系统会将新记录添加到表中。\n\n键值内存表在指定所有键值字段时才能达到最佳的查询性能。然而，在实际应用中，并不总是需要查询所有键值字段的信息。对于那些只需查询部分键值字段的情况，可以考虑使用索引内存表。\n\n关于对索引内存表和[键值内存表](https://docs.dolphindb.cn/zh/funcs/k/keyedTable.html)使用怎样的查询语句以及如何进行查询优化，详见下表：\n\n<table id=\"table_sbg_tkx_dcc\"><thead><tr><th>\n\n</th><th>\n\nindexedTable\n\n</th><th>\n\nkeyedTable\n\n</th></tr></thead><tbody><tr><td>\n\n查询优化\n\n</td><td>\n\n* 查询语句必须包含 *keyColumns* 的第 1 列，且该列过滤条件中只能使用 =, in 或 and；\n\n* 除 keyColumns 的第 1 列外，其它列可以通过 between、比较运算符等进行范围查询，且查询效率高于使用 in 谓词。\n\n* 所有过滤条件中，对不同列使用的 in 的次数不超过2次；\n\n* 建议调用 [sliceByKey](https://docs.dolphindb.cn/zh/funcs/s/sliceByKey.html) 以提高性能。\n\n</td><td>\n\n* 查询语句必须包含 *keyColumns* 所有列。\n\n* 过滤条件中只能使用 =, in 或 and，且对不同列使用 in 的次数不超过2次；\n\n* 建议调用 [sliceByKey](https://docs.dolphindb.cn/zh/funcs/s/sliceByKey.html) 以提高性能。\n\n</td></tr><tr><td>\n\n查询语句特点\n\n</td><td>\n\n只需要包含 *keyColumns* 的第 1 列，而无需包含所有列。\n\n</td><td>\n\n包含 keyColumns 的所有列。此时查询性能优于 indexedTable。\n\n</td></tr></tbody>\n</table>## 参数\n\n**keyColumns** 是一个字符串标量或向量，表示主键。主键的数据类型必须属于以下类别： INTEGRAL, TEMPORAL 或 LITERAL。\n\n第一种用法中，**X**, **X1**, **X2** ... 可以是向量、数组向量、矩阵或元组。每个向量、元组、数组向量的长度，以及矩阵中每列长度都必须相同。**当 Xk 是元组时：**\n\n* 若 Xk 的元素是等长的向量，\\*\\*元组的每个元素将作为表的一列。\\*\\*元组的长度必须等于表的行数。\n\n* 若 Xk 包含不同类型或不等长元素，\\*\\*则将单独作为表的一列（列类型为 ANY），其每个元素将作为该列每行的元素值。\\*\\*Xk 的长度仍然必须和表的行数保持一致。\n\n第二种用法中：\n\n* **capacity** 是正整数，表示建表时系统为该表分配的内存（以记录数为单位）。当记录数超过 *capacity* 时，系统首先会分配 *capacity* 1.2\\~2倍的新的内存空间，然后复制数据到新的内存空间，最后释放原来的内存。对于规模较大的表，此类操作的内存占用会很高。因此，建议建表时预先分配一个合理的 *capacity*。\n\n* **size** 是整数，表示该表新建时的行数。若 *size* =0，创建一个空表。 若 *size*>0，则建立一个只包含 size 条记录的表，记录初始值如下：\n\n  * BOOL 类型默认值为 false；\n\n  * 数值类型、时间类型、IPADDR、COMPLEX、POINT 的默认值为 0；\n\n  * Literal, INT128 类型的默认值为 NULL。\n\n  **Note:** 如果 *colTypes* 指定为数组向量， *size* 必须为0。\n\n* **colNames** 是一个向量，表示列名。\n\n* **colTypes** 是一个向量，表示每列的数据类型，允许主键外的其它列指定为数组向量类型或元组（ANY）类型。可使用表示数据类型的系统保留字或相应的字符串。\n\n第三种用法中，**table** 是一个表（非流数据表）。注意，*table* 中的 *keyColumns* 不能包含重复值。\n\n#### 返回值\n\n返回一个索引内存表。\n\n#### 例子\n\n例1. 创建索引表\n\n第一种写法：\n\n```\nsym=`A`B`C`D`E\nid=5 4 3 2 1\nval=52 64 25 48 71\nt=indexedTable(`sym`id,sym,id,val)\nt;\n```\n\n| sym | id | val |\n| --- | -- | --- |\n| A   | 5  | 52  |\n| B   | 4  | 64  |\n| C   | 3  | 25  |\n| D   | 2  | 48  |\n| E   | 1  | 71  |\n\n第二种写法：\n\n```\nt=indexedTable(`sym`id,1:0,`sym`id`val,[SYMBOL,INT,INT])\ninsert into t values(`A`B`C`D`E,5 4 3 2 1,52 64 25 48 71);\n```\n\n第三种写法：\n\n```\ntmp=table(sym, id, val)\nt=indexedTable(`sym`id, tmp);\n```\n\n创建索引内存分区表：\n\n```\nt=indexedTable(`sym`id,sym,id,val)\ndb=database(\"\",VALUE, sym)\npt=db.createPartitionedTable(t,`pt,`sym).append!(t);\n```\n\n例2. 更新索引表\n\n```\nt=indexedTable(`sym,1:0,`sym`datetime`price`qty,[SYMBOL,DATETIME,DOUBLE,DOUBLE])\ninsert into t values(`APPL`IBM`GOOG,2018.06.08T12:30:00 2018.06.08T12:30:00 2018.06.08T12:30:00,50.3 45.6 58.0,5200 4800 7800)\nt;\n```\n\n| sym  | datetime            | price | qty  |\n| ---- | ------------------- | ----- | ---- |\n| APPL | 2018.06.08T12:30:00 | 50.3  | 5200 |\n| IBM  | 2018.06.08T12:30:00 | 45.6  | 4800 |\n| GOOG | 2018.06.08T12:30:00 | 58    | 7800 |\n\n插入新记录，并且新记录中的 *keyColumns* 的值与表中 *keyColumns* 的值重复：\n\n```\ninsert into t values(`APPL`IBM`GOOG,2018.06.08T12:30:01 2018.06.08T12:30:01 2018.06.08T12:30:01,65.8 45.2 78.6,5800 8700 4600)\nt;\n```\n\n| sym  | datetime            | price | qty  |\n| ---- | ------------------- | ----- | ---- |\n| APPL | 2018.06.08T12:30:01 | 65.8  | 5800 |\n| IBM  | 2018.06.08T12:30:01 | 45.2  | 8700 |\n| GOOG | 2018.06.08T12:30:01 | 78.6  | 4600 |\n\n*keyColumns* 的值不允许更新：\n\n```\nupdate t set sym=\"C_\"+sym;\n// output: Can't update a key column.\n```\n\n例3. 查询索引内存表\n\nSQL 语句中若不使用 or，且某个过滤条件包含 *keyColumns* 的第1列，且该过滤条件使用 = 或 in 谓词，且 in 谓词使用不超过两次，则查询索引内存表的性能优于查询普通内存表。与之对比，若希望查询键值表的性能优于普通内存表，过滤条件必须包含全部 *keyColumns*。\n\n首先，分别创建包含100万条记录的普通内存表 t 和索引内存表 t1。\n\n```\nid=shuffle(1..1000000)\ndate=take(2012.06.01..2012.06.10, 1000000)\ntype=take(0..9, 1000000)\nval=rand(100.0, 1000000)\nt=table(id, date, type, val)\nt1=indexedTable(`id`date`type, id, date, type, val);\n```\n\n使用 *keyColumns* 的第一列进行过滤：\n\n```\ntimer(100) select * from t where id=500000;\n// output: Time elapsed: 177.286 ms\n\ntimer(100) select * from t1 where id=500000;\n// output: Time elapsed: 1.245 ms\n\ntimer(100) sliceByKey(t1, 500000)\n// output: Time elapsed: 0.742 ms\n\ntimer(100) select * from t where id in [500000, 600000, 700000];\n// output: Time elapsed: 1134.429 ms\n\ntimer(100) select * from t1 where id in [500000, 600000, 700000];\n// output: Time elapsed: 1.377 ms\n```\n\n若 *keyColumns* 第一列的过滤条件不使用 = 或 in ，则查询索引内存表的性能不会优化：\n\n```\ntimer(100) select * from t where id between 500000:500010;\n// output: Time elapsed: 641.544 ms\n\ntimer(100) select * from t1 where id between 500000:500010;\n// output: Time elapsed: 599.752 ms\n```\n\n使用 *keyColumns* 的第一列与第三列进行过滤：\n\n```\ntimer(100) select * from t where id=500000, type in [3,6];\n// output: Time elapsed: 172.808 ms\n\ntimer(100) select * from t1 where id=500000, type in [3,6];\n// output: Time elapsed: 1.664 ms\n```\n\n若不使用第一列 *keyColumns* 进行过滤，则查询索引内存表的性能不会优化：\n\n```\ntimer(100) select * from t where date in [2012.06.03, 2012.06.06];\n// output: Time elapsed: 490.182 ms\n\ntimer(100) select * from t1 where date in [2012.06.03, 2012.06.06];\n// output: Time elapsed: 544.015 ms\n\ntimer(100) select * from t where date=2012.06.03, type=8;\n// output: Time elapsed: 205.443 ms\n\ntimer(100) select * from t1 where date=2012.06.03, type=8;\n// output: Time elapsed: 204.532 ms\n```\n\n若过滤条件使用超过两个 in 谓词，则查询索引内存表的性能不会优化：\n\n```\ntimer(100) select * from t where id in [100,200], date in [2012.06.03, 2012.06.06], type in [3,6];\n// output: Time elapsed: 208.714 ms\n\ntimer(100) select * from t1 where id in [100,200], date in [2012.06.03, 2012.06.06], type in [3,6];\n// output: Time elapsed: 198.674 ms\n```\n\n例4. 使用 `indexedTable` 保留每只股票卖方委托的最新五档报价。\n\n```\nsym=[\"a\",\"b\",\"c \"] \ntime=22:58:52.827 22:58:53.627 22:58:53.827 \nvolume=array(INT[]).append!([[100,110,120,115,125],[200,230,220,225,230],[320,300,310,315,310]])\nprice=array(DOUBLE[]).append!([[10.5,10.6,10.7,10.77,10.85],[8.6,8.7,8.76,8.83,8.9],[6.3,6.37,6.42,6.48,6.52]])\nt=indexedTable(`sym,sym,time,volume,price)\nt\n```\n\n<table id=\"table_lr3_2wt_x1c\"><thead><tr><th>\n\nsym\n\n</th><th>\n\ntime\n\n</th><th>\n\nvolume\n\n</th><th>\n\nprice\n\n</th></tr></thead><tbody><tr><td>\n\na\n\n</td><td>\n\n22:58:52.827\n\n</td><td>\n\n\\[100, 110, 120, 115, 125]\n\n</td><td>\n\n\\[10.5, 10.6, 10.7, 10.77, 10.85]\n\n</td></tr><tr><td>\n\nb\n\n</td><td>\n\n22:58:53.627\n\n</td><td>\n\n\\[200, 230, 220, 225, 230]\n\n</td><td>\n\n\\[8.6, 8.7, 8.76, 8.83, 8.9]\n\n</td></tr><tr><td>\n\nc\n\n</td><td>\n\n22:58:53.827\n\n</td><td>\n\n\\[320, 300, 310, 315, 310]\n\n</td><td>\n\n\\[6.3, 6.37, 6.42, 6.48, 6.52]\n\n</td></tr></tbody>\n</table>```\n//最新的报价数量和价格\nnewVolume=array(INT[]).append!([[130,110,110,115,120]])\nnewPrice= array(DOUBLE[]).append!([[10.55,10.57,10.62,10.68,10.5]])\n//更新名为 a 的股票的最新报价\nupdate t set volume=newVolume, price=newPrice where sym=\"a\"\nt\n```\n\n<table id=\"table_qr3_2wt_x1c\"><thead><tr><th>\n\nsym\n\n</th><th>\n\ntime\n\n</th><th>\n\nvolume\n\n</th><th>\n\nprice\n\n</th></tr></thead><tbody><tr><td>\n\na\n\n</td><td>\n\n22:58:52.827\n\n</td><td>\n\n\\[130, 110, 110, 115, 120]\n\n</td><td>\n\n\\[10.55, 10.57, 10.62, 10.68, 10.5]\n\n</td></tr><tr><td>\n\nb\n\n</td><td>\n\n22:58:53.627\n\n</td><td>\n\n\\[200, 230, 220, 225, 230]\n\n</td><td>\n\n\\[8.6, 8.7, 8.76, 8.83, 8.9]\n\n</td></tr><tr><td>\n\nc\n\n</td><td>\n\n22:58:53.827\n\n</td><td>\n\n\\[320, 300, 310, 315, 310]\n\n</td><td>\n\n\\[6.3, 6.37, 6.42, 6.48, 6.52]\n\n</td></tr></tbody>\n</table>需要注意的是，更新 array vector 列的数据时，新记录中各行向量的元素个数必须和原记录中对应行向量的元素个数相同，否则会出现报错。如下例，新记录向量中有4个元素，而已有记录对应行的向量中有5个元素，数量不相同，出现报错：\n\n```\nnewPrice= array(DOUBLE[]).append!([[10.55,10.57,10.62,10.5]])\nupdate t set volume=newVolume, price=newPrice where sym=\"a\"\n// error: Failed to update column: price\n```\n\n相关函数：[keyedTable](https://docs.dolphindb.cn/zh/funcs/k/keyedTable.html)\n"
    },
    "initcap": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/initcap.html",
        "signatures": [
            {
                "full": "initcap(X)",
                "name": "initcap",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [initcap](https://docs.dolphindb.cn/zh/funcs/i/initcap.html)\n\n\n\n#### 语法\n\ninitcap(X)\n\n#### 详情\n\n将 *X* 中由分隔符分隔的字符串中的第一个英文字符设置为大写，其余英文字符设置为小写。其中，分隔符是除英文字符和数字外的任意字符，例如：汉字，空格，@ 等。\n\n**Note:** 该函数将数字也视为英文字符。\n\n#### 参数\n\n**X** STRING 类型的标量/向量，或 SYMBOL 类型的向量。\n\n#### 返回值\n\n和 *X* 类型保持一致。\n\n#### 例子\n\n```\ninitcap(\"hello world\")\n// output\nHello World\n\ninitcap(\"1aBBBBBB\")\n// output\n1abbbbbb\n\ninitcap(\"nihao, hello@you\")\n// output\nNihao, Hello@You\n\ninitcap(\"你好hello\" \"hello You\")\n// output\n[\"你好Hello\",\"Hello You\"]\ninitcap(symbol([\"adhE\",\"\",\"1yI\"]))\n// output\n[\"Adhe\",,\"1yi\"]\n```\n"
    },
    "initIMOLTPCheckpointEncryption": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/initimoltpcheckpointencryption.html",
        "signatures": [
            {
                "full": "initIMOLTPCheckpointEncryption(mode)",
                "name": "initIMOLTPCheckpointEncryption",
                "parameters": [
                    {
                        "full": "mode",
                        "name": "mode"
                    }
                ]
            }
        ],
        "markdown": "### [initIMOLTPCheckpointEncryption](https://docs.dolphindb.cn/zh/funcs/i/initimoltpcheckpointencryption.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\ninitIMOLTPCheckpointEncryption(mode)\n\n#### 详情\n\n该函数用于初始化 IMOLTP 库表的数据静态加密，仅支持全局加密（即对 checkpoint 中的所有库表统一应用加密）。\n\n注意：仅 Linux 系统支持该功能。一旦完成初始化，加密方式无法修改或关闭，请谨慎操作。\n\n#### 参数\n\n**mode** 字符串标量，指定表的加密方式，默认为不加密（明文模式）。目前支持以下可选值（大小写不区分）：plaintext, aes\\_128\\_ctr, aes\\_128\\_cbc, aes\\_128\\_ecb, aes\\_192\\_ctr, aes\\_192\\_cbc, aes\\_192\\_ecb, aes\\_256\\_ctr, aes\\_256\\_cbc, aes\\_256\\_ecb, sm4\\_128\\_cbc, sm4\\_128\\_ecb\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\ninitIMOLTPCheckpointEncryption(`aes_128_ctr)\n```\n"
    },
    "installModule": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/installmodule.html",
        "signatures": [
            {
                "full": "installModule(moduleName, [serverAddr])",
                "name": "installModule",
                "parameters": [
                    {
                        "full": "moduleName",
                        "name": "moduleName"
                    },
                    {
                        "full": "[serverAddr]",
                        "name": "serverAddr",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [installModule](https://docs.dolphindb.cn/zh/funcs/i/installmodule.html)\n\n首发版本：3.00.5，3.00.4.3\n\n\n\n#### 语法\n\ninstallModule(moduleName, \\[serverAddr])\n\n#### 详情\n\n下载并解压指定模块到节点的模块目录下。可通过 [listRemoteModules](https://docs.dolphindb.cn/zh/funcs/l/listremotemodules.html) 函数查询可供下载的模块。\n\n#### 参数\n\n**moduleName** STRING 类型标量，用于指定模块名称。\n\n**serverAddr** 可选参数，STRING 类型标量，用于指定模块仓库的 HTTP 地址。默认为 \"<http://dolphindb.cn>\" 。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n从市场下载名为 ops 的模块：\n\n```\ninstallModule(\"ops\")\n```\n\n**相关函数**\n\n[listRemoteModules](https://docs.dolphindb.cn/zh/funcs/l/listremotemodules.html)\n\n[loadModule](https://docs.dolphindb.cn/zh/funcs/l/loadModule.html)\n"
    },
    "installPlugin": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/installPlugin.html",
        "signatures": [
            {
                "full": "installPlugin(pluginName, [pluginVersion], [pluginServerAddr])",
                "name": "installPlugin",
                "parameters": [
                    {
                        "full": "pluginName",
                        "name": "pluginName"
                    },
                    {
                        "full": "[pluginVersion]",
                        "name": "pluginVersion",
                        "optional": true
                    },
                    {
                        "full": "[pluginServerAddr]",
                        "name": "pluginServerAddr",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [installPlugin](https://docs.dolphindb.cn/zh/funcs/i/installPlugin.html)\n\n#### 语法\n\ninstallPlugin(pluginName, \\[pluginVersion], \\[pluginServerAddr])\n\n#### 详情\n\n下载并解压指定名称的插件的二进制文件（Windows 版本 server 使用 .dll，Linux 版本 server 使用 .so）和插件描述文件（.txt）到 DolphinDB 的插件目录（`/server/plugins/`）下。返回插件描述文件的完整路径。后续可通过该路径加载插件。\n\n可通过 [listRemotePlugins](https://docs.dolphindb.cn/zh/funcs/l/listRemotePlugins.html) 函数查看所支持的插件名称及版本信息。\n\n#### 参数\n\n**pluginName** STRING 类型，用于指定插件名称。\n\n**pluginVersion** 可选，STRING 类型，用于指定插件版本。如果不指定该参数，则使用插件的最新版本。\n\n**pluginServerAddr** 可选，STRING 类型，用于指定插件仓库的 HTTP 地址。如果不配置该参数，使用默认的 HTTP 地址：\"<http://plugins.dolphindb.cn/plugins\"。如果> DolphinDB 服务位于国外，建议填写 \"<http://plugins.dolphindb.com/plugins>\" 以提高查询速度。\n\n#### 返回值\n\n字符串标量，表示插件描述文件的完整路径。\n\n#### 例子\n\n在 Linux 中下载指定的插件：\n\n```\ninstallPlugin(\"mysql\")\n```\n\n返回： `/home/DolphinDB_Linux64_V2.00.10/server/plugins/mysql/PluginMySQL.txt`\n\n通过 `loadPlugin` 加载插件：\n\n```\nloadPlugin(\"mysql\")\n```\n\n\n\n**Related information**\n\n[listRemotePlugins](https://docs.dolphindb.cn/zh/funcs/l/listRemotePlugins.html)\n\n[loadPlugin](https://docs.dolphindb.cn/zh/funcs/l/loadPlugin.html)\n"
    },
    "instrumentPricer": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/instrumentPricer.html",
        "signatures": [
            {
                "full": "instrumentPricer(instrument, pricingDate, marketData)",
                "name": "instrumentPricer",
                "parameters": [
                    {
                        "full": "instrument",
                        "name": "instrument"
                    },
                    {
                        "full": "pricingDate",
                        "name": "pricingDate"
                    },
                    {
                        "full": "marketData",
                        "name": "marketData"
                    }
                ]
            }
        ],
        "markdown": "### [instrumentPricer](https://docs.dolphindb.cn/zh/funcs/i/instrumentPricer.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\ninstrumentPricer(instrument, pricingDate, marketData)\n\n#### 详情\n\n对一个或多个金融合约（可为相同类型或不同类型）进行定价。\n\n在 DolphinDB 中，每个金融合约可抽象为一个 INSTRUMENT 类型，定价需要用到的每一个市场数据（即期/曲线/曲面）也可抽象为一个 MKTDATA 类型。系统根据既定规则，将合约与对应的市场数据自动匹配，从而进行批量定价。\n\n**Note:** DolphinDB 还提供了基础定价函数，如 `bondPricer`、`irDepositPricer` 等。`instrumentPricer` 与这些函数的区别在于：\n\n* 基础定价函数针对单一资产类型设计，每个函数只能对特定类型的金融工具定价。用户需要手动指定每个定价函数所需的具体市场数据参数（如折现曲线、远期曲线、即期汇率、波动率曲面等），不同函数的市场数据参数各不相同。对多种资产类型定价时，需要分别调用不同函数并编写 if-else 逻辑进行分发。\n* instrumentPricer 提供统一的定价接口，支持所有系统已支持的资产类型。系统根据合约信息自动匹配所需的市场数据，不同类型的合约可放入同一向量中批量定价，一次调用即可完成全部定价，无需按类型分别处理。\n\n#### 参数\n\n**instrument**INSTRUMENT 类型对象，表示需要定价的金融工具。可以是单个合约，也可以是多个合约。\n\n**pricingDate**DATE 类型标量，表示定价日，即计算合约价值所对应的日期。\n\n**marketData**MKTDATA 类型向量/嵌套字典/ 市场数据引擎句柄/用户自定义函数，表示市场数据。\n\n* MKTDATA 类型向量：\n\n  * 若为曲线类市场数据，需指定 curveName 字段。\n\n  * 若为曲面类市场数据，需指定 surfaceName 字段。\n\n* 嵌套字典的结构如下：\n\n  * 第一层：key 为数据类别，可选值：\"Price\", \"Curve\", \"Surface\"。\n\n  * 第二层：key 为定价日期（DATE 类型标量）。\n\n  * 第三层：key 为曲线或曲面名称，value 为对应的 MKTDATA 类型标量。\n\n* 自定义函数：参数为 (kind，date，name)。\n\n#### 返回值\n\n* 若 *instrument* 为标量：返回 DOUBLE 类型标量，表示该合约的定价结果。\n\n* 若 *instrument* 为向量：返回 DOUBLE 类型向量，依次表示输入合约的定价结果。\n\n#### instrument 和 marketData 的匹配规则\n\n目前支持下图分类树中叶节点所示的金融工具类型：\n\n![](https://docs.dolphindb.cn/zh/funcs/images/instrumentPricer.png)\n\n在定价过程中，系统会按照以下优先级确定市场数据：\n\n1. 若 *instrument* 中已显式指定市场数据，则直接使用该数据；\n\n2. 若未指定，则系统根据预定义规则自动匹配合适的市场数据。\n\n以下将对不同类型金融工具的匹配规则进行说明。\n\n##### 债券（Bond）\n\n债券定价需要用到折现曲线。用户可以通过 discountCurve 字段指定折现曲线名称，例如：\n\n```\nbond = {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Bond\",\n    \"bondType\": \"FixedRateBond\",\n    \"instrumentId\": \"1382011.IB\",\n    \"start\": \"2013.01.14\",\n    \"maturity\": \"2028.01.14\",\n    \"issuePrice\": 100.0,\n    \"coupon\": 0.058,\n    \"frequency\": \"Annual\",\n    \"dayCountConvention\": \"ActualActualISDA\",\n    \"currency\": \"CNY\",              //可选字段 \n    \"subType\": \"MTN\",               //可选字段\n    \"creditRating\": \"AAA\",          //可选字段\n    \"discountCurve\": \"CNY_MTN_AAA\"  //可选字段\n}\n```\n\n折现曲线选择规则如下：\n\n* 如果 discountCurve 已指定，则优先使用 discountCurve 的值。\n\n* 如果 discountCurve 未指定：\n\n  * 指定了 currency，subType 和 creditRating，系统会选择名为 currency + \"\\_\" + subType + \"\\_\" + creditRating 的折现曲线。\n  * 指定了 currency，且 subType 为 `TREASURY_BOND`，`CENTRAL_BANK_BILL`，`CDB_BOND`，`EIBC_BOND`，`ADBC_BOND` 之一，则不需要 creditRating，系统会选择名为 currency + \"\\_\" + subType 的折现曲线。\n  * 指定了 currency，且 subType 不为 `TREASURY_BOND`，`CENTRAL_BANK_BILL`，`CDB_BOND`，`EIBC_BOND`，`ADBC_BOND` 之一，同时未指定 creditRating，系统会选择名为 currency + \"\\_TREASURY\\_BOND\" 的折现曲线。\n  * 指定了 currency，且未指定 subType 和 creditRating，系统会选择名为 currency + \"\\_TREASURY\\_BOND\" 的折现曲线。\n  * currency，subType 和 creditRating 均未指定，系统会选择名为 \"CNY\\_TREASURY\\_BOND\" 的折现曲线。\n\n##### 国债期货（BondFutures）\n\n无需指定 discountCurve，函数会使用其标的债券（underlying）的 dicountCurve。\n\n##### 存款（Deposit）\n\n存款定价仅需指定折现曲线 discountCurve：\n\n* 如果 discountCurve 已指定，则使用用户指定的曲线进行定价。\n\n* 如果未指定，则根据币种自动匹配折现曲线，规则如下：\n\n| currency | discountCurve |\n| -------- | ------------- |\n| CNY      | CNY\\_FR\\_007  |\n| USD      | USD\\_SOFR     |\n| EUR      | EUR\\_ESTR     |\n\n##### 利率互换（IrFixedFloatingSwap）\n\n利率互换定价需要传入三条曲线：discountCurve、forwardCurve 和 assetPriceCurve。当前版本仅支持以 FR\\_007 和 SHIBOR\\_3M 作为浮动参考利率的利率互换。\n\n* 如果用户在 *instrument* 中指定了相应曲线，则使用用户指定的曲线进行定价。\n\n* 如果未指定，则根据币种和浮动利率基准自动匹配三条默认曲线，如下表所示：\n\n| currency | iborIndex  | discountCurve | forwardCurve    | assetPriceCurve   |\n| -------- | ---------- | ------------- | --------------- | ----------------- |\n| CNY      | FR\\_007    | CNY\\_FR\\_007  | CNY\\_FR\\_007    | PRICE\\_FR\\_007    |\n| CNY      | SHIBOR\\_3M | CNY\\_FR\\_007  | CNY\\_SHIBOR\\_3M | PRICE\\_SHIBOR\\_3M |\n\n其中 assetPriceCurve 填入的是浮动参考利率的历史数据，用于计算定价日起第一笔现金流的浮动利率。\n\n##### 外汇远期（FxForward）/ 外汇掉期（FxSwap）\n\n这两类线性产品定价需要绑定 domesticCurve 和 foreignCurve，并基于 currencyPair 获取相应的 FxSpot。\n\n* 若用户在 *instrument* 中指定了 domesticCurve 和 foreignCurve，则直接使用用户指定的曲线。\n\n* 若未指定，则系统会根据货币对自动匹配默认曲线，如下表所示：\n\n| currencyPair | domesticCurve | foreignCurve    |\n| ------------ | ------------- | --------------- |\n| USDCNY       | CNY\\_FR\\_007  | USD\\_USDCNY\\_FX |\n| EURCNY       | CNY\\_FR\\_007  | EUR\\_EURCNY\\_FX |\n| EURUSD       | USD\\_SOFR     | EUR\\_EURUSD\\_FX |\n\n其中 foreignCurve 是根据外汇掉期交易，并结合利率平价公式推导得到的外币隐含即期曲线。\n\n##### 外汇欧式期权（FxEuropeanOption）\n\n外汇期权定价除需使用 domesticCurve 与 foreignCurve 外，还依赖 FxSpot 和 FxVolatilitySurface。\n\n这两个市场数据均可根据期权的 underlying（货币对） 自动匹配。\n\n* 若用户在 *instrument* 中明确指定，则优先使用用户提供的 domesticCurve、foreignCurve。\n\n* 若未指定，则系统会根据 `currencyPair` 自动匹配，规则如下：\n\n| currencyPair | fxSpot | domesticCurve | foreignCurve    | volSurf |\n| ------------ | ------ | ------------- | --------------- | ------- |\n| USDCNY       | USDCNY | CNY\\_FR\\_007  | USD\\_USDCNY\\_FX | USDCNY  |\n| EURCNY       | EURCNY | CNY\\_FR\\_007  | EUR\\_EURCNY\\_FX | EURCNY  |\n| EURUSD       | EURUSD | USD\\_SOFR     | EUR\\_EURUSD\\_FX | EURUSD  |\n\n#### 例子\n\n创建外汇远期。\n\n```\nfxFwd1 = {\n    \"productType\": \"Forward\",\n    \"forwardType\": \"FxForward\",\n    \"expiry\": 2025.10.08,\n    \"delivery\": 2025.10.10,\n    \"currencyPair\": \"USDCNY\",\n    \"direction\": \"Buy\",\n    \"notionalCurrency\": \"USD\",\n    \"notionalAmount\": 1E6,\n    \"strike\": 7.2\n}\nfxFwdUsdCny = parseInstrument(fxFwd1)\nfxFwd2 = {\n    \"productType\": \"Forward\",\n    \"forwardType\": \"FxForward\",\n    \"expiry\": 2025.10.08,\n    \"delivery\": 2025.10.10,\n    \"currencyPair\": \"EURCNY\",\n    \"direction\": \"Buy\",\n    \"notionalCurrency\": \"EUR\",\n    \"notionalAmount\": 1E6,\n    \"strike\": 8.2\n}\nfxFwdEurCny = parseInstrument(fxFwd2)\n```\n\n创建外汇掉期。\n\n```\nfxSwap1 = {\n    \"productType\": \"Swap\",\n    \"swapType\": \"FxSwap\",\n    \"currencyPair\": \"USDCNY\",\n    \"direction\": \"Buy\",\n    \"notionalCurrency\": \"USD\",\n    \"notionalAmount\": 1E6,\n    \"nearStrike\": 7.2,\n    \"nearExpiry\": 2025.12.08,\n    \"nearDelivery\": 2025.12.10,\n    \"farStrike\": 7.3,\n    \"farExpiry\": 2026.06.08,\n    \"farDelivery\": 2026.06.10\n}\nfxSwapUsdCny = parseInstrument(fxSwap1)\nfxSwap2 = {\n    \"productType\": \"Swap\",\n    \"swapType\": \"FxSwap\",\n    \"currencyPair\": \"EURCNY\",\n    \"direction\": \"Buy\",\n    \"notionalCurrency\": \"EUR\",\n    \"notionalAmount\": 1E6,\n    \"nearStrike\": 8.2,\n    \"nearExpiry\": 2025.12.08,\n    \"nearDelivery\": 2025.12.10,\n    \"farStrike\": 8.3,\n    \"farExpiry\": 2026.06.08,\n    \"farDelivery\": 2026.06.10\n}\nfxSwapEurCny = parseInstrument(fxSwap2)\n```\n\n创建外汇欧式期权。\n\n```\nfxOption1 = {\n    \"productType\": \"Option\",\n    \"optionType\": \"EuropeanOption\",\n    \"assetType\": \"FxEuropeanOption\",\n    \"notionalCurrency\": \"USD\",\n    \"notionalAmount\": 1E6,\n    \"strike\": 7.0,\n    \"maturity\": 2025.12.08,\n    \"payoffType\": \"Call\",\n    \"dayCountConvention\": \"Actual365\",\n    \"underlying\": \"USDCNY\"\n}\nfxOptionUsdCny = parseInstrument(fxOption1)\nfxOption2 = {\n    \"productType\": \"Option\",\n    \"optionType\": \"EuropeanOption\",\n    \"assetType\": \"FxEuropeanOption\",\n    \"notionalCurrency\": \"EUR\",\n    \"notionalAmount\": 1E6,\n    \"strike\": 8.0,\n    \"maturity\": 2025.12.08,\n    \"payoffType\": \"Call\",\n    \"dayCountConvention\": \"Actual365\",\n    \"underlying\": \"EURCNY\"\n}\n\nfxOptionEurCny= parseInstrument(fxOption2)\n```\n\n创建债券。\n\n```\nbond1 = {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Bond\",\n    \"bondType\": \"FixedRateBond\",\n    \"instrumentId\": \"220010.IB\",\n    \"start\": 2020.12.25,\n    \"maturity\": 2031.12.25,\n    \"issuePrice\": 100.0,\n    \"coupon\": 0.0149,\n    \"frequency\": \"Annual\",\n    \"dayCountConvention\": \"ActualActualISDA\",\n    \"discountCurve\": \"CNY_TREASURY_BOND\"\n}\nbond = parseInstrument(bond1)\n```\n\n创建国债期货。\n\n```\nbondFut1 = {\n    \"productType\": \"Futures\",\n    \"futuresType\": \"BondFutures\",\n    \"instrumentId\": \"T2509\",\n    \"nominal\": 100.0,\n    \"maturity\": \"2025.09.12\",\n    \"settlement\": \"2025.09.16\",\n    \"underlying\": bond1,\n    \"nominalCouponRate\": 0.03\n}\nbondFut = parseInstrument(bondFut1)\n```\n\n创建存款。\n\n```\ndeposit1 = {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Deposit\",\n    \"start\": 2025.06.15,\n    \"maturity\": 2025.12.15,\n    \"rate\": 0.02,\n    \"dayCountConvention\": \"Actual360\",\n    \"notionalCurrency\": \"CNY\",\n    \"notionalAmount\": 1E6,\n    \"payReceive\": \"Receive\"\n}\ndeposit = parseInstrument(deposit1)\n```\n\n创建利率互换。\n\n```\nirs1 =  {\n    \"productType\": \"Swap\",\n    \"swapType\": \"IrSwap\",\n    \"irSwapType\": \"IrFixedFloatingSwap\",\n    \"start\": 2025.06.16,\n    \"maturity\": 2028.06.16,\n    \"frequency\": \"Quarterly\",\n    \"fixedRate\": 0.018,\n    \"calendar\": \"CFET\", \n    \"fixedDayCountConvention\": \"Actual365\",\n    \"floatingDayCountConvention\": \"Actual365\",\n    \"payReceive\": \"Pay\",\n    \"iborIndex\": \"FR_007\",\n    \"spread\": 0.0001,\n    \"notionalCurrency\": \"CNY\",\n    \"notionalAmount\": 1E8\n}\nirs = parseInstrument(irs1)\n```\n\n创建市场数据。\n\n```\naod = 2025.08.18\nfxSpot1 = {\n    \"mktDataType\": \"Price\",\n    \"priceType\": \"FxSpotRate\",\n    \"spotDate\": aod+2 ,\n    \"referenceDate\": aod ,\n    \"value\": 7.1627,\n    \"unit\": \"USDCNY\"\n}\nfxSpotUsdCny = parseMktData(fxSpot1)\nfxSpot2 = {\n    \"mktDataType\": \"Price\",\n    \"priceType\": \"FxSpotRate\",\n    \"spotDate\": aod+2 ,\n    \"referenceDate\": aod ,\n    \"value\": 8.3768,\n    \"unit\": \"EURCNY\"\n}\nfxSpotEurCny = parseMktData(fxSpot2)\ncurve1 = {\n    \"mktDataType\": \"Curve\",\n    \"curveType\": \"IrYieldCurve\",\n    \"curveName\": \"CNY_FR_007\",\n    \"referenceDate\": aod,\n    \"currency\": \"CNY\",\n    \"dayCountConvention\": \"ActualActualISDA\",\n    \"compounding\": \"Continuous\",\n    \"interpMethod\": \"Linear\",\n    \"extrapMethod\": \"Flat\",\n    \"dates\":[2025.08.21, 2025.08.27, 2025.09.03, 2025.09.10, 2025.09.22, 2025.10.20, 2025.11.20, \n             2026.02.24,2026.05.20, 2026.08.20, 2027.02.22, 2027.08.20, 2028.08.21],\n    \"values\":[1.4759, 1.5331, 1.5697, 1.5239, 1.4996, 1.5144, 1.5209, \n              1.5539, 1.5461, 1.5316, 1.5376, 1.5435, 1.5699] / 100.0\n}\ncurveCnyFr007 = parseMktData(curve1)\ncurve2 = {\n    \"mktDataType\": \"Curve\",\n    \"curveType\": \"IrYieldCurve\",\n    \"curveName\": \"USD_USDCNY_FX\",\n    \"referenceDate\": aod ,\n    \"currency\": \"USD\",\n    \"dayCountConvention\": \"ActualActualISDA\",\n    \"compounding\": \"Continuous\",\n    \"interpMethod\": \"Linear\",\n    \"extrapMethod\": \"Flat\",\n    \"dates\":[2025.08.21, 2025.08.27, 2025.09.03, 2025.09.10, 2025.09.22, 2025.10.20, 2025.11.20, \n             2026.02.24,2026.05.20, 2026.08.20, 2027.02.22, 2027.08.20, 2028.08.21],\n    \"values\":[4.3345, 4.3801, 4.3119, 4.3065, 4.2922, 4.2196, 4.1599, \n              4.0443, 4.0244, 3.9698, 3.7740, 3.6289, 3.5003] / 100.0\n}\ncurveUsdUsdCnyFx = parseMktData(curve2)\ncurve3 = {\n    \"mktDataType\": \"Curve\",\n    \"curveType\": \"IrYieldCurve\",\n    \"curveName\": \"EUR_EURCNY_FX\",\n    \"referenceDate\": aod,\n    \"currency\": \"EUR\",\n    \"dayCountConvention\": \"ActualActualISDA\",\n    \"compounding\": \"Continuous\",\n    \"interpMethod\": \"Linear\",\n    \"extrapMethod\": \"Flat\",\n    \"dates\":[2025.08.21, 2025.08.27, 2025.09.03, 2025.09.10, 2025.09.22, 2025.10.20, 2025.11.20, \n             2026.02.24,2026.05.20, 2026.08.20, 2027.02.22, 2027.08.20, 2028.08.21],\n    \"values\":[1.9165, 1.9672, 1.8576, 1.8709, 1.8867, 1.8749,1.8700,\n              1.8576, 1.9253, 1.9738, 1.9908, 1.9850, 2.0362] / 100.0\n}\ncurveEurEurCnyFx = parseMktData(curve3)\nsurf1 = {\n\t\"surfaceName\": \"USDCNY\",\n\t\"mktDataType\": \"Surface\",\n\t\"surfaceType\": \"FxVolatilitySurface\",\n\t\"referenceDate\": \"2025.08.18\",\n\t\"smileMethod\": \"Linear\",\n\t\"termDates\": [\n\t\t\"2025.08.21\",\n\t\t\"2026.08.20\"\n\t],\n\t\"volSmiles\":[{\"strikes\": [6.5,7,7.5],\"vols\": [0.1,0.1,0.1]},{\"strikes\": [6.5,7,7.5],\"vols\": [0.1,0.1,0.1]}],\n\t\"currencyPair\": \"USDCNY\"\n}\nsurfUsdCny = parseMktData(surf1)\nsurf2 = {\n\t\"surfaceName\": \"EURCNY\",\n\t\"mktDataType\": \"Surface\",\n\t\"surfaceType\": \"FxVolatilitySurface\",\n\t\"referenceDate\": \"2025.08.18\",\n\t\"smileMethod\": \"Linear\",\n\t\"termDates\": [\n\t\t\"2025.08.21\",\n\t\t\"2026.08.20\"\n\t],\n\t\"volSmiles\":[{\"strikes\": [7.5,8.0,8.5],\"vols\": [0.1,0.1,0.1]},{\"strikes\": [7.5,8.0,8.5],\"vols\": [0.1,0.1,0.1]}],\n\t\"currencyPair\": \"EURCNY\"\n}\nsurfEurCny = parseMktData(surf2)\nbondCurve =  {\n    \"mktDataType\": \"Curve\",\n    \"curveType\": \"IrYieldCurve\",\n    \"referenceDate\": aod,\n    \"currency\": \"CNY\",\n    \"curveName\": \"CNY_TREASURY_BOND\",\n    \"dayCountConvention\": \"ActualActualISDA\",\n    \"compounding\": \"Compounded\",\n    \"interpMethod\": \"Linear\",\n    \"extrapMethod\": \"Flat\",\n    \"frequency\": \"Annual\",\n    // 0.083 0.25 0.5 1.0 2.0 3.0 5.0 7.0 10.0 15.0 20.0 30.0 40.0 50.0\n    \"dates\":[2025.09.18, 2025.11.18, 2026.02.18, 2026.08.18, 2027.08.18, 2028.08.18, 2030.08.18,\n             2032.08.18, 2035.08.18, 2040.08.18, 2045.08.18, 2055.08.18,2065.08.18, 2075.08.18],\n    \"values\":[1.3000, 1.3700, 1.3898, 1.3865, 1.4299, 1.4471, 1.6401,\n              1.7654, 1.7966, 1.9930, 2.1834, 2.1397, 2.1987, 2.2225] / 100.0\n}\ncurveCnyTreasuryBond = parseMktData(bondCurve)\nfr007HistCurve = {\n    \"mktDataType\": \"Curve\",\n    \"curveType\": \"AssetPriceCurve\",\n    \"curveName\": \"PRICE_FR_007\",\n    \"referenceDate\": aod,\n    \"currency\": \"CNY\",\n    \"dates\":[2025.05.09, 2025.05.12, 2025.05.13, 2025.05.14, 2025.05.15, 2025.05.16, 2025.05.19, 2025.05.20, 2025.05.21, 2025.05.22,\n             2025.05.23, 2025.05.26, 2025.05.27, 2025.05.28, 2025.05.29, 2025.05.30, 2025.06.03, 2025.06.04, 2025.06.05, 2025.06.06,\n             2025.06.09, 2025.06.10, 2025.06.11, 2025.06.12, 2025.06.13, 2025.06.16, 2025.06.17, 2025.06.18, 2025.06.19, 2025.06.20,\n             2025.06.23, 2025.06.24, 2025.06.25, 2025.06.26, 2025.06.27, 2025.06.30, 2025.07.01, 2025.07.02, 2025.07.03, 2025.07.04,\n             2025.07.07, 2025.07.08, 2025.07.09, 2025.07.10, 2025.07.11, 2025.07.14, 2025.07.15, 2025.07.16, 2025.07.17, 2025.07.18,\n             2025.07.21, 2025.07.22, 2025.07.23, 2025.07.24, 2025.07.25, 2025.07.28, 2025.07.29, 2025.07.30, 2025.07.31, 2025.08.01,\n             2025.08.04, 2025.08.05, 2025.08.06, 2025.08.07, 2025.08.08, 2025.08.11, 2025.08.12, 2025.08.13, 2025.08.14, 2025.08.15\n       ],\n    \"values\":[1.6000, 1.5600, 1.5300, 1.5500, 1.5500, 1.6300, 1.6500, 1.6000, 1.5900, 1.5800, \n              1.6300, 1.7000, 1.7000, 1.7000, 1.7500, 1.7500, 1.5900, 1.5800, 1.5700, 1.5600, \n              1.5500, 1.5500, 1.5600, 1.5900, 1.5900, 1.5700, 1.5500, 1.5600, 1.5679, 1.6000, \n              1.5700, 1.8500, 1.8300, 1.8400, 1.8500, 1.9500, 1.6036, 1.5800, 1.5200, 1.5000, \n              1.5000, 1.5100, 1.5100, 1.5300, 1.5200, 1.5500, 1.6000, 1.5400, 1.5400, 1.5000, \n              1.5000, 1.4800, 1.5000, 1.6000, 1.7500, 1.6400, 1.6200, 1.6300, 1.6000, 1.5000, \n              1.4800, 1.4700, 1.4800, 1.4900, 1.4600, 1.4600, 1.4600, 1.4800, 1.4800, 1.4900  \n               ]\\100\n}\npriceCurveFr007 = parseMktData(fr007HistCurve)\n```\n\n将以上多个金融工具对象（外汇远期、外汇掉期、欧式期权、债券、利率互换等）组合为一个 INSTRUMENT 类型的向量，以便通过 `instrumentPricer` 批量定价。\n\n```\ninstrument = [fxFwdUsdCny, fxFwdEurCny, fxSwapUsdCny, fxSwapEurCny, \n              fxOptionUsdCny, fxOptionEurCny, bond, bondFut, deposit, irs]\nmktData= [fxSpotUsdCny, fxSpotEurCny, curveCnyFr007, curveUsdUsdCnyFx, curveEurEurCnyFx, surfUsdCny, surfEurCny, curveCnyTreasuryBond, priceCurveFr007]\npricingDate = aod\nresults1 = instrumentPricer(instrument, pricingDate, mktData)\n```\n\n将各类市场数据组织成一个嵌套字典，外层按数据类型（Price、Curve、Surface）区分，内层按参考日再区分具体市场对象，然后传入 `instrumentPricer` 进行定价。\n\n```\nspots = dict(string, MKTDATA)\nspots[\"USDCNY\"] = fxSpotUsdCny\nspots[\"EURCNY\"] = fxSpotEurCny\ncurves = dict(string, MKTDATA)\ncurves[\"CNY_FR_007\"] = curveCnyFr007\ncurves[\"USD_USDCNY_FX\"] = curveUsdUsdCnyFx\ncurves[\"EUR_EURCNY_FX\"] = curveEurEurCnyFx\ncurves[\"CNY_TREASURY_BOND\"] = curveCnyTreasuryBond\ncurves[\"PRICE_FR_007\"] = priceCurveFr007\nsurfs = dict(string, MKTDATA)\nsurfs[\"USDCNY\"] = surfUsdCny\nsurfs[\"EURCNY\"] = surfEurCny\ndSpots = dict(DATE, ANY)\ndSpots[aod] = spots\ndCurves = dict(DATE, ANY)\ndCurves[aod] = curves\ndSurfs = dict(DATE, ANY)\ndSurfs[aod] = surfs\nmktData2 = dict(STRING, ANY)\nmktData2 = {\"Price\": dSpots,\n            \"Curve\": dCurves,\n            \"Surface\": dSurfs}\nresults2 = instrumentPricer(instrument, pricingDate, mktData2)\nprint(results2)\n// output: [-65560.1519,171923.5349,180871.3848,117636.4977,29773.4419,50067.7879,99.6008,107.7764,1005141.9397,-651143.5256]\n```\n\n使用市场数据引擎进行定价：\n\n```\ntbdata = table(1:0, `eventTime`type`subType`name`term`price, [NANOTIMESTAMP, STRING, STRING, STRING, STRING, DOUBLE])\ninsert into tbdata values(now(), \"Bond\", string(), \"0001\", \"1d\", 3.2415)\ninsert into tbdata values(now(), \"Bond\", string(), \"0002\", \"1d\", 2.1584)\nbond1 = {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Bond\",\n    \"bondType\": \"FixedRateBond\",\n    \"version\": 0, \n    \"nominal\": 100,\n    \"instrumentId\": \"0001\",\n    \"start\": 2022.05.15,\n    \"maturity\": 2032.05.15,\n    \"dayCountConvention\": \"ActualActualISDA\",\n    \"cashflow\":[],\n    \"coupon\": 0.0276,\n    \"issuePrice\": 100.0,\n    \"frequency\": \"Semiannual\"\n}\nbond2 = {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Bond\",\n    \"bondType\": \"FixedRateBond\",\n    \"version\": 0, \n    \"nominal\": 100,\n    \"instrumentId\": \"0002\",\n    \"start\": 2023.05.15,\n    \"maturity\": 2033.05.15,\n    \"dayCountConvention\": \"ActualActualISDA\",\n    \"cashflow\":[],\n    \"coupon\": 0.0276,\n    \"issuePrice\": 100.0,\n    \"frequency\": \"Semiannual\"\n}\nbondcurveConfig = {\n\t\"name\":\"CNY_TREASURY_BOND\",\n\t\"type\": \"BondYieldCurve\",\n\t\"bonds\":[parseInstrument(bond1), parseInstrument(bond2)],\n\t\"currency\": \"CNY\",\n\t\"dayCountConvention\": \"ActualActualISDA\",\n\t\"compounding\": \"Compounded\",\n\t\"frequency\": \"Semiannual\",\n\t\"interpMethod\": \"Linear\",\n\t\"extrapMethod\": \"Flat\",\n\t\"method\": \"Bootstrap\"\n}\nengine = createMktDataEngine(\"engine\", 2022.06.10, bondcurveConfig)\nengine.append!(tbdata)\nsleep(1000)\nins = parseInstrument(bond1)\nresults3 = instrumentPricer([ins], 2022.06.10, engine)\nprint(results3)\n\n// output: 55.2648\n```\n\n**相关函数**：[createMktDataEngine](https://docs.dolphindb.cn/zh/funcs/c/createMktDataEngine.html)\n"
    },
    "int": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/int.html",
        "signatures": [
            {
                "full": "int(X)",
                "name": "int",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [int](https://docs.dolphindb.cn/zh/funcs/i/int.html)\n\n\n\n#### 语法\n\nint(X)\n\n#### 详情\n\n将输入的数据转换为 INT 类型数据。\n\n#### 参数\n\n**X** 可以是任意数据类型。\n\n#### 返回值\n\n整型，数据形式同 *X*。\n\n#### 例子\n\n```\nx=int();\nx;\n```\n\n返回：null\n\n```\ntypestr x;\n```\n\n返回：INT\n\n```\nint(`10.9);\n```\n\n返回：10\n\n```\nint(2147483647);\n```\n\n返回：2,147,483,647\n\n**Note:** INT 数据类型的最大值为 231 -1 = 2,147,483,647。\n\n```\nint(2147483648);\n```\n\n由于2,147,483,648 超出了 INT 数据类型的最大值，因此返回：null\n"
    },
    "int128": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/int128.html",
        "signatures": [
            {
                "full": "int128(X)",
                "name": "int128",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [int128](https://docs.dolphindb.cn/zh/funcs/i/int128.html)\n\n\n\n#### 语法\n\nint128(X)\n\n#### 详情\n\n把字符串转换为 INT128 类型。\n\n#### 参数\n\n**X** 是一个字符串标量或向量。\n\n#### 返回值\n\nINT128 类型标量或向量。\n\n#### 例子\n\n```\na=int128(\"e1671797c52e15f763380b45e841ec32\")\n```\n\n返回：e1671797c52e15f763380b45e841ec32\n\n```\ntypestr(a);\n```\n\n返回：INT128\n"
    },
    "integral": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/integral.html",
        "signatures": [
            {
                "full": "integral(func, start, end, [start2], [end2])",
                "name": "integral",
                "parameters": [
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "start",
                        "name": "start"
                    },
                    {
                        "full": "end",
                        "name": "end"
                    },
                    {
                        "full": "[start2]",
                        "name": "start2",
                        "optional": true
                    },
                    {
                        "full": "[end2]",
                        "name": "end2",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [integral](https://docs.dolphindb.cn/zh/funcs/i/integral.html)\n\n\n\n#### 语法\n\nintegral(func, start, end, \\[start2], \\[end2])\n\n#### 详情\n\n返回 *func* 在 *start* 和 *end* 范围内的积分，或在平面区域 *start* ≤ x ≤ *end* 和 *start2* ≤ y ≤ *end2* 上 *func* 的积分。\n\n当结果中出现无穷值或者计算过程中出现有关复数的计算时会返回 NULL。\n\n#### 参数\n\n**func** 是一元或二元函数。\n\n**start** 是一个数值标量或向量，表示开始值。*start* 用 NULL 值表示负无穷。\n\n**end** 是一个数值标量或向量，表示结束值。*end* 用 NULL 值表示正无穷。\n\n**start2** 是一个数值标量，向量或一元函数，表示二重积分第二维度的开始值。*start2* 用 NULL 值表示负无穷。\n\n**end2** 是一个数值标量，向量或一元函数，表示二重积分第二维度的结束值。*end2* 用 NULL 值表示正无穷。\n\n如果 *start* 和 *end* 都是向量，或需要计算二重积分时，*start*, *end* , *start2* 和 *end2* 为向量，则它们的长度必须相同。如果部分为标量，其余为向量时，则会将标量当作与向量长度相同，所有元素值等于该标量的向量。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\nintegral(abs, -10, 10);\n// output\n100\n\nintegral(acos, [0.1, -0.10], [0.3, 0.10]);\n// output\n[0.273816,0.314159]\n\nintegral(acosh, [1, 2, 9, 9], 10);\n// output\n[19.982354,19.080489,2.941187,2.941187]\n\nintegral(pow{,3}, 5, 9);\n// output\n1484\n\nintegral(abs, NULL, NULL);\n// output\n00F\n\ndef f(x1,x2){\n   fx=100*(x2-x1*2)+square(1-x1)\n   return fx\n}\n\nintegral(f,0,1,7,1)\n// output\n-1802\n\nintegral(f,[0,1,2,3],7,2,[0,1,2,3])\n// output\n[8255.333333, 8256, 7856.666667, 7061.333333]\n```\n"
    },
    "interpolate": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/interpolate.html",
        "signatures": [
            {
                "full": "interpolate(X, [method='linear'], [limit], [inplace=false], [limitDirection='forward'], [limitArea], [index])",
                "name": "interpolate",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[method='linear']",
                        "name": "method",
                        "optional": true,
                        "default": "'linear'"
                    },
                    {
                        "full": "[limit]",
                        "name": "limit",
                        "optional": true
                    },
                    {
                        "full": "[inplace=false]",
                        "name": "inplace",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[limitDirection='forward']",
                        "name": "limitDirection",
                        "optional": true,
                        "default": "'forward'"
                    },
                    {
                        "full": "[limitArea]",
                        "name": "limitArea",
                        "optional": true
                    },
                    {
                        "full": "[index]",
                        "name": "index",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [interpolate](https://docs.dolphindb.cn/zh/funcs/i/interpolate.html)\n\n\n\n#### 语法\n\ninterpolate(X, \\[method='linear'], \\[limit], \\[inplace=false], \\[limitDirection='forward'], \\[limitArea], \\[index])\n\n#### 详情\n\n填充数值型向量中的缺失值。默认情况下，基于 X 中每个元素的下标索引（0, 1, 2, ..., size(X)-1）进行插值计算。支持自定义横坐标的插值计算，详见参数 *index*。\n\n#### 参数\n\n**X** 是一个数值型向量。\n\n**method** 可选参数，是一个字符串，表示插值的方式。它的可取值为：\n\n* 'linear'：线性插值\n\n* 'pad'：使用已有的值填充\n\n* 'nearest'：使用最接近 NULL 值的有效值填充\n\n  **Note:** 若 *method* = 'nearest' 且*limitDirection =* 'both'，当 NULL 值与两侧最近有效值的距离相同时，取**左侧**的有效值填充。\n\n* 'krogh'：使用 krogh 多项式插值\n\n如果没有指定，默认值为 'linear'。\n\n**limit** 可选参数，是一个正整数，表示最多要填充的连续 NULL 值的个数。\n\n**inplace** 可选参数， 是一个布尔值，表示是否使用结果覆盖输入的 *X*。默认值为 false，会返回一个新的向量。\n\n**limitDirection** 可选参数， 是一个字符串，表示填充 NULL 的方向。它的可取值为：'forward', 'backward' 和 'both'。默认值为 'forward'。\n\n**limitArea** 可选参数， 是一个字符串，表示填充的区域。它的可取值为：\n\n* 空字符串： 填充的区域没有限制\n\n* 'inside'： 只填充有效值包围的 NULL 值\n\n* 'outside'： 只填充有效值之外的 NULL 值\n\n**index** 可选参数，是一个时间类型或数值类型的索引向量，与 X 等长且不包含空值。当指定 *index*时，函数将以该索引向量为横坐标，X 为纵坐标，对 X 中的缺失值进行插值。\n\n#### 返回值\n\n返回填充后的数值型向量。\n\n#### 例子\n\n```\na=[NULL,NULL,1,2,NULL,NULL,5,6,NULL,NULL];\n\ninterpolate(a);\n// output: [,,1,2,3,4,5,6,6,6]\n\ninterpolate(X=a, method=\"pad\");\n// output: [,,1,2,2,2,5,6,6,6]\n\ninterpolate(X=a, limitDirection='both');\n// output: [1,1,1,2,3,4,5,6,6,6]\n\ninterpolate(X=a, limit=1, limitDirection='both');\n// output: [,1,1,2,3,4,5,6,6,]\n\ninterpolate(X=a, limitDirection='both', limitArea='outside');\n// output: [1,1,1,2,,,5,6,6,6]\n\na;\n// output: [,,1,2,,,5,6,,]\n\ninterpolate(X=a, limitDirection='backward', inplace=true);\n// output: [1,1,1,2,3,4,5,6,,]\n\na;\n// output: [1,1,1,2,3,4,5,6,,]\n\ndates=[2023.10.01, 2023.10.03, 2023.10.08, 2023.10.13, 2023.10.31, 2023.11.02, 2023.11.07, 2023.11.08,2023.11.09,2023.11.14]\n\ninterpolate(X=a,index=dates)\n// output\n[,,1,2,4.160000000000001,4.400000000000001,5,6,6,6]\n\na=[10,NULL,30,NULL,50];\nindex=[0, 3, 4, 7, 8]\ninterpolate(X=a,method='linear',index=index)\n// output\n[10,25,30,45,50]\n```\n"
    },
    "intersection": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/intersection.html",
        "signatures": [
            {
                "full": "intersection(X, Y)",
                "name": "intersection",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [intersection](https://docs.dolphindb.cn/zh/funcs/i/intersection.html)\n\n\n\n#### 语法\n\nintersection(X, Y) 或 X\\&Y\n\n#### 详情\n\n若 *X* 和 *Y* 均为集合，返回其交集。\n\n若 *X* 和 *Y* 是相同长度的整形向量或标量，返回位运算 `AND` 的结果。\n\n#### 参数\n\n**X** 和 **Y** 均为集合，或是相同长度的整型向量或标量。\n\n#### 返回值\n\n集合、整型向量或标量。\n\n#### 例子\n\n```\nx=set([5,5,3,4,6])\ny=set(8 9 4 4 6)\nx & y;\n\n// output: set(4,6)\n\n6 7 8 & 4 5 6;\n// output\n[4,5,0]\n```\n"
    },
    "invBeta": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/invBeta.html",
        "signatures": [
            {
                "full": "invBeta(alpha, beta, X)",
                "name": "invBeta",
                "parameters": [
                    {
                        "full": "alpha",
                        "name": "alpha"
                    },
                    {
                        "full": "beta",
                        "name": "beta"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [invBeta](https://docs.dolphindb.cn/zh/funcs/i/invBeta.html)\n\n\n\n#### 语法\n\ninvBeta(alpha, beta, X)\n\n#### 详情\n\n返回 Beta 分布的累计密度函数的逆函数值。\n\n#### 参数\n\n形状参数 **alpha** 和 **beta** 都是正数。\n\n**X** 是 0 到 1 之间的浮点型标量或向量。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\ninvBeta(2.31, 0.627, [0.001, 0.5, 0.999]);\n// output\n[0.068102, 0.852866, 0.999994]\n\ninvBeta(2.31, 0.627, [0.1, 0.3, 0.5, 0.7, 0.9]);\n// output\n[0.471316, 0.717156, 0.852866, 0.939378, 0.989912]]\n```\n"
    },
    "invBinomial": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/invBinomial.html",
        "signatures": [
            {
                "full": "invBinomial(trials, p, X)",
                "name": "invBinomial",
                "parameters": [
                    {
                        "full": "trials",
                        "name": "trials"
                    },
                    {
                        "full": "p",
                        "name": "p"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [invBinomial](https://docs.dolphindb.cn/zh/funcs/i/invBinomial.html)\n\n\n\n#### 语法\n\ninvBinomial(trials, p, X)\n\n#### 详情\n\n返回二项分布的累计密度函数的逆函数值。\n\n#### 参数\n\n**trials** 是正整数，形状参数。\n\n**p** 是0到1之间的浮点数，形状参数。\n\n**X** 是0到1之间的浮点型标量或向量。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\ninvBinomial(10, 0.1, [0.1, 0.5, 0.9]);\n// output: [0, 1, 2]\n\ninvBinomial(12,0.627, [0.1, 0.3, 0.5, 0.7, 0.9]);\n// output: [5, 7, 8, 8, 10]\n```\n"
    },
    "invChiSquare": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/invChiSquare.html",
        "signatures": [
            {
                "full": "invChiSquare(df, X)",
                "name": "invChiSquare",
                "parameters": [
                    {
                        "full": "df",
                        "name": "df"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [invChiSquare](https://docs.dolphindb.cn/zh/funcs/i/invChiSquare.html)\n\n\n\n#### 语法\n\ninvChiSquare(df, X)\n\n#### 详情\n\n返回卡方分布的累计密度函数的逆函数值。\n\n#### 参数\n\n**df** 是正数，表示卡方分布的自由度。\n\n**X** 是0到1之间的浮点型标量或向量。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\ninvChiSquare(1, [0, 0.05, 0.15, 0.25]);\n// output\n[0, 0.003932, 0.035766, 0.101531]\n\ninvChiSquare(1, [0.1, 0.3, 0.5, 0.7, 0.9]);\n\n// output\n[0.015791, 0.148472, 0.454936, 1.074194, 2.705543]\n```\n"
    },
    "inverse": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/inverse.html",
        "signatures": [
            {
                "full": "inverse(X)",
                "name": "inverse",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [inverse](https://docs.dolphindb.cn/zh/funcs/i/inverse.html)\n\n\n\n#### 语法\n\ninverse(X)\n\n#### 详情\n\n如果 *X* 可逆，返回矩阵 *X* 的逆矩阵。\n\n#### 参数\n\n**X** 是一个矩阵。\n\n#### 返回值\n\n如果 *X* 可逆，返回矩阵 *X* 的逆矩阵。否则报错。\n\n#### 例子\n\n```\nx=1..4$2:2;\nx;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 3  |\n| 2  | 4  |\n\n```\nx.inverse();\n```\n\n| #0 | #1   |\n| -- | ---- |\n| -2 | 1.5  |\n| 1  | -0.5 |\n"
    },
    "invExp": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/invExp.html",
        "signatures": [
            {
                "full": "invExp(mean, X)",
                "name": "invExp",
                "parameters": [
                    {
                        "full": "mean",
                        "name": "mean"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [invExp](https://docs.dolphindb.cn/zh/funcs/i/invExp.html)\n\n\n\n#### 语法\n\ninvExp(mean, X)\n\n#### 详情\n\n返回指数分布的累计密度函数的逆函数值。\n\n#### 参数\n\n**mean** 是指数分布的均值。\n\n**X** 是0到1之间的浮点型标量或向量。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\ninvExp(1, [0.05, 0.15, 0.25, 0.35]);\n// output: [0.051293, 0.162519, 0.287682, 0.430783]\n\ninvExp(1, [0.1, 0.3, 0.5, 0.7, 0.9]);\n// output: [0.105361, 0.356675, 0.693147, 1.203973, 2.302585]\n```\n"
    },
    "invF": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/invF.html",
        "signatures": [
            {
                "full": "invF(numeratorDF, denominatorDF, X)",
                "name": "invF",
                "parameters": [
                    {
                        "full": "numeratorDF",
                        "name": "numeratorDF"
                    },
                    {
                        "full": "denominatorDF",
                        "name": "denominatorDF"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [invF](https://docs.dolphindb.cn/zh/funcs/i/invF.html)\n\n\n\n#### 语法\n\ninvF(numeratorDF, denominatorDF, X)\n\n#### 详情\n\n返回F分布的累计密度函数的逆函数值。\n\n#### 参数\n\n**numeratorDF** 和 **denominatorDF** 都是正数，表示F分布的自由度。\n\n**X** 是0到1之间的浮点型标量或向量。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\ninvF(2.31, 0.627, [0.001, 0.5, 0.7]);\n// output: [0.002024, 2.69427, 14.992595]\n\ninvF(2.31,0.627, [0.1, 0.3, 0.5, 0.7, 0.9]);\n// output: [0.146649, 0.718555, 2.69427, 14.992595, 508.444221]\n```\n"
    },
    "invGamma": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/invGamma.html",
        "signatures": [
            {
                "full": "invGamma(shape, scale, X)",
                "name": "invGamma",
                "parameters": [
                    {
                        "full": "shape",
                        "name": "shape"
                    },
                    {
                        "full": "scale",
                        "name": "scale"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [invGamma](https://docs.dolphindb.cn/zh/funcs/i/invGamma.html)\n\n\n\n#### 语法\n\ninvGamma(shape, scale, X)\n\n#### 详情\n\n返回Gamma分布的累计密度函数的逆函数值。\n\n#### 参数\n\n**shape** 为形状参数，是正数。\n\n**scale** 为尺度参数，是正数。\n\n**X** 是0到1之间的浮点型标量或向量。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\ninvGamma(2.31, 0.627, [0.001, 0.5, 0.999]);\n// output: [0.049713, 1.245583, 6.191955]\n\ninvGamma(2.31,0.627, [0.1, 0.3, 0.5, 0.7, 0.9]);\n// output: [0.437696, 0.843572, 1.245583, 1.760732, 2.724121]\n```\n"
    },
    "invLogistic": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/invLogistic.html",
        "signatures": [
            {
                "full": "invLogistic(mean, s, X)",
                "name": "invLogistic",
                "parameters": [
                    {
                        "full": "mean",
                        "name": "mean"
                    },
                    {
                        "full": "s",
                        "name": "s"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [invLogistic](https://docs.dolphindb.cn/zh/funcs/i/invLogistic.html)\n\n\n\n#### 语法\n\ninvLogistic(mean, s, X)\n\n#### 详情\n\n返回 Logistic 分布的累计密度函数的逆函数值。\n\n#### 参数\n\n**mean** 是 Logistic 分布的均值。\n\n**s** 是Logistic分布的尺度参数。\n\n**X** 是0到1之间的浮点型标量或向量。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\ninvLogistic( 2.31, 0.627, [0.5, 0.3, 0.5, 0.7, 0.1]);\n// output: [2.31, 1.778744, 2.31, 2.841256, 0.93234]\n```\n"
    },
    "invNormal": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/invNormal.html",
        "signatures": [
            {
                "full": "invNormal(mean, stdev, X)",
                "name": "invNormal",
                "parameters": [
                    {
                        "full": "mean",
                        "name": "mean"
                    },
                    {
                        "full": "stdev",
                        "name": "stdev"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [invNormal](https://docs.dolphindb.cn/zh/funcs/i/invNormal.html)\n\n\n\n#### 语法\n\ninvNormal(mean, stdev, X)\n\n#### 详情\n\n返回均值为 *mean*，标准差为 *stdev* 的正态分布的累计密度函数的逆函数值。\n\n#### 参数\n\n**mean** 是正态分布的均值。\n\n**stdev** 是正态分布的标准差。\n\n**X** 是0到1之间的浮点型标量或向量。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\ninvNormal(0,1,0.33);\n// output: -0.439913\n\ninvNormal(10, 20, [0.1, 0.2, 0.3]);\n// output: [-15.631031, -6.832425, -0.48801]\n```\n"
    },
    "invPoisson": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/invPoisson.html",
        "signatures": [
            {
                "full": "invPoisson(mean, X)",
                "name": "invPoisson",
                "parameters": [
                    {
                        "full": "mean",
                        "name": "mean"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [invPoisson](https://docs.dolphindb.cn/zh/funcs/i/invPoisson.html)\n\n\n\n#### 语法\n\ninvPoisson(mean, X)\n\n#### 详情\n\n返回泊松分布的累计分布函数的逆函数值。\n\n#### 参数\n\n**mean** 是泊松分布的均值。\n\n**X** 是0到1之间的浮点型标量或向量。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\ninvPoisson(1, [0.91, 0.92, 0.93]);\n// output: [2, 3, 3]\n\ninvPoisson(3, [0.81, 0.83, 0.95, 0.97, 0.99]);\n// output: [4, 5, 6, 7, 8]\n```\n"
    },
    "invStudent": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/invStudent.html",
        "signatures": [
            {
                "full": "invStudent(df, X)",
                "name": "invStudent",
                "parameters": [
                    {
                        "full": "df",
                        "name": "df"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [invStudent](https://docs.dolphindb.cn/zh/funcs/i/invStudent.html)\n\n\n\n#### 语法\n\ninvStudent(df, X)\n\n#### 详情\n\n返回 t 分布的累计密度函数的逆函数值。\n\n#### 参数\n\n**df** 是正数，表示t分布的自由度。\n\n**X** 是0到1之间的浮点型标量或向量。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\ninvStudent(1, [0.15, 0.25, 0.35]);\n// output: [-1.962611, -1, -0.509525]\n\ninvStudent(1, [0.1, 0.3, 0.5, 0.7, 0.9]);\n// output: [-3.077684, -0.726543, 0, 0.726543, 3.077684]\n```\n"
    },
    "invUniform": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/invUniform.html",
        "signatures": [
            {
                "full": "invUniform(lower, upper, X)",
                "name": "invUniform",
                "parameters": [
                    {
                        "full": "lower",
                        "name": "lower"
                    },
                    {
                        "full": "upper",
                        "name": "upper"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [invUniform](https://docs.dolphindb.cn/zh/funcs/i/invUniform.html)\n\n\n\n#### 语法\n\ninvUniform(lower, upper, X)\n\n#### 详情\n\n返回均匀分布的累计密度函数的逆函数值。\n\n#### 参数\n\n**lower** 和 **upper** 是数值型标量，表示连续均匀分布的下限和上限。\n\n**X** 是0到1之间的浮点型标量或向量。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\ninvUniform(0.627, 2.31, [0.001, 0.5, 0.999]);\n// output: [0.628683, 1.4685, 2.308317]\n\ninvUniform(0.627, 2.31, [0.1, 0.3, 0.5, 0.7, 0.9]);\n// output: [0.7953, 1.1319, 1.4685, 1.8051, 2.1417]\n```\n"
    },
    "invWeibull": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/invWeibull.html",
        "signatures": [
            {
                "full": "invWeibull(alpha, beta, X)",
                "name": "invWeibull",
                "parameters": [
                    {
                        "full": "alpha",
                        "name": "alpha"
                    },
                    {
                        "full": "beta",
                        "name": "beta"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [invWeibull](https://docs.dolphindb.cn/zh/funcs/i/invWeibull.html)\n\n\n\n#### 语法\n\ninvWeibull(alpha, beta, X)\n\n#### 详情\n\n返回Weibull分布的累计密度函数的逆函数值。\n\n#### 参数\n\n**alpha** 和 **beta** 为形状参数，都是正数。\n\n**X** 是0到1之间的浮点型标量或向量。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\ninvWeibull(2.31, 0.627, [0.001, 0.5, 0.999]);\n// output: [0.031525, 0.535009, 1.447494]\n\ninvWeibull(2.31,0.627, [0.1, 0.3, 0.5, 0.7, 0.9]);\n// output: [0.236692, 0.401279, 0.535009, 0.679464, 0.899644]\n```\n"
    },
    "ipaddr": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/ipaddr.html",
        "signatures": [
            {
                "full": "ipaddr(X)",
                "name": "ipaddr",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [ipaddr](https://docs.dolphindb.cn/zh/funcs/i/ipaddr.html)\n\n\n\n#### 语法\n\nipaddr(X)\n\n#### 详情\n\n把字符串转换成用于表达 IPv4 或 IPv6 地址的 IPADDR 类型数据。\n\n#### 参数\n\n**X** 是一个字符串标量或向量。\n\n#### 返回值\n\nIPADDR 类型标量或向量。\n\n#### 例子\n\n```\na=ipaddr(\"192.168.1.13\");\na;\n```\n\n返回：192.168.1.13\n\n```\ntypestr(a);\n```\n\n返回：IPADDR\n"
    },
    "irCrossCurrencyCurveBuilder": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/irCrossCurrencyCurveBuilder.html",
        "signatures": [
            {
                "full": "irCrossCurrencyCurveBuilder(referenceDate, currency, instNames, instTypes, terms, quotes, currencyPair, spot, dayCountConvention, discountCurve, [compounding='Continuous'], [frequency='Annual'], [curveName])",
                "name": "irCrossCurrencyCurveBuilder",
                "parameters": [
                    {
                        "full": "referenceDate",
                        "name": "referenceDate"
                    },
                    {
                        "full": "currency",
                        "name": "currency"
                    },
                    {
                        "full": "instNames",
                        "name": "instNames"
                    },
                    {
                        "full": "instTypes",
                        "name": "instTypes"
                    },
                    {
                        "full": "terms",
                        "name": "terms"
                    },
                    {
                        "full": "quotes",
                        "name": "quotes"
                    },
                    {
                        "full": "currencyPair",
                        "name": "currencyPair"
                    },
                    {
                        "full": "spot",
                        "name": "spot"
                    },
                    {
                        "full": "dayCountConvention",
                        "name": "dayCountConvention"
                    },
                    {
                        "full": "discountCurve",
                        "name": "discountCurve"
                    },
                    {
                        "full": "[compounding='Continuous']",
                        "name": "compounding",
                        "optional": true,
                        "default": "'Continuous'"
                    },
                    {
                        "full": "[frequency='Annual']",
                        "name": "frequency",
                        "optional": true,
                        "default": "'Annual'"
                    },
                    {
                        "full": "[curveName]",
                        "name": "curveName",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [irCrossCurrencyCurveBuilder](https://docs.dolphindb.cn/zh/funcs/i/irCrossCurrencyCurveBuilder.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\nirCrossCurrencyCurveBuilder(referenceDate, currency, instNames, instTypes, terms, quotes, currencyPair, spot, dayCountConvention, discountCurve, \\[compounding='Continuous'], \\[frequency='Annual'], \\[curveName])\n\n#### 详情\n\n构建跨币种利率互换收益率曲线。\n\n#### 参数\n\n**referenceDate** DATE 类型标量，指定收益率曲线的参考日期。\n\n**currency** STRING 类型标量，表示曲线定义的货币，可选值为：\n\n* \"CNY\"：人民币\n\n* \"USD\"：美元\n\n* \"EUR\"：欧元\n\n* \"GBP\"：英镑\n\n* \"JPY\"：日元\n\n* \"HKD\"：港币\n\n**instNames** STRING 类型向量，表示金融工具名称。\n\n**instTypes** STRING 类型向量，表示金融工具类型。\n\n目前*instTypes* 仅支持 \"FxSwap\"，此时 *instNames* 必须为货币对，例如 \"USDCNY\"。\n\n**terms** STRING 或 DURATION 类型向量，表示合约剩余期限，例如 \"1M\"。\n\n**quotes** 数值类型向量，表示构建曲线所需的市场报价。\n\n**currencyPair**STRING 类型标量，表示货币对，形式为 \"EURUSD\"，\"EUR.USD\" 或 \"EUR/USD\"。支持的货币对包括：\n\n* EURUSD：欧元兑美元\n\n* USDCNY：美元兑人民币\n\n* EURCNY：欧元兑人民币\n\n* GBPCNY：英镑兑人民币\n\n* JPYCNY：日元兑人民币\n\n* HKDCNY：港币兑人民币\n\n**spot** DOUBLE 类型标量，表示参考日期的即期汇率。\n\n**dayCountConvention** STRING 类型，表示计息日数规则，可选值为：\n\n* \"Actual360\": 实际/360\n\n* \"Actual365\": 实际/365\n\n* \"ActualActualISMA\": 实际/实际，遵循 ISMA（International Securities Market Association，国际证券市场协会）规则\n\n* \"ActualActualISDA\"：实际/实际，遵循 ISDA（International Swaps and Derivatives Association，国际掉期及衍生工具协会）规则。\n\n* \"Thirty360EU\": 欧洲 30/360\n\n* \"Thirty360US\": 美国 (NASD) 30/360\n\n**discountCurve** MKTDATA 类型对象（IrYieldCurve），表示货币对中另一方的贴现曲线，必须由 bootstrap 方法构建。曲线所需包含的关键字段见[曲线字段要求](https://docs.dolphindb.cn/zh/funcs/i/irCrossCurrencyCurveBuilder.html#topic_fjf_yk2_ngc)。\n\n**compounding** 可选参数，STRING 类型标量，表示利率复利方式。可选值为：\n\n* \"Compounded\"：离散复利。\n\n* \"Simple\"：简单复利。\n\n* \"Continuous\"：默认值，连续复利。\n\n**frequency** 可选参数，STRING 类型标量，表示计算计息频率。可选值为：\n\n* \"NoFrequency\"：无计息频率\n\n* \"Annual\"：每年付息一次\n\n* \"Semiannual\"：每半年付息一次\n\n* \"EveryFourthMonth\"：每四个月付息一次\n\n* \"Quarterly\"：每季度付息一次\n\n* \"BiMonthly\"：每两月付息一次\n\n* \"Monthly\"：每月付息一次\n\n* \"EveryFourthWeek\"：每四周付息一次\n\n* \"BiWeekly\"：每两周付息一次\n\n* \"Weekly\"：每周付息一次\n\n* \"Daily\"：每日付息一次\n\n* \"Other\"：其他计息频率\n\n**curveName** 可选参数，STRING 类型标量，表示生成的曲线名称，默认为空。\n\n#### 返回值\n\nMKTDATA 类型对象。\n\n#### 例子\n\n```\n// 以2025年8月18日的USDCNY美元隐含收益率曲线构建为例\nrefDate = 2025.08.18\nspotDate1 = temporalAdd(refDate, 2, \"XNYS\")   //美元的即期日   \nspotDate2 = temporalAdd(refDate, 2, \"CFET\")   //人民币的即期日  \nspotDate = max(spotDate1, spotDate2)\ninstNames = take(\"USDCNY\", 13)\ninstTypes = take(\"FxSwap\", 13)\nterms = [\"1d\", \"1w\", \"2w\", \"3w\", \"1M\", \"2M\", \"3M\", \"6M\", \"9M\", \"1y\", \"18M\", \"2y\", \"3y\"]\ncurveDates = array(DATE)\nfor(term in terms){\n    dur = duration(term)\n    days1 = transFreq(temporalAdd(spotDate, dur), \"XNYS\", \"right\", \"right\")\n    days2 = transFreq(temporalAdd(spotDate, dur), \"CFET\", \"right\", \"right\")\n    curveDates.append!(max(transFreq(temporalAdd(spotDate, dur), \"XNYS\", \"right\", \"right\"), transFreq(temporalAdd(spotDate, dur), \"CFET\", \"right\", \"right\")))\n }\nquotes = [-5.54, \n          -39.00, \n          -75.40, \n          -113.20, \n          -177.00, \n          -317.00, \n          -466.00, \n          -898.50, \n          -1284.99, \n          -1676.00, \n          -2320.00, \n          -2870.00, \n          -3962.50] \\ 10000  // fx swap points\n\ncnyShibor3m = {\n    \"mktDataType\": \"Curve\",\n    \"curveType\": \"IrYieldCurve\",\n    \"referenceDate\": refDate,\n    \"currency\": \"CNY\",\n    \"dayCountConvention\": \"Actual365\",\n    \"compounding\": \"Continuous\",\n    \"interpMethod\": \"Linear\",\n    \"extrapMethod\": \"Flat\",\n    \"dates\": curveDates,\n    \"values\": [1.5113,\n               1.5402,\n               1.5660,\n               1.5574,\n               1.5556,\n               1.5655,\n               1.5703,\n               1.5934,\n               1.6040,\n               1.6020,\n               1.5928,\n               1.5842,\n               1.6068] \\ 100,\n    \"settlement\": spotDate\n}\n\ncnyShibor3m = parseMktData(cnyShibor3m)\n\nspot = 7.1627\ncurve = irCrossCurrencyCurveBuilder(refDate, \"USD\", instNames, instTypes, terms, quotes, \"USDCNY\", spot, \"Actual365\", cnyShibor3m, \"Continuous\")\ncurveDict = extractMktData(curve)\nfor(i in 0..(size(quotes)-1) ){\n    print(curveDict[\"values\"][i]*100)\n}\n```\n\n**相关函数：**[bondYieldCurveBuilder](https://docs.dolphindb.cn/zh/funcs/b/bondYieldCurveBuilder.html), [irSingleCurrencyCurveBuilder](https://docs.dolphindb.cn/zh/funcs/i/irSingleCurrencyCurveBuilder.html)，[parseMktData](https://docs.dolphindb.cn/zh/funcs/p/parseMktData.html)\n\n#### 曲线字段要求\n\n<table id=\"table_pqm_pbr_ngc\"><thead><tr><th>\n\n字段名\n\n</th><th>\n\n类型\n\n</th><th>\n\n描述\n\n</th><th>\n\n是否必填\n\n</th></tr></thead><tbody><tr><td>\n\nmktDataType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"Curve\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nreferenceDate\n\n</td><td>\n\nDATE\n\n</td><td>\n\n参考日期\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ncurveType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"IrYieldCurve\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ndayCountConvention\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n曲线的日期计数惯例，可选值为：\n\n* \"Actual360\"：实际天数除以360\n\n* \"Actual365\"：实际天数除以365（不区分闰年）\n\n* \"ActualActualISMA\"：实际天数/实际天数（ISMA规则）\n\n* \"ActualActualISDA\"：实际天数/实际天数（ISDA规则）\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ninterpMethod\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n内插方法，可选值为：\n\n* \"Linear\"：线性插值\n\n* \"CubicSpline\"：三次样条插值\n\n* \"CubicHermiteSpline\"：三次埃尔米特样条插值\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nextrapMethod\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n外插方法，可选值为：\n\n* \"Flat\"：平插\n\n* \"Linear\"：线性插值\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ndates\n\n</td><td>\n\nDATE 向量\n\n</td><td>\n\n数据点的日期\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nvalues\n\n</td><td>\n\nDOUBLE 向量\n\n</td><td>\n\n数据点的值，与 *dates* 中的元素一一对应\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ncurveName\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n曲线名称\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ncurrency\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n货币，可选值为\"CNY\", \"USD\", \"EUR\", \"GBP\", \"JPY\", \"HKD\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ncompounding\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n复利类型，可选值为：\n\n* \"Simple\"：单利\n\n* \"Compounded\"：离散复利\n\n* \"Continuous\"：连续复利\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nsettlement\n\n</td><td>\n\nDATE\n\n</td><td>\n\n结算日，如果指定了结算日，则后续期限间隔的计算都将从 *settlement* 开始，而不是 *referenceDate*\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\nfrequency\n\n</td><td>\n\nINTEGRAL或 STRING\n\n</td><td>\n\n计息频率，可选值为：\n\n* -1 或 \"NoFrequency\"：无效计息频率\n\n* 0 或 \"Once\"：到期一次还本付息\n\n* 1 或 \"Annual\"：每年付息一次\n\n* 2 或 \"Semiannual\"：每半年付息一次\n\n* 3 或 \"EveryFourthMonth\"：每四个月付息一次\n\n* 4 或 \"Quarterly\"：每季度付息一次\n\n* 6 或 \"BiMonthly\"：每两月付息一次\n\n* 12 或 \"Monthly\"：每月付息一次\n\n* 13 或 \"EveryFourthWeek\"：每四周付息一次\n\n* 26 或 \"BiWeekly\"：每两周付息一次\n\n* 52 或 \"Weekly\"：每周付息一次\n\n* 365 或 \"Daily\"：每日付息一次\n\n* 999 或 \"Other\"：其他计息频率\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ncurveModel\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n曲线构建模型，目前仅支持 \"Bootstrap\"。\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ncurveParams\n\n</td><td>\n\nDICT\n\n</td><td>\n\n模型的参数。\n\n</td><td>\n\n否\n\n</td></tr></tbody>\n</table>\n"
    },
    "irDepositPricer": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/irDepositPricer.html",
        "signatures": [
            {
                "full": "irDepositPricer(instrument, pricingDate, discountCurve)",
                "name": "irDepositPricer",
                "parameters": [
                    {
                        "full": "instrument",
                        "name": "instrument"
                    },
                    {
                        "full": "pricingDate",
                        "name": "pricingDate"
                    },
                    {
                        "full": "discountCurve",
                        "name": "discountCurve"
                    }
                ]
            }
        ],
        "markdown": "### [irDepositPricer](https://docs.dolphindb.cn/zh/funcs/i/irDepositPricer.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\nirDepositPricer(instrument, pricingDate, discountCurve)\n\n#### 详情\n\n计算存款（Certificate of Deposit, CD）的定价。\n\n#### 参数\n\n注意：所有输入向量必须等长，输入标量将自动扩展以匹配其它向量的长度。\n\n**instrument** INSTRUMENT 类型标量或向量，一个 Deposit 对象，表示需要定价的存款。\n\n**pricingDate** DATE 类型标量或向量，表示定价日期。\n\n**discountCurve** MKTDATA 类型标量或向量，一个 IrYieldCurve 对象，表示用于计算折现因子的即期曲线。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\ndeposit =  {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Deposit\",\n    \"start\": 2025.05.15,\n    \"maturity\": 2025.08.15,\n    \"rate\": 0.02,\n    \"dayCountConvention\": \"Actual360\",\n    \"notionalCurrency\": \"CNY\",\n    \"notionalAmount\": 1E6,\n    \"payReceive\": \"Receive\"\n}\nrate = deposit[\"rate\"]\ninstrument = parseInstrument(deposit)\nprint(instrument)\npricingDate = 2025.06.10\ncurve_dict = {\n    \"mktDataType\": \"Curve\",\n    \"curveType\": \"IrYieldCurve\",\n    \"referenceDate\": pricingDate,\n    \"currency\": \"CNY\",\n    \"dayCountConvention\": \"Actual365\",\n    \"compounding\": \"Continuous\",  //连续复利\n    \"interpMethod\": \"Linear\",\n    \"extrapMethod\": \"Flat\",\n    \"frequency\": \"Annual\",\n    \"dates\":[2025.07.25, 2030.09.25],\n    \"values\":[0.015, 0.015]\n}\ndiscountCurve = parseMktData(curve_dict)\nirDepositPricer(instrument,2025.06.10,discountCurve)   // output:1002388.613154108868911\nirDepositPricer([instrument, instrument],pricingDate,discountCurve)\nirDepositPricer(instrument,[pricingDate, pricingDate, pricingDate],discountCurve)\nirDepositPricer(instrument,pricingDate,[discountCurve, discountCurve, discountCurve])\n```\n\n**相关函数：**[parseInstrument](https://docs.dolphindb.cn/zh/funcs/p/parseInstrument.html)，[parseMktData](https://docs.dolphindb.cn/zh/funcs/p/parseMktData.html)\n"
    },
    "irFixedFloatingSwapPricer": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/irFixedFloatingSwapPricer.html",
        "signatures": [
            {
                "full": "irFixedFloatingSwapPricer(instrument, pricingDate, discountCurve, forwardCurve, assetPriceCurve, [setting])",
                "name": "irFixedFloatingSwapPricer",
                "parameters": [
                    {
                        "full": "instrument",
                        "name": "instrument"
                    },
                    {
                        "full": "pricingDate",
                        "name": "pricingDate"
                    },
                    {
                        "full": "discountCurve",
                        "name": "discountCurve"
                    },
                    {
                        "full": "forwardCurve",
                        "name": "forwardCurve"
                    },
                    {
                        "full": "assetPriceCurve",
                        "name": "assetPriceCurve"
                    },
                    {
                        "full": "[setting]",
                        "name": "setting",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [irFixedFloatingSwapPricer](https://docs.dolphindb.cn/zh/funcs/i/irFixedFloatingSwapPricer.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\nirFixedFloatingSwapPricer(instrument, pricingDate, discountCurve, forwardCurve, assetPriceCurve, \\[setting])\n\n#### 详情\n\n计算固定利率互换（IR Fixied-Floating Swap, IRS）的定价。\n\n#### 参数\n\n注意：所有输入向量必须等长，输入标量将自动扩展以匹配其它向量的长度。\n\n**instrument** INSTRUMENT 类型标量或向量，一个 IrFixedFloatingSwap 对象，表示需要定价的固定利率互换。\n\n**pricingDate** DATE 类型标量或向量，表示定价日期。\n\n**discountCurve** MKTDATA 类型标量或向量，一个 IrYieldCurve 对象，表示用于计算折现因子的即期曲线。\n\n**forwardCurve** MKTDATA 类型标量或向量，一个 IrYieldCurve 对象，表示用于计算远期利率的即期曲线。\n\n**assetPriceCurve** MKTDATA 类型标量或向量，一个 AssetPriceCurve 对象，用于传入利率互换浮动端参考利率的历史数据。\n\n**setting** 可选参数，一个键为 STRING 类型，值为 ANY 类型的字典，用于指定计算设置，支持的键值对包括：\n\n| key          | value | 说明      |\n| ------------ | ----- | ------- |\n| calcCashFlow | BOOL  | 是否计算现金流 |\n\n#### 返回值\n\n* 当 *setting* 设置 calcCashFlow 时返回一个字典或元组。\n\n* 否则，返回一个 DOUBLE 标量或向量。\n\n#### 例子\n\n例1. 以 FR\\_007 为参考利率的利率互换定价。\n\n```\nirs =  {\n    \"productType\": \"Swap\",\n    \"swapType\": \"IrSwap\",\n    \"irSwapType\": \"IrFixedFloatingSwap\",\n    \"start\": 2025.06.16,\n    \"maturity\": 2028.06.16,\n    \"frequency\": \"Quarterly\",\n    \"fixedRate\": 0.018,\n    \"calendar\": \"CFET\", \n    \"fixedDayCountConvention\": \"Actual365\",\n    \"floatingDayCountConvention\": \"Actual365\",\n    \"payReceive\": \"Pay\",\n    \"iborIndex\": \"FR_007\",\n    \"spread\": 0.0001,\n    \"notionalCurrency\": \"CNY\",\n    \"notionalAmount\": 1E8\n}\npricingDate = 2025.08.18\ncurve = {\n    \"mktDataType\": \"Curve\",\n    \"curveType\": \"IrYieldCurve\",\n    \"referenceDate\": pricingDate,\n    \"currency\": \"CNY\",\n    \"curveName\": \"CNY_FR_007\",\n    \"dayCountConvention\": \"Actual365\",\n    \"compounding\": \"Continuous\",     \n    \"interpMethod\": \"Linear\",\n    \"extrapMethod\": \"Flat\",\n    \"frequency\": \"Annual\",\n    \"dates\":[2025.08.21, 2025.08.27, 2025.09.03, 2025.09.10, 2025.09.22, 2025.10.20, 2025.11.20, \n             2026.02.24, 2026.05.20, 2026.08.20, 2027.02.22, 2027.08.20,2028.08.21],\n    \"values\":[1.4759, 1.5331, 1.5697, 1.5239, 1.4996, 1.5144, 1.5209,\n              1.5539, 1.5461, 1.5316, 1.5376, 1.5435,1.5699] / 100\n}\n// 为了计算定价日后面的第一笔现金流用到的浮动利率，需要传入参考利率的历史数据\n// 因为 FR_007 利率互换的付息频率为季度，建议传入的 FR_007 的历史定盘数据不少于 70 个交易日\nfr007HistCurve = {\n    \"mktDataType\": \"Curve\",\n    \"curveType\": \"AssetPriceCurve\",\n    \"referenceDate\": pricingDate,\n    \"currency\": \"CNY\",\n    \"dates\":[2025.05.09, 2025.05.12, 2025.05.13, 2025.05.14, 2025.05.15, 2025.05.16, 2025.05.19, 2025.05.20, 2025.05.21, 2025.05.22,\n             2025.05.23, 2025.05.26, 2025.05.27, 2025.05.28, 2025.05.29, 2025.05.30, 2025.06.03, 2025.06.04, 2025.06.05, 2025.06.06,\n             2025.06.09, 2025.06.10, 2025.06.11, 2025.06.12, 2025.06.13, 2025.06.16, 2025.06.17, 2025.06.18, 2025.06.19, 2025.06.20,\n             2025.06.23, 2025.06.24, 2025.06.25, 2025.06.26, 2025.06.27, 2025.06.30, 2025.07.01, 2025.07.02, 2025.07.03, 2025.07.04,\n             2025.07.07, 2025.07.08, 2025.07.09, 2025.07.10, 2025.07.11, 2025.07.14, 2025.07.15, 2025.07.16, 2025.07.17, 2025.07.18,\n             2025.07.21, 2025.07.22, 2025.07.23, 2025.07.24, 2025.07.25, 2025.07.28, 2025.07.29, 2025.07.30, 2025.07.31, 2025.08.01,\n             2025.08.04, 2025.08.05, 2025.08.06, 2025.08.07, 2025.08.08, 2025.08.11, 2025.08.12, 2025.08.13, 2025.08.14, 2025.08.15\n       ],\n    \"values\":[1.6000, 1.5600, 1.5300, 1.5500, 1.5500, 1.6300, 1.6500, 1.6000, 1.5900, 1.5800, \n              1.6300, 1.7000, 1.7000, 1.7000, 1.7500, 1.7500, 1.5900, 1.5800, 1.5700, 1.5600, \n              1.5500, 1.5500, 1.5600, 1.5900, 1.5900, 1.5700, 1.5500, 1.5600, 1.5679, 1.6000, \n              1.5700, 1.8500, 1.8300, 1.8400, 1.8500, 1.9500, 1.6036, 1.5800, 1.5200, 1.5000, \n              1.5000, 1.5100, 1.5100, 1.5300, 1.5200, 1.5500, 1.6000, 1.5400, 1.5400, 1.5000, \n              1.5000, 1.4800, 1.5000, 1.6000, 1.7500, 1.6400, 1.6200, 1.6300, 1.6000, 1.5000, \n              1.4800, 1.4700, 1.4800, 1.4900, 1.4600, 1.4600, 1.4600, 1.4800, 1.4800, 1.4900  \n               ]\\100\n}\ninstrument = parseInstrument(irs)\ncurve = parseMktData(curve)\ndiscountCurve = curve\nforwardCurve = curve\nassetPriceCurve = parseMktData(fr007HistCurve)\n// 仅计算 npv\nnpv = irFixedFloatingSwapPricer(instrument, pricingDate, discountCurve, forwardCurve, assetPriceCurve)\nprint(npv)\n// 计算包括 npv、现金流\nsetting = {\n    \"calcCashFlow\": true\n}\nirFixedFloatingSwapPricer(instrument, pricingDate, discountCurve, forwardCurve, assetPriceCurve, setting)\n// 同时计算多个利率互换的定价\nirFixedFloatingSwapPricer([instrument, instrument], pricingDate, discountCurve, forwardCurve, assetPriceCurve, setting)\nirFixedFloatingSwapPricer(instrument, [pricingDate, pricingDate], discountCurve, forwardCurve, assetPriceCurve, setting)\nirFixedFloatingSwapPricer(instrument, pricingDate, [discountCurve, discountCurve], forwardCurve, assetPriceCurve, setting)\nirFixedFloatingSwapPricer(instrument, pricingDate, discountCurve, [forwardCurve, forwardCurve], assetPriceCurve, setting)\nirFixedFloatingSwapPricer(instrument, pricingDate, discountCurve, forwardCurve, [assetPriceCurve, assetPriceCurve], setting)\n```\n\n例2. 以 SHIBOR\\_3M 为参考利率的利率互换定价。\n\n```\nirs =  {\n    \"productType\": \"Swap\",\n    \"swapType\": \"IrSwap\",\n    \"irSwapType\": \"IrFixedFloatingSwap\",\n    \"start\": 2025.06.16,\n    \"maturity\": 2028.06.16,\n    \"frequency\": \"Quarterly\",\n    \"fixedRate\": 0.018,\n    \"calendar\": \"CFET\", \n    \"fixedDayCountConvention\": \"Actual365\",\n    \"floatingDayCountConvention\": \"Actual360\",\n    \"payReceive\": \"Receive\",\n    \"iborIndex\": \"SHIBOR_3M\",\n    \"spread\": 0.0001,\n    \"notionalCurrency\": \"CNY\",\n    \"notionalAmount\": 1E8\n}\npricingDate = 2025.08.18\n\ncurve1 = {\n    \"mktDataType\": \"Curve\",\n    \"curveType\": \"IrYieldCurve\",\n    \"referenceDate\": pricingDate,\n    \"currency\": \"CNY\",\n    \"curveName\": \"CNY_FR_007\",\n    \"dayCountConvention\": \"Actual365\",\n    \"compounding\": \"Continuous\",     \n    \"interpMethod\": \"Linear\",\n    \"extrapMethod\": \"Flat\",\n    \"frequency\": \"Annual\",\n    \"dates\":[2025.08.21, 2025.08.27, 2025.09.03, 2025.09.10, 2025.09.22, 2025.10.20, 2025.11.20, \n             2026.02.24, 2026.05.20, 2026.08.20, 2027.02.22, 2027.08.20,2028.08.21],\n    \"values\":[1.4759, 1.5331, 1.5697, 1.5239, 1.4996, 1.5144, 1.5209,\n              1.5539, 1.5461, 1.5316, 1.5376, 1.5435,1.5699] / 100\n}\n\ncurve2 = {\n    \"mktDataType\": \"Curve\",\n    \"curveType\": \"IrYieldCurve\",\n    \"referenceDate\": pricingDate,\n    \"currency\": \"CNY\",\n    \"curveName\": \"CNY_SHIBOR_3M\",\n    \"dayCountConvention\": \"Actual365\",\n    \"compounding\": \"Continuous\",     \n    \"interpMethod\": \"Linear\",\n    \"extrapMethod\": \"Flat\",\n    \"frequency\": \"Annual\",\n    \"dates\":[2025.08.21, 2025.08.27, 2025.09.03, 2025.09.10, 2025.09.22, 2025.10.20, 2025.11.20, \n             2026.02.24, 2026.05.20, 2026.08.20, 2027.02.22, 2027.08.20,2028.08.21],\n    \"values\":[1.5113, 1.5402, 1.5660, 1.5574, 1.5556, 1.5655, 1.5703, \n              1.5934, 1.6040, 1.6020, 1.5928, 1.5842, 1.6068] / 100\n}\n// 为了计算定价日后面的第一笔现金流用到的浮动利率，需要传入参考利率的历史数据\n// 因为 SHIBOR_3M 利率互换的付息频率为季度，建议传入的 SHIBOR_3M 的历史定盘数据不少于 70 个交易日\nshibor3mHistCurve = {\n    \"mktDataType\": \"Curve\",\n    \"curveType\": \"AssetPriceCurve\",\n    \"referenceDate\": pricingDate,\n    \"currency\": \"CNY\",\n    \"dates\":[2025.05.09, 2025.05.12, 2025.05.13, 2025.05.14, 2025.05.15, 2025.05.16, 2025.05.19, 2025.05.20, 2025.05.21, 2025.05.22,\n             2025.05.23, 2025.05.26, 2025.05.27, 2025.05.28, 2025.05.29, 2025.05.30, 2025.06.03, 2025.06.04, 2025.06.05, 2025.06.06,\n             2025.06.09, 2025.06.10, 2025.06.11, 2025.06.12, 2025.06.13, 2025.06.16, 2025.06.17, 2025.06.18, 2025.06.19, 2025.06.20,\n             2025.06.23, 2025.06.24, 2025.06.25, 2025.06.26, 2025.06.27, 2025.06.30, 2025.07.01, 2025.07.02, 2025.07.03, 2025.07.04,\n             2025.07.07, 2025.07.08, 2025.07.09, 2025.07.10, 2025.07.11, 2025.07.14, 2025.07.15, 2025.07.16, 2025.07.17, 2025.07.18,\n             2025.07.21, 2025.07.22, 2025.07.23, 2025.07.24, 2025.07.25, 2025.07.28, 2025.07.29, 2025.07.30, 2025.07.31, 2025.08.01,\n             2025.08.04, 2025.08.05, 2025.08.06, 2025.08.07, 2025.08.08, 2025.08.11, 2025.08.12, 2025.08.13, 2025.08.14, 2025.08.15\n       ],\n    \"values\":[1.6960, 1.6720, 1.6620, 1.6530, 1.6450, 1.6470, 1.6450, 1.6420, 1.6400, 1.6400, \n              1.6420, 1.6430, 1.6440, 1.6470, 1.6520, 1.6520, 1.6520, 1.6520, 1.6520, 1.6510, \n              1.6490, 1.6450, 1.6420, 1.6390, 1.6380, 1.6360, 1.6340, 1.6300, 1.6300, 1.6290, \n              1.6290, 1.6290, 1.6300, 1.6300, 1.6300, 1.6300, 1.6280, 1.6195, 1.6060, 1.5970, \n              1.5790, 1.5700, 1.5620, 1.5590, 1.5570, 1.5610, 1.5590, 1.5590, 1.5570, 1.5550, \n              1.5530, 1.5490, 1.5510, 1.5530, 1.5590, 1.5600, 1.5600, 1.5640, 1.5660, 1.5630, \n              1.5590, 1.5580, 1.5590, 1.5600, 1.5544, 1.5490, 1.5480, 1.5480, 1.5490, 1.5470  \n               ]\\100\n}\n\ninstrument = parseInstrument(irs) \ndiscountCurve = parseMktData(curve1) //CNY_FR_007\nforwardCurve = parseMktData(curve2)  //CNY_SHIBOR_3M\nassetPriceCurve = parseMktData(shibor3mHistCurve)\n\n// 仅计算 npv\nnpv = irFixedFloatingSwapPricer(instrument, pricingDate, discountCurve, forwardCurve, assetPriceCurve)\nprint(npv)\n\n// 计算包括 npv、现金流\nsetting = {\n    \"calcCashFlow\": true\n}\nresults = irFixedFloatingSwapPricer(instrument, pricingDate, discountCurve, forwardCurve, assetPriceCurve, setting)\nprint(results)\n```\n\n**相关函数：**[parseInstrument](https://docs.dolphindb.cn/zh/funcs/p/parseInstrument.html)，[parseMktData](https://docs.dolphindb.cn/zh/funcs/p/parseMktData.html)\n"
    },
    "irSingleCurrencyCurveBuilder": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/irSingleCurrencyCurveBuilder.html",
        "signatures": [
            {
                "full": "irSingleCurrencyCurveBuilder(referenceDate, currency, instNames, instTypes, terms, quotes, dayCountConvention, [discountCurve], [compounding='Continuous'], [frequency='Annual'], [curveName])",
                "name": "irSingleCurrencyCurveBuilder",
                "parameters": [
                    {
                        "full": "referenceDate",
                        "name": "referenceDate"
                    },
                    {
                        "full": "currency",
                        "name": "currency"
                    },
                    {
                        "full": "instNames",
                        "name": "instNames"
                    },
                    {
                        "full": "instTypes",
                        "name": "instTypes"
                    },
                    {
                        "full": "terms",
                        "name": "terms"
                    },
                    {
                        "full": "quotes",
                        "name": "quotes"
                    },
                    {
                        "full": "dayCountConvention",
                        "name": "dayCountConvention"
                    },
                    {
                        "full": "[discountCurve]",
                        "name": "discountCurve",
                        "optional": true
                    },
                    {
                        "full": "[compounding='Continuous']",
                        "name": "compounding",
                        "optional": true,
                        "default": "'Continuous'"
                    },
                    {
                        "full": "[frequency='Annual']",
                        "name": "frequency",
                        "optional": true,
                        "default": "'Annual'"
                    },
                    {
                        "full": "[curveName]",
                        "name": "curveName",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [irSingleCurrencyCurveBuilder](https://docs.dolphindb.cn/zh/funcs/i/irSingleCurrencyCurveBuilder.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\nirSingleCurrencyCurveBuilder(referenceDate, currency, instNames, instTypes, terms, quotes, dayCountConvention, \\[discountCurve], \\[compounding='Continuous'], \\[frequency='Annual'], \\[curveName])\n\n#### 详情\n\n构建单货币利率互换收益率曲线。目前仅支持 CNY\\_FR\\_007 和 CNY\\_SHIBOR\\_3M 两条曲线构建。\n\n#### 参数\n\n**referenceDate** DATE 类型标量，收益率曲线的参考日期。\n\n**currency** STRING 类型标量，表示曲线定义的货币，目前仅支持 \"CNY\"。\n\n**instNames** STRING 类型向量，表示金融工具名称。\n\n**instTypes** STRING 类型向量，表示金融工具类型。暂时仅支持 \"Deposit\" 和 \"IrVanillaSwap\"。\n\n**terms** DURATION 类型向量，表示合约剩余期限，例如 \"1M\"。\n\n**quotes** 数值向量，表示构建曲线所需的市场报价。\n\n**dayCountConvention** STRING 类型标量，表示计息日数规则，可选值为：\n\n* \"Actual360\": 实际/360\n\n* \"Actual365\": 实际/365\n\n* \"ActualActualISMA\": 实际/实际，遵循 ISMA（International Securities Market Association，国际证券市场协会）规则\n\n* \"ActualActualISDA\"：实际/实际，遵循 ISDA（International Swaps and Derivatives Association，国际掉期及衍生工具协会）规则。\n\n**discountCurve** 可选参数，MKTDATA 类型对象（IrYieldCurve），表示贴现曲线。当构建目标曲线的市场工具在自身定价时需要外部贴现曲线，则通过该参数指定。若不传入，则默认不使用外部贴现曲线。曲线所需包含的关键字段见[曲线字段要求](https://docs.dolphindb.cn/zh/funcs/i/irSingleCurrencyCurveBuilder.html#topic_hw5_mg2_ngc)。\n\n**compounding** 可选参数，STRING 类型标量，表示利率复利方式。可选值为：\n\n* \"Compounded\"：离散复利。\n\n* \"Simple\"：单利。\n\n* \"Continuous\"：默认值，连续复利。\n\n**frequency** 可选参数，STRING 类型标量，表示计算贴现因子的频率。可选值为：\n\n* \"NoFrequency\"：无计息频率\n\n* \"Annual\"：默认值，每年付息一次\n\n* \"Semiannual\"：每半年付息一次\n\n* \"EveryFourthMonth\"：每四个月付息一次\n\n* \"Quarterly\"：每季度付息一次\n\n* \"BiMonthly\"：每两月付息一次\n\n* \"Monthly\"：每月付息一次\n\n* \"EveryFourthWeek\"：每四周付息一次\n\n* \"BiWeekly\"：每两周付息一次\n\n* \"Weekly\"：每周付息一次\n\n* \"Daily\"：每日付息一次\n\n* \"Other\"：其他计息频率\n\n**curveName** 可选参数，STRING 类型标量，表示生成的曲线名称，默认为空。\n\n#### 返回值\n\nMKTDATA 类型对象。\n\n#### 例子\n\n例1. 构建一条以人民币计价、参考 FR007 浮动利率的利率互换曲线。\n\n```\nreferenceDate = 2021.05.26\ncurrency = \"CNY\"\nterms = [7d, 1M, 3M, 6M, 9M, 1y, 2y, 3y, 4y, 5y, 7y, 10y]\ninstNames = take(\"CNY_FR_007\", size(terms))\ninstNames[0] = \"FR_007\"\ninstTypes = take(\"IrVanillaSwap\", size(terms))\ninstTypes[0] = \"Deposit\"\nquotes = [2.3500, 2.3396, 2.3125, 2.3613, 2.4075, 2.4513, 2.5750, 2.6763, 2.7650, 2.8463, 2.9841, 3.1350]\\100\ndayCountConvention = \"Actual365\"\ncurve = irSingleCurrencyCurveBuilder(referenceDate, currency, instNames, instTypes, terms, quotes, dayCountConvention, curveName=\"CNY_FR_007\")\ncurveDict = extractMktData(curve)\nprint(curveDict)\n```\n\n例2. 根据短期存款和利率互换市场报价，构建人民币利率互换收益率曲线。\n\n```\nreferenceDate = 2021.05.26\ncurrency = \"CNY\"\nterms = [1w, 2w, 1M, 3M, 6M, 9M, 1y, 2y, 3y, 4y, 5y, 7y, 10y]\ninstNames = take(\"CNY_SHIBOR_3M\", size(terms))\ninstNames[0] = \"SHIBOR_1W\"\ninstNames[1] = \"SHIBOR_2W\"\ninstNames[2] = \"SHIBOR_1M\"\ninstNames[3] = \"SHIBOR_3M\"\ninstTypes = take(\"IrVanillaSwap\", size(terms))\ninstTypes[0] = \"Deposit\"\ninstTypes[1] = \"Deposit\"\ninstTypes[2] = \"Deposit\"\ninstTypes[3] = \"Deposit\"\nquotes = [2.269,\n          2.311,\n          2.405,\n          2.479,\n          2.6013,\n          2.7038,\n          2.7725,\n          2.9625,\n          3.11,\n          3.24,\n          3.3513,\n          3.5313,\n          3.7125]/100\ndayCountConvention = \"Actual365\"\ncurve = irSingleCurrencyCurveBuilder(referenceDate, currency, instNames, instTypes, terms, quotes, dayCountConvention)\ncurveDict = extractMktData(curve)\nprint(curveDict)\n```\n\n例3. 构建一个双曲线利率互换收益率曲线（CNY\\_SHIBOR\\_3M）。\n\n```\nreferenceDate = 2021.05.26\ncurrency = \"CNY\"\ncurveName = \"CNY_SHIBOR_3M\"\ndiscountCurve = {\n    \"mktDataType\": \"Curve\",\n    \"curveType\": \"IrYieldCurve\",\n    \"curveName\": \"CNY_FR_007\",\n    \"referenceDate\": referenceDate,\n    \"currency\": \"CNY\",\n    \"dayCountConvention\": \"Actual365\",\n    \"compounding\": \"Continuous\",\n    \"interpMethod\": \"Linear\",\n    \"extrapMethod\": \"Flat\",\n    \"dates\":[2021.06.02,2021.06.28,2021.08.27,2021.11.29,2022.02.28,2022.05.27,2023.05.29,2024.05.27,2025.05.27,2026.05.27,2028.05.29,2031.05.27],\n    \"values\": [2.3495, 2.3376, 2.3063, 2.3543, 2.4004, 2.4442, 2.5686, 2.6715, 2.7625, 2.8468, 2.9922, 3.1559] / 100.0\n}\ndiscountCurve = parseMktData(discountCurve)\nterms = [1w, 2w, 1M, 3M, 6M, 9M, 1y, 2y, 3y, 4y, 5y, 7y, 10y]\ninstNames = take(\"CNY_SHIBOR_3M\", size(terms))\ninstNames[0] = \"SHIBOR_1W\"\ninstNames[1] = \"SHIBOR_2W\"\ninstNames[2] = \"SHIBOR_1M\"\ninstNames[3] = \"SHIBOR_3M\"\ninstTypes = take(\"IrVanillaSwap\", size(terms))\ninstTypes[0] = \"Deposit\"\ninstTypes[1] = \"Deposit\"\ninstTypes[2] = \"Deposit\"\ninstTypes[3] = \"Deposit\"\nquotes = [2.269,\n          2.311,\n          2.405,\n          2.479,\n          2.6013,\n          2.7038,\n          2.7725,\n          2.9625,\n          3.11,\n          3.24,\n          3.3513,\n          3.5313,\n          3.7125]/100\ndayCountConvention = \"Actual365\"\n\ncurve = irSingleCurrencyCurveBuilder(referenceDate, currency, instNames, instTypes, terms, quotes, dayCountConvention, discountCurve)\ncurveDict = extractMktData(curve)\nprint(curveDict)\n```\n\n**相关函数：**[bondYieldCurveBuilder](https://docs.dolphindb.cn/zh/funcs/b/bondYieldCurveBuilder.html), [extractMktData](https://docs.dolphindb.cn/zh/funcs/e/extractMktData.html), [irCrossCurrencyCurveBuilder](https://docs.dolphindb.cn/zh/funcs/i/irCrossCurrencyCurveBuilder.html)，[parseMktData](https://docs.dolphindb.cn/zh/funcs/p/parseMktData.html)\n\n#### 曲线字段要求\n\n<table id=\"table_l53_s4j_ngc\"><thead><tr><th>\n\n字段名\n\n</th><th>\n\n类型\n\n</th><th>\n\n描述\n\n</th><th>\n\n是否必填\n\n</th></tr></thead><tbody><tr><td>\n\nmktDataType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"Curve\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nreferenceDate\n\n</td><td>\n\nDATE\n\n</td><td>\n\n参考日期\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ncurveType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"IrYieldCurve\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ndayCountConvention\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n曲线的日期计数惯例，可选值为：\n\n* \"Actual360\"：实际天数除以360\n\n* \"Actual365\"：实际天数除以365（不区分闰年）\n\n* \"ActualActualISMA\"：实际天数/实际天数（ISMA规则）\n\n* \"ActualActualISDA\"：实际天数/实际天数（ISDA规则）\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ninterpMethod\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n内插方法，可选值为：\n\n* \"Linear\"：线性插值\n\n* \"CubicSpline\"：三次样条插值\n\n* \"CubicHermiteSpline\"：三次埃尔米特样条插值\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nextrapMethod\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n外插方法，可选值为：\n\n* \"Flat\"：平插\n\n* \"Linear\"：线性插值\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ndates\n\n</td><td>\n\nDATE 向量\n\n</td><td>\n\n数据点的日期\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nvalues\n\n</td><td>\n\nDOUBLE 向量\n\n</td><td>\n\n数据点的值，与 *dates* 中的元素一一对应\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ncurveName\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n曲线名称\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ncurrency\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n货币，可选值为\"CNY\", \"USD\", \"EUR\", \"GBP\", \"JPY\", \"HKD\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ncompounding\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n复利类型，可选值为：\n\n* \"Simple\"：单利\n\n* \"Compounded\"：离散复利\n\n* \"Continuous\"：连续复利\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nsettlement\n\n</td><td>\n\nDATE\n\n</td><td>\n\n结算日，如果指定了结算日，则后续期限间隔的计算都将从 *settlement* 开始，而不是 *referenceDate*\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\nfrequency\n\n</td><td>\n\nINTEGRAL或 STRING\n\n</td><td>\n\n计息频率，可选值为：\n\n* -1 或 \"NoFrequency\"：无效计息频率\n\n* 0 或 \"Once\"：到期一次还本付息\n\n* 1 或 \"Annual\"：每年付息一次\n\n* 2 或 \"Semiannual\"：每半年付息一次\n\n* 3 或 \"EveryFourthMonth\"：每四个月付息一次\n\n* 4 或 \"Quarterly\"：每季度付息一次\n\n* 6 或 \"BiMonthly\"：每两月付息一次\n\n* 12 或 \"Monthly\"：每月付息一次\n\n* 13 或 \"EveryFourthWeek\"：每四周付息一次\n\n* 26 或 \"BiWeekly\"：每两周付息一次\n\n* 52 或 \"Weekly\"：每周付息一次\n\n* 365 或 \"Daily\"：每日付息一次\n\n* 999 或 \"Other\"：其他计息频率\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ncurveModel\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n曲线构建模型，目前仅支持 \"Bootstrap\"。\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ncurveParams\n\n</td><td>\n\nDICT\n\n</td><td>\n\n模型的参数。\n\n</td><td>\n\n否\n\n</td></tr></tbody>\n</table>\n"
    },
    "isAlNum": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/isAlNum.html",
        "signatures": [
            {
                "full": "isAlNum(X)",
                "name": "isAlNum",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [isAlNum](https://docs.dolphindb.cn/zh/funcs/i/isAlNum.html)\n\n\n\n#### 语法\n\nisAlNum(X)\n\n#### 详情\n\n判断 *X* 是否只包含字母或数字。如果 *X* 中的所有字符都是字母和数字，该函数返回 true，反之返回 false。对于空字符串（STRING类型的NULL值），该函数返回 false。\n\n当 *X* 是表时，函数仅作用于其中 CHAR、STRING、SYMBOL 列，其他类型的列将被忽略。\n\n#### 参数\n\n**X** 是字符/字符串/SYMBOL 类型的标量、向量，或表。\n\n#### 返回值\n\n* 当 *X* 是标量时，返回布尔标量。\n* 当 *X* 是向量时，返回布尔向量。\n* 当 *X* 是表时，返回一个表。\n\n#### 例子\n\n```\nisAlNum(\"123456\");\n// output: true\n\nisAlNum(\"1And1\");\n// output: true\n\nisAlNum(\"10.05\");\n// output: false\n\nisAlNum(string());\n// output: false\n```\n"
    },
    "isAlpha": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/isAlpha.html",
        "signatures": [
            {
                "full": "isAlpha(X)",
                "name": "isAlpha",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [isAlpha](https://docs.dolphindb.cn/zh/funcs/i/isAlpha.html)\n\n\n\n#### 语法\n\nisAlpha(X)\n\n#### 详情\n\n判断 *X* 是否只包含字母。如果 *X* 中的所有字符都是字母，该函数返回 true，反之，返回 false。对于空字符串（STRING 类型的 NULL 值），该函数返回 false。\n\n#### 参数\n\n**X** 是字符或字符串类型的标量、向量或表。\n\n#### 返回值\n\n* 当 *X* 是标量时，返回布尔标量。\n* 当 *X* 是向量时，返回布尔向量。\n* 当 *X* 是表时，返回一个表。\n\n#### 例子\n\n```\nisAlpha(\"hello\");\n// output: true\n\nisAlpha(\"hello world\");\n// output: false\n\nisAlpha(\"1And1\");\n// output: false\n\nisAlpha(string());\n// output: false\n```\n"
    },
    "isCheckpointingHaMvcc": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/isCheckpointingHaMvcc.html",
        "signatures": [
            {
                "full": "isCheckpointingHaMvcc(groupId)",
                "name": "isCheckpointingHaMvcc",
                "parameters": [
                    {
                        "full": "groupId",
                        "name": "groupId"
                    }
                ]
            }
        ],
        "markdown": "### [isCheckpointingHaMvcc](https://docs.dolphindb.cn/zh/funcs/i/isCheckpointingHaMvcc.html)\n\n首发版本：3.00.5\n\n\n\n#### 语法\n\nisCheckpointingHaMvcc(groupId)\n\n#### 详情\n\n检查指定 MVCC Raft 组当前是否正在执行 checkpoint。\n\n#### 参数\n\n**groupId** 是一个整数，表示 MVCC Raft 组 ID。\n\n#### 返回值\n\nBOOL 类型标量。\n\n#### 例子\n\n```\nisCheckpointingHaMvcc(5)\n// output:false\n```\n\n**相关函数**：[haMvccTable](https://docs.dolphindb.cn/zh/funcs/h/haMvccTable.html)\n"
    },
    "isChunkNodeInit": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/isChunkNodeInit.html",
        "signatures": [
            {
                "full": "isDataNodeInitialized()",
                "name": "isDataNodeInitialized",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [isChunkNodeInit](https://docs.dolphindb.cn/zh/funcs/i/isChunkNodeInit.html)\n\n是 [isDataNodeInitialized](https://docs.dolphindb.cn/zh/funcs/i/isDataNodeInitialized.html) 的别名。\n\n\n以下是 `isDataNodeInitialized` 函数的文档：\n### [isDataNodeInitialized](https://docs.dolphindb.cn/zh/funcs/i/isDataNodeInitialized.html)\n\n\n\n#### 语法\n\nisDataNodeInitialized()\n\n#### 详情\n\n查看当前节点是否启动完成。若启动完成返回true，否则返回false。\n\n只适用于数据节点/计算节点。代理节点和控制节点不可用。\n\n#### 返回值\n\n布尔标量。\n\n#### 例子\n\n```\nisDataNodeInitialized()\n// output: true\n```\n\n相关函数：[isControllerInitialized](https://docs.dolphindb.cn/zh/funcs/i/isControllerInitialized.html)\n"
    },
    "isClientAuth": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/isclientauth.html",
        "signatures": [
            {
                "full": "isClientAuth()",
                "name": "isClientAuth",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [isClientAuth](https://docs.dolphindb.cn/zh/funcs/i/isclientauth.html)\n\n\n\n#### 语法\n\nisClientAuth()\n\n#### 详情\n\n获取配置项 *enableClientAuth* 的值。\n\n当*enableClientAuth* 设置为 true 时，访客用户必须登录才能执行脚本，可通过 API 调用少数运维函数，包括：`isClientAuth`, `getNodeType`, `getNodeAlias`, `login`, `authenticateByTicket`, `getControllerAlias`, `version`, `license`, `getActiveMaster`, `getClusterPerf`, `loadClusterNodesConfigs`, `getConfig`, `oauthLogin`, `getCurrentSessionAndUser`, `getDynamicPublicKey`。\n\n#### 返回值\n\n一个布尔值。\n"
    },
    "isColumnarTuple": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/isColumnarTuple.html",
        "signatures": [
            {
                "full": "isColumnarTuple(X)",
                "name": "isColumnarTuple",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [isColumnarTuple](https://docs.dolphindb.cn/zh/funcs/i/isColumnarTuple.html)\n\n\n\n#### 语法\n\nisColumnarTuple(X)\n\n#### 详情\n\n判断一个元组是否是 columnar tuple。\n\n#### 参数\n\n`X` 是一个元组。\n\n#### 返回值\n\n布尔标量。\n\n#### 例子\n\n```\ntp = [[1,2,3], [4,5,6], [7,8]]\nisColumnarTuple(tp)\n// output: false\n\ntp.setColumnarTuple!()\nisColumnarTuple(tp)\n// output: true\n```\n\n```\n\nid = 3 2 1 4\nval = [`aa`bb, `aa`cc`dd, `bb, `cc`dd]\nt = table(id, val)\n\nisColumnarTuple(t.val)\n// output: true\n\nisColumnarTuple(t.id)\n// output: false\n\nexec isColumnarTuple(val) from t\n// output: true\n\nav = array(INT[], 0, 10).append!([1 1 1 3, 2 4 2 5, 8 9 7 1, 5 4 3])\nt = table(id, av)\nisColumnarTuple(t.av)\n// output: false\n```\n"
    },
    "isControllerInitialized": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/isControllerInitialized.html",
        "signatures": [
            {
                "full": "isControllerInitialized()",
                "name": "isControllerInitialized",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [isControllerInitialized](https://docs.dolphindb.cn/zh/funcs/i/isControllerInitialized.html)\n\n\n\n#### 语法\n\nisControllerInitialized()\n\n#### 详情\n\n查看控制节点是否启动完成。若启动完成返回 true，否则返回 false。普通集群环境下，仅在控制节点调用；高可用集群环境下，仅在 leader 节点调用。\n\n#### 返回值\n\n布尔标量。\n\n#### 例子\n\n```\nisControllerInitialized()\n// output: true\n```\n\n相关函数：[isDataNodeInitialized](https://docs.dolphindb.cn/zh/funcs/i/isDataNodeInitialized.html)\n"
    },
    "isDataNodeInitialized": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/isDataNodeInitialized.html",
        "signatures": [
            {
                "full": "isDataNodeInitialized()",
                "name": "isDataNodeInitialized",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [isDataNodeInitialized](https://docs.dolphindb.cn/zh/funcs/i/isDataNodeInitialized.html)\n\n\n\n#### 语法\n\nisDataNodeInitialized()\n\n#### 详情\n\n查看当前节点是否启动完成。若启动完成返回true，否则返回false。\n\n只适用于数据节点/计算节点。代理节点和控制节点不可用。\n\n#### 返回值\n\n布尔标量。\n\n#### 例子\n\n```\nisDataNodeInitialized()\n// output: true\n```\n\n相关函数：[isControllerInitialized](https://docs.dolphindb.cn/zh/funcs/i/isControllerInitialized.html)\n"
    },
    "isDigit": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/isDigit.html",
        "signatures": [
            {
                "full": "isDigit(X)",
                "name": "isDigit",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [isDigit](https://docs.dolphindb.cn/zh/funcs/i/isDigit.html)\n\n\n\n#### 语法\n\nisDigit(X)\n\n#### 详情\n\n判断 *X* 是否只包含数字。如果 *X* 中的所有字符都是数字，该函数返回 true，反之返回 false。对于空字符串（STRING 类型的 NULL 值），该函数返回 false。\n\n**Note:** 该函数和 [isNumeric](https://docs.dolphindb.cn/zh/funcs/i/isNumeric.html) 等价，可任选其一使用。\n\n#### 参数\n\n**X** 是字符或字符串类型的标量、向量或表。\n\n#### 返回值\n\n* 当 *X* 是标量时，返回布尔标量。\n* 当 *X* 是向量时，返回布尔向量。\n* 当 *X* 是表时，返回一个表。\n\n#### 例子\n\n```\nisDigit(\"123456\");\n// output: true\n\nisDigit(\"1And1\");\n// output: false\n\nisDigit(\"10.05\");\n// output: false\n\nisDigit(string());\n// output: false\n```\n"
    },
    "isDuplicated": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/isDuplicated.html",
        "signatures": [
            {
                "full": "isDuplicated(X, [keep=FIRST])",
                "name": "isDuplicated",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[keep=FIRST]",
                        "name": "keep",
                        "optional": true,
                        "default": "FIRST"
                    }
                ]
            }
        ],
        "markdown": "### [isDuplicated](https://docs.dolphindb.cn/zh/funcs/i/isDuplicated.html)\n\n\n\n#### 语法\n\nisDuplicated(X, \\[keep=FIRST])\n\n#### 详情\n\n判断向量中是否包含重复值。如果输入向量中有多个重复值，\n\n* *keep* 的取值为 FIRST 表示，返回结果中第一个重复值对应位置的值为 false，其他重复值对应位置的值为 true。\n\n* *keep* 的取值为 LAST 表示，返回结果中最后一个重复值对应位置的值为 false，其他重复值对应位置的值为 true。\n\n* *keep* 的取值为 NONE 表示，返回结果中所有重复值对应位置的值都为 true。\n\n#### 参数\n\n**X** 是一个向量或包含多个等长向量的元组。\n\n**keep** 是一个常量，表示系统处理多个重复值的方式。它的取值可以是 FIRST, LAST 或 NONE。它是一个可选参数，默认值为 FIRST。\n\n#### 返回值\n\n* 如果 *X* 是一个向量，返回的结果是一个与 *X* 长度相同的布尔向量。\n* 如果 *X* 是一个元组，返回的结果是一个与 *X* 中每个元素等长的布尔向量。\n\n#### 例子\n\n下面通过一个例子说明 *keep* 参数不同取值的区别。\n\n```\nv = [1,3,1,-6,NULL,2,NULL,1]\nisDuplicated(v,FIRST);\n//output: [false,false,true,false,false,false,true,true]\n// 1在向量 v 中出现了三次，所在的位置是第0、第2和第7位，由于 isDuplicated 的第二个参数为 FIRST，因此返回结果中第0位为 false，第2和第7位为 true。\n\nv = [1,3,1,-6,NULL,2,NULL,1]\nisDuplicated(v,LAST);\n//output: [true,false,true,false,true,false,false,false]\n// 1在向量 v 中出现了三次，所在的位置是第0、第2和第7位，由于 isDuplicated 的第二个参数为 LAST，因此返回结果中第7位为 false，第0和第2位为 true。\n\nv = [1,3,1,-6,NULL,2,NULL,1]\nisDuplicated(v,NONE);\n//output: [true,false,true,false,true,false,true,true]\n// 1在向量 v 中出现了三次，所在的位置是第0、第2和第7位，由于 isDuplicated 的第二个参数为 NONE，因此返回结果中第0、第2位和第7位都为 true。\n```\n\n`isDuplicated` 函数可以去除表中的重复记录。\n\n```\nt=table(1 2 4 8 4 2 7 1 as id, 10 20 40 80 40 20 70 10 as val);\nt;\n```\n\n| id | val |\n| -- | --- |\n| 1  | 10  |\n| 2  | 20  |\n| 4  | 40  |\n| 8  | 80  |\n| 4  | 40  |\n| 2  | 20  |\n| 7  | 70  |\n| 1  | 10  |\n\n```\nselect * from t where isDuplicated([id,val],FIRST)=false;\n// 保留第一条重复的记录，去除表中其他重复的记录\n```\n\n| id | val |\n| -- | --- |\n| 1  | 10  |\n| 2  | 20  |\n| 4  | 40  |\n| 8  | 80  |\n| 7  | 70  |\n\n下例展示 `isDuplicated` 判断 BLOB 类型数据。\n\n```\na=[blob(\"s1\"), blob(\"s2\")]\nisDuplicated(a)\n//output: [false, false]\n\na1=[blob(\"s1\"), blob(\"s2\"), blob(\"s1\"), blob(\"s2\")]\nisDuplicated(a1)\n//output: [false, false, true, true]\n```\n"
    },
    "isIndexedMatrix": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/isIndexedMatrix.html",
        "signatures": [
            {
                "full": "isIndexedMatrix(X)",
                "name": "isIndexedMatrix",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [isIndexedMatrix](https://docs.dolphindb.cn/zh/funcs/i/isIndexedMatrix.html)\n\n\n\n#### 语法\n\nisIndexedMatrix(X)\n\n#### 详情\n\n判断 *X* 是否为有索引的矩阵。\n\n#### 参数\n\n**X** 是一个矩阵。\n\n#### 返回值\n\n布尔标量。\n\n#### 例子\n\n```\nm=matrix(1..10, 11..20)\nm.rename!(2020.01.01..2020.01.10, `A`B);\n\nisIndexedMatrix(m);\n// output: false\n\nm.setIndexedMatrix!()\nisIndexedMatrix(m);\n// output: true\n```\n"
    },
    "isIndexedSeries": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/isIndexedSeries.html",
        "signatures": [
            {
                "full": "isIndexedSeries(X)",
                "name": "isIndexedSeries",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [isIndexedSeries](https://docs.dolphindb.cn/zh/funcs/i/isIndexedSeries.html)\n\n\n\n#### 语法\n\nisIndexedSeries(X)\n\n#### 详情\n\n判断 *X* 是否为有索引的序列。\n\n#### 参数\n\n**X** 是一个单列矩阵。\n\n#### 返回值\n\n布尔标量。\n\n#### 例子\n\n```\ns=matrix(1..10).rename!(2020.01.01..2020.01.10, );\n\nisIndexedSeries(s);\n// output: false\n\ns.setIndexedSeries!()\nisIndexedSeries(s);\n// output: true\n```\n"
    },
    "isLeapYear": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/isLeapYear.html",
        "signatures": [
            {
                "full": "isLeapYear(X)",
                "name": "isLeapYear",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [isLeapYear](https://docs.dolphindb.cn/zh/funcs/i/isLeapYear.html)\n\n\n\n#### 语法\n\nisLeapYear(X)\n\n#### 详情\n\n判断 *X* 是否为闰年。\n\n#### 参数\n\n**X** 可以是 DATE, DATEHOUR, DATETIME, TIMESTAMP 或 NANOTIMESTAMP 类型的标量或向量。\n\n#### 返回值\n\n布尔标量或向量。\n\n#### 例子\n\n```\nisLeapYear(2012.06.12T12:30:00);\n// output: true\n\nisLeapYear([2012.01.01,2013.01.01,2014.01.01,2015.01.01]);\n// output: [true,false,false,false]\n```\n"
    },
    "isLoggedIn": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/isLoggedIn.html",
        "signatures": [
            {
                "full": "isLoggedIn(userId)",
                "name": "isLoggedIn",
                "parameters": [
                    {
                        "full": "userId",
                        "name": "userId"
                    }
                ]
            }
        ],
        "markdown": "### [isLoggedIn](https://docs.dolphindb.cn/zh/funcs/i/isLoggedIn.html)\n\n\n\n#### 语法\n\nisLoggedIn(userId)\n\n#### 详情\n\n检查用户是否已经登录。\n\n#### 参数\n\n**userId** 是表示用户名的字符串。它只能包含字母、数字和下划线。它不能以数字开头，长度不能超过30个字符。\n\n#### 返回值\n\n返回一个布尔值。\n\n#### 例子\n\n```\nisLoggedIn(`AlexSmith)\n// output: false\n```\n"
    },
    "isLower": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/isLower.html",
        "signatures": [
            {
                "full": "isLower(X)",
                "name": "isLower",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [isLower](https://docs.dolphindb.cn/zh/funcs/i/isLower.html)\n\n\n\n#### 语法\n\nisLower(X)\n\n#### 详情\n\n判断字符串中的字母是否全部为小写。对于空字符串，该函数返回 false。\n\n#### 参数\n\n**X** 是字符或字符串类型的标量、向量或表。\n\n#### 返回值\n\n* 当 *X* 是标量时，返回布尔标量。\n* 当 *X* 是向量时，返回布尔向量。\n* 当 *X* 是表时，返回一个表。\n\n#### 例子\n\n```\nisLower(\"this is string example....wow!!!\");\n// output: true\n\nisLower(\"THIS is string example....wow!!!\");\n// output: false\n\nisLower(\"123456abc\");\n// output: true\n\nisLower(\"123\");\n// output: false\n\nisLower([\"  \",string()]);\n// output: [false,false]\n```\n\n相关函数：[isUpper](https://docs.dolphindb.cn/zh/funcs/i/isUpper.html), [isTitle](https://docs.dolphindb.cn/zh/funcs/i/isTitle.html)\n"
    },
    "isMonotonic": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/isMonotonic.html",
        "signatures": [
            {
                "full": "isMonotonicIncreasing(X)",
                "name": "isMonotonicIncreasing",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [isMonotonic](https://docs.dolphindb.cn/zh/funcs/i/isMonotonic.html)\n\n是 [isMonotonicIncreasing](https://docs.dolphindb.cn/zh/funcs/i/isMonotonicIncreasing.html) 的别名。\n\n\n以下是 `isMonotonicIncreasing` 函数的文档：\n### [isMonotonicIncreasing](https://docs.dolphindb.cn/zh/funcs/i/isMonotonicIncreasing.html)\n\n\n\n#### 语法\n\nisMonotonicIncreasing(X)\n\n#### 详情\n\n判断 *X* 是否为单调递增。\n\n#### 参数\n\n**X** 可以是标量或向量。\n\n#### 返回值\n\n布尔型标量或向量。\n\n#### 例子\n\n```\na=[int(),2,5,7,10]\nisMonotonicIncreasing(a);\n// output: true\n\na=[2.1,double(),3.5,4.7,8.2,10.5]\nisMonotonicIncreasing(a);\n// output: false\n\na=[5,10,14,20,int()]\nisMonotonicIncreasing(a);\n// output: false\n```\n\n相关函数：[isMonotonicDecreasing](https://docs.dolphindb.cn/zh/funcs/i/isMonotonicDecreasing.html), [isMonotonic](https://docs.dolphindb.cn/zh/funcs/i/isMonotonic.html)\n"
    },
    "isMonotonicDecreasing": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/isMonotonicDecreasing.html",
        "signatures": [
            {
                "full": "isMonotonicDecreasing(X)",
                "name": "isMonotonicDecreasing",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [isMonotonicDecreasing](https://docs.dolphindb.cn/zh/funcs/i/isMonotonicDecreasing.html)\n\n\n\n#### 语法\n\nisMonotonicDecreasing(X)\n\n#### 详情\n\n判断 *X* 是否为单调递减。\n\n#### 参数\n\n**X** 可以是标量或向量。\n\n#### 返回值\n\n布尔型标量或向量。\n\n#### 例子\n\n```\na=[10,7,5,2,int()];\nisMonotonicDecreasing(a);\n// output: true\n\na=[10.5,8.7,int(),5.3,1.0];\nisMonotonicDecreasing(a);\n// output: false\n\na=[5,10,14,20,int()];\nisMonotonicDecreasing(a);\n// output: false\n```\n\n相关函数：[isMonotonicIncreasing](https://docs.dolphindb.cn/zh/funcs/i/isMonotonicIncreasing.html), [isMonotonic](https://docs.dolphindb.cn/zh/funcs/i/isMonotonic.html)\n"
    },
    "isMonotonicIncreasing": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/isMonotonicIncreasing.html",
        "signatures": [
            {
                "full": "isMonotonicIncreasing(X)",
                "name": "isMonotonicIncreasing",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [isMonotonicIncreasing](https://docs.dolphindb.cn/zh/funcs/i/isMonotonicIncreasing.html)\n\n\n\n#### 语法\n\nisMonotonicIncreasing(X)\n\n#### 详情\n\n判断 *X* 是否为单调递增。\n\n#### 参数\n\n**X** 可以是标量或向量。\n\n#### 返回值\n\n布尔型标量或向量。\n\n#### 例子\n\n```\na=[int(),2,5,7,10]\nisMonotonicIncreasing(a);\n// output: true\n\na=[2.1,double(),3.5,4.7,8.2,10.5]\nisMonotonicIncreasing(a);\n// output: false\n\na=[5,10,14,20,int()]\nisMonotonicIncreasing(a);\n// output: false\n```\n\n相关函数：[isMonotonicDecreasing](https://docs.dolphindb.cn/zh/funcs/i/isMonotonicDecreasing.html), [isMonotonic](https://docs.dolphindb.cn/zh/funcs/i/isMonotonic.html)\n"
    },
    "isMonthEnd": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/isMonthEnd.html",
        "signatures": [
            {
                "full": "isMonthEnd(X)",
                "name": "isMonthEnd",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [isMonthEnd](https://docs.dolphindb.cn/zh/funcs/i/isMonthEnd.html)\n\n\n\n#### 语法\n\nisMonthEnd(X)\n\n#### 详情\n\n判断 *X* 是否为月末最后一天。\n\n#### 参数\n\n**X** 可以是 DATE, DATEHOUR, DATETIME, TIMESTAMP 或 NANOTIMESTAMP 类型的标量或向量。\n\n#### 返回值\n\n布尔型标量或向量。\n\n#### 例子\n\n```\nisMonthEnd(2012.05.31);\n// output: true\n\nisMonthEnd([2012.05.30,2012.05.31]);\n// output: [false,true]\n```\n\n相关函数：[isMonthStart](https://docs.dolphindb.cn/zh/funcs/i/isMonthStart.html)\n"
    },
    "isMonthStart": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/isMonthStart.html",
        "signatures": [
            {
                "full": "isMonthStart(X)",
                "name": "isMonthStart",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [isMonthStart](https://docs.dolphindb.cn/zh/funcs/i/isMonthStart.html)\n\n\n\n#### 语法\n\nisMonthStart(X)\n\n#### 详情\n\n判断 *X* 是否为月初第一天。\n\n#### 参数\n\n**X** 可以是 DATE, DATEHOUR, DATETIME, TIMESTAMP 或 NANOTIMESTAMP 类型的标量或向量。\n\n#### 返回值\n\n布尔型标量或向量。\n\n#### 例子\n\n```\nisMonthStart(2012.05.01);\n// output: true\n\nisMonthStart([2012.05.01,2012.05.02]);\n// output: [true,false]\n```\n\n相关函数：[isMonthEnd](https://docs.dolphindb.cn/zh/funcs/i/isMonthEnd.html)\n"
    },
    "isNanInf": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/isNanInf.html",
        "signatures": [
            {
                "full": "isNanInf(X, [includeNull=false])",
                "name": "isNanInf",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[includeNull=false]",
                        "name": "includeNull",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [isNanInf](https://docs.dolphindb.cn/zh/funcs/i/isNanInf.html)\n\n\n\n#### 语法\n\nisNanInf(X, \\[includeNull=false])\n\n#### 详情\n\n检测 *X* 中的每一个元素是否为 NaN 或 Inf。若 *includeNull* 设为 true，NULL 值会被视为 Nan 或 Inf，默认为 false。\n\n#### 参数\n\n**X** 是 DOUBLE 类型的标量/向量/矩阵。\n\n**includeNull** 是一个布尔值。\n\n#### 返回值\n\n返回布尔类型，数据形式同 X。\n\n#### 例子\n\n```\nx = [1.5, float(`nan), 2.3, float(`inf), NULL, 3.7]  \n  \n// includeNull = false (默认)，不检查 NULL 值  \nisNanInf(x)  \n// output: [false,true,false,true,false,false]\n\n// includeNull = true，NULL 值将被视为 Nan 或 Inf\nisNanInf(x)  \n// output: [false,true,false,true,true,false]\n```\n\n相关函数：[countNanInf](https://docs.dolphindb.cn/zh/funcs/c/countNanInf.html)\n"
    },
    "isNothing": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/isNothing.html",
        "signatures": [
            {
                "full": "isNothing(X)",
                "name": "isNothing",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [isNothing](https://docs.dolphindb.cn/zh/funcs/i/isNothing.html)\n\n\n\n#### 语法\n\nisNothing(X)\n\n#### 详情\n\n`isNothing` 用于检查一个函数被调用时，函数的参数是否被传了值进来。\n\n在 DolphinDB 中，Nothing 是 VOID 类型的两个特殊对象之一，用于表示“未传入参数”。\n\n#### 参数\n\n**X** 可以是任何数据类型或形式。\n\n#### 返回值\n\n布尔型标量或向量。\n\n#### 例子\n\n```\nf=def(x,y): isNothing(y);\nf(5,);\n// output: true\n\nf(5, NULL);\n// output: false\n```\n"
    },
    "isNull": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/isNull.html",
        "signatures": [
            {
                "full": "isNull(X)",
                "name": "isNull",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [isNull](https://docs.dolphindb.cn/zh/funcs/i/isNull.html)\n\n\n\n#### 语法\n\nisNull(X)\n\n#### 详情\n\n用于检查是否是 NULL 值。如果元素是 NULL，返回 true。自 2.00.5 版本开始，当 *X* 是字典、元组、数组向量或表时，该函数将检查每一行中的元素是否是 NULL 值，返回一个具有相同维度的字典、元组或表。\n\n**Note:**\n\nDolphinDB `isNull` 和 [pandas.isnull](https://pandas.pydata.org/docs/reference/api/pandas.isnull.html) 都能用来判断是否是空值。区别如下：\n\n* DolphinDB `isNull` 用于 DolphinDB 自身类型系统里的 NULL 值检测，适用于标量、向量、矩阵等对象。\n\n* `pandas.isnull` 用于 Python 数据分析场景中的“缺失值”检测，主要识别 NaN、NaT、pd.NA、None 等。\n\n#### 参数\n\n**X** 可以是标量、数据对、向量、字典、矩阵或内存表。\n\n#### 返回值\n\n返回布尔类型，数据形式同 X。\n\n#### 例子\n\n```\nisNull(00i);\n// output: true\n\nisNull(1 NULL NULL 6 NULL 7);\n\n[0,1,1,0,1,0]\n\nisNull(1/0);\n// output: true\n\nx=1 NULL 5 NULL 4 6$2:3;\nx;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1  | 5  | 4  |\n|    |    | 6  |\n\n```\nisNull(x);\n```\n\n| #0    | #1    | #2    |\n| ----- | ----- | ----- |\n| false | false | false |\n| true  | true  | false |\n\n```\nt=table(1 2 3 as id, `a`b`c as name, 10 NULL 7 as vol)\nisNull(t)\n```\n\n| id    | name  | vol   |\n| ----- | ----- | ----- |\n| false | false | false |\n| false | false | true  |\n| false | false | false |\n\n相关函数：[hasNull](https://docs.dolphindb.cn/zh/funcs/h/hasNull.html), [nullFill](https://docs.dolphindb.cn/zh/funcs/n/nullFill.html)\n"
    },
    "isNumeric": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/isNumeric.html",
        "signatures": [
            {
                "full": "isNumeric(X)",
                "name": "isNumeric",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [isNumeric](https://docs.dolphindb.cn/zh/funcs/i/isNumeric.html)\n\n\n\n#### 语法\n\nisNumeric(X)\n\n#### 详情\n\n判断 *X* 是否只包含数字。如果 *X* 中的所有字符都是数字，该函数返回 true，反之返回 false。对于空字符串（STRING 类型的 NULL 值），该函数返回 false。\n\n**Note:** 该函数和 [isDigit](https://docs.dolphindb.cn/zh/funcs/i/isDigit.html) 等价，可任选其一使用。\n\n#### 参数\n\n**X** 是字符或字符串类型的标量、向量或表。\n\n#### 返回值\n\n* 当 *X* 是标量时，返回布尔标量。\n* 当 *X* 是向量时，返回布尔向量。\n* 当 *X* 是表时，返回一个表。\n\n#### 例子\n\n```\nisNumeric(\"123456\");\n// output: true\n\nisNumeric(\"1And1\");\n// output: false\n\nisNumeric(\"10.05\");\n// output: false\n\nisNumeric(string());\n// output: false\n```\n"
    },
    "isOrderedDict": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/isOrderedDict.html",
        "signatures": [
            {
                "full": "isOrderedDict(X)",
                "name": "isOrderedDict",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [isOrderedDict](https://docs.dolphindb.cn/zh/funcs/i/isOrderedDict.html)\n\n\n\n#### 语法\n\nisOrderedDict(X)\n\n#### 参数\n\n**X** 一个字典对象。\n\n#### 详情\n\n判断 *X* 是否为一个有序字典：\n\n* 如果是，返回 *true*；\n* 如果不是， *false*。\n\n#### 返回值\n\n布尔标量。\n\n#### 例子\n\n```\nx=1 5 3\ny=4.5 7.8 4.3\nz=dict(x,y);\nisOrderedDict(z)\n// output: false\n\nz1=dict(x,y,true);\nisOrderedDict(z1)\n// output: true\n```\n"
    },
    "isort": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/isort.html",
        "signatures": [
            {
                "full": "isort(X, [ascending=true])",
                "name": "isort",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [isort](https://docs.dolphindb.cn/zh/funcs/i/isort.html)\n\n\n\n#### 语法\n\nisort(X, \\[ascending=true])\n\n#### 详情\n\n和 [sort!](https://docs.dolphindb.cn/zh/funcs/s/sort_.html) 返回一个排序后的数组不同，*isort* 返回排序后的每个元素在原始向量中的索引。\n\nX\\[isort X] 等价于 sort(X)。\n\n#### 参数\n\n**X** 是一个向量或一个由多个等长向量组成的元组。\n\n**ascending** 是布尔值标量或向量，表示按升序排序还是按降序排序。默认值为 true（按升序排序）。\n\n#### 返回值\n\n一个整型向量，表示排序后的每个元素在原始向量中的索引。\n\n#### 例子\n\n```\nx = 4 1 3 2;\ny = isort(x);\ny;\n// output: [1,3,2,0]\n// 对于排序后的 x: [1 2 3 4]，第一个元素 1 在原始的 x 中的位置是 1，第二个元素 2 在原始 x 中的位置是 3，... 以此类推。\nx[y];\n// output: [1,2,3,4]\n// 等价于 sort(x)\n\nz=isort(x, false);\nz;\n// output: [0,2,3,1]\nx[z];\n// output: [4,3,2,1]\n\nx=2 2 1 1\ny=2 1 1 2\nisort([x,y]);\n// output: [2,3,1,0]\nisort([x,y],[0,0]);\n// output: [0,1,3,2]\n```\n\n基于表的单列排序：\n\n```\nt2 = table(4 2 3 1 as x, 9 6 7 3 as y);\nt2;\n```\n\n| x | y |\n| - | - |\n| 4 | 9 |\n| 2 | 6 |\n| 3 | 7 |\n| 1 | 3 |\n\n```\nt2[isort(t2.x)];\n```\n\n| x | y |\n| - | - |\n| 1 | 3 |\n| 2 | 6 |\n| 3 | 7 |\n| 4 | 9 |\n\n```\nt2[isort(t2.x, false)];\n```\n\n| x | y |\n| - | - |\n| 4 | 9 |\n| 3 | 7 |\n| 2 | 6 |\n| 1 | 3 |\n\n基于表的多列排序：\n\n```\na=5 5 5 3 3 8 7 7;\nb=`MSFT`GOOG`IBM`YHOO`X`YHOO`C`ORCL;\nt=table(a,b);\nt;\n```\n\n| a | b    |\n| - | ---- |\n| 5 | MSFT |\n| 5 | GOOG |\n| 5 | IBM  |\n| 3 | YHOO |\n| 3 | X    |\n| 8 | YHOO |\n| 7 | C    |\n| 7 | ORCL |\n\n```\nt[isort([a,b], false true)];\n// 先基于 a 降序排序，再基于 b 升序排序\n```\n\n| a | b    |\n| - | ---- |\n| 8 | YHOO |\n| 7 | C    |\n| 7 | ORCL |\n| 5 | GOOG |\n| 5 | IBM  |\n| 5 | MSFT |\n| 3 | X    |\n| 3 | YHOO |\n\n```\nt[isort([a,b], false)];\n// 等价于 t[isort([a,b], false false)];\n```\n\n| a | b    |\n| - | ---- |\n| 8 | YHOO |\n| 7 | ORCL |\n| 7 | C    |\n| 5 | MSFT |\n| 5 | IBM  |\n| 5 | GOOG |\n| 3 | YHOO |\n| 3 | X    |\n"
    },
    "isortTop": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/isortTop.html",
        "signatures": [
            {
                "full": "isortTop(X, top, [ascending=true])",
                "name": "isortTop",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "top",
                        "name": "top"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [isortTop](https://docs.dolphindb.cn/zh/funcs/i/isortTop.html)\n\n\n\n#### 语法\n\nisortTop(X, top, \\[ascending=true])\n\n#### 详情\n\n返回 *X* 排序后前 *top* 个元素对应的索引。\n\n#### 参数\n\n**X** 可以是一个向量或一个由多个等长向量组成的元组。\n\n**top** 是一个正整数，它的值不能超过 *X* 的长度。\n\n**ascending** 是一个布尔型的标量或向量，表示 *X* 按升序排序还是降序排序。它是可选参数，默认值为 true，表示按升序排序。\n\n#### 返回值\n\n整型向量。\n\n#### 例子\n\n```\nisortTop(2 1 4 3 6 5, 3);\n// output: [1,0,3]\n\nisortTop(2 1 4 3 6 5, 3, false);\n// output: [4,5,2]\n\nx=1 1 2 2 3 3\ny=1 2 1 2 1 2\nisortTop([x,y], 3);\n// output: [0,1,2]\n\nx=1 1 2 2 3 3\ny=1 2 1 2 1 2\nisortTop([x,y], 3, [false, false]);\n// 先基于 x 降序排序，对于 x 中相同的元素，再基于 y 降序排序后，取前3个元素对应的索引\n// output: [5,4,3]\n```\n"
    },
    "isort!": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/isort_.html",
        "signatures": [
            {
                "full": "isort!(X, [ascending=true], indices)",
                "name": "isort!",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "indices",
                        "name": "indices"
                    }
                ]
            }
        ],
        "markdown": "### [isort!](https://docs.dolphindb.cn/zh/funcs/i/isort_.html)\n\n\n\n#### 语法\n\nisort!(X, \\[ascending=true], indices)\n\n#### 详情\n\nisort!(x, ascending, y) 相当于 y\\[isort(x, ascending)]，结果会赋给 y。\n\n#### 参数\n\n**X** 是一个向量或一个由多个等长向量组成的元组。\n\n**ascending** 是布尔值，表示按升序排序还是按降序排序。默认值为 true（按升序排序）。\n\n**indices** 是一个向量，它的长度与 *X* 中每个向量的长度相同。\n\n#### 返回值\n\n一个排序后的向量，类型同 *X*。\n\n#### 例子\n\n```\nx=3 1 NULL 2\ny=5 7 8 3\nisort!(x, false, y);\n// output: [5, 3, 7, 8]\n// 排序后的x为[3, 2, 1, NULL]，第一个元素3与y中的5对应，第二个元素与2与y中的3对应，第三个元素1与y中的7对应，...以此类推。\n\nx=2 2 1 1\ny=2 1 1 2\nisort!([x,y],[1,0],5 4 3 2);\n// output: [2,3,5,4]\n```\n"
    },
    "isPeak": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/isPeak.html",
        "signatures": [
            {
                "full": "isPeak(X, [strict=true])",
                "name": "isPeak",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[strict=true]",
                        "name": "strict",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [isPeak](https://docs.dolphindb.cn/zh/funcs/i/isPeak.html)\n\n\n\n#### 语法\n\nisPeak(X, \\[strict=true])\n\n#### 详情\n\n若 *X* 为向量，计算 *X* 中的每个元素是否为峰值点，若是则返回 true，否则返回 false。\n\n若 *X* 为矩阵，在每列进行上述计算，返回值一个同 *X* 维度相同的矩阵。若 *X* 为表，则只对数值型的列进行上述计算。\n\n#### 参数\n\n**X** 数值型向量/矩阵/表。\n\n**strict** 布尔值，默认值为 true。\n\n* 若 *strict* = true，相邻元素不为空且严格小于该元素\n* 若 *strict* = false，相邻元素不为空且小于等于该元素\n\n#### 返回值\n\n* 当 *X* 是向量时，返回布尔向量。\n* 当 *X* 是矩阵时，返回布尔矩阵。\n* 当 *X* 是表时，返回一个表。\n\n#### 例子\n\n```\nv = [1, 2.2, 2.2, 2.2, 2.3, 1, 1.2]\nisPeak(v)\n// output: [false,false,false,false,true,false,false]\n\nv = [1, 2.2, 2.2, 2.2, 1.6, 1, 1.2]\nisPeak(v)\n// output: [false,false,false,false,false,false,false]\nisPeak(v, false)\n// output: [false,true,true,true,false,false,false]\n\n// 矩阵在每列单独计算\nm = matrix(3.3 2.8 5.6 NULL 2.5 1.2, 4.5 3.5 4.6 2.8 3.9 NULL)\nisPeak(m)\n```\n\n| #0    | #1    |\n| ----- | ----- |\n| false | false |\n| false | false |\n| false | true  |\n| false | false |\n| false | false |\n| false | false |\n\n```\n// 表只在数值列进行计算\nt = table(`01`01`00`01`02`00 as id, 388.3 390.6 390.8 390.6 390.3 391.5 as price)\nisPeak(t)\n```\n\n| id | price |\n| -- | ----- |\n| 01 | false |\n| 01 | false |\n| 00 | true  |\n| 01 | false |\n| 02 | false |\n| 00 | false |\n\n相关函数：[isValley](https://docs.dolphindb.cn/zh/funcs/i/isValley.html)\n"
    },
    "isQuarterEnd": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/isQuarterEnd.html",
        "signatures": [
            {
                "full": "isQuarterEnd(X)",
                "name": "isQuarterEnd",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [isQuarterEnd](https://docs.dolphindb.cn/zh/funcs/i/isQuarterEnd.html)\n\n\n\n#### 语法\n\nisQuarterEnd(X)\n\n#### 详情\n\n判断 *X* 是否为季度最后一天。\n\n#### 参数\n\n**X** 可以是 DATE, DATEHOUR, DATETIME, TIMESTAMP 或 NANOTIMESTAMP 类型的标量或向量。\n\n#### 返回值\n\n布尔标量或向量。\n\n#### 例子\n\n```\nisQuarterEnd(2012.06.30);\n// output: true\n\nisQuarterEnd([2012.06.30,2012.07.01]);\n// output: [true,false]\n```\n\n相关函数：[isQuarterStart](https://docs.dolphindb.cn/zh/funcs/i/isQuarterStart.html)\n"
    },
    "isQuarterStart": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/isQuarterStart.html",
        "signatures": [
            {
                "full": "isQuarterStart(X)",
                "name": "isQuarterStart",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [isQuarterStart](https://docs.dolphindb.cn/zh/funcs/i/isQuarterStart.html)\n\n\n\n#### 语法\n\nisQuarterStart(X)\n\n#### 详情\n\n判断 *X* 是否为季度第一天。\n\n#### 参数\n\n**X** 可以是 DATE, DATEHOUR, DATETIME, TIMESTAMP 或 NANOTIMESTAMP 类型的标量或向量。\n\n#### 返回值\n\n布尔标量或向量。\n\n#### 例子\n\n```\nisQuarterStart(2012.04.01);\n// output: true\n\nisQuarterStart([2012.04.01,2012.05.01]);\n// output: [true,false]\n```\n\n相关函数：[isQuarterEnd](https://docs.dolphindb.cn/zh/funcs/i/isQuarterEnd.html)\n"
    },
    "isSorted": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/isSorted.html",
        "signatures": [
            {
                "full": "isSorted(X, [ascending=true])",
                "name": "isSorted",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [isSorted](https://docs.dolphindb.cn/zh/funcs/i/isSorted.html)\n\n\n\n#### 语法\n\nisSorted(X, \\[ascending=true])\n\n#### 详情\n\n检查 *X* 是否有序。\n\n#### 参数\n\n**X** 是一个向量。\n\n**ascending** 是布尔值，表示 *X* 按升序排序（true）或降序排序（false）。默认值为 true。\n\n#### 返回值\n\n布尔标量。\n\n#### 例子\n\n```\nx=NULL 1 2 3\nisSorted(x);\n// output: true\n\nt=table(9 7 5 3 as x, 1 5 2 4 as y)\nt.x.isSorted(false);\n// output: true\n\nt.y.isSorted();\n// output: false\n```\n"
    },
    "isSpace": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/isSpace.html",
        "signatures": [
            {
                "full": "isSpace(X)",
                "name": "isSpace",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [isSpace](https://docs.dolphindb.cn/zh/funcs/i/isSpace.html)\n\n\n\n#### 语法\n\nisSpace(X)\n\n#### 详情\n\n判断 *X* 是否为空格类字符串。如果 *X* 中的字符都是空格、跳格符(\\t)、回车符(\\r)或换行符(\\n)，该函数返回 true，反之，返回 false。对于空字符串（STRING 类型的 NULL 值），该函数返回 false。\n\n#### 参数\n\n**X** 是字符或字符串类型的标量、向量或表。\n\n#### 返回值\n\n* 当 *X* 是标量时，返回布尔标量。\n* 当 *X* 是向量时，返回布尔向量。\n* 当 *X* 是表时，返回一个表。\n\n#### 例子\n\n```\nisSpace(\"hello world\");\n// output: false\n\nisSpace(\" \\t \");\n// output: true\n\nisSpace(string());\n// output: false\n```\n"
    },
    "isTitle": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/isTitle.html",
        "signatures": [
            {
                "full": "isTitle(X)",
                "name": "isTitle",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [isTitle](https://docs.dolphindb.cn/zh/funcs/i/isTitle.html)\n\n\n\n#### 语法\n\nisTitle(X)\n\n#### 详情\n\n判断字符串中每个单词的第一个字母是否为大写，其他字母都为小写。对于不包含字母的字符串和空字符串，该函数返回 false。\n\n#### 参数\n\n**X** 可以是字符串标量或向量。\n\n#### 返回值\n\n布尔标量或向量。\n\n#### 例子\n\n```\nisTitle(\"Hello World\");\n// output: true\n\nisTitle(\"Hello world\");\n// output: false\n\nisTitle([\"Hello\",\"468\",\"  \"]);\n// output: [true,false,false]\n\nisTitle(\"1And1\");\n// output: true\n```\n\n相关函数：[isLower](https://docs.dolphindb.cn/zh/funcs/i/isLower.html), [isUpper](https://docs.dolphindb.cn/zh/funcs/i/isUpper.html)\n"
    },
    "isTransferCompressionToComputeNodeEnabled": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/istransfercompressiontocomputenodeenabled.html",
        "signatures": [
            {
                "full": "isTransferCompressionToComputeNodeEnabled()",
                "name": "isTransferCompressionToComputeNodeEnabled",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [isTransferCompressionToComputeNodeEnabled](https://docs.dolphindb.cn/zh/funcs/i/istransfercompressiontocomputenodeenabled.html)\n\n\n\n#### 语法\n\nisTransferCompressionToComputeNodeEnabled()\n\n#### 详情\n\n查询数据节点到计算节点的数据传输是否启用压缩。\n\n#### 参数\n\n无\n\n#### 返回值\n\n布尔值。true 表示开启了压缩，false 表示未开启压缩。\n\n#### 例子\n\n```\nisTransferCompressionToComputeNodeEnabled()\n\n//输出：true\n```\n\n**相关函数：**[enableTransferCompressionToComputeNode](https://docs.dolphindb.cn/zh/funcs/e/enabletransfercompressiontocomputenode.html)\n"
    },
    "isUpper": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/isUpper.html",
        "signatures": [
            {
                "full": "isUpper(X)",
                "name": "isUpper",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [isUpper](https://docs.dolphindb.cn/zh/funcs/i/isUpper.html)\n\n\n\n#### 语法\n\nisUpper(X)\n\n#### 详情\n\n判断字符串中的字母是否全部为大写。对于空字符串，该函数返回 false。\n\n#### 参数\n\n**X** 是字符或字符串类型的标量或向量。\n\n#### 返回值\n\n布尔标量或向量。\n\n#### 例子\n\n```\nisUpper(\"THIS IS STRING EXAMPLE....WOW!!!\");\n// output: true\n\nisUpper(\"THIS is string example....wow!!!\");\n// output: false\n\nisUpper(\"123456ABC\");\n// output: true\n\nisUpper(\"123\");\n// output: false\n\nisUpper([\"  \",string()]);\n// output: [false,false]\n```\n\n相关函数：[isLower](https://docs.dolphindb.cn/zh/funcs/i/isLower.html), [isTitle](https://docs.dolphindb.cn/zh/funcs/i/isTitle.html)\n"
    },
    "isValid": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/isValid.html",
        "signatures": [
            {
                "full": "isValid(X)",
                "name": "isValid",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [isValid](https://docs.dolphindb.cn/zh/funcs/i/isValid.html)\n\n\n\n#### 语法\n\nisValid(X)\n\n#### 详情\n\n检查每个元素是否为有效数（非 NULL 值）。如果是，返回 true；否则返回 false。\n\n#### 参数\n\n**X** 可以是标量、数据对、向量或矩阵。\n\n#### 返回值\n\n布尔标量、数据对、向量或矩阵。\n\n#### 例子\n\n```\nisValid(00i);\n// output: false\n\nisValid(1 NULL NULL 6 NULL 7);\n// output: [true,false,false,true,false,true]\n\nisValid(1/0);\n// output: false\n```\n"
    },
    "isValley": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/isValley.html",
        "signatures": [
            {
                "full": "isValley(X, [strict=true])",
                "name": "isValley",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[strict=true]",
                        "name": "strict",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [isValley](https://docs.dolphindb.cn/zh/funcs/i/isValley.html)\n\n\n\n#### 语法\n\nisValley(X, \\[strict=true])\n\n#### 详情\n\n若 *X* 为向量，计算 *X* 中的每个元素是否为谷值点，若是则返回 true，否则返回 false。\n\n若 *X* 为矩阵，在每列进行上述计算，返回值一个同 X 维度相同的矩阵。若 *X* 为表，则只对数值型的列进行上述计算。\n\n#### 参数\n\n**X** 数值型向量/矩阵/表。\n\n**strict** 布尔值，表示是否取严格的谷值点。默认值为 true。\n\n* 若 *strict* = true，相邻元素不为空且严格大于该元素\n* 若 *strict* = false，相邻元素不为空且大于等于该元素\n\n#### 返回值\n\n* 当 *X* 是向量时，返回布尔向量。\n* 当 *X* 是矩阵时，返回布尔矩阵。\n* 当 *X* 是表时，返回一个表。\n\n#### 例子\n\n```\nv = [3.1, 2.2, 2.2, 2.2, 1.3, 2.1, 1.2]\nisValley(v)\n// output: [false,false,false,false,true,false,false]\n\nv = [3.1, 2.2, 2.2, 2.2, 2.6, 1, 1.2]\nisValley(v)\n// output: [false,false,false,false,false,true,false]\nisValley(v, false)\n// output: [false,true,true,true,false,true,false]\n\n// 矩阵在每列单独计算\nm = matrix(5.3 5.8 5.6 NULL 5.7 1.2, 4.5 3.5 4.6 2.8 3.9 NULL)\nisValley(m)\n```\n\n| #0    | #1    |\n| ----- | ----- |\n| false | false |\n| false | true  |\n| false | false |\n| false | true  |\n| false | false |\n| false | false |\n\n```\n// 表只在数值列进行计算\nt = table(`01`01`00`01`02`00 as id, 388.3 390.6 390.8 390.6 390.3 391.5 as price)\nisValley(t)\n```\n\n| id | price |\n| -- | ----- |\n| 01 | false |\n| 01 | false |\n| 00 | false |\n| 01 | false |\n| 02 | true  |\n| 00 | false |\n\n相关函数：[isPeak](https://docs.dolphindb.cn/zh/funcs/i/isPeak.html)\n"
    },
    "isVoid": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/isVoid.html",
        "signatures": [
            {
                "full": "isVoid(X)",
                "name": "isVoid",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [isVoid](https://docs.dolphindb.cn/zh/funcs/i/isVoid.html)\n\n\n\n#### 语法\n\nisVoid(X)\n\n#### 详情\n\n检查一个对象是否是 VOID 类型。有两种 VOID 类型的对象：一种是 NULL 对象；另一种是 Nothing 对象。参见 [isNothing](https://docs.dolphindb.cn/zh/funcs/i/isNothing.html)。\n\n#### 参数\n\n**X** 可以是系统支持的任意数据形式。\n\n#### 参数\n\n布尔类型，数据形式同 *X*。\n\n#### 例子\n\n```\nisVoid(NULL);\n// output: true\n\nisVoid(1 NULL 2);\n// output: false\n\n// 和 isNull 相比\nisNull(1 NULL 2);\n// output: [false,true,false]\n\nisVoid(matrix(NULL 2 NULL, NULL 2 1))\n// output: false\n```\n"
    },
    "isYearEnd": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/isYearEnd.html",
        "signatures": [
            {
                "full": "isYearEnd(X)",
                "name": "isYearEnd",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [isYearEnd](https://docs.dolphindb.cn/zh/funcs/i/isYearEnd.html)\n\n\n\n#### 语法\n\nisYearEnd(X)\n\n#### 详情\n\n判断 *X* 是否为年末最后一天。\n\n#### 参数\n\n**X** 可以是 DATE, DATEHOUR, DATETIME, TIMESTAMP 或 NANOTIMESTAMP 类型的标量或向量。\n\n#### 返回值\n\n布尔标量或向量。\n\n#### 例子\n\n```\nisYearEnd(2012.12.31);\n// output: true\n\nisYearEnd([2012.12.30,2012.12.31]);\n// output: [false,true]\n```\n\n相关函数：[isYearStart](https://docs.dolphindb.cn/zh/funcs/i/isYearStart.html)\n"
    },
    "isYearStart": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/isYearStart.html",
        "signatures": [
            {
                "full": "isYearStart(X)",
                "name": "isYearStart",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [isYearStart](https://docs.dolphindb.cn/zh/funcs/i/isYearStart.html)\n\n\n\n#### 语法\n\nisYearStart(X)\n\n#### 详情\n\n判断 *X* 是否为年初第一天。\n\n#### 参数\n\n**X** 可以是 DATE, DATEHOUR, DATETIME, TIMESTAMP 或 NANOTIMESTAMP 类型的标量或向量。\n\n#### 返回值\n\n布尔标量或向量。\n\n#### 例子\n\n```\nisYearStart(2012.01.01);\n// output: true\n\nisYearStart([2012.01.01,2012.02.01]);\n// output: [true,false]\n```\n\n相关函数：[isYearEnd](https://docs.dolphindb.cn/zh/funcs/i/isYearEnd.html)\n"
    },
    "iterate": {
        "url": "https://docs.dolphindb.cn/zh/funcs/i/iterate.html",
        "signatures": [
            {
                "full": "iterate(init, coeffs, input)",
                "name": "iterate",
                "parameters": [
                    {
                        "full": "init",
                        "name": "init"
                    },
                    {
                        "full": "coeffs",
                        "name": "coeffs"
                    },
                    {
                        "full": "input",
                        "name": "input"
                    }
                ]
            }
        ],
        "markdown": "### [iterate](https://docs.dolphindb.cn/zh/funcs/i/iterate.html)\n\n\n\n#### 语法\n\niterate(init, coeffs, input)\n\n#### 详情\n\n* 若 *init*、*coeffs* 与 *input* 均为标量，返回等比数列\\[ *init* \\* *coeffs* , *init* \\* *coeffs* 2, *init* \\* *coeffs*3, ...]，其长度为 *input*。\n\n* 若 *init*、*coeffs* 为标量，*input* 为向量，返回数列x，满足以下条件：x\\[0]= *init* \\* *coeffs* + *input* \\[0]，x\\[n]=x\\[n-1]\\* *coeffs* + *input* \\[n]。数列x的长度为 *input* 的长度。\n\n* 若 *init*、*coeffs* 为向量，*input* 为标量，返回数列x，满足以下条件：x\\[n]=y(n)\\*\\* *coeffs* , y(n)=y(n-1)\\[1:].append!(x\\[n-1]), y(0)= *init*, x的长度为 *input* 。其中\\*\\*表示点乘，返回两个向量的内积。\n\n* 若 *init*、*coeffs* 与 *input* 均为向量，返回数列x，满足以下条件：x\\[n]=y(n)\\*\\* *coeffs* + *input* \\[n], y(n)=y(n-1)\\[1:].append!(x\\[n-1]), y(0)= *init*。其中\\*\\*表示点乘，返回两个向量的内积。\n\n#### 参数\n\n**init** 是初始值。\n\n**coeffs** 是迭代系数。*init* 和 *coeffs* 的长度必须相同。\n\n**input** 是整型标量，或者是向量。如果 *input* 是整型标量，表示迭代的次数；如果 *input* 是向量，其长度表示迭代的次数，每个元素在每次迭代后都添加到结果中。\n\n#### 返回值\n\nDOUBLE 类型向量。\n\n#### 例子\n\n```\niterate(1, 0.8, 3);\n// output: [0.8,0.64,0.512]\n// 1*0.8=0.8, 0.8*0.8=0.64, 0.64*0.8=0.512\n\niterate(1, 0.8, 0.1 0.2 0.3);\n// output: [0.9,0.92,1.036]\n// 1*0.8+0.1=0.9, 0.9*0.8+0.2=0.92, 0.92*0.8+0.3=1.036\n\niterate(1 1, 1 1, 10);\n// output: [2,3,5,8,13,21,34,55,89,144]\n// 斐波那契数列: 1*1+1*1=2; 1*1+2*1=3; 2*1+3*1=5; 3*1+5*1=8; ... ; 55*1+89*1=144.\n\niterate(1 1, 1 1, 1 2 3 4 5);\n// output: [3,6,12,22,39]\n// 1*1+1*1+1=3; 1*1+3*1+2=6; 3*1+6*1+3=12; 6*1+12*1+4=22; 12*1+22*1+5=39.\n```\n"
    },
    "lasso": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/lasso.html",
        "signatures": [
            {
                "full": "lasso(ds, yColName, xColNames, [alpha=1.0], [intercept=true], [normalize=false], [maxIter=1000], [tolerance=0.0001], [positive=false], [swColName], [checkInput=true])",
                "name": "lasso",
                "parameters": [
                    {
                        "full": "ds",
                        "name": "ds"
                    },
                    {
                        "full": "yColName",
                        "name": "yColName"
                    },
                    {
                        "full": "xColNames",
                        "name": "xColNames"
                    },
                    {
                        "full": "[alpha=1.0]",
                        "name": "alpha",
                        "optional": true,
                        "default": "1.0"
                    },
                    {
                        "full": "[intercept=true]",
                        "name": "intercept",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[normalize=false]",
                        "name": "normalize",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[maxIter=1000]",
                        "name": "maxIter",
                        "optional": true,
                        "default": "1000"
                    },
                    {
                        "full": "[tolerance=0.0001]",
                        "name": "tolerance",
                        "optional": true,
                        "default": "0.0001"
                    },
                    {
                        "full": "[positive=false]",
                        "name": "positive",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[swColName]",
                        "name": "swColName",
                        "optional": true
                    },
                    {
                        "full": "[checkInput=true]",
                        "name": "checkInput",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [lasso](https://docs.dolphindb.cn/zh/funcs/l/lasso.html)\n\n\n\n#### 语法\n\nlasso(ds, yColName, xColNames, \\[alpha=1.0], \\[intercept=true], \\[normalize=false], \\[maxIter=1000], \\[tolerance=0.0001], \\[positive=false], \\[swColName], \\[checkInput=true])\n\n#### 详情\n\n进行 lasso 回归估计。\n\n最小化以下目标函数：\n\n![lasso](https://docs.dolphindb.cn/zh/images/lasso.png)\n\n#### 参数\n\n**ds** 是内存表或通常用 [sqlDS](https://docs.dolphindb.cn/zh/funcs/s/sqlDS.html) 函数生成的数据源。\n\n**yColName** 是字符串，表示数据源中因变量的列名。\n\n**xColNames** 是字符串标量或向量，表示数据源中自变量的列名。\n\n**alpha** 是浮点数，表示乘以 L1 范数惩罚项的系数。默认值是1.0。\n\n**intercept** 是布尔值，表示是否回归模型包含截距。默认值为 true。\n\n**normalize** 是布尔值。默认值为 false。若设为 true，则所有自变量均会进行如下标准化：减去平均值，然后除以 L2 范数。若 *intercept* 为 false，该参数会被忽略。\n\n**maxIter** 是正整数，表示最大迭代次数。默认值是1000。\n\n**tolerance** 是浮点数，表示迭代中止的边界差值。默认值是0.0001。\n\n**positive** 是布尔值，表示是否强制系数为正数。默认值是 false。\n\n**swColName** 字符串，表示列名，必须为 *ds* 中存在的列名。如果未指定该参数，则所有样本的权重都默认为1；如果指定该参数，则将指定的列作为样本的权重。\n\n**checkInput** 布尔值，表示是否检查输入参数（*yColName*, *xColNames* 和 *swColName*）的合法性。\n\n* 若 *checkInput*=true（默认值），则会检查这些参数中是否存在无效值（NULL），若存在，则会报错；\n\n* 若 *checkInput*=false，则不检查无效值。\n\n**Note:** 强烈建议开启 *checkInput*，以检查输入参数的有效性。如果不开启 *checkInput*，则必须确保输入参数中不存在无效值，并且中间计算过程中不会产生无效值，否则可能得到一个无用的模型。\n\n#### 返回值\n\n一个字典，包含以下 key：\n\n* modelName：模型名称。\n* coefficients：模型的回归系数。\n* intercept：截距。\n* dual\\_gap：优化结束时的对偶间隙。\n* tolerance：迭代中止的边界差值。\n* iterations：迭代次数。\n* xColNames：数据源中自变量的列名。\n* predict：用于预测的函数。\n\n#### 例子\n\n```\ny = [225.720746,-76.195841,63.089878,139.44561,-65.548346,2.037451,22.403987,-0.678415,37.884102,37.308288];\nx0 = [2.240893,-0.854096,0.400157,1.454274,-0.977278,-0.205158,0.121675,-0.151357,0.333674,0.410599];\nx1 = [0.978738,0.313068,1.764052,0.144044,1.867558,1.494079,0.761038,0.950088,0.443863,-0.103219];\nt = table(y, x0, x1);\n\nlasso(t, `y, `x0`x1);\n```\n\n如果 t 是一个 DFS 表，则应使用数据源作为输入：\n\n```\nlasso(sqlDS(<select * from t>), `y, `x0`x1);\n```\n"
    },
    "lassoBasic": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/lassoBasic.html",
        "signatures": [
            {
                "full": "lassoBasic(Y, X, [mode=0], [alpha=1.0], [intercept=true], [normalize=false], [maxIter=1000], [tolerance=0.0001], [positive=false], [swColName], [checkInput=true])",
                "name": "lassoBasic",
                "parameters": [
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[mode=0]",
                        "name": "mode",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[alpha=1.0]",
                        "name": "alpha",
                        "optional": true,
                        "default": "1.0"
                    },
                    {
                        "full": "[intercept=true]",
                        "name": "intercept",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[normalize=false]",
                        "name": "normalize",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[maxIter=1000]",
                        "name": "maxIter",
                        "optional": true,
                        "default": "1000"
                    },
                    {
                        "full": "[tolerance=0.0001]",
                        "name": "tolerance",
                        "optional": true,
                        "default": "0.0001"
                    },
                    {
                        "full": "[positive=false]",
                        "name": "positive",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[swColName]",
                        "name": "swColName",
                        "optional": true
                    },
                    {
                        "full": "[checkInput=true]",
                        "name": "checkInput",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [lassoBasic](https://docs.dolphindb.cn/zh/funcs/l/lassoBasic.html)\n\n\n\n#### 语法\n\nlassoBasic(Y, X, \\[mode=0], \\[alpha=1.0], \\[intercept=true], \\[normalize=false], \\[maxIter=1000], \\[tolerance=0.0001], \\[positive=false], \\[swColName], \\[checkInput=true])\n\n#### 详情\n\n进行 lasso 回归估计。最小化以下目标函数：\n\n![lasso](https://docs.dolphindb.cn/zh/images/lasso.png)\n\n#### 参数\n\n**Y** 数值类型的向量，表示因变量。\n\n**X** 数值类型的向量/元组/矩阵/表，表示自变量。\n\n* 当 *X* 是向量/元组时，其长度必须等于 *Y* 的长度。\n\n* 当 *X* 是矩阵/表时，其行数必须等于 *Y* 的长度。\n\n**mode** 一个整数，可取以下 3 个值:\n\n* 0（默认值）: 输出一个系数估计向量\n\n* 1: 输出一个具有系数估计，标准差，t 统计量和 p 值的表\n\n* 2: 输出一个具有 ANOVA（方差分析）、RegressionStat（回归统计）、Cofficient（系数）和 Residual（残差）的字典，具体含义见下表：\n\n键 ANOVA 对应值：\n\n| Source of Variance | 自由度(Degree of freedom) | 平方和(Sum of Square) | 均方差(Mean of square) | F统计量          | Significance |\n| ------------------ | ---------------------- | ------------------ | ------------------- | ------------- | ------------ |\n| Regression（回归）     | 变量个数（p）                | 回归平方和（SSR）         | 回归均方差（MSR=SSR/R）    | MSR 对 MSE 的比值 | 显著性，即统计出的P值  |\n| Residual（残差）       | 残差自由度（n-p-1）           | 残差平方和（SSE）         | 残差均方差（MSE=MSE/E）    |               |              |\n| Total              | 样本自由度， 不包括常数项（n-1）     | 总离差平方和（SST）        |                     |               |              |\n\n键 RegressionStat 对应值：\n\n| item         | 统计值                                                              |\n| ------------ | ---------------------------------------------------------------- |\n| R2           | R 决定系数，描述回归曲线对真实数据点拟合程度的统计量。范围在 \\[0,1]之间，越接近1 ，说明对y的解释能力越强，拟合越好。 |\n| AdjustedR2   | 经自由度修正后的决定系数，通过样本数量与模型数量对 R-squared 进行修正。                        |\n| StdError     | 回归残差标准误差，残差经自由度修正后的标准差。                                          |\n| Observations | 观察样本个数。                                                          |\n\n键 Coefficient 对应值：\n\n| 元素       | 说明                |\n| -------- | ----------------- |\n| factor   | 自变量名称             |\n| beta     | 回归系数估计值           |\n| stdError | 回归系数标准误差。         |\n| tstat    | T 统计值，衡量系数的统计显著性。 |\n\n键 Residual 对应每一个预测值和实际值之间的残差。\n\n**alpha** 一个浮点数，表示乘以 L1 范数惩罚项的系数。默认值是1.0。\n\n**intercept** 布尔值，表示是否包含回归中的截距。默认值为 true，此时系统自动给 *X* 添加一列 “1” 以生成截距。\n\n**normalize** 布尔值，默认值为 false。若设为 true，则所有自变量均会进行如下标准化：减去平均值，然后除以 L2 范数。若 *intercept* 为 false，该参数会被忽略。\n\n**maxIter** 一个正整数，表示最大迭代次数。默认值是1000。\n\n**tolerance** 一个浮点数，表示迭代中止的边界差值。默认值是0.0001。\n\n**positive** 是布尔值，表示是否强制系数为正数。默认值是 false。\n\n**swColName** 字符串，表示列名，必须为 *X* 中存在的列名。如果未指定该参数，则所有样本的权重都默认为1；如果指定该参数，则将指定的列作为自变量的权重。\n\n**checkInput** 布尔值，表示是否检查输入参数（*Y* 和 *X*）的合法性。\n\n* 若 *checkInput*=true（默认值），则会检查参数中是否存在无效值（NULL），若存在，则会报错；\n\n* 若 *checkInput*=false，则不检查无效值。\n\n**Note:** 强烈建议开启 *checkInput*，以检查输入参数的有效性。如果不开启 *checkInput*，则必须确保输入参数中不存在无效值，并且中间计算过程中不会产生无效值，否则可能得到一个无用的模型。\n\n#### 返回值\n\n取决于 *mode* 参数的值。\n\n#### 例子\n\n```\nx1=1 3 5 7 11 16 23\nx2=2 8 11 34 56 54 100\ny=0.1 4.2 5.6 8.8 22.1 35.6 77.2;\nprint(lassoBasic(y, (x1,x2), mode = 0));\n// output\n[-9.133706333069543,2.535935196073186,0.189298948643987]\n\n\nprint(lassoBasic(y, (x1,x2), mode = 1));\n// output\nfactor    beta               stdError          tstat              pvalue           \n--------- ------------------ ----------------- ------------------ -----------------\nintercept -9.133706333069543 5.247492365971091 -1.740584968222107 0.156730846105191\nx1        2.535935196073186  1.835793667840723 1.38138356205138   0.239309472176311\nx2        0.189298948643987  0.410201227095842 0.461478260277749  0.66843504931137 \n\n\nprint(lassoBasic(y, (x1,x2), mode = 2));\n// output\nCoefficient->\nfactor    beta               stdError          tstat              pvalue           \n--------- ------------------ ----------------- ------------------ -----------------\nintercept -9.133706333069543 5.247492365971091 -1.740584968222107 0.156730846105191\nx1        2.535935196073186  1.835793667840723 1.38138356205138   0.239309472176311\nx2        0.189298948643987  0.410201227095842 0.461478260277749  0.66843504931137 \n\nRegressionStat->\nitem         statistics       \n------------ -----------------\nR2           0.931480447323074\nAdjustedR2   0.897220670984611\nStdError     8.195817208870076\nObservations 7                \n\nANOVA->\nBreakdown  DF SS                   MS                   F                  Significance     \n---------- -- -------------------- -------------------- ------------------ -----------------\nRegression 2  4165.242566095043912 2082.621283047521956 31.004574440904473 0.003672076469395\nResidual   4  268.685678884843582  67.171419721210895                                       \nTotal      6  4471.637142857141952                                                          \n\nResidual->\n[6.319173239708383,4.21150915569809,-0.028258082380245,-6.254004293338318,-7.262321947798779,-6.063400030876729,9.077301958987561]\n```\n"
    },
    "lassoCV": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/lassoCV.html",
        "signatures": [
            {
                "full": "lassoCV(ds, yColName, xColNames, [alphas=[0.01,0.1,1.0]], [intercept=true], [normalize=false], [maxIter=1000], [tolerance=0.0001], [positive=false], [swColName], [checkInput=true])",
                "name": "lassoCV",
                "parameters": [
                    {
                        "full": "ds",
                        "name": "ds"
                    },
                    {
                        "full": "yColName",
                        "name": "yColName"
                    },
                    {
                        "full": "xColNames",
                        "name": "xColNames"
                    },
                    {
                        "full": "[alphas=[0.01",
                        "name": "[alphas=[0.01"
                    },
                    {
                        "full": "0.1",
                        "name": "0.1"
                    },
                    {
                        "full": "1.0]]",
                        "name": "1.0]]"
                    },
                    {
                        "full": "[intercept=true]",
                        "name": "intercept",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[normalize=false]",
                        "name": "normalize",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[maxIter=1000]",
                        "name": "maxIter",
                        "optional": true,
                        "default": "1000"
                    },
                    {
                        "full": "[tolerance=0.0001]",
                        "name": "tolerance",
                        "optional": true,
                        "default": "0.0001"
                    },
                    {
                        "full": "[positive=false]",
                        "name": "positive",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[swColName]",
                        "name": "swColName",
                        "optional": true
                    },
                    {
                        "full": "[checkInput=true]",
                        "name": "checkInput",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [lassoCV](https://docs.dolphindb.cn/zh/funcs/l/lassoCV.html)\n\n#### 语法\n\nlassoCV(ds, yColName, xColNames, \\[alphas=\\[0.01,0.1,1.0]], \\[intercept=true], \\[normalize=false], \\[maxIter=1000], \\[tolerance=0.0001], \\[positive=false], \\[swColName], \\[checkInput=true])\n\n#### 详情\n\n使用五折交叉验证方法进行 lasso 回归估计，输出最优参数对应的模型。\n\n#### 参数\n\n**alphas** 是浮点型标量或向量，表示乘以 L1 范数惩罚项的系数。默认值是 \\[0.01, 0.1, 1.0]。\n\n**Note:** 除 *alphas* 参数外，其它参数都和 [lasso](https://docs.dolphindb.cn/zh/funcs/l/lasso.html) 的参数相同，参数描述可参考 [lasso](https://docs.dolphindb.cn/zh/funcs/l/lasso.html)。这里仅说明 *alphas* 参数。\n\n#### 返回值\n\n返回一个字典，包含以下 key：\n\n* modelName：模型名称。LassoCV 方法对应的模型名为 \"lassoCV\"。\n* coefficients：模型的回归系数。\n* intercept：截距。\n* dual\\_gap：优化结束时的对偶间隙。\n* tolerance：迭代中止的边界差值。\n* iterations：迭代次数。\n* xColNames：数据源中自变量的列名。\n* predict：用于预测的函数。\n* alpha：交叉验证选择的惩罚量。\n\n#### 例子\n\n```\ny = [225.720746,-76.195841,63.089878,139.44561,-65.548346,2.037451,22.403987,-0.678415,37.884102,37.308288]\nx0 = [2.240893,-0.854096,0.400157,1.454274,-0.977278,-0.205158,0.121675,-0.151357,0.333674,0.410599]\nx1 = [0.978738,0.313068,1.764052,0.144044,1.867558,1.494079,0.761038,0.950088,0.443863,-0.103219]\nt = table(y, x0, x1);\n\nlassoCV(t, `y, `x0`x1);\n```\n\n返回如下：\n\n```\ndual_gap->0.0009\nmodelName->lassoCV\nintercept->0.0313\nalpha->0.0100\ncoefficients->[94.4493,14.3045]\npredict->coordinateDescentPredict\nxColNames->[x0,x1]\ntolerance->0.0001\niterations->5\n```\n\n"
    },
    "last": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/last.html",
        "signatures": [
            {
                "full": "last(X)",
                "name": "last",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [last](https://docs.dolphindb.cn/zh/funcs/l/last.html)\n\n\n\n#### 语法\n\nlast(X)\n\n或\n\nlast X\n\n#### 详情\n\n返回向量的最后一个元素，或矩阵、表的最后一行。\n\n**Note:** 若向量的最后一个元素为 NULL，则返回 NULL。若要返回最后一个非 NULL 的元素，请使用 [lastNot](https://docs.dolphindb.cn/zh/funcs/l/lastNot.html) 函数。\n\n#### 参数\n\n**X** 可以是标量、向量、矩阵或表。\n\n#### 返回值\n\n* 如果 *X* 是一个标量/向量，返回一个标量。\n* 如果 *X* 是一个矩阵，返回一个向量。\n* 如果 *X* 是一张表，返回一张表。\n\n#### 例子\n\n```\nlast(`hello `world);\n```\n\n输出返回：world\n\n```\nlast(1..10);\n```\n\n输出返回：10\n\n```\nm = matrix(1 2 3, 4 5 6);\nm;\n```\n\n输出返回：\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 4  |\n| 2  | 5  |\n| 3  | 6  |\n\n```\nlast(m);\n```\n\n输出返回：\\[3,6]\n\n相关函数：[first](https://docs.dolphindb.cn/zh/funcs/f/first.html)\n"
    },
    "lastNot": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/lastNot.html",
        "signatures": [
            {
                "full": "lastNot(X, [k])",
                "name": "lastNot",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[k]",
                        "name": "k",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [lastNot](https://docs.dolphindb.cn/zh/funcs/l/lastNot.html)\n\n\n\n#### 语法\n\nlastNot(X, \\[k])\n\n#### 详情\n\n若 *X* 是向量：\n\n* 如果没有指定 *k*，返回 *X* 中最后一个不为 NULL 的元素。\n\n* 如果指定 *k*，返回 *X* 中最后一个不为 *k* 或 NULL 的元素。\n\n若 *X* 是矩阵或表，在每列内进行上述计算，返回一个向量。\n\n`lastNot` 函数也支持查询分布式表和分区表。\n\n#### 参数\n\n**X** 是向量、矩阵或表。\n\n**k** 是标量。它是一个可选参数。\n\n#### 返回值\n\n* 如果 *X* 是一个向量，返回一个标量。\n* 如果 *X* 是一个矩阵，返回一个向量。\n* 如果 *X* 是一张表，返回一张表。\n\n#### 例子\n\n```\nlastNot(1 6 0 0 0, 0);\n```\n\n输出返回：6\n\n```\nlastNot(1 6 0 0 0 2 3 0 NULL, 0);\n```\n\n输出返回：3\n\n```\nlastNot(1 6 0 0 0 2 3 0 NULL);\n```\n\n输出返回：0\n\n```\nt=table(1 1 1 1 1 2 2 2 2 2 as id, 1 2 0 0 0 3 NULL NULL 0 0 as x);\nt;\n```\n\n输出返回：\n\n| id | x  |\n| :- | :- |\n| 1  | 1  |\n| 1  | 2  |\n| 1  | 0  |\n| 1  | 0  |\n| 1  | 0  |\n| 2  | 3  |\n| 2  |    |\n| 2  |    |\n| 2  | 0  |\n| 2  | 0  |\n\n```\nselect lastNot(x, 0) from t group by id;\n```\n\n输出返回：\n\n| id | lastNot\\_x |\n| -- | ---------- |\n| 1  | 2          |\n| 2  | 3          |\n\n```\nm=matrix(2 NULL 1 0 NULL, NULL 2 NULL 6 0);\nm;\n```\n\n输出返回：\n\n| #0 | #1  |\n| :- | :-- |\n| 2  | 2   |\n| 1  |     |\n| 0  | 6 0 |\n\n```\nlastNot(m, 0);\n```\n\n输出返回：\\[1,6]\n"
    },
    "lastWeekOfMonth": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/lastWeekOfMonth.html",
        "signatures": [
            {
                "full": "lastWeekOfMonth(X, [weekday=0], [offset], [n=1])",
                "name": "lastWeekOfMonth",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[weekday=0]",
                        "name": "weekday",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[offset]",
                        "name": "offset",
                        "optional": true
                    },
                    {
                        "full": "[n=1]",
                        "name": "n",
                        "optional": true,
                        "default": "1"
                    }
                ]
            }
        ],
        "markdown": "### [lastWeekOfMonth](https://docs.dolphindb.cn/zh/funcs/l/lastWeekOfMonth.html)\n\n\n\n#### 语法\n\nlastWeekOfMonth(X, \\[weekday=0], \\[offset], \\[n=1])\n\n#### 详情\n\n返回 *X* 所在月份或上一个月份中最后一个 *weekday* 对应的日期。假设 *X* 所在月份的最后一个 *weekday* 对应日期为 d：\n\n* 如果 *X\\<d*，*lastWeekOfMonth* 函数返回 *X* 的上一个月中最后一个 *weekday* 对应的日期。\n\n* 如果 *X>=d*，*lastWeekOfMonth* 函数返回 *X* 所在月份的最后一个 *weekday* 对应的日期。\n\n如果指定了 *offset* 和 *n*，且 *n* > 1，则函数按长度为 *n* 个月的周期计算。此时，*offset* 用于确定多月周期的对齐方式：系统会先根据 *weekday* 计算出 *offset* 所在月份最后一个指定星期几对应的日期，然后以该日期为基准，每隔 *n* 个月更新一次结果，并返回 *X* 所属周期对应的目标日期。\n\n#### 参数\n\n**X** 可以是 DATE, DATETIME, DATEHOUR, TIMESTAMP 或 NANOTIMESTAMP 类型的标量或向量。\n\n**weekday** 是0到6之间的整数，表示星期编号。0表示星期一，1表示星期二，... ，6表示星期日。默认值为0。\n\n**offset** 是与 *X* 类型相同的标量，并且它必须小于等于 *X* 中的最小值。它是一个可选参数。如果没有指定，offset默认为 *X* 中的最小值。\n\n**n** 是一个正整数。它是一个可选参数，默认值为1。\n\n#### 返回值\n\nDATE 类型的标量或向量。\n\n#### 例子\n\n```\nlastWeekOfMonth(2019.11.24,2);\n// output: 2019.10.30\n// 2019年11月最后一个星期三为2019.11.27，2019.11.24在2019.11.27之前，因此返回2019年10月的最后一个星期三\n\nlastWeekOfMonth(2019.11.29,2);\n// output: 2019.11.27\n\ndate=2012.01.02 2012.02.03 2012.03.07 2012.04.08 2012.05.12 2012.06.16 2012.07.18 2012.08.20 2012.09.25 2012.10.28\ntime = [09:34:07,09:36:42,09:36:51,09:36:59,09:32:47,09:35:26,09:34:16,09:34:26,09:38:12,09:38:13]\nsym = take(`MSFT,10)\nprice= 49.6 29.46 29.52 30.02 174.97 175.23 50.76 50.32 51.29 52.38\nqty = 2200 1900 2100 3200 6800 5400 1300 2500 8800 4500\nt1 = table(date, time, sym, qty, price);\n\nselect avg(price),sum(qty) from t1 group by lastWeekOfMonth(date,4,2012.01.01,2);\n```\n\n| lastWeekOfMonth\\_date | avg\\_price | sum\\_qty |\n| --------------------- | ---------- | -------- |\n| 2011.12.30            | 39.53      | 4100     |\n| 2012.02.24            | 29.77      | 5300     |\n| 2012.04.27            | 175.1      | 12200    |\n| 2012.06.29            | 50.54      | 3800     |\n| 2012.08.31            | 51.29      | 8800     |\n| 2012.10.26            | 52.38      | 4500     |\n"
    },
    "latestIndexedTable": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/latestIndexedTable.html",
        "signatures": [
            {
                "full": "latestIndexedTable(keyColumns, timeColumn, [X1], [X2], .....)",
                "name": "latestIndexedTable",
                "parameters": [
                    {
                        "full": "keyColumns",
                        "name": "keyColumns"
                    },
                    {
                        "full": "timeColumn",
                        "name": "timeColumn"
                    },
                    {
                        "full": "[X1]",
                        "name": "X1",
                        "optional": true
                    },
                    {
                        "full": "[X2]",
                        "name": "X2",
                        "optional": true
                    },
                    {
                        "full": ".....",
                        "name": "....."
                    }
                ]
            },
            {
                "full": "latestIndexedTable(keyColumns, timeColumn, capacity:size, colNames, colTypes)",
                "name": "latestIndexedTable",
                "parameters": [
                    {
                        "full": "keyColumns",
                        "name": "keyColumns"
                    },
                    {
                        "full": "timeColumn",
                        "name": "timeColumn"
                    },
                    {
                        "full": "capacity:size",
                        "name": "capacity:size"
                    },
                    {
                        "full": "colNames",
                        "name": "colNames"
                    },
                    {
                        "full": "colTypes",
                        "name": "colTypes"
                    }
                ]
            },
            {
                "full": "latestIndexedTable(keyColumns, timeColumn, table)",
                "name": "latestIndexedTable",
                "parameters": [
                    {
                        "full": "keyColumns",
                        "name": "keyColumns"
                    },
                    {
                        "full": "timeColumn",
                        "name": "timeColumn"
                    },
                    {
                        "full": "table",
                        "name": "table"
                    }
                ]
            }
        ],
        "markdown": "### [latestIndexedTable](https://docs.dolphindb.cn/zh/funcs/l/latestIndexedTable.html)\n\n\n\n#### 语法\n\nlatestIndexedTable(keyColumns, timeColumn, \\[X1], \\[X2], .....)\n\n或\n\nlatestIndexedTable(keyColumns, timeColumn, capacity:size, colNames, colTypes)\n\n或\n\nlatestIndexedTable(keyColumns, timeColumn, table)\n\n#### 详情\n\n该函数用于创建索引内存表，包含一个主键。主键可由一个或多个字段组成。其相较于 indexedTable，除主键外，还包含一个时间列，用于判断是否更新记录。\n\n向表中添加新记录时，系统自动检查新记录的主键值。如果新记录的主键值与已有记录的主键值相同，且新记录的时间戳大于等于已有记录的时间戳，则更新表中对应的记录，否则不更新。因为在写入数据时会判断时间列，对相同主键的记录进行去重，所以`latestIndexedTable`写入性能较`indexedTable`差，但查询性能不受影响。\n\n**Note:**\n\n* 不允许对主键进行更新操作。\n\n优化查询 latestIndexedTable 的方法和相关案例请参照函数 indexedTable。\n\n#### 参数\n\n在 [indexedTable](https://docs.dolphindb.cn/zh/funcs/i/indexedTable.html) 的基础上，增加了 *timeColumn* 参数。\n\n**timeColumn** 字符串，表示时间列，可以为整型或时间类型。\n\n#### 返回值\n\n一张表。\n\n#### 例子\n\n例1. 创建索引表\n\n第一种写法：\n\n```\nsym=`A`B`C`D`E\nid=5 4 3 2 1\nval=52 64 25 48 71\ntimeCol = 2022.12.07T00:00:00.001+0..4\nt=latestIndexedTable(`sym`id,`timeCol,sym,id,timeCol,val)\nt;\n```\n\n输出返回：\n\n| sym | id | timeCol                 | val |\n| --- | -- | ----------------------- | --- |\n| A   | 5  | 2022.12.07T00:00:00.001 | 52  |\n| B   | 4  | 2022.12.07T00:00:00.002 | 64  |\n| C   | 3  | 2022.12.07T00:00:00.003 | 25  |\n| D   | 2  | 2022.12.07T00:00:00.004 | 48  |\n| E   | 1  | 2022.12.07T00:00:00.005 | 71  |\n\n第二种写法：\n\n```\nt=latestIndexedTable(`sym`id,`timeCol, 1:0,`sym`id`timeCol`val,[SYMBOL,INT,TIMESTAMP, INT])\ninsert into t values(`A`B`C`D`E,5 4 3 2 1,2022.12.07T00:00:00.001+0..4,52 64 25 48 71);\n```\n\n第三种写法：\n\n```\ntmp=table(sym, id, timeCol, val)\nt=latestIndexedTable(`sym`id, `timeCol, tmp);\n```\n\n例2. 更新内存表\n\n插入新记录，并且新记录中的主键值与表中主键值重复，根据时间列来确定保留哪条记录：\n\n```\ninsert into t values(`A`A`E,5 5 1, 2022.12.07T00:00:00.001 2022.12.07T00:00:00.007 2022.12.07T00:00:00.003, 44 66 28);\nt;\n```\n\n输出返回：\n\n| sym | id | timeCol                 | val |\n| --- | -- | ----------------------- | --- |\n| A   | 5  | 2022.12.07T00:00:00.007 | 66  |\n| B   | 4  | 2022.12.07T00:00:00.002 | 64  |\n| C   | 3  | 2022.12.07T00:00:00.003 | 25  |\n| D   | 2  | 2022.12.07T00:00:00.004 | 48  |\n| E   | 1  | 2022.12.07T00:00:00.005 | 71  |\n\n相关函数：[keyedTable](https://docs.dolphindb.cn/zh/funcs/k/keyedTable.html), [indexedTable](https://docs.dolphindb.cn/zh/funcs/i/indexedTable.html), [latestKeyedTable](https://docs.dolphindb.cn/zh/funcs/l/latestKeyedTable.html)\n"
    },
    "latestKeyedStreamTable": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/latestkeyedstreamtable.html",
        "signatures": [
            {
                "full": "latestKeyedStreamTable(keyColumns, timeColumn, [X1], [X2], .....)",
                "name": "latestKeyedStreamTable",
                "parameters": [
                    {
                        "full": "keyColumns",
                        "name": "keyColumns"
                    },
                    {
                        "full": "timeColumn",
                        "name": "timeColumn"
                    },
                    {
                        "full": "[X1]",
                        "name": "X1",
                        "optional": true
                    },
                    {
                        "full": "[X2]",
                        "name": "X2",
                        "optional": true
                    },
                    {
                        "full": ".....",
                        "name": "....."
                    }
                ]
            },
            {
                "full": "latestKeyedStreamTable(keyColumns, timeColumn, capacity:size, colNames, colTypes)",
                "name": "latestKeyedStreamTable",
                "parameters": [
                    {
                        "full": "keyColumns",
                        "name": "keyColumns"
                    },
                    {
                        "full": "timeColumn",
                        "name": "timeColumn"
                    },
                    {
                        "full": "capacity:size",
                        "name": "capacity:size"
                    },
                    {
                        "full": "colNames",
                        "name": "colNames"
                    },
                    {
                        "full": "colTypes",
                        "name": "colTypes"
                    }
                ]
            }
        ],
        "markdown": "### [latestKeyedStreamTable](https://docs.dolphindb.cn/zh/funcs/l/latestkeyedstreamtable.html)\n\n\n\n#### 语法\n\nlatestKeyedStreamTable(keyColumns, timeColumn, \\[X1], \\[X2], .....)\n\n或\n\nlatestKeyedStreamTable(keyColumns, timeColumn, capacity:size, colNames, colTypes)\n\n#### 详情\n\n创建一个键值流数据表，该表包含一个主键，且该主键不允许重复值。主键可由一个或多个字段组成。其相较于 keyedStreamTable，除主键外，还包含一个时间列，用于判断是否添加记录。\n\n向表中添加新记录时，系统会自动检查新记录的主键值：\n\n* 如果新记录的主键值与内存中已有记录的主键值相同，且新记录的时间戳大于已有记录的时间戳，则将新记录添加至表中，否则直接舍弃。\n\n* 一次性批量插入新记录时，若有多条记录具有相同的主键值，且该主键值与已有记录的主键值不同，只有时间戳最大的记录可以插入成功。\n\n#### 参数\n\n在 [keyedStreamTable](https://docs.dolphindb.cn/zh/funcs/k/keyedStreamTable.html) 的基础上，增加了 *timeColumn* 参数。\n\n**timeColumn** 字符串标量或长度为 2 的向量，分别用于指定 1 个或 2 个时间列。当仅指定 1 个时间列时，该列可以为整型或时间类型；当指定 2 个时间列时，第 1 列必须是 DATE 类型，第 2 列则是 TIME, SECOND 或 NANOTIME 类型。通过这两列，可以共同确定唯一的时间值。\n\n#### 返回值\n\n一张表。\n\n#### 例子\n\n例1. 主键为 1 个字段\n\n第一种写法：\n\n```\nid = `A`B`C`D`E\nx = 1 2 3 4 5\ntimeCol = 2024.09.10T00:00:00.001+0..4\nt1 = latestKeyedStreamTable(`id, `timeCol, id, x, timeCol)\nt1;\n```\n\n<table id=\"table_p5k_xlw_bdc\"><thead><tr><th>\n\nid\n\n</th><th>\n\nx\n\n</th><th>\n\ntimeCol\n\n</th></tr></thead><tbody><tr><td>\n\nA\n\n</td><td>\n\n1\n\n</td><td>\n\n2024.09.10T00:00:00.001\n\n</td></tr><tr><td>\n\nB\n\n</td><td>\n\n2\n\n</td><td>\n\n2024.09.10T00:00:00.002\n\n</td></tr><tr><td>\n\nC\n\n</td><td>\n\n3\n\n</td><td>\n\n2024.09.10T00:00:00.003\n\n</td></tr><tr><td>\n\nD\n\n</td><td>\n\n4\n\n</td><td>\n\n2024.09.10T00:00:00.004\n\n</td></tr><tr><td>\n\nE\n\n</td><td>\n\n5\n\n</td><td>\n\n2024.09.10T00:00:00.005\n\n</td></tr></tbody>\n</table>第二种写法：\n\n```\nt2=latestKeyedStreamTable(`id, `timeCol, 100:0, `id`x`timeCol, [INT,INT,TIMESTAMP])\ninsert into t2 values(1 2 3, 10 20 30, [2024.09.10T00:00:00.001,\n2024.09.10T00:00:00.002, 2024.09.10T00:00:00.003])\n\nt2\n```\n\n<table id=\"table_u5k_xlw_bdc\"><thead><tr><th>\n\nid\n\n</th><th>\n\nx\n\n</th><th>\n\ntimeCol\n\n</th></tr></thead><tbody><tr><td>\n\n1\n\n</td><td>\n\n10\n\n</td><td>\n\n2024.09.10T00:00:00.001\n\n</td></tr><tr><td>\n\n2\n\n</td><td>\n\n20\n\n</td><td>\n\n2024.09.10T00:00:00.002\n\n</td></tr><tr><td>\n\n3\n\n</td><td>\n\n30\n\n</td><td>\n\n2024.09.10T00:00:00.003\n\n</td></tr></tbody>\n</table>向表 t1 中插入新记录，并且新记录中的主键值与表中主键值相同时，将根据 *timeColumn* 来确定是否插入新记录：\n\n```\ninsert into t1 values(`D`E`F, 6 7 8, [2024.09.10T00:00:00.005,\n 2024.09.10T00:00:00.005, 2024.09.10T00:00:00.005])\nt1\n```\n\n<table id=\"table_uyx_1mw_bdc\"><thead><tr><th>\n\nid\n\n</th><th>\n\nx\n\n</th><th>\n\ntimeCol\n\n</th></tr></thead><tbody><tr><td>\n\nA\n\n</td><td>\n\n1\n\n</td><td>\n\n2024.09.10T00:00:00.001\n\n</td></tr><tr><td>\n\nB\n\n</td><td>\n\n2\n\n</td><td>\n\n2024.09.10T00:00:00.002\n\n</td></tr><tr><td>\n\nC\n\n</td><td>\n\n3\n\n</td><td>\n\n2024.09.10T00:00:00.003\n\n</td></tr><tr><td>\n\nD\n\n</td><td>\n\n4\n\n</td><td>\n\n2024.09.10T00:00:00.004\n\n</td></tr><tr><td>\n\nE\n\n</td><td>\n\n5\n\n</td><td>\n\n2024.09.10T00:00:00.005\n\n</td></tr><tr><td>\n\nD\n\n</td><td>\n\n6\n\n</td><td>\n\n2024.09.10T00:00:00.005\n\n</td></tr><tr><td>\n\nF\n\n</td><td>\n\n8\n\n</td><td>\n\n2024.09.10T00:00:00.005\n\n</td></tr></tbody>\n</table>可以看到，新插入了 id=\\`D 和 id=\\`F 的记录，而 id=\\`E 的记录被丢弃了。新增的 id 为 D 的记录因为时间戳大于已存在的 id 为 D 的记录，所以插入成功；id 为 E 的记录因为时间戳等于已有的 id 为 E 的记录，所以被舍弃；因为已有记录中没有 id 为 F 的记录，所以它被成功插入。\n\n例2. 主键为多个字段\n\n```\nt3 = latestKeyedStreamTable(`id`x, `timeCol, id, x, timeCol)\ninsert into t3 values(`D`E, 4 5, [2024.09.10T00:00:00.004, 2024.09.10T00:00:00.005])\ninsert into t3 values(`D`F, 6 7, [2024.09.10T00:00:00.004, 2024.09.10T00:00:00.005])\nt3\n```\n\n<table id=\"table_bfb_dmw_bdc\"><thead><tr><th>\n\nid\n\n</th><th>\n\nx\n\n</th><th>\n\ntimeCol\n\n</th></tr></thead><tbody><tr><td>\n\nA\n\n</td><td>\n\n1\n\n</td><td>\n\n2024.09.10T00:00:00.001\n\n</td></tr><tr><td>\n\nB\n\n</td><td>\n\n2\n\n</td><td>\n\n2024.09.10T00:00:00.002\n\n</td></tr><tr><td>\n\nC\n\n</td><td>\n\n3\n\n</td><td>\n\n2024.09.10T00:00:00.003\n\n</td></tr><tr><td>\n\nD\n\n</td><td>\n\n4\n\n</td><td>\n\n2024.09.10T00:00:00.004\n\n</td></tr><tr><td>\n\nE\n\n</td><td>\n\n5\n\n</td><td>\n\n2024.09.10T00:00:00.005\n\n</td></tr><tr><td>\n\nD\n\n</td><td>\n\n6\n\n</td><td>\n\n2024.09.10T00:00:00.004\n\n</td></tr><tr><td>\n\nF\n\n</td><td>\n\n7\n\n</td><td>\n\n2024.09.10T00:00:00.005\n\n</td></tr></tbody>\n</table>例3. 时间列指定为两列\n\n```\nid = `A`B`C`D`E\ndateCol = take(2024.09.10, 5)\ntimeCol = 00:00:00.001+0..4\nt4 = latestKeyedStreamTable(`id, `dateCol`timeCol, id, x, dateCol, timeCol)\nt4\n```\n\n<table id=\"table_s3f_fmw_bdc\"><thead><tr><th>\n\nid\n\n</th><th>\n\nx\n\n</th><th>\n\ndateCol\n\n</th><th>\n\ntimeCol\n\n</th></tr></thead><tbody><tr><td>\n\nA\n\n</td><td>\n\n1\n\n</td><td>\n\n2024.09.10\n\n</td><td>\n\n00:00:00.001\n\n</td></tr><tr><td>\n\nB\n\n</td><td>\n\n2\n\n</td><td>\n\n2024.09.10\n\n</td><td>\n\n00:00:00.002\n\n</td></tr><tr><td>\n\nC\n\n</td><td>\n\n3\n\n</td><td>\n\n2024.09.10\n\n</td><td>\n\n00:00:00.003\n\n</td></tr><tr><td>\n\nD\n\n</td><td>\n\n4\n\n</td><td>\n\n2024.09.10\n\n</td><td>\n\n00:00:00.004\n\n</td></tr><tr><td>\n\nE\n\n</td><td>\n\n5\n\n</td><td>\n\n2024.09.10\n\n</td><td>\n\n00:00:00.005\n\n</td></tr></tbody>\n</table>向表 t4 中插入新记录，并且新记录中的主键值与表中主键值相同时，将根据`concatDateTime(dateCol, timeCol)` 的值来确定是否插入新记录：\n\n```\ninsert into t4 values(`D`E, 4 5, [2024.09.10,  2024.09.11], [00:00:00.004, 00:00:00.005]);\nt4\n```\n\n<table id=\"table_j3v_hmw_bdc\"><thead><tr><th>\n\nid\n\n</th><th>\n\nx\n\n</th><th>\n\ndateCol\n\n</th><th>\n\ntimeCol\n\n</th></tr></thead><tbody><tr><td>\n\nA\n\n</td><td>\n\n1\n\n</td><td>\n\n2024.09.10\n\n</td><td>\n\n00:00:00.001\n\n</td></tr><tr><td>\n\nB\n\n</td><td>\n\n2\n\n</td><td>\n\n2024.09.10\n\n</td><td>\n\n00:00:00.002\n\n</td></tr><tr><td>\n\nC\n\n</td><td>\n\n3\n\n</td><td>\n\n2024.09.10\n\n</td><td>\n\n00:00:00.003\n\n</td></tr><tr><td>\n\nD\n\n</td><td>\n\n4\n\n</td><td>\n\n2024.09.10\n\n</td><td>\n\n00:00:00.004\n\n</td></tr><tr><td>\n\nE\n\n</td><td>\n\n5\n\n</td><td>\n\n2024.09.10\n\n</td><td>\n\n00:00:00.005\n\n</td></tr><tr><td>\n\nE\n\n</td><td>\n\n5\n\n</td><td>\n\n2024.09.11\n\n</td><td>\n\n00:00:00.005\n\n</td></tr></tbody>\n</table>\n"
    },
    "latestKeyedTable": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/latestKeyedTable.html",
        "signatures": [
            {
                "full": "latestKeyedTable(keyColumns, timeColumn, [X1], [X2], .....)",
                "name": "latestKeyedTable",
                "parameters": [
                    {
                        "full": "keyColumns",
                        "name": "keyColumns"
                    },
                    {
                        "full": "timeColumn",
                        "name": "timeColumn"
                    },
                    {
                        "full": "[X1]",
                        "name": "X1",
                        "optional": true
                    },
                    {
                        "full": "[X2]",
                        "name": "X2",
                        "optional": true
                    },
                    {
                        "full": ".....",
                        "name": "....."
                    }
                ]
            },
            {
                "full": "latestKeyedTable(keyColumns, timeColumn, capacity:size, colNames, colTypes)",
                "name": "latestKeyedTable",
                "parameters": [
                    {
                        "full": "keyColumns",
                        "name": "keyColumns"
                    },
                    {
                        "full": "timeColumn",
                        "name": "timeColumn"
                    },
                    {
                        "full": "capacity:size",
                        "name": "capacity:size"
                    },
                    {
                        "full": "colNames",
                        "name": "colNames"
                    },
                    {
                        "full": "colTypes",
                        "name": "colTypes"
                    }
                ]
            },
            {
                "full": "latestKeyedTable(keyColumns, timeColumn, table)",
                "name": "latestKeyedTable",
                "parameters": [
                    {
                        "full": "keyColumns",
                        "name": "keyColumns"
                    },
                    {
                        "full": "timeColumn",
                        "name": "timeColumn"
                    },
                    {
                        "full": "table",
                        "name": "table"
                    }
                ]
            }
        ],
        "markdown": "### [latestKeyedTable](https://docs.dolphindb.cn/zh/funcs/l/latestKeyedTable.html)\n\n\n\n#### 语法\n\nlatestKeyedTable(keyColumns, timeColumn, \\[X1], \\[X2], .....)\n\n或\n\nlatestKeyedTable(keyColumns, timeColumn, capacity:size, colNames, colTypes)\n\n或\n\nlatestKeyedTable(keyColumns, timeColumn, table)\n\n#### 详情\n\n该函数用于创建键值内存表，包含一个主键。主键可由一个或多个字段组成。其相较于 keyedTable，除主键外，还包含一个时间列，用于判断是否更新记录。\n\n向表中添加新记录时，系统自动检查新记录的主键值。如果新记录的主键值与已有记录的主键值相同，且新记录的时间戳大于等于已有记录的时间戳，则更新表中对应的记录，否则不更新。因为在写入数据时会判断时间列，对相同主键的记录进行去重，所以`latestKeyedTable`写入性能较`keyedTable`差，但查询性能不受影响。\n\n**Note:**\n\n* 不允许对主键进行修改（update, replaceColumn!）和删除（alter, dropColumns!）操作。\n\n优化查询 latestKeyedTable 的方法和相关案例请参照函数 keyedTable。\n\n#### 参数\n\n在 [keyedTable](https://docs.dolphindb.cn/zh/funcs/k/keyedTable.html) 的基础上，增加了 *timeColumn* 参数。\n\n**timeColumn** 字符串，表示时间列，可以为整型或时间类型。\n\n#### 返回值\n\n一张表。\n\n#### 例子\n\n例1. 创建键值表\n\n第一种写法：\n\n```\nsym=`A`B`C`D`E\nid=5 4 3 2 1\nval=52 64 25 48 71\ntimeCol = 2022.12.07T00:00:00.001+0..4\nt=latestKeyedTable(`sym`id,`timeCol,sym,id,timeCol,val)\nt;\n```\n\n输出返回：\n\n| sym | id | timeCol                 | val |\n| --- | -- | ----------------------- | --- |\n| A   | 5  | 2022.12.07T00:00:00.001 | 52  |\n| B   | 4  | 2022.12.07T00:00:00.002 | 64  |\n| C   | 3  | 2022.12.07T00:00:00.003 | 25  |\n| D   | 2  | 2022.12.07T00:00:00.004 | 48  |\n| E   | 1  | 2022.12.07T00:00:00.005 | 71  |\n\n第二种写法：\n\n```\nt=latestKeyedTable(`sym`id,`timeCol, 1:0,`sym`id`timeCol`val,[SYMBOL,INT,TIMESTAMP, INT])\ninsert into t values(`A`B`C`D`E,5 4 3 2 1,2022.12.07T00:00:00.001+0..4,52 64 25 48 71);\n```\n\n第三种写法：\n\n```\ntmp=table(sym, id, timeCol, val)\nt=latestKeyedTable(`sym`id, `timeCol, tmp);\n```\n\n例2. 更新键值表\n\n插入新记录，并且新记录中的主键值与表中主键值重复，根据时间列来确定保留哪条记录：\n\n```\ninsert into t values(`A`A`E,5 5 1, 2022.12.07T00:00:00.001 2022.12.07T00:00:00.007 2022.12.07T00:00:00.003, 44 66 28);\nt;\n```\n\n输出返回：\n\n| sym | id | timeCol                 | val |\n| --- | -- | ----------------------- | --- |\n| A   | 5  | 2022.12.07T00:00:00.007 | 66  |\n| B   | 4  | 2022.12.07T00:00:00.002 | 64  |\n| C   | 3  | 2022.12.07T00:00:00.003 | 25  |\n| D   | 2  | 2022.12.07T00:00:00.004 | 48  |\n| E   | 1  | 2022.12.07T00:00:00.005 | 71  |\n\n相关函数：[keyedTable](https://docs.dolphindb.cn/zh/funcs/k/keyedTable.html), [indexedTable](https://docs.dolphindb.cn/zh/funcs/i/indexedTable.html), [latestIndexedTable](https://docs.dolphindb.cn/zh/funcs/l/latestIndexedTable.html)\n"
    },
    "le": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/le.html",
        "signatures": [
            {
                "full": "le(X, Y)",
                "name": "le",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [le](https://docs.dolphindb.cn/zh/funcs/l/le.html)\n\n\n\n#### 语法\n\nle(X, Y) 或 X<=Y\n\n#### 详情\n\n如果 *X* 和 *Y* 都不是集合，返回逐个元素比较 *X*<=*Y* 的结果。\n\n如果 *X* 和 *Y* 都是集合，则检查 *X* 是否为 *Y* 的子集。\n\n#### 参数\n\n**X** 和 **Y** 可以是标量、数据对、向量、矩阵或集合。如果 *X* 或 *Y* 的其中一个是数据对、向量或矩阵，另一个必须是一个标量，或具有相同长度或维度的数据对、向量或矩阵。\n\n#### 返回值\n\n一个布尔值标量/向量/矩阵。\n\n#### 例子\n\n```\n1 2 3 <= 2;\n// output\n[true,true,false]\n\n1 2 3<=0 2 4;\n// output\n[false,true,true]\n\n2:3<=1:6;\n// output\n[false,true]\n\nm1=1..6$2:3;\nm1;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1  | 3  | 5  |\n| 2  | 4  | 6  |\n\n```\nm1 le 4;\n```\n\n| #0   | #1   | #2    |\n| ---- | ---- | ----- |\n| true | true | false |\n| true | true | false |\n\n```\nm2=6..1$2:3;\nm2;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 6  | 4  | 2  |\n| 5  | 3  | 1  |\n\n```\nm1<=m2;\n```\n\n| #0   | #1    | #2    |\n| ---- | ----- | ----- |\n| true | true  | false |\n| true | false | false |\n\n集合操作：如果 *X*<*Y*，则 *X* 是 *Y* 的子集。\n\n```\nx=set(4 6);\ny=set(4 6 8);\n\nx<=y;\n// output\ntrue\nx<=x;\n// output\ntue\n```\n"
    },
    "left": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/left.html",
        "signatures": [
            {
                "full": "left(X,n)",
                "name": "left",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "n",
                        "name": "n"
                    }
                ]
            }
        ],
        "markdown": "### [left](https://docs.dolphindb.cn/zh/funcs/l/left.html)\n\n\n\n#### 语法\n\nleft(X,n)\n\n#### 详情\n\n返回 *X* 左边 *n* 个字符。\n\n当 *X* 是表时，函数仅作用于其中字符串列，其他类型的列将被忽略。\n\n#### 参数\n\n**X** 是字符串类型的标量、向量，或表。\n\n**n** 必须是一个非负整数。\n\n#### 返回值\n\n返回值的类型和形式与 *X* 保持一致。\n\n#### 例子\n\n返回左边的6个字符（包含空格）。\n\n```\nleft(\"I love this game!\", 6);\n// output\nI love\n```\n"
    },
    "lfill": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/lfill.html",
        "signatures": [
            {
                "full": "lfill(obj)",
                "name": "lfill",
                "parameters": [
                    {
                        "full": "obj",
                        "name": "obj"
                    }
                ]
            }
        ],
        "markdown": "### [lfill](https://docs.dolphindb.cn/zh/funcs/l/lfill.html)\n\n\n\n#### 语法\n\nlfill(obj)\n\n#### 详情\n\n* 如果 *obj* 是向量，线性填充两个非空元素之间的 NULL值。\n\n* 如果 *obj* 是表，对于表中的每一列，线性填充两个非空元素之间的 NULL 值。\n\n`lfill` 不会改变向量的值，[lfill!](https://docs.dolphindb.cn/zh/funcs/l/lfill_.html) 会改变向量的值。\n\n#### 参数\n\n**obj** 是数值型向量或只包含数值类型的表。\n\n#### 返回值\n\n返回值的类型和形式与 *obj* 保持一致。\n\n#### 例子\n\n```\na= NULL 1.5 NULL NULL 4.5\na.lfill();\n// output\n[NULL,1.5,2.5,3.5,4.5]\n\nb=1 NULL NULL 6\nb.lfill();\n// output\n[1,3,4,6]\n\nt=table(1 NULL NULL 4 5 6 as id,2.1 2.2 NULL NULL 2.4 2.6 as val);\nselect * from lfill(t);\n```\n\n| id | val      |\n| -- | -------- |\n| 1  | 2.1      |\n| 2  | 2.2      |\n| 3  | 2.266667 |\n| 4  | 2.333333 |\n| 5  | 2.4      |\n| 6  | 2.6      |\n\n相关函数：[bfill](https://docs.dolphindb.cn/zh/funcs/b/bfill.html), [bfill!](https://docs.dolphindb.cn/zh/funcs/b/bfill_.html), [lfill!](https://docs.dolphindb.cn/zh/funcs/l/lfill_.html)\n"
    },
    "lfill!": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/lfill_.html",
        "signatures": [
            {
                "full": "lfill!(obj)",
                "name": "lfill!",
                "parameters": [
                    {
                        "full": "obj",
                        "name": "obj"
                    }
                ]
            }
        ],
        "markdown": "### [lfill!](https://docs.dolphindb.cn/zh/funcs/l/lfill_.html)\n\n\n\n#### 语法\n\nlfill!(obj)\n\n#### 详情\n\n* 如果 *obj* 是向量，线性填充两个非空元素之间的 NULL 值。\n\n* 如果 *obj* 是表，对于表中的每一列，线性填充两个非空元素之间的 NULL 值。\n\n#### 参数\n\n**obj** 是数值型向量或只包含数值类型的表。\n\n#### 返回值\n\n返回值的类型和形式与 *obj* 保持一致。\n\n#### 例子\n\n```\na= NULL 1.5 NULL NULL 4.5\na.lfill!()\na;\n// output\n[NULL,1.5,2.5,3.5,4.5]\n\nb=1 NULL NULL 6\nb.lfill!()\nb;\n// output\n[1,3,4,6]\n\nt=table(1 NULL NULL 4 5 6 as id,2.1 2.2 NULL NULL 2.4 2.6 as val);\nlfill!(t);\nt;\n```\n\n| id | val      |\n| -- | -------- |\n| 1  | 2.1      |\n| 2  | 2.2      |\n| 3  | 2.266667 |\n| 4  | 2.333333 |\n| 5  | 2.4      |\n| 6  | 2.6      |\n\n相关函数：[bfill](https://docs.dolphindb.cn/zh/funcs/b/bfill.html), [bfill!](https://docs.dolphindb.cn/zh/funcs/b/bfill_.html), [lfill](https://docs.dolphindb.cn/zh/funcs/l/lfill.html)\n"
    },
    "license": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/license.html",
        "signatures": [
            {
                "full": "license([fileName], [pubKeyFile], [read=false])",
                "name": "license",
                "parameters": [
                    {
                        "full": "[fileName]",
                        "name": "fileName",
                        "optional": true
                    },
                    {
                        "full": "[pubKeyFile]",
                        "name": "pubKeyFile",
                        "optional": true
                    },
                    {
                        "full": "[read=false]",
                        "name": "read",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [license](https://docs.dolphindb.cn/zh/funcs/l/license.html)\n\n\n\n#### 语法\n\nlicense(\\[fileName], \\[pubKeyFile], \\[read=false])\n\n#### 详情\n\n显示 DolphinDB 的许可证信息。\n\n**Note:** 若不指定 *fileName*，则默认读取保存在内存中的 license 信息\n\n#### 参数\n\n**fileName** 可选参数。需要指定的 license 文件的路径。\n\n**pubKeyFile** 可选参数。需要指定的公钥文件的路径。\n\n**read** 可选参数。布尔值，表示是否关闭对 license 文件的校检功能。默认值为 false，表示进行校检。\n\n#### 返回值\n\n一个字典，包含以下 Key：\n\n| Key              | 含义                                                                                                                                                          |\n| ---------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| authorization    | 授权的类型：trial（试用版）/test（测试版）/commercial（商业版）。                                                                                                                 |\n| licenseType      | 许可证验证类型，有以下可选值：1：机器指纹绑定；2：在线验证；3：license server；0：其他方式                                                                                                      |\n| maxMemoryPerNode | 每个节点的内存上限，单位为 GB。                                                                                                                                           |\n| bindCores        | 进程绑定的 CPU 内核的编号（从0开始）。注意，仅当 bindCPU 为 true 时有效。                                                                                                             |\n| maxCoresPerNode  | 每个节点允许最大 CPU 核数。                                                                                                                                            |\n| clientName       | 客户名称。                                                                                                                                                       |\n| port             | 为节点绑定的端口号。仅 License Server 和连接它的节点会返回此字段。                                                                                                                   |\n| bindCPU          | 进程是否绑定 CPU。                                                                                                                                                 |\n| expiration       | 许可证到期时间。                                                                                                                                                    |\n| maxNodes         | 集群允许的最大节点数。                                                                                                                                                 |\n| version          | server 的版本号。用户只能使用不高于 version 版本的 server。若为空，则对版本没有限制。                                                                                                      |\n| modules          | 可用模块的编码。若为 13 则表示支持所有模块；若为 -1 则表示不支持任何模块。                                                                                                                   |\n| moduleNames      | 与 *modules* 有关，返回具体的模块名。目前支持返回：orderbook, internalFunction, cep, gpu, starfish, PowerTrading,Beluga, Backtest, MatchingEngineSimulator, starfishAI。社区版返回为空。 |\n| productKey       | 当前产品类型。目前支持返回：DOLPHIN, IOTBASIC, IOTPRO, SHARK, SWORDFISH, ORCA, DOLPHINX。                                                                                  |\n\n#### 例子\n\n```\nlicense();\n```\n\n返回：\n\n```\nclientName->internal\nbindCPU->true\nmaxNodes->128\nmoduleNames-> orderbook internalFunction cep gpu\nproductKey->DOLPHIN\nversion->3.10\nmodules->15\nauthorization->trial\nmaxMemoryPerNode->512\nlicenseType->0\nbindCores->\nmaxCoresPerNode->128\nport->0\nexpiration->2024.09.30\n```\n"
    },
    "like": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/like.html",
        "signatures": [
            {
                "full": "like(X, pattern)",
                "name": "like",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "pattern",
                        "name": "pattern"
                    }
                ]
            }
        ],
        "markdown": "### [like](https://docs.dolphindb.cn/zh/funcs/l/like.html)\n\n\n\n#### 语法\n\nlike(X, pattern)\n\n#### 详情\n\n确定 *X* 是否与 *Pattern* 指定的模式相匹配。比较操作是区分大小写的。\n\n#### 参数\n\n**X** 可以是字符串类型的标量/向量。\n\n**pattern** 是一个字符串，通常包含通配符（例如 \"%\"）。\n\n#### 返回值\n\n一个布尔值标量或向量。\n\n#### 例子\n\n```\nlike(`ABCDEFG, `DE);\n// output\nfalse\n\nlike(`ABCDEFG, \"%DE%\");\n// output\ntrue\n\n\na=`IBM`ibm`MSFT`Goog`YHOO`ORCL;\nlike(a, \"%OO%\");\n// output\n[false,false,false,false,true,false]\na[like(a, \"%OO%\")];\n// output\n[\"YHOO\"]\n```\n\n`like` 可以搭配 `select` 使用，用于筛选字符串类型的列的范围：\n\n```\nt = table(`abb`aac`aaa as sym, 1.8 2.3 3.7 as price);\nselect * from t where sym like \"%aa%\";\n```\n\n| sym | price |\n| --- | ----- |\n| aac | 2.3   |\n| aaa | 3.7   |\n\n相关函数：[ilike](https://docs.dolphindb.cn/zh/funcs/i/ilike.html)\n"
    },
    "linearInterpolateFit": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/linearinterpolatefit.html",
        "signatures": [
            {
                "full": "linearInterpolateFit(X, Y, [fillValue], [sorted=false])",
                "name": "linearInterpolateFit",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "[fillValue]",
                        "name": "fillValue",
                        "optional": true
                    },
                    {
                        "full": "[sorted=false]",
                        "name": "sorted",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [linearInterpolateFit](https://docs.dolphindb.cn/zh/funcs/l/linearinterpolatefit.html)\n\n\n\n#### 语法\n\nlinearInterpolateFit(X, Y, \\[fillValue], \\[sorted=false])\n\n#### 详情\n\n为一组点集进行线性插值，支持内插（interpolate）和外插（extrapolate）两种模式。内插用于估计已知数据点之间的未知值，而外插则用于估计已知数据点范围之外的未知值。\n\n#### 参数\n\n**X**数值向量，表示用于插值的点的 x 坐标。注意：\n\n* X 的长度至少为 2，即至少需要两个已知数据点才能进行插值。\n\n* X中的值必须是唯一的且不可包含 NULL 值。\n\n**Y** 数值向量，表示用于插值的点的 y 坐标。注意：*Y* 和 *X* 的长度必须一致，且不包含 NULL 值。\n\n**fillValue** 可选参数，表示位于已知数据点范围之外的预测数据的赋值方式。支持以下两种方式：\n\n* 形如 `(below, above)` 的数值类型数据对，below 和 above 分别表示当预测数据小于 X 的最小值或大于 X 的最大值时的赋值。具体含义如下，Xmin 和 Xmax 分别表示输入参数 *X* 向量中的最小值和最大值。\n\n  * 当预测数据 Xnew < Xmin，将其赋值为 below；\n\n  * 当预测数据 Xnew > Xmax，将其赋值为 above。\n\n* 字符串 “extrapolate”，表示进行外插赋值，为默认值。\n\n**sorted** 可选参数，布尔值标量，表示输入参数 X 是否有序递增。\n\n* 如果为 true，则 *X* 必须是递增序列。\n\n* 如果为 false，函数内部会对 *X* 进行排序，并相应调整 *Y* 的顺序。默认为 false。\n\n#### 返回值\n\n一个字典，包含以下 key：\n\n* modelName：字符串类型，表示模型名称，值为 “linearInterpolate”。\n\n* sortedX：Double 类型向量，表示对输入 *X* 进行升序排序后的向量。\n\n* sortedY：Double 类型向量，表示与 *sortedX* 所对应的 y 值。\n\n* fillValue：表示外插方式，即输入的 *fillValue* 参数值。\n\n* predict：模型的预测函数，`predict` 函数将返回在新 X 点处的线性插值结果。可通过 `model.predict(X)` 或 `predict(model, X)` 进行调用。其中：\n\n  * model：字典类型，即 `linearInterpolateFit` 的输出。\n\n  * X： 数值向量，表示需要求值的点的 x 坐标。\n\n#### 例子\n\n通过自定义函数 linspace 创建一组点集，对其进行线性插值。\n\n```\ndef linspace(start, end, num, endpoint=true){\n\tif(endpoint) return end$DOUBLE\\(num-1), start + end$DOUBLE\\(num-1)*0..(num-1)\n\telse return start + (end-start)$DOUBLE\\(num)*0..(num-1)\t\n}\nx = 0..9\ny = exp(-x/3.0)\nmodel = linearInterpolateFit(x, y, sorted=true)\n\n/*Output\nsortedX->[0.0,1.000000000000,2.000000000000,3.000000000000,4.000000000000,5.000000000000,6.000000000000,7.000000000000,8.000000000000,9.000000000000]\nmodelName->linearInterpolate\npredict->linearInterpolatePredict\nfillValue->extrapolate\nsortedY->[1.000000000000,0.716531310573,0.513417119032,0.367879441171,0.263597138115,0.188875602837,0.135335283236,0.096971967864,0.069483451222,0.049787068367]\n*/\n\n// 使用新 X 值进行预测  \nxnew = linspace(0,9,15,false)\nmodel.predict(xnew)\n\n//Output：[1,0.829918786344274,0.67590847226555,0.554039957340832,0.455202047888132,0.367879441171442,0.305310059338013,0.248652831060094,0.203819909893195,0.167459474997182,0.135335283236613,0.112317294013288,0.091474264536084,0.074981154551122,0.061604898080826]\n```\n"
    },
    "linearTimeTrend": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/linearTimeTrend.html",
        "signatures": [
            {
                "full": "linearTimeTrend(X, window)",
                "name": "linearTimeTrend",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    }
                ]
            }
        ],
        "markdown": "### [linearTimeTrend](https://docs.dolphindb.cn/zh/funcs/l/linearTimeTrend.html)\n\n\n\n#### 语法\n\nlinearTimeTrend(X, window)\n\nTA-lib 系列函数参数说明和窗口计算规则请参考: [TA-lib 系列](https://docs.dolphindb.cn/zh/funcs/themes/TAlib.html)\n\n#### 详情\n\n基于数据 *X* 中的每个元素，向前选取 *window* 指定范围的窗口计算线性回归。\n\n当 X 中存在空值时：\n\n* 第一个非空元素之前的空值将遵循 TA-lib 系列的处理规则，即被忽略，并保留到结果中；\n* 第一个非空元素之后的空值将按 0 处理。\n\n#### 返回值\n\n一个元组，包含两个元素 alpha 和 beta，对应 talib 中的 linearreg\\_intercept（线性回归截距）和 linearreg\\_slope（线性回归斜率指标）\n\n#### 例子\n\n```\nx = 3 3 5 7 8 9 10 11 15 13 12 11 10\nprint linearTimeTrend(x,3)\n// output：([,,2.666666666666666,3,5.166666666666667,7,8,9,9.5,12,14.833333333333333,13,12],[,,1,2,1.5,1,1,1,2.5,1,-1.5,-1,-1])\n\n```\n\n```\nn = 10\nt = table(09:00:00 + 1..n as time, rand(`A`B, n) as sym, rand(100.0, n) as val1, rand(1000..2000, n) as val2)\nselect time, sym, linearTimeTrend(val1, 3) as `alpha`beta from t\n```\n\n| time     | sym | alpha   | beta     |\n| -------- | --- | ------- | -------- |\n| 09:00:01 | B   |         |          |\n| 09:00:02 | A   |         |          |\n| 09:00:03 | A   | 85.0844 | -30.0688 |\n| 09:00:04 | B   | 49.3461 | 7.3621   |\n| 09:00:05 | B   | 30.4248 | 28.3589  |\n| 09:00:06 | A   | 83.106  | -7.7515  |\n| 09:00:07 | B   | 78.4412 | -17.7575 |\n| 09:00:08 | A   | 56.8575 | 4.4732   |\n| 09:00:09 | A   | 53.8492 | -6.0653  |\n| 09:00:10 | A   | 61.7888 | -4.5586  |\n"
    },
    "linprog": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/linprog.html",
        "signatures": [
            {
                "full": "linprog(f, [A], [b], [Aeq], [beq], [lb], [ub], [method='simplex'])",
                "name": "linprog",
                "parameters": [
                    {
                        "full": "f",
                        "name": "f"
                    },
                    {
                        "full": "[A]",
                        "name": "A",
                        "optional": true
                    },
                    {
                        "full": "[b]",
                        "name": "b",
                        "optional": true
                    },
                    {
                        "full": "[Aeq]",
                        "name": "Aeq",
                        "optional": true
                    },
                    {
                        "full": "[beq]",
                        "name": "beq",
                        "optional": true
                    },
                    {
                        "full": "[lb]",
                        "name": "lb",
                        "optional": true
                    },
                    {
                        "full": "[ub]",
                        "name": "ub",
                        "optional": true
                    },
                    {
                        "full": "[method='simplex']",
                        "name": "method",
                        "optional": true,
                        "default": "'simplex'"
                    }
                ]
            }
        ],
        "markdown": "### [linprog](https://docs.dolphindb.cn/zh/funcs/l/linprog.html)\n\n\n\n#### 语法\n\nlinprog(f, \\[A], \\[b], \\[Aeq], \\[beq], \\[lb], \\[ub], \\[method='simplex'])\n\n#### 详情\n\n求线性目标函数在约束条件下的最优解。具体模型如下：\n\n![linprog](https://docs.dolphindb.cn/zh/images/linprog.png)\n\n#### 参数\n\n**f** 是线性规划中的一次项向量。\n\n**A** 是线性不等约束的系数矩阵。\n\n**b** 是线性不等约束的右端向量。\n\n**Aeq** 是线性等式约束的系数矩阵。\n\n**beq** 是线性等式约束的右端向量。\n\n**lb** 表示变量的下界。\n\n**ub** 表示变量的上界。\n\n**method** 是字符串，表示算法，目前支持 'simplex' 和 'interior-point'。推荐使用 simplex 算法，部分特殊场景下建议使用 interior-point 算法。\n\n#### linprog 函数的参数有以下要求：\n\n* *A* 和 *Aeq* 必须是列数相同的矩阵\n\n* *f*, *b* 和 *beq* 是向量\n\n* *lb* 和 *ub* 可以是标量，也可以是和x等长的向量。\n\n  * 若 *lb* 或 *ub* 是标量，则所有变量都受同一个下界或上界约束。若 *lb* 或 *ub* 为NULL，表示x无相应的下界或上界约束。\n\n  * 若 *lb* 或 *ub* 是向量，则x中的元素受 *lb* 或 *ub* 中相应位置的元素约束。若向量 *lb* 或 *ub* 中某元素为NULL，表示此位置的x元素无相应的下界或上界约束\n\n#### 返回值\n\n返回具有两个元素的元组。第一个元素是目标函数的最小值，第二个元素是目标函数取最小值时，x的取值。\n\n#### 例子\n\n例1. 求 x，y 满足以下约束条件时，目标函数 x+2y 的最小值。\n\n![linprog1](https://docs.dolphindb.cn/zh/images/linprog1.png)\n\n```\nf = [1, 2];\nA = [-1, -1]$1:2;\nb = [-2];\nub = 2;\nre = linprog(f, A, b, , , , ub);\n\nre[0];\n// output\n2\n\nre[1];\n// output\n[2,0]\n```\n\n下面详细解释如何获取上例中的 A, b 和 ub。不等式约束条件为 x+y>=2，而模型中的不等式约束条件的符号为<=，因此需要转换成 -x-y<=-2。因此，不等式约束条件的系数矩阵为 \\[-1,-1]$1:2，不等式约束条件的右端向量为-2。变量 x, y 的上界都是2，因此 ub 可用标量表示。\n\n例2. 求 x，y 满足以下约束条件时，目标函数 -3x1-2x2 的最小值。\n\n![linprog2](https://docs.dolphindb.cn/zh/images/linprog2.png)\n\n```\nf = [-3, -2];\nA = [2, 1, 1, 1]$2:2;\nb = [10, 8];\nub = [4, NULL];\nre = linprog(f, A, b, , , , ub);\n\nre[0];\n// output\n-18\n\nre[1];\n// output\n[2,6]\n```\n\n相关函数：[scs](https://docs.dolphindb.cn/zh/funcs/s/scs.html), [quadprog](https://docs.dolphindb.cn/zh/funcs/q/quadprog.html)\n"
    },
    "listAllMarkets": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/listAllMarkets.html",
        "signatures": [
            {
                "full": "listAllMarkets()",
                "name": "listAllMarkets",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [listAllMarkets](https://docs.dolphindb.cn/zh/funcs/l/listAllMarkets.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nlistAllMarkets()\n\n#### 详情\n\n获取当前节点所有的交易日历。\n\n#### 返回值\n\n一个包含节点上所有交易日历标识的向量。\n\n#### 例子\n\n```\nlistAllMarkets()\n// [\"XTSE\",\"XCSE\",\"XLIM\",\"ADDA\",\"XSTO\",\"XIST\",\"AIXK\",\"SSE\",\"XMIL\",\"XFRA\",\"INE\",\"XMEX\",\"XBUD\",\"XICE\",\"XDUB\",\"SHFE\",\"CMES\",\"XOSL\",\"DCE\",\"CCFX\",\"CFFEX\",\"XIDX\",\"BVMF\",\"XBOG\",\"XKAR\",\"XSAU\",\"XBUE\",\"XTKS\",\"XBSE\",\"XMOS\"...]\n```\n\n**相关函数：**[addMarketHoliday](https://docs.dolphindb.cn/zh/funcs/a/addMarketHoliday.html)、[deleteMarketHoliday](https://docs.dolphindb.cn/zh/funcs/d/deleteMarketHoliday.html)\n"
    },
    "listMCPPrompts": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/listMCPPrompts.html",
        "signatures": [
            {
                "full": "listMCPPrompts()",
                "name": "listMCPPrompts",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [listMCPPrompts](https://docs.dolphindb.cn/zh/funcs/l/listMCPPrompts.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\nlistMCPPrompts()\n\n#### 详情\n\n查看当前用户具有 MCP\\_EXEC 权限的 MCP prompt 模板。\n\n#### 返回值\n\n一张表，包含以下字段：\n\n* name：STRING 类型，prompt 模板的名称。\n* message：STRING 类型，prompt 模板的内容。\n* description：STRING 类型，prompt 模板的描述。\n* title：STRING 类型，prompt 模板的 title。\n* lastModifyTime：TIMESTAMP 类型，最后一次修改时间。\n* publishTime：TIMESTAMP 类型，发布时间。\n\n#### 例子\n\n```\nlistMCPPrompts()\n```\n\n返回结果\n\n| name           | message                                       | description    | title  | lastModifyTime          | publishTime |\n| -------------- | --------------------------------------------- | -------------- | ------ | ----------------------- | ----------- |\n| stock\\_summary | 请总结 ${stock} 在 ${startDate} 至 ${endDate} 的表现。 | 更新后的 Prompt 描述 | 股票走势总结 | 2025.08.24 17:17:29.091 |             |\n"
    },
    "listMCPTools": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/listMCPTools.html",
        "signatures": [
            {
                "full": "listMCPTools()",
                "name": "listMCPTools",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [listMCPTools](https://docs.dolphindb.cn/zh/funcs/l/listMCPTools.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\nlistMCPTools()\n\n#### 详情\n\n查看当前用户具有 MCP\\_EXEC 权限的 MCP Tools。\n\n#### 返回值\n\n一张表，包含以下字段：\n\n* name：STRING 类型，tool 的名称。\n\n* title：STRING 类型，tool 的 title。\n\n* description：STRING 类型，tool 的描述。\n\n* args：STRING 类型，参数列表，格式为 `argName1: argType1, argName2: argType2, ...`。\n\n* lastModifyTime：TIMESTAMP 类型，最后一次修改时间。\n\n* publishTime：TIMESTAMP 类型，发布时间。\n\n* function：BLOB 类型，函数定义。\n\n#### 例子\n\n```\nlistMCPTools()\n```\n\n返回结果\n\n| name   | title           | description    | args     | lastModifyTime          | publishTime             | function                             |\n| ------ | --------------- | -------------- | -------- | ----------------------- | ----------------------- | ------------------------------------ |\n| myTool | DolphinDB Tools | This is a tool | a:number | 2025.08.13 09:51:56.550 | 2025.08.13 15:14:14.255 | def myTool(x){ return (x \\* 2) + 1 } |\n"
    },
    "listPluginsByCluster": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/listPluginsByCluster.html",
        "signatures": [
            {
                "full": "listPluginsByCluster(clusterName)",
                "name": "listPluginsByCluster",
                "parameters": [
                    {
                        "full": "clusterName",
                        "name": "clusterName"
                    }
                ]
            }
        ],
        "markdown": "### [listPluginsByCluster](https://docs.dolphindb.cn/zh/funcs/l/listPluginsByCluster.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nlistPluginsByCluster(clusterName)\n\n#### 详情\n\n获取集群中每个节点上插件的安装情况。\n\n#### 参数\n\n**clusterName** 字符串标量，表示要查询的集群名称。只能由管理员在 MoM（Master of Master，管理集群）上执行该函数。\n\n#### 返回值\n\n一张表，包含以下字段：\n\n* plugin：插件名称。\n* version：插件版本。\n* user：安装该插件的用户名称。\n* time：插件安装时间，单位为毫秒。\n* node：插件安装所在的节点名称。\n\n#### 例子\n\n```\n// MoMSender 集群节点:\ninstallPlugin(\"mysql\")\nloadPlugin(\"mysql\")\n  \n// MoM 集群:\nlistPluginsByCluster(\"MoMSender\")\n  \n```\n\n| plugin | version  | user  | time                    | node           |\n| ------ | -------- | ----- | ----------------------- | -------------- |\n| mysql  | 3.00.3   | admin | 2025.05.24T17:10:42.300 | dnode1         |\n| zip    | 3.00.3   | admin | 2025.05.24T17:10:42.285 | dnode1         |\n| mysql  | 3.00.1.3 | admin | 2025.05.24T17:10:49.135 | controller8899 |\n| zip    | 3.00.3   | admin | 2025.05.24T17:10:49.120 | controller8899 |\n"
    },
    "listRemoteModules": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/listremotemodules.html",
        "signatures": [
            {
                "full": "listRemoteModules([serverAddr])",
                "name": "listRemoteModules",
                "parameters": [
                    {
                        "full": "[serverAddr]",
                        "name": "serverAddr",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [listRemoteModules](https://docs.dolphindb.cn/zh/funcs/l/listremotemodules.html)\n\n首发版本：3.00.5，3.00.4.3\n\n\n\n#### 语法\n\nlistRemoteModules(\\[serverAddr])\n\n#### 详情\n\n查询已在市场发布的模块。\n\n#### 参数\n\n**serverAddr** 可选参数，STRING 类型标量，用于指定模块仓库的 HTTP 地址。默认为\"<http://dolphindb.cn\"。>\n\n#### 返回值\n\n一张表，包含以下字段：\n\n* moduleName：模块名称。\n* moduleVersion：模块版本。\n\n#### 例子\n\n列出市场上所有可供下载的模块：\n\n```\nlistRemoteModules()\n```\n\n返回一张模块信息表，如下所示：\n\n| moduleName       | moduleVersion |\n| ---------------- | ------------- |\n| DolphinDBModules | 1.0.0         |\n| LogSearcher      | 1.0.0         |\n| alphalens        | 1.0.0         |\n| gtja191Alpha     | 1.0.0         |\n| marketHoliday    | 1.0.0         |\n| mytt             | 1.0.0         |\n| ops              | 1.0.0         |\n\n**相关函数**\n\n[installModule](https://docs.dolphindb.cn/zh/funcs/i/installmodule.html)\n\n[loadModule](https://docs.dolphindb.cn/zh/funcs/l/loadModule.html)\n"
    },
    "listRemotePlugins": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/listRemotePlugins.html",
        "signatures": [
            {
                "full": "listRemotePlugins([pluginName], [pluginServerAddr])",
                "name": "listRemotePlugins",
                "parameters": [
                    {
                        "full": "[pluginName]",
                        "name": "pluginName",
                        "optional": true
                    },
                    {
                        "full": "[pluginServerAddr]",
                        "name": "pluginServerAddr",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [listRemotePlugins](https://docs.dolphindb.cn/zh/funcs/l/listRemotePlugins.html)\n\n#### 语法\n\nlistRemotePlugins(\\[pluginName], \\[pluginServerAddr])\n\n#### 详情\n\n返回一个表，显示当前 DolphinDB 所支持的插件和其对应的版本信息。\n\n**Note:** 使用该命令获取的插件信息取决于：\n\n* DolphinDB server 版本\n* 操作系统\n\n如果不指定 pluginName，则返回所有插件；如果指定 pluginName，则返回指定插件；如果指定的插件不存在，则返回空。\n\n#### 参数\n\n**pluginName** 可选，STRING 类型，用于指定插件名称。\n\n**pluginServerAddr** 可选，STRING 类型，用于指定插件仓库的 HTTP 地址。如果不配置该参数，使用默认的 HTTP 地址：\"<http://plugins.dolphindb.cn/plugins\"。如果> DolphinDB 服务位于国外，建议填写 \"<http://plugins.dolphindb.com/plugins>\" 以提高查询速度。\n\n#### 返回值\n\n一张表，包含以下字段：\n\n* PluginName：插件名称。\n* PluginVersion：插件版本。\n\n#### 例子\n\n* 列出插件仓库所有可用插件：\n\n  ```\n  listRemotePlugins()\n  ```\n\n  均会返回类似以下的插件列表：\n\n  | PluginName  | PluginVersion      |\n  | ----------- | ------------------ |\n  | hdf5        | *\\<PluginVersion>* |\n  | matchEngine | *\\<PluginVersion>* |\n  | mongodb     | *\\<PluginVersion>* |\n  | mqtt        | *\\<PluginVersion>* |\n  | mseed       | *\\<PluginVersion>* |\n  | mysql       | *\\<PluginVersion>* |\n  | nsq         | *\\<PluginVersion>* |\n  | odbc        | *\\<PluginVersion>* |\n  | opc         | *\\<PluginVersion>* |\n  | opcua       | *\\<PluginVersion>* |\n  | zip         | *\\<PluginVersion>* |\n\n  其中 *\\<PluginVersion>* 为插件的版本信息，例如：2.00.11。\n\n* 返回指定插件及其版本信息。例如，获取 MySQL 插件的版本信息：\n\n  ```\n  listRemotePlugins(\"mysql\")\n  ```\n\n  返回：\n\n  | PluginName | PluginVersion |\n  | :--------- | :------------ |\n  | mysql      | 2.00.11       |\n\n\n\n**Related information**\n\n[installPlugin](https://docs.dolphindb.cn/zh/funcs/i/installPlugin.html)\n\n[loadPlugin](https://docs.dolphindb.cn/zh/funcs/l/loadPlugin.html)\n"
    },
    "listStreamingSQLTables": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/listStreamingSQLTables.html",
        "signatures": [
            {
                "full": "listStreamingSQLTables()",
                "name": "listStreamingSQLTables",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [listStreamingSQLTables](https://docs.dolphindb.cn/zh/funcs/l/listStreamingSQLTables.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\nlistStreamingSQLTables()\n\n#### 详情\n\n列出当前用户已通过 `declareStreamingSQLTable` 声明的所有流式 SQL 表。\n\n如果调用者是管理员（admin），则会返回系统中所有用户声明的流式 SQL 表。\n\n#### 返回值\n\n一张表，包含如下字段：表名（tableName）、是否共享（shared）、声明用户（users）。\n\n#### 例子\n\n```\nt=table(1..10 as id,rand(100,10) as val)\nshare t as st\ndeclareStreamingSQLTable(st)\n\nlistStreamingSQLTables()\n```\n\n| tableName | shared | users |\n| --------- | ------ | ----- |\n| st        | true   | admin |\n\n**相关函数：**[declareStreamingSQLTable](https://docs.dolphindb.cn/zh/funcs/d/declareStreamingSQLTable.html)\n"
    },
    "listTables": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/listTables.html",
        "signatures": [
            {
                "full": "listTables(dbUrl)",
                "name": "listTables",
                "parameters": [
                    {
                        "full": "dbUrl",
                        "name": "dbUrl"
                    }
                ]
            }
        ],
        "markdown": "### [listTables](https://docs.dolphindb.cn/zh/funcs/l/listTables.html)\n\n\n\n#### 语法\n\nlistTables(dbUrl)\n\n#### 详情\n\n返回一个表对象，包含两列，分别为数据库中的表名和物理索引名。\n\n**Note:** 只有表级分区具有物理索引。\n\n#### 参数\n\n**dbUrl** 是一个字符串，表示分布式数据库的路径。\n\n#### 例子\n\n```\nlistTables(dbPath)\n```\n\n| tableName | physicalIndex |\n| --------- | ------------- |\n| pt1       | 1By           |\n| pt        | 1Bw           |\n"
    },
    "loadBackup": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/loadBackup.html",
        "signatures": [
            {
                "full": "loadBackup(backupDir, dbPath, partition, tableName)",
                "name": "loadBackup",
                "parameters": [
                    {
                        "full": "backupDir",
                        "name": "backupDir"
                    },
                    {
                        "full": "dbPath",
                        "name": "dbPath"
                    },
                    {
                        "full": "partition",
                        "name": "partition"
                    },
                    {
                        "full": "tableName",
                        "name": "tableName"
                    }
                ]
            }
        ],
        "markdown": "### [loadBackup](https://docs.dolphindb.cn/zh/funcs/l/loadBackup.html)\n\n\n\n#### 语法\n\nloadBackup(backupDir, dbPath, partition, tableName)\n\n#### 详情\n\n加载指定分布式表中某个分区的备份数据。该函数必须要用户登录后才能执行。\n\n请注意，目前该函数只支持加载 SQL 元代码（即 [backup](https://docs.dolphindb.cn/zh/funcs/b/backup.html) 时指定 *sqlObj* 参数）备份的数据。\n\n#### 参数\n\n**backupDir** 是字符串，表示存放备份数据的目录。\n\n**dbPath** 是字符串，表示 DFS 数据库的路径，例如 `\"dfs://demo\"`。\n\n**partition** 是字符串，表示分区在数据库内的路径，例如 `\"/20190101/GOOG\"`。\n\n**Note:** 若使用 2.00.4 到 2.00.6 版本 server，对表级分区数据进行备份和恢复时，该参数必须指定路径到物理索引（可通过函数 [listTables](https://docs.dolphindb.cn/zh/funcs/l/listTables.html) 获取），例如分区 `\"/compoDB/20170807/0_50\"` 下表的物理索引为8，则 *partition* 需指定为 `\"/compoDB/20170807/0_50/8\"`。\n\n**tableName** 是字符串，表示分布式表的名称。\n\n#### 返回值\n\n一张表。\n\n#### 例子\n\n```\nloadBackup(\"/home/DolphinDB/backup\",\"dfs://valuedb\", \"/200001M\",\"pt\");\n```\n\n输出返回：\n\n| month    | x   |\n| -------- | --- |\n| 2000.01M | 1   |\n| 2000.01M | 205 |\n| 2000.01M | 409 |\n| 2000.01M | 613 |\n| 2000.01M | 817 |\n"
    },
    "loadDistributedInMemoryTable": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/loadDistributedInMemoryTable.html",
        "signatures": [
            {
                "full": "loadDistributedInMemoryTable(tableName)",
                "name": "loadDistributedInMemoryTable",
                "parameters": [
                    {
                        "full": "tableName",
                        "name": "tableName"
                    }
                ]
            }
        ],
        "markdown": "### [loadDistributedInMemoryTable](https://docs.dolphindb.cn/zh/funcs/l/loadDistributedInMemoryTable.html)\n\n\n\n#### 语法\n\nloadDistributedInMemoryTable(tableName)\n\n#### 详情\n\n返回分布式共享内存表的句柄。该函数只能在数据节点/计算节点上执行。\n\n#### 参数\n\n**tableName** 字符串标量，表示分布式共享内存表的名称。\n\n#### 返回值\n\n一个分布式共享内存表的句柄。\n\n#### 例子\n\n```\npt = createDistributedInMemoryTable(`dt, `time`id`value, `DATETIME`INT`LONG, HASH, [INT, 2],`id)\ntime = take(2021.08.20 00:00:00..2021.08.30 00:00:00, 40);\nid = 0..39;\nvalue = rand(100, 40);\ntmp = table(time, id, value);\n\npt = loadDistributedInMemoryTable(`dt)\npt.append!(tmp);\nselect * from pt;\n```\n\n相关函数：[dropDistributedInMemoryTable](https://docs.dolphindb.cn/zh/funcs/d/dropDistributedInMemoryTable.html), [createDistributedInMemoryTable](https://docs.dolphindb.cn/zh/funcs/c/createDistributedInMemoryTable.html)\n"
    },
    "loadHaMvccTable": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/loadHaMvccTable.html",
        "signatures": [
            {
                "full": "loadHaMvccTable(tableName)",
                "name": "loadHaMvccTable",
                "parameters": [
                    {
                        "full": "tableName",
                        "name": "tableName"
                    }
                ]
            }
        ],
        "markdown": "### [loadHaMvccTable](https://docs.dolphindb.cn/zh/funcs/l/loadHaMvccTable.html)\n\n首发版本：3.00.5\n\n\n\n#### 语法\n\nloadHaMvccTable(tableName)\n\n#### 详情\n\n加载并返回指定名称的高可用 MVCC 表的句柄。\n\n**Note:**\n\n* `loadHaMvccTable` 是非 Leader 节点上使用高可用 MVCC 表的唯一方式。\n\n* 对高可用 MVCC 表查询（select）可在 Leader 和 Follower 上执行，推荐在 Leader 上执行。\n\n#### 参数\n\n**tableName** 字符串标量，表示要加载的高可用 MVCC 表的名称。\n\n#### 返回值\n\n返回高可用 MVCC 表的句柄。\n\n#### 例子\n\n```\nhmvcct = loadHaMvccTable(\"demoHaMvcc\")\n```\n\n**相关函数**：[haMvccTable](https://docs.dolphindb.cn/zh/funcs/h/haMvccTable.html)\n"
    },
    "loadIPCInMemoryTable": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/loadIPCInMemoryTable.html",
        "signatures": [
            {
                "full": "loadIPCInMemoryTable(tableName)",
                "name": "loadIPCInMemoryTable",
                "parameters": [
                    {
                        "full": "tableName",
                        "name": "tableName"
                    }
                ]
            }
        ],
        "markdown": "### [loadIPCInMemoryTable](https://docs.dolphindb.cn/zh/funcs/l/loadIPCInMemoryTable.html)\n\n\n\n#### 语法\n\nloadIPCInMemoryTable(tableName)\n\n#### 详情\n\n加载跨进程共享内存表，并返回该表的句柄。\n\n注意：此函数仅适用于 Linux 系统。\n\n#### 参数\n\n**tableName** 字符串，表示跨进程共享内存表的名称。\n\n#### 返回值\n\n一个共享内存表句柄。\n\n#### 例子\n\n加载函数 `createIPCInMemoryTable` 例子中创建的表 ipc\\_table。\n\n```\nipc_t = loadIPCInMemoryTable(\"ipc_table\")\nipc_t\n// output\ntimestamp temperature\n```\n"
    },
    "loadModel": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/loadModel.html",
        "signatures": [
            {
                "full": "loadModel(file)",
                "name": "loadModel",
                "parameters": [
                    {
                        "full": "file",
                        "name": "file"
                    }
                ]
            }
        ],
        "markdown": "### [loadModel](https://docs.dolphindb.cn/zh/funcs/l/loadModel.html)\n\n\n\n#### 语法\n\nloadModel(file)\n\n#### 详情\n\n把模型加载到内存中，以字典的形式返回模型。\n\n#### 参数\n\n**file** 是模型所在的本地文件的路径。\n\n#### 返回值\n\n一个字典，表示加载到内存中的模型。\n\n#### 例子\n\n```\nx1 = rand(100.0, 100)\nx2 = rand(100.0, 100)\nb0 = 6\nb1 = 1\nb2 = -2\nerr = norm(0, 10, 100)\ny = b0 + b1 * x1 + b2 * x2 + err\nt = table(x1, x2, y)\nmodel = randomForestRegressor(sqlDS(<select * from t>), `y, `x1`x2)\nsaveModel(model, \"/home/DolphinDB/Data/regressionModel.txt\");\n\nmodel = loadModel(\"/home/DolphinDB/Data/regressionModel.txt\")\nyhat = predict(model, t);\n```\n"
    },
    "loadModule": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/loadModule.html",
        "signatures": [
            {
                "full": "loadModule(name, [moduleDir])",
                "name": "loadModule",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "[moduleDir]",
                        "name": "moduleDir",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [loadModule](https://docs.dolphindb.cn/zh/funcs/l/loadModule.html)\n\n\n\n#### 语法\n\nloadModule(name, \\[moduleDir])\n\n#### 详情\n\n将模块或插件中的函数加载成系统的内置函数。如果加载的模块依赖了其他模块，系统会一并加载其他模块。该函数必须要用户登录后才能执行。\n\n系统启动时，根据配置项 *moduleDir* 的设置，寻找并决定模块所在目录：\n\n* 配置项 *moduleDir* 设置为一个绝对目录，则该目录即为搜索模块所在的目录。\n\n* 配置项 *moduleDir* 设置为一个相对目录，系统会依次在 *HOMEDIR*，*WORKDIR* 和 *EXECDIR* 三个目录下搜索。如果找到了，就以该目录作为 *moduleDir*；如果搜索不到，就以 *\\<HOMEDIR>* + “/” + *\\<moduleDir>* 作为 modules 的绝对目录\n\n* 配置项 *moduleDir* 没有设置，搜索方式同相对目录。\n\n如果 *modules* 目录中包含同名的 dos 文件和 dom 文件，系统仅会加载 dom 文件。\n\n**Note:** 该函数只能在系统的初始化脚本（默认为 *dolphindb.dos* 文件）中使用。\n\n`loadModule` 函数与配置参数 *preloadModules* 的功能相同。\n\n#### 参数\n\n**name** 是一个字符串，表示模块的名称。\n\n**moduleDir** 是一个字符串，表示模块 dos 文件或 dom 文件所在的目录。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n例1. 加载模块\n\n```\nloadModule(\"ta\");\n\nloadModule(\"system::log::fileLog\");\n```\n\n例2. 加载插件\n\n```\nloadModule(\"plugins::mysql\");\n\nloadModule(\"plugins::odbc\");\n```\n\n**Related information**\n\n[saveModule](https://docs.dolphindb.cn/zh/funcs/s/saveModule.html)\n"
    },
    "loadModuleFromScript": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/loadmodulefromscript.html",
        "signatures": [
            {
                "full": "loadModuleFromScript(moduleNamespace, moduleScript, [reload=false])",
                "name": "loadModuleFromScript",
                "parameters": [
                    {
                        "full": "moduleNamespace",
                        "name": "moduleNamespace"
                    },
                    {
                        "full": "moduleScript",
                        "name": "moduleScript"
                    },
                    {
                        "full": "[reload=false]",
                        "name": "reload",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [loadModuleFromScript](https://docs.dolphindb.cn/zh/funcs/l/loadmodulefromscript.html)\n\n#### 语法\n\nloadModuleFromScript(moduleNamespace, moduleScript, \\[reload=false])\n\n#### 详情\n\n解析包含模块定义的字符串，并加载该模块。如果模块脚本中包含模块引用，则无需关注其依赖顺序，函数会自动解析。\n\n#### 参数\n\n**moduleNamespace**：字符串标量或向量，表示模块的命名空间。如果模块之间存在依赖，则需要输入全部模块的命名空间。\n\n**moduleScript**：字符串标量或向量，表示模块的脚本。\n\n**reload**：布尔标量，表示是否重新加载模块,默认值为 false。如果之前已加载同名模块，要使更新的 *moduleScript* 生效，必须将此参数设置为 true。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\nmoduleName = \"test\"\nmoduleScript = \"module test \\n def testFunc(x,y){ return x+y }\"\nloadModuleFromScript(moduleName,moduleScript)\ngo\ntest::testFunc(2,3)\n// output\n5\n```\n\n如果模块脚本中包含模块引用：\n\n```\nmoduleNames = [\"test2\",\"test1\"]\nmoduleScripts = [\n\"module test2\nuse test1\ndef func4(x,y){\n    return func1(x) + func2(y)\n}\n\",\n\"module test1\ndef func1(x){\n    return x+1\n}\ndef func2(x){\n    return x+2\n}\ndef func3(x){\n    print(func1(x)+func2(x))\n}\n\"\n]\nloadModuleFromScript(moduleNames,moduleScripts)\ngo\ntest1::func3(2)\n// output\n7\ntest2::func4(2,3)\n// output\n8\n```\n\n"
    },
    "loadMvccTable": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/loadMvccTable.html",
        "signatures": [
            {
                "full": "loadMvccTable(path, tableName)",
                "name": "loadMvccTable",
                "parameters": [
                    {
                        "full": "path",
                        "name": "path"
                    },
                    {
                        "full": "tableName",
                        "name": "tableName"
                    }
                ]
            }
        ],
        "markdown": "### [loadMvccTable](https://docs.dolphindb.cn/zh/funcs/l/loadMvccTable.html)\n\n\n\n#### 语法\n\nloadMvccTable(path, tableName)\n\n#### 详情\n\n把磁盘上可并发读写的表加载到内存中。\n\n#### 参数\n\n**path** 是一个字符串，表示绝对路径或相对路径。\n\n**tableName** 是一个字符串，表示表名。\n\n#### 返回值\n\n一张表。\n\n#### 例子\n\n```\nn=5\nsyms=`IBM`C`MS`MSFT`JPM`ORCL`FB`GE\ntimestamp=09:30:00+rand(18000,n)\nsym=rand(syms,n)\nqty=100*(1+rand(100,n))\nprice=5.0+rand(100.0,n)\ntemp=table(timestamp,sym,qty,price)\nt1= mvccTable(1:0,`timestamp`sym`qty`price,[TIMESTAMP,SYMBOL,INT,DOUBLE],\"/home/DolphinDB/Data\",\"t1\")\nt1.append!(temp);\n\nloadMvccTable(\"/home/DolphinDB/Data\",\"t1\");\n```\n\n| timestamp               | sym  | qty  | price     |\n| ----------------------- | ---- | ---- | --------- |\n| 1970.01.01T00:00:39.091 | MSFT | 4500 | 99.808702 |\n| 1970.01.01T00:00:35.293 | FB   | 3600 | 26.644715 |\n| 1970.01.01T00:00:36.334 | MSFT | 3800 | 66.754334 |\n| 1970.01.01T00:00:40.362 | ORCL | 4800 | 15.480288 |\n| 1970.01.01T00:00:35.565 | MSFT | 1700 | 23.107408 |\n"
    },
    "loadNpy": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/loadNpy.html",
        "signatures": [
            {
                "full": "loadNpy(fileName)",
                "name": "loadNpy",
                "parameters": [
                    {
                        "full": "fileName",
                        "name": "fileName"
                    }
                ]
            }
        ],
        "markdown": "### [loadNpy](https://docs.dolphindb.cn/zh/funcs/l/loadNpy.html)\n\n\n\n#### 语法\n\nloadNpy(fileName)\n\n#### 详情\n\n读取 Python Numpy 的 npy 格式二进制文件，并转化为 DolphinDB 的向量或矩阵。Numpy 对象中的 NaN 值会被转化为 DolphinDB 的 NULL 值。\n\n#### 参数\n\n**filename** 是字符串，表示 npy 文件的路径。\n\n#### 返回值\n\n一个向量或矩阵。\n\n#### 例子\n\n在 Python 中导出 npy 格式文件：\n\n```\nimport numpy as np\nnp.save(\"intVec.npy\", np.array([5,6,1,3,4,8]))\nnp.save(\"doubleMat.npy\", np.array([[1.5,5.6,-7.87],[-1.0,3.4,4.5]]))\n```\n\n在 DolphinDB 中加载 npy 文件：\n\n```\nloadNpy(\"intVec.npy\");\n```\n\n输出返回：\\[5,6,1,3,4,8]\n\n```\nloadNpy(\"doubleMat.npy\");\n```\n\n输出返回：\n\n| #0  | #1  | #2    |\n| --- | --- | ----- |\n| 1.5 | 5.6 | -7.87 |\n| -1  | 3.4 | 4.5   |\n\n相关函数：[saveAsNpy](https://docs.dolphindb.cn/zh/funcs/s/saveAsNpy.html)\n"
    },
    "loadNpz": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/loadNpz.html",
        "signatures": [
            {
                "full": "loadNpz(fileName)",
                "name": "loadNpz",
                "parameters": [
                    {
                        "full": "fileName",
                        "name": "fileName"
                    }
                ]
            }
        ],
        "markdown": "### [loadNpz](https://docs.dolphindb.cn/zh/funcs/l/loadNpz.html)\n\n\n\n#### 语法\n\nloadNpz(fileName)\n\n#### 详情\n\n读取 Python Numpy 的 npz 格式二进制文件，并转化为 DolphinDB 的对象。Numpy 对象中的 NaN 值会被转化为 DolphinDB 的 NULL 值。\n\nPython np.array 和 DolphinDB 对象对照表：\n\n支持转换的数据类型有：BOOL, CHAR, SHORT, INT, LONG, FLOAT, DOUBLE, STRING（只支持一维）\n\n| numpy array | DolphinDB object |\n| ----------- | ---------------- |\n| 一维          | 向量               |\n| 二维          | 矩阵               |\n| 三维          | 元组。元组的每一个元素是一个矩阵 |\n\n#### 参数\n\n**filename** 是字符串，表示 npz 文件的路径。\n\n#### 返回值\n\n一个字典，键为 npz 文件中数组的名称，值为对应的向量、矩阵或元组。\n\n#### 例子\n\n在 Python 中导出 npz 格式文件：\n\n```\nimport numpy as np\na = np.array([[[97, 98]]], dtype=np.int8)\na1 = np.array(['133', '211', '3dds', 'ddd4', 'e5', 'w6'])\nb1 = np.array([[0.7, 0.8, 9.2], [0, np.nan, np.nan], [1.5, 2.8, 0.2]])\nc1 = np.array([[[0.2, 3.3], [1.9, 4.3]], [[5, 6], [1, 2]]])\nnp.savez('my_path/array_save.npz', char=a, a1=a1, b1=b1, c1=c1)\n```\n\n在 DolphinDB 中加载 npz 文件：\n\n```\npath=\"my_path/array_save.npz\"\nloadNpz(path)\n// output\na1->[133,211,3dds,ddd4,e5,w6]\nchar->(#0  #1\n'a' 'b'\n)\nc1->(#0  #1\n0.2 3.3\n1.9 4.3\n,#0 #1\n5  6\n1  2\n)\nb1->\n#0  #1  #2\n0.7 0.8 9.2\n0\n1.5 2.8 0.2\n```\n\n相关函数：[loadNpy](https://docs.dolphindb.cn/zh/funcs/l/loadNpy.html)\n"
    },
    "loadPlugin": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/loadPlugin.html",
        "signatures": [
            {
                "full": "loadPlugin(filepath)",
                "name": "loadPlugin",
                "parameters": [
                    {
                        "full": "filepath",
                        "name": "filepath"
                    }
                ]
            }
        ],
        "markdown": "### [loadPlugin](https://docs.dolphindb.cn/zh/funcs/l/loadPlugin.html)\n\n#### 语法\n\nloadPlugin(filepath)\n\n#### 详情\n\n加载 DolphinDB 插件。该函数必须要用户登录后才能执行。\n\n**Note:**\n\n* 在产品体验阶段，如果未自行创建用户或管理员账号，可以使用 DolphinDB 提供的初始管理员账号（admin）及密码（123456）。在生产环境中，务必使用具备中等以上安全强度的用户或管理员密码。\n\n* 加载前请确保有对应插件的使用权限。收费插件需要另行购买。\n\n来自 DolphinDB 插件市场的插件在使用 [installPlugin](https://docs.dolphindb.cn/zh/funcs/i/installPlugin.html) 命令安装后，会在`<server路径>/plugins/<插件名称>`路径下生成一个命名方式为 \"Plugin\" + \"插件名称\"的 txt 格式的插件描述文件和相关的二进制文件（Windows 版本下为 .dll，Linux 版本下为 .so）。例如，安装在 Windows 版本 DolphinDB server 2.00.10 的 odbc 插件描述文件存储于：\n\n```\n../DolphinDB_Win64_V2.00.10/server/plugins/odbc/PluginODBC.txt\n```\n\n该文件包含以下内容：\n\n```\nodbc,libPluginODBC.dll,2.00.10\nodbcQuery,query,system,2,5,0\nodbcConnect,connect,system,1,2,0\nodbcClose,close,system,1,1,0\nodbcExecute,execute,system,2,2,0\nodbcAppend,append,system,3,5,0\n```\n\n该文件格式如下：\n\n* 第一行：插件名称、lib 文件、版本号，用 “,” 分隔；\n* 其他行用于描述该插件提供的函数，依次包含以下信息：lib 文件中的某个函数的名称、对应的 DolphinDB 函数的名称、函数的类型（operator 表示运算符，system 表示系统函数）、函数所需的最小参数个数、函数所需的最大参数个数、是否为聚合函数（1 表示聚合函数，0 表示非聚合函数）、是否为序列函数（1表示序列函数，0表示非序列函数）。\n\n#### 参数\n\n**filepath** 是文本文件的绝对路径。例如：`/home/DolphinDB_Linux64_V2.00.10/server/plugins/mysql/PluginMySQL.txt`。\n\n自2.00.11版本起，可以将其指定为插件名（大小写敏感）。系统会根据插件名称和配置项 *pluginDir* 拼接出插件的加载路径。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n**加载来自插件市场的插件**\n\n以在 Windows 操作系统上安装 MQTT 插件为例，加载方法有两种：\n\n* 使用插件描述文件的绝对路径加载插件：\n\n  ```\n  installPlugin(\"mqtt\") \n  loadPlugin(\"D:/TEST/DolphinDB_Win64_V2.00.10/server/plugins/mqtt/PluginMQTT.txt\")\n  ```\n\n  **Note:** 在 Windows 操作系统中使用绝对路径加载插件时，务必确保路径中使用\"/\"代替\"\\\\\"。\n\n* 或指定插件名称：\n\n  ```\n  installPlugin(\"mqtt\") \n  loadPlugin(\"mqtt\")\n  ```\n\n**加载自行编译的插件**\n\n以 DolphinDB Linux 版本的 odbc 插件为例，其描述文件 odbc.txt 内容如下：\n\n```\nodbc,libPluginODBC.so,2.00.10\nodbcQuery,query,system,2,5,0\nodbcConnect,connect,system,1,2,0\nodbcClose,close,system,1,1,0\nodbcExecute,execute,system,2,2,0\nodbcAppend,append,system,3,5,0\n\n```\n\nodbc 插件提供了 5 个函数：`query`, `connect`, `close`, `execute` 和 `append`，需要加载插件后才能使用。下面的例子介绍了如何加载 odbc 插件，并调用 odbc 插件提供的函数。\n\n```\nloadPlugin(\"/home/DolphinDB/server/plugins/odbc/odbc.txt\")\n//或者通过插件名进行加载\nloadPlugin(\"odbc\")\nuse odbc\nConnStr=\"Driver=MySQL;Data Source=odbc_test;Server=127.0.0.1;Uid=root;Pwd=123456;Database=odbc_test\"\nconn=connect(connStr)      // 创建 MySQL 连接\n\nt=query(conn,\"select * from test\")\nclose(conn)\n```\n\n\n\n**Related information**\n\n[installPlugin](https://docs.dolphindb.cn/zh/funcs/i/installPlugin.html)\n\n[listRemotePlugins](https://docs.dolphindb.cn/zh/funcs/l/listRemotePlugins.html)\n"
    },
    "loadRecord": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/loadRecord.html",
        "signatures": [
            {
                "full": "loadRecord(filename, schema, [skipBytes=0], [count])",
                "name": "loadRecord",
                "parameters": [
                    {
                        "full": "filename",
                        "name": "filename"
                    },
                    {
                        "full": "schema",
                        "name": "schema"
                    },
                    {
                        "full": "[skipBytes=0]",
                        "name": "skipBytes",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[count]",
                        "name": "count",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [loadRecord](https://docs.dolphindb.cn/zh/funcs/l/loadRecord.html)\n\n\n\n#### 语法\n\nloadRecord(filename, schema, \\[skipBytes=0], \\[count])\n\n#### 详情\n\n将每个字段长度固定的行式二进制文件加载到内存中。\n\n#### 参数\n\n**filename** 是一个字符串，表示文件路径。\n\n**schema** 是一个元组。元组中的每个向量表示一个列的名称、数据类型。如果该列是字符串，还需指定字符串长度。如果长度不足，需在最后补0达到指定长度。\n\n**skipBytes** 是一个非负整数，表示从文件头开始忽略的字节数。它是一个可选参数，默认值为0。\n\n**count** 是一个正整数，表示要加载的记录数。如果没有指定，表示加载所有记录。\n\n#### 返回值\n\n一张表。\n\n#### 例子\n\n一个二进制文件 sample.bin，包含46个字段，内容如下：\n\n```\n0000000 3036 3131 3737 532e 0048 0000 0000 0000\n0000010 0000 0000 0000 0000 0000 0000 0000 0000\n0000020 16b6 0134 d160 0578 0000 0000 0000 0000\n0000030 0000 0000 3333 4137 0000 0000 0000 0000\n0000040 0000 0000 0000 0000 0000 0000 0000 0000\n0000050 0000 0000 0000 0000 0000 0000 00c8 0000\n0000060 0000 0000 0000 0000 0000 0000 0000 0000\n*\n0000080 0000 0000 3333 4137 0000 0000 0000 0000\n0000090 0000 0000 0000 0000 0000 0000 0000 0000\n00000a0 0000 0000 0000 0000 0000 0000 00c8 0000\n00000b0 0384 0000 0000 0000 0000 0000 0000 0000\n00000c0 0000 0000 0000 0000 0000 0000 0000 0000\n00000d0 0000 0000 3036 3131 3737 532e 0048 0000\n00000e0 0000 0000 0000 0000 0000 0000 0000 0000\n00000f0 0000 0000 16b6 0134 ea58 057b 0000 0000\n0000100 0000 0000 0000 0000 3333 4137 0000 0000\n0000110 0000 0000 0000 0000 0000 0000 0000 0000\n*\n0000130 00c8 0000 0000 0000 0000 0000 0000 0000\n0000140 0000 0000 0000 0000 0000 0000 0000 0000\n0000150 0000 0000 0000 0000 3333 4137 0000 0000\n0000160 0000 0000 0000 0000 0000 0000 0000 0000\n*\n0000180 00c8 0000 0b54 0000 0000 0000 0000 0000\n0000190 0000 0000 0000 0000 0000 0000 0000 0000\n00001a0 0000 0000 0000 0000 3036 3131 3737 532e\n00001b0 0048 0000 0000 0000 0000 0000 0000 0000\n00001c0 0000 0000 0000 0000 16b6 0134 82b0 057c\n00001d0 0000 0000 0000 0000 0000 0000 3333 4137\n00001e0 0000 0000 0000 0000 0000 0000 0000 0000\n*\n0000200\n```\n\n现将该文件导入到 DolphinDB。其中 code 列是字符串，在二进制文件中的长度是固定的，为32。\n\n```\nschema = [(\"code\", SYMBOL, 32),(\"date\", INT),(\"time\", INT),(\"last\", FLOAT),(\"volume\", INT),(\"value\", FLOAT),(\"ask1\", FLOAT),(\"ask2\", FLOAT),(\"ask3\", FLOAT),(\"ask4\", FLOAT),(\"ask5\", FLOAT),(\"ask6\", FLOAT),(\"ask7\", FLOAT),(\"ask8\", FLOAT),(\"ask9\", FLOAT),(\"ask10\", FLOAT),(\"ask_size1\", INT),(\"ask_size2\", INT),(\"ask_size3\", INT),(\"ask_size4\", INT),(\"ask_size5\", INT),(\"ask_size6\", INT),(\"ask_size7\", INT),(\"ask_size8\", INT),(\"ask_size9\", INT),(\"ask_size10\", INT),(\"bid1\", FLOAT),(\"bid2\", FLOAT),(\"bid3\", FLOAT),(\"bid4\", FLOAT),(\"bid5\", FLOAT),(\"bid6\", FLOAT),(\"bid7\", FLOAT),(\"bid8\", FLOAT),(\"bid9\", FLOAT),(\"bid10\", FLOAT),(\"bid_size1\", INT),(\"bid_size2\", INT),(\"bid_size3\", INT),(\"bid_size4\", INT),(\"bid_size5\", INT),(\"bid_size6\", INT),(\"bid_size7\", INT),(\"bid_size8\", INT),(\"bid_size9\", INT),(\"bid_size10\", INT)];\nt=loadRecord(\"/home/DolphinDB/sample.bin\",schema);\nselect code, date,time,last,volume,value,ask1,ask_size1,bid1,bid_size1 from t;\n```\n\n| code      | date     | time     | last | volume | value | ask1  | ask\\_size1 | bid1  | bid\\_size1 |\n| --------- | -------- | -------- | ---- | ------ | ----- | ----- | ---------- | ----- | ---------- |\n| 601177.SH | 20190902 | 91804000 | 0    | 0      | 0     | 11.45 | 200        | 11.45 | 200        |\n| 601177.SH | 20190902 | 92007000 | 0    | 0      | 0     | 11.45 | 200        | 11.45 | 200        |\n"
    },
    "loadTable": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/loadTable.html",
        "signatures": [
            {
                "full": "loadTable(database, tableName, [partitions], [memoryMode=false])",
                "name": "loadTable",
                "parameters": [
                    {
                        "full": "database",
                        "name": "database"
                    },
                    {
                        "full": "tableName",
                        "name": "tableName"
                    },
                    {
                        "full": "[partitions]",
                        "name": "partitions",
                        "optional": true
                    },
                    {
                        "full": "[memoryMode=false]",
                        "name": "memoryMode",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [loadTable](https://docs.dolphindb.cn/zh/funcs/l/loadTable.html)\n\n\n\n#### 语法\n\nloadTable(database, tableName, \\[partitions], \\[memoryMode=false])\n\n#### 详情\n\n将数据加载到内存中。\n\n#### 参数\n\n**database** 字符串，表示数据库的路径，也可以是数据库句柄。可以是分布式数据库或本地磁盘数据库。\n\n**tableName** 字符串，表示表的名称，它需要使用反引号(\\`)或双引号。\n\n**partitions** 标量或向量，表示要加载的分区。注意，只有本地磁盘数据库支持该参数，分布式数据库不支持该参数。\n\n**memoryMode** 布尔值，表示是否把数据加载到内存。如果 *memoryMode* =false，表示只加载元数据到内存；如果 *memoryMode* =true， 表示将实际数据加载到内存。注意，只有本地磁盘数据库支持该参数，分布式数据库不支持该参数。对于分布式数据库，只将元数据加载到内存中。\n\n#### 返回值\n\n* 对于分布式数据库，返回包含元数据的表对象。\n\n* 对于本地磁盘数据库，如果 *memoryMode* =false，返回包含元数据的表对象；如果 *memoryMode* =true，返回包含实际数据的内存分区表。\n\n#### 例子\n\n##### 例1. 分布式数据库\n\n```\nn=1000000\nID=rand(100, n)\ndates=2017.08.07..2017.08.11\ndate=rand(dates, n)\nx=rand(10.0, n)\nt1=table(ID, date, x);\n\ndbDate = database(, VALUE, 2017.08.07..2017.08.11)\ndbID=database(, RANGE, 0 50 100);\ndb = database(\"dfs://compoDB\", COMPO, [dbDate, dbID]);\npt = db.createPartitionedTable(t1, `pt, `date`ID).append!(t1)\n\nt2=table(0..100 as ID,take(2017.08.07..2017.08.11,101) as date)\ndt = db.createTable(t2, `dt).append!(t2)\n```\n\n* 加载维度表：\n\n```\ntmp = loadTable(\"dfs://compoDB\", `dt)\nselect count(*) from tmp\n```\n\n| count |\n| ----- |\n| 101   |\n\n* 加载分区表：\n\n```\ntmp = loadTable(\"dfs://compoDB\", `pt)\nselect count(*) from tmp\n```\n\n| count   |\n| ------- |\n| 1000000 |\n\n* 对于分布式数据库，`loadTable` 函数不支持加载指定分区的数据。如果需要将某些分区的数据加载到内存中，可以在 SQL 语句中指定过滤条件。\n\n```\ntmp = loadTable(\"dfs://compoDB\", `pt)\nselect * from tmp where date=2017.08.07\n```\n\n对于内存的分区表，我们可以执行一些函数，如 [update!](https://docs.dolphindb.cn/zh/funcs/u/update_.html), [drop!](https://docs.dolphindb.cn/zh/funcs/d/dropColumns_.html), [rename!](https://docs.dolphindb.cn/zh/funcs/r/rename_.html), [sortBy!](https://docs.dolphindb.cn/zh/funcs/s/sortBy_.html)。\n"
    },
    "loadTableBySQL": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/loadTableBySQL.html",
        "signatures": [
            {
                "full": "loadTableBySQL(sql)",
                "name": "loadTableBySQL",
                "parameters": [
                    {
                        "full": "sql",
                        "name": "sql"
                    }
                ]
            }
        ],
        "markdown": "### [loadTableBySQL](https://docs.dolphindb.cn/zh/funcs/l/loadTableBySQL.html)\n\n\n\n#### 语法\n\nloadTableBySQL(sql)\n\n#### 详情\n\n把分区表中满足 SQL 查询的记录行加载到内存中。返回的是分区的内存表，其分区机制与分区表一致。\n\n**Note:** 该函数用于根据 *sql* 创建分区内存表，存在一些查询限制。因此，在大数据量查询场景下，使用该函数可能会出现内存占用多的情况。建议在这种情况下直接使用 SQL 语句进行查询。\n\n#### 参数\n\n**sql** 是表示 SQL 查询的元代码。它可以用 WHERE 子句来过滤分区或记录行，也可以用 SELECT 语句选择包括计算列在内的列，但不能包含 TOP 子句、GROUP BY 子句、 ORDER BY 子句、CONTEXT BY 子句和 LIMIT 子句。\n\n#### 返回值\n\n一张表。\n\n#### 例子\n\n```\nn=1000000\nt=table(rand('A'..'Z',n) as sym, 2000.01.01+rand(365,n) as date, 10.0+rand(2.0,n) as price1, 100.0+rand(20.0,n) as price2, rand(10,n) as qty1, rand(100,n) as qty2)\n\ndb = database(\"dfs://tradeDB\", VALUE, 'A'..'Z')\ntrades=db.createPartitionedTable(t,`trades,`sym).append!(t)\n\nsample=select * from loadTableBySQL(<select * from trades where date between 2000.03.01 : 2000.05.01>)\nsample=select * from loadTableBySQL(<select sym, date, price1, qty1 from trades where date between 2000.03.01 : 2000.05.01>)\n\ndates = 2000.01.16 2000.02.14 2000.08.01\nst = sql(<select sym, date, price1, qty1>, trades, expr(<date>, in, dates))\nsample = select * from loadTableBySQL(st)\n\ncolNames =`sym`date`qty2`price2\nst= sql(sqlCol(colNames), trades)\nsample = select * from loadTableBySQL(st)\n```\n"
    },
    "loadText": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/loadText.html",
        "signatures": [
            {
                "full": "loadText(filename, [delimiter], [schema], [skipRows=0], [arrayDelimiter], [containHeader], [arrayMarker])",
                "name": "loadText",
                "parameters": [
                    {
                        "full": "filename",
                        "name": "filename"
                    },
                    {
                        "full": "[delimiter]",
                        "name": "delimiter",
                        "optional": true
                    },
                    {
                        "full": "[schema]",
                        "name": "schema",
                        "optional": true
                    },
                    {
                        "full": "[skipRows=0]",
                        "name": "skipRows",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[arrayDelimiter]",
                        "name": "arrayDelimiter",
                        "optional": true
                    },
                    {
                        "full": "[containHeader]",
                        "name": "containHeader",
                        "optional": true
                    },
                    {
                        "full": "[arrayMarker]",
                        "name": "arrayMarker",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [loadText](https://docs.dolphindb.cn/zh/funcs/l/loadText.html)\n\n\n\n#### 语法\n\nloadText(filename, \\[delimiter], \\[schema], \\[skipRows=0], \\[arrayDelimiter], \\[containHeader], \\[arrayMarker])\n\n#### 详情\n\n将数据文件加载到 DolphinDB 的内存表中。`loadText` 使用单个线程加载数据，如果需要使用多个线程并行加载数据，请使用 [ploadText](https://docs.dolphindb.cn/zh/funcs/p/ploadText.html) 函数。\n\n* 解析列名：\n\n  * 不指定 *containHeader* 时，导入文本文件时将以字符串格式读取第一行数据，并根据该数据解析列名。但需要注意，系统内部对第一行数据设置了读取上限，即不能超过 256 KB。解析时，如果文件中第一行的内容不包含以数字开头的数据，那么加载文件时系统会将第一行作为列名。如果文件第一行记录中某列记录以数字开头，那么加载文件时系统可能会使用col0, col1, ...等作为列名。\n\n  * 指定 *containHeader* = true 时，则系统将第一行数据视为标题行，并解析出列名。\n\n  * 指定 *containHeader* = false 时，则系统将添加列名 col0, col1, ... 。\n\n* 解析类型：\n\n  * 当 DolphinDB 加载数据文件时，会进行随机抽样，并基于样本决定每列的数据类型。这个方法不一定每次都能准确决定各列的数据类型。因此我们建议，在加载数据前，使用 [extractTextSchema](https://docs.dolphindb.cn/zh/funcs/e/extractTextSchema.html) 函数查看 DolphinDB 识别每列的数据类型。\n\n  * 当加载的数据文件中包含了表达时间、日期的数据时，满足分隔符要求的这部分数据（日期数据分隔符包含\"-\"、\"/\"和\".\"，时间数据分隔符为\":\"）会解析为相应的类型。例如，\"12:34:56\"解析为SECOND类型；\"23.04.10\"解析为DATE类型。对于不包含分隔符的数据，形如\"yyMMdd\"的数据同时满足0<=yy<=99，0<=MM<=12，1<=dd<=31，会被优先解析成DATE；形如\"yyyyMMdd\"的数据同时满足1900<=yyyy<=2100，0<=MM<=12，1<=dd<=31会被优先解析成DATE。\n\n  * 如果 DolphinDB 识别的数据类型不符合预期，可以在 schema 的 type 列中指定数据类型。对于日期列或时间列，如果 DolphinDB 识别的数据类型不符合预期，不仅需要在 schema 的 type 列指定时间类型，还需要在 format 列中指定数据文件中日期或时间的格式（用字符串表示），如 \"MM/dd/yyyy\"。如何表示日期和时间格式请参考 [ParsingandFormatofTemporalVariables](https://docs.dolphindb.cn/zh/progr/data_mani/format_temp_obj.html)。\n\n如果只需加载数据文件中的部分列，需要在 schema 的 col 列中指定要加载的列的下标。\n\n由于 DolphinDB 的字符串采用 UTF-8 编码，加载的文件必须是 UTF-8 编码。\n\n由于 DolphinDB 中列名仅可使用中文或英文字母、数字或下划线 (\\_)，且必须以中文或英文字母开头，若数据文件中的列名不符合要求，系统会依据以下规则自动调整列名：\n\n* 若数据中列名存在中文或英文字母、数字或下划线之外的字符，将其转换为下划线。\n\n* 若数据中列名第一个字符不是中文或英文字母，添加 \"c\" 作为该列名首字符。\n\n以下是数据文件中不合规列名以及自动转换的列名的例子：\n\n| 数据文件中列名 | 自动转换的列名   |\n| ------- | --------- |\n| 1\\_test | c1\\_test  |\n| test-a! | test\\_a\\_ |\n| \\[test] | c\\_test\\_ |\n\n**Note:** 从 2.00.10 版本开始，`loadText` 支持加载一条记录中包含多个换行符的数据文件。\n\n#### 参数\n\n**filename** 字符串，表示数据文件的路径。仅支持 CSV 格式的文件。若传入其他格式文件，则无法保证数据准确性。\n\n**delimiter** 字符串标量，表示数据文件中各列的分隔符。分隔符可以是一个或多个字符，默认是逗号（\",\"）。\n\n**schema** 表对象，用于指定各字段的数据类型。它可以包含以下四列（其中，name 和 type 这两列是必需的）\n\n| 列名     | 含义                                                    |\n| ------ | ----------------------------------------------------- |\n| name   | 字符串，表示列名                                              |\n| type   | 字符串，表示各列的数据类型。暂不支持 BLOB, COMPLEX, POINT, DURATION 类型。 |\n| format | 字符串，表示数据文件中日期或时间列的格式                                  |\n| col    | 整型，表示要加载的列的下标。该列的值必须是升序。                              |\n\n**Note:** 若 type 为时间类型，则源数据的时间类型格式需要和 DolphinDB 时间类型数据格式一致。若原始数据的时间戳和 DolphinDB 时间类型不兼容，建议导入时先指定为字符串类型，再通过 [temporalParse](https://docs.dolphindb.cn/zh/funcs/t/temporalParse.html) 函数进行转换。\n\n**skipRows** 0 到 1024 之间的整数，表示从文件头开始忽略的行数。它是一个可选参数。默认值为 0。\n\n**arrayDelimiter** 数据文件中数组向量列的分隔符。默认是逗号。由于不支持自动识别数组向量，必须同步修改 *schema* 的 type 列修为数组向量类型。\n\n**containHeader** 布尔值，表示数据文件是否包含标题行，默认为空。若不设置，则系统将会分析第一行数据并确定其是否为标题行。不同设置下，列名解析规则见详情描述。\n\n**arrayMarker** 包含两个字符的字符串或或 CHAR 类型数据对，两个字符分别表示数组向量左右边界的标识符。默认标识符为双引号（\"）。\n\n* 不能包含空格、Tab(`\\t`) 和换行符(`\\t`和`\\n`)。\n\n* 不能包含数字或字母。\n\n* 如果其中一个为双引号(\")，另一个也必须为双引号。\n\n* 如果标识符为 `'`，`\"` 或`\\` ，需视情况添加转义符。例如 `arrayMarker=\"\\\"\\\"\"`。\n\n* 如果 *delimiter*是单个字符，则 *arrayMarker*不能包含与其相同的字符。\n\n* 如果 *delimiter*是多个字符，则 *arrayMarker* 左边界不能与 *delimiter*的首个字符相同。\n\n#### 返回值\n\n一张表。\n\n#### 例子\n\n首先，使用以下脚本生成模拟的数据文件：\n\n```\nn=10\nsym=rand(`AAPL`ORCL`MS`SUN,n)\npermno=take(10001,n)\ndate=rand(2019.06.01..2019.06.10,n)\nopen=rand(100.0,n)\nhigh=rand(200.0,n)\nclose=rand(200.0,n)\npre_close=rand(200.0,n)\nchange=rand(100.0,n)\nvol=rand(10000,n)\namount=rand(100000.0,n)\nt=table(sym,permno,date,open,high,close,pre_close,change,vol,amount)\nsaveText(t,\"/home/DolphinDB/Data/stock.csv\");\n```\n\n#### 例 1. 直接加载数据文件\n\n```\ntt=loadText(\"/home/DolphinDB/Data/stock.csv\");\n// output\ntt;\n```\n\n| sym  | permno | date       | open      | high       | close      | pre\\_close | change    | vol  | amount       |\n| ---- | ------ | ---------- | --------- | ---------- | ---------- | ---------- | --------- | ---- | ------------ |\n| MS   | 10001  | 2019.06.06 | 90.346594 | 80.530542  | 96.474428  | 146.305659 | 0.720236  | 1045 | 90494.568297 |\n| AAPL | 10001  | 2019.06.07 | 91.165315 | 8.482074   | 85.514922  | 16.259077  | 76.797829 | 7646 | 91623.485996 |\n| AAPL | 10001  | 2019.06.03 | 45.361885 | 14.077451  | 149.848419 | 89.110375  | 45.499145 | 9555 | 98171.601654 |\n| MS   | 10001  | 2019.06.04 | 8.98688   | 0.591778   | 155.54643  | 132.423187 | 69.95799  | 1202 | 3512.927634  |\n| MS   | 10001  | 2019.06.07 | 62.866173 | 33.465237  | 174.20712  | 102.695818 | 74.580523 | 3524 | 61943.64517  |\n| MS   | 10001  | 2019.06.09 | 32.819915 | 13.319577  | 136.729618 | 63.980405  | 60.66375  | 7078 | 85138.216568 |\n| MS   | 10001  | 2019.06.07 | 90.210866 | 22.728777  | 150.212291 | 59.454705  | 73.916303 | 5306 | 19883.845607 |\n| AAPL | 10001  | 2019.06.06 | 83.752686 | 71.3501    | 98.211979  | 145.60098  | 94.428343 | 8852 | 9236.020781  |\n| ORCL | 10001  | 2019.06.01 | 81.64719  | 129.702202 | 182.784373 | 117.575967 | 74.84595  | 2942 | 43394.871242 |\n| AAPL | 10001  | 2019.06.02 | 10.068382 | 80.875383  | 181.674585 | 138.783821 | 25.298267 | 1088 | 82981.043775 |\n\n```\nschema(tt).colDefs;\n```\n\n| name       | typeString | typeInt | comment |\n| ---------- | ---------- | ------- | ------- |\n| sym        | SYMBOL     | 17      |         |\n| permno     | INT        | 4       |         |\n| date       | DATE       | 6       |         |\n| open       | DOUBLE     | 16      |         |\n| high       | DOUBLE     | 16      |         |\n| close      | DOUBLE     | 16      |         |\n| pre\\_close | DOUBLE     | 16      |         |\n| change     | DOUBLE     | 16      |         |\n| vol        | INT        | 4       |         |\n| amount     | DOUBLE     | 16      |         |\n\n#### 例 2. 指定某列的数据类型来加载数据文件\n\n例如，我们想要把 permno 列的数据类型转换成 SYMBOL，可以用 [extractTextSchema](https://docs.dolphindb.cn/zh/funcs/e/extractTextSchema.html) 函数获取输入文件的结构，在导入数据前修改该列的数据类型，并指定 `loadText` 函数的 *schema* 参数。\n\n```\nschema=extractTextSchema(\"/home/DolphinDB/Data/stock.csv\");\nupdate schema set type=`SYMBOL where name=`permno;\ntt=loadText(\"/home/DolphinDB/Data/stock.csv\",,schema);\nschema(tt).colDefs;\n```\n\n| name       | typeString | typeInt | comment |\n| ---------- | ---------- | ------- | ------- |\n| sym        | SYMBOL     | 17      |         |\n| permno     | SYMBOL     | 17      |         |\n| date       | DATE       | 6       |         |\n| open       | DOUBLE     | 16      |         |\n| high       | DOUBLE     | 16      |         |\n| close      | DOUBLE     | 16      |         |\n| pre\\_close | DOUBLE     | 16      |         |\n| change     | DOUBLE     | 16      |         |\n| vol        | INT        | 4       |         |\n| amount     | DOUBLE     | 16      |         |\n\n用户也可以指定所有数据类型：\n\n```\nschematable=table(`sym`permno`date`open`high`close`pre_close`change`vol`amount as name,`SYMBOL`SYMBOL`DATE`DOUBLE`DOUBLE`DOUBLE`DOUBLE`DOUBLE`INT`DOUBLE as type)\ntt=loadText(\"/home/DolphinDB/Data/stock.csv\",,schematable)\nschema(tt).colDefs;\n```\n\n| name       | typeString | typeInt | comment |\n| ---------- | ---------- | ------- | ------- |\n| sym        | SYMBOL     | 17      |         |\n| permno     | SYMBOL     | 17      |         |\n| date       | DATE       | 6       |         |\n| open       | DOUBLE     | 16      |         |\n| high       | DOUBLE     | 16      |         |\n| close      | DOUBLE     | 16      |         |\n| pre\\_close | DOUBLE     | 16      |         |\n| change     | DOUBLE     | 16      |         |\n| vol        | INT        | 4       |         |\n| amount     | DOUBLE     | 16      |         |\n\n#### 例 3. 只加载部分列\n\n例如，只需加载 sym, date, open, high, close, vol, amount 这 7 列。注意，加载数据时，不能改变各列的先后顺序。如果需要调整列的顺序，可以将数据文件加载后，再使用`reorderColumns!`函数。\n\n```\nschema=extractTextSchema(\"/home/DolphinDB/Data/stock.csv\");\nschema=select * from schema where name in `sym`date`open`high`close`vol`amount\nschema[`col]=[0,2,3,4,5,8,9]\n\ntt=loadText(\"/home/DolphinDB/Data/stock.csv\",,schema);\ntt;\n```\n\n| sym  | date       | open      | high       | close      | vol  | amount       |\n| ---- | ---------- | --------- | ---------- | ---------- | ---- | ------------ |\n| SUN  | 2019.06.10 | 18.675316 | 72.754005  | 136.463909 | 1376 | 31371.319038 |\n| AAPL | 2019.06.05 | 42.098717 | 196.873587 | 41.513899  | 3632 | 9950.864129  |\n| ORCL | 2019.06.05 | 62.223474 | 197.099027 | 123.785675 | 3069 | 38035.800937 |\n| SUN  | 2019.06.03 | 0.18163   | 50.669866  | 4.652098   | 6213 | 1842.198893  |\n| SUN  | 2019.06.06 | 32.54134  | 67.012502  | 130.312294 | 4891 | 55744.156823 |\n| SUN  | 2019.06.07 | 56.899091 | 81.709825  | 61.786176  | 1133 | 69057.849515 |\n| AAPL | 2019.06.08 | 77.026838 | 38.504431  | 22.68496   | 3672 | 34420.187073 |\n| ORCL | 2019.06.07 | 62.752656 | 39.33621   | 48.483091  | 4382 | 41601.601639 |\n| AAPL | 2019.06.02 | 8.5487    | 17.623418  | 141.88325  | 8092 | 15449.159988 |\n| AAPL | 2019.06.02 | 26.178685 | 197.320455 | 110.52407  | 5541 | 14616.820449 |\n\n#### 例 4. 加载文件时，忽略数据文件的前 2 行。\n\n示例文件的第一行为列名，因此忽略前 2 行后，总的数据条数为 9。\n\n```\nre=loadText(filename=\"/home/DolphinDB/Data/stock.csv\",skipRows=2)\nselect count(*) from re;\n```\n\n| count |\n| ----- |\n| 9     |\n\n#### 例 5. 指定时间类型的格式来加载数据文件\n\n生成本例所需的数据文件：\n\n```\ntime=[\"20190623145457\",\"20190623155423\",\"20190623163025\"]\nsym=`AAPL`MS`IBM\nqty=2200 5400 8670\nprice=54.78 59.64 65.23\nt=table(time,sym,qty,price)\nsaveText(t,\"/home/DolphinDB/Data/t2.csv\");\n```\n\n加载数据前，使用 [extractTextSchema](https://docs.dolphindb.cn/zh/funcs/e/extractTextSchema.html) 函数获取该数据文件的结构：\n\n```\nextractTextSchema(\"/home/DolphinDB/Data/t2.csv\");\n```\n\n| name  | type   |\n| ----- | ------ |\n| time  | LONG   |\n| sym   | SYMBOL |\n| qty   | INT    |\n| price | DOUBLE |\n\n由于 time 列的时间格式与 DolphinDB 中的时间格式不同，如果直接加载该文件，time 列的数据将会被识别为长整型。为了能够正确加载该文件 time 列的数据，需要指定 time 列的数据类型为 DATETIME，并且指定该列的格式为 \"yyyyMMddHHmmss\"。\n\n```\nschema=extractTextSchema(\"/home/DolphinDB/Data/t2.csv\")\nupdate schema set type = \"DATETIME\" where name = \"time\"\nschema[`format]=[\"yyyyMMddHHmmss\",,,];\n\nloadText(\"/home/DolphinDB/Data/t2.csv\",,schema);\n```\n\n| time                | sym  | qty  | price |\n| ------------------- | ---- | ---- | ----- |\n| 2019.06.23T14:54:57 | AAPL | 2200 | 54.78 |\n| 2019.06.23T15:54:23 | MS   | 5400 | 59.64 |\n| 2019.06.23T16:30:25 | IBM  | 8670 | 65.23 |\n\n#### 例 6. 加载包含数组向量列的数据\n\n使用以下脚本模拟生成一个 csv 文本文件：\n\n```\nbid = array(DOUBLE[], 0, 20).append!([1.4799 1.479 1.4787, 1.4796 1.479 1.4784, 1.4791 1.479 1.4784])\nask = array(DOUBLE[], 0, 20).append!([1.4821 1.4825 1.4828, 1.4818 1.482 1.4821, 1.4814 1.4818 1.482])\nTradeDate = 2022.01.01 + 1..3\nSecurityID = rand(`APPL`AMZN`IBM, 3)\nt = table(SecurityID as `sid, TradeDate as `date, bid as `bid, ask as `ask)\nt;\nsaveText(t,filename=\"/home/DolphinDB/Data/t.csv\",delimiter=',',append=true)\n```\n\nsaveText在保存数组向量到 csv 文件时，把原数据中的`[ ]` 替换为了 `\" \"`，文件内容如下：\n\n```\nsid,date,bid,ask\nAPPL,2022.01.02,\"1.4799,1.479,1.4787\",\"1.4821,1.4825,1.4828\"\nIBM,2022.01.03,\"1.4796,1.479,1.4784\",\"1.4818,1.482,1.4821\"\nAPPL,2022.01.04,\"1.4791,1.479,1.4784\",\"1.4814,1.4818,1.482\"\n```\n\n然后调用 loadText 导入该文件：\n\n```\npath = \"/home/DolphinDB/Data/t.csv\"\nschema=extractTextSchema(path);\nupdate schema set type = \"DOUBLE[]\" where name=\"bid\" or name =\"ask\"\nt = loadText(path, schema=schema, arrayDelimiter=\",\")\nt;\n```\n\n| sid  | date       | bid                    | ask                     |\n| ---- | ---------- | ---------------------- | ----------------------- |\n| AMZN | 2022.01.02 | \\[1.4799,1.479,1.4787] | \\[1.4821,1.4825,1.4828] |\n| AMZN | 2022.01.03 | \\[1.4796,1.479,1.4784] | \\[1.4818,1.482,1.4821]  |\n| IBM  | 2022.01.04 | \\[1.4791,1.479,1.4784] | \\[1.4814,1.4818,1.482]  |\n\n通过 saveText 导出 csv 文件时，数组向量的边界标识默认为双引号（”），本例中 t.csv 的内容如下\n\n当数组向量的边界标识不为双引号时，可以通过设置参数 arrayMarker 导入，例如当 t.csv 的内容如下时\n\n```\nsid,date,bid,ask\nAPPL,2022.01.02,[1.4799,1.479,1.4787],[1.4821,1.4825,1.4828]\nIBM,2022.01.03,[1.4796,1.479,1.4784],[1.4818,1.482,1.4821]\nAPPL,2022.01.04,[1.4791,1.479,1.4784],[1.4814,1.4818,1.482]\n```\n\n通过以下脚本导入\n\n```\npath = \"/home/DolphinDB/Data/t.csv\"\nschema=extractTextSchema(path);\nupdate schema set type = \"DOUBLE[]\" where name=\"bid\" or name =\"ask\"\nt = loadText(path, schema=schema, arrayDelimiter=\",\",arrayMarker=\"[]\")\nt;\n```\n\n#### 例 7. 批量导入小文件\n\n在现实场景中，数据供应商会将一只股票数据保存到一个文件中，这种场景的特点是文件数量比较多，但单个文件比较小。如果将文件一个个导入，则效率会比较低。为提高导入效率，可以考虑将多个小文件批量合并后再导入。\n\n数据文件：[smallDataset.zip](https://cdn.dolphindb.cn/zh/tutorials/data/smallDataset.zip)\n\n```\ndb = database(\"dfs://k_day_level\")\ncolName = `securityid`tradetime`open`close`high`low`vol`val`vwap\ncolType = [SYMBOL,TIMESTAMP,DOUBLE,DOUBLE,DOUBLE,DOUBLE,INT,DOUBLE,DOUBLE]\ntbSchema = table(1:0, colName, colType)\nif(existsDatabase(\"dfs://k_day_level\")){\n\tdropDatabase(\"dfs://k_day_level\")\n}\ndatabase(directory = 'dfs://k_day_level', partitionType = RANGE, partitionScheme =[2000.01M,2001.01M,2002.01M,2003.01M,2004.01M,2005.01M,2006.01M,2007.01M,2008.01M,2009.01M,2010.01M,2011.01M,2012.01M,2013.01M,2014.01M,2015.01M,2016.01M,2017.01M,2018.01M,2019.01M,2020.01M,2021.01M,2022.01M,2023.01M,2024.01M]$7, engine= `OLAP, atomic = `TRANS)\ndb.createPartitionedTable(table=tbSchema,tableName=`k_day,partitionColumns=`tradetime)\n\n//2. 导入数据文件\nbatchNum=1000 \ndir = \"/home/data/smallDataset/\"\nallFiles = files(dir).filename\ni = 0\ns = allFiles.size()\ndo{\n    files =allFiles[i:min(i+batchNum, s)]\n    data = each(loadText, dir + files).unionAll(false)\n    loadTable(\"dfs://k_day_level\",\"k_day\").append!(data)\n    i = i + batchNum\n}while(i < s)\n\nselect top 10* from loadTable(\"dfs://k_day_level\",\"k_day\")\n```\n\n| securityid | tradetime               | open    | close   | high    | low     | vol    | val            | vwap    |\n| ---------- | ----------------------- | ------- | ------- | ------- | ------- | ------ | -------------- | ------- |\n| sz000001   | 2010.01.01T00:00:00.000 | 35.9484 | 35.4385 | 36.3261 | 35.9569 | 10,732 | 380,325.7701   | 35.4385 |\n| sz000002   | 2010.01.01T00:00:00.000 | 5.4374  | 7.2864  | 5.4665  | 3.8142  | 45,577 | 332,092.5668   | 7.2864  |\n| sz000003   | 2010.01.01T00:00:00.000 | 8.4177  | 10.5074 | 8.7004  | 7.577   | 96,865 | 1,017,794.5994 | 10.5074 |\n| sz000004   | 2010.01.01T00:00:00.000 | 78.7732 | 76.4809 | 79.1491 | 78.4188 | 67,520 | 5,163,993.091  | 76.4809 |\n| sz000005   | 2010.01.01T00:00:00.000 | 23.5196 | 25.8487 | 23.9986 | 23.9379 | 1,156  | 29,881.1144    | 25.8487 |\n| sz000006   | 2010.01.01T00:00:00.000 | 75.3909 | 73.9721 | 75.5661 | 74.8373 | 70,337 | 5,202,974.0605 | 73.9721 |\n| sz000007   | 2010.01.01T00:00:00.000 | 21.9932 | 22.7951 | 22.5291 | 21.218  | 76,912 | 1,753,219.9525 | 22.7951 |\n| sz000008   | 2010.01.01T00:00:00.000 | 21.0682 | 21.5055 | 21.6914 | 20.733  | 9,320  | 200,431.077    | 21.5055 |\n| sz000009   | 2010.01.01T00:00:00.000 | 77.2482 | 75.6649 | 78.2001 | 76.9927 | 13,538 | 1,024,351.3968 | 75.6649 |\n| sz000010   | 2010.01.01T00:00:00.000 | 54.2793 | 55.6466 | 54.3281 | 53.6054 | 31,924 | 1,776,461.4488 | 55.6466 |\n"
    },
    "loadTextEx": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/loadTextEx.html",
        "signatures": [
            {
                "full": "loadTextEx(dbHandle, tableName, partitionColumns, filename, [delimiter], [schema], [skipRows=0], [transform], [sortColumns], [atomic=false], [arrayDelimiter], [containHeader], [arrayMarker])",
                "name": "loadTextEx",
                "parameters": [
                    {
                        "full": "dbHandle",
                        "name": "dbHandle"
                    },
                    {
                        "full": "tableName",
                        "name": "tableName"
                    },
                    {
                        "full": "partitionColumns",
                        "name": "partitionColumns"
                    },
                    {
                        "full": "filename",
                        "name": "filename"
                    },
                    {
                        "full": "[delimiter]",
                        "name": "delimiter",
                        "optional": true
                    },
                    {
                        "full": "[schema]",
                        "name": "schema",
                        "optional": true
                    },
                    {
                        "full": "[skipRows=0]",
                        "name": "skipRows",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[transform]",
                        "name": "transform",
                        "optional": true
                    },
                    {
                        "full": "[sortColumns]",
                        "name": "sortColumns",
                        "optional": true
                    },
                    {
                        "full": "[atomic=false]",
                        "name": "atomic",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[arrayDelimiter]",
                        "name": "arrayDelimiter",
                        "optional": true
                    },
                    {
                        "full": "[containHeader]",
                        "name": "containHeader",
                        "optional": true
                    },
                    {
                        "full": "[arrayMarker]",
                        "name": "arrayMarker",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [loadTextEx](https://docs.dolphindb.cn/zh/funcs/l/loadTextEx.html)\n\n\n\n#### 语法\n\nloadTextEx(dbHandle, tableName, partitionColumns, filename, \\[delimiter], \\[schema], \\[skipRows=0], \\[transform], \\[sortColumns], \\[atomic=false], \\[arrayDelimiter], \\[containHeader], \\[arrayMarker])\n\n#### 详请\n\n将数据文件加载到数据库中。\n\n* 如果要将数据文件加载到分布式数据库中，必须指定 *tableName*，并且不能为空字符串。\n\n* 如果要将数据文件加载到内存数据库中，那么 *tableName* 为空字符串或者不指定 *tableName*。\n\n如果指定了 *transform* 参数，需要先创建分区表，再加载数据。系统会对数据文件中的数据执行 *transform* 参数指定的函数，再将得到的结果保存到数据库中。\n\n`loadTextEx` 函数与 [loadText](https://docs.dolphindb.cn/zh/funcs/l/loadText.html) 函数有很多共同之处，例如第一行数据是否判断为列名，如何确定各列的数据类型，列名的要求及自动调整等。细节请参见 [loadText](https://docs.dolphindb.cn/zh/funcs/l/loadText.html) 函数文档。\n\n#### 参数\n\n**dbHandle** 是数据库的句柄，可以是内存数据库或分布式数据库。\n\n**tableName** 是一个字符串，表示表的名称。\n\n**partitionColumns** 是字符串标量或向量，表示分区列。对于顺序分区类型的数据库，*partitionColumns* 为空字符串\"\"。对于组合分区类型的数据库，*partitionColumns* 是字符串向量。\n\n**filename** 是字符串，表示数据文件的路径。仅支持 CSV 格式的文件。若传入其他格式文件，则无法保证数据准确性。\n\n**delimiter** 字符串标量，表示数据文件中各列的分隔符。分隔符可以是一个或多个字符，默认是逗号（\",\"）。\n\n**schema** 是一个表，用于指定各列的数据类型。具体请参考 [loadText](https://docs.dolphindb.cn/zh/funcs/l/loadText.html) 的 *schema* 参数。\n\n**skipRows** 是0到1024之间的整数，表示从文件头开始忽略的行数。它是一个可选参数。默认值为0。\n\n**transform** 是一元函数，并且该函数接受的参数必须是一个表。\n\n**sortColumns** 字符串标量或向量，用于指定每一分区内的排序列，每次写入磁盘的数据在每一分区内将按 *sortColumns* 进行排序。系统默认 *sortColumns* （指定多列时） 除最后一列外的列字段作为排序的索引列，称作 sort key。每一分区内，同一个 sort key 组合值对应的数据将按最后一列的值顺序连续存放在一起。查询时，若查询条件包含索引列，可以快速定位数据所在的数据块位置，提高查询性能。\n\n* 仅当 dbHandle 指示的数据库采用 \"TSDB\" 引擎（engine=\"TSDB\"）时，本参数才生效。\n* *sortColumns* 只能是 INTEGER, TEMPORAL, LITERAL 类别（除 BLOB） 或 DECIMAL 类型。\n  * 若 *sortColumns* 指定为多列，则 *sortColumns* 的最后一列必须为时间类型或整型，其余列为索引列，且索引列不能为为 TIME, TIMESTAMP, NANOTIME, NANOTIMESTAMP 类型。\n  * 若 *sortColumns* 仅指定一列，则该列作为 sort key，其类型可以是除 TIME, TIMESTAMP, NANOTIME, NANOTIMESTAMP 之外的任意类型。若 *sortColumns* 为时间类型 （非分区列），且同时指定了 *sortKeyMappingFunction*，则查询的过滤条件中 *sortColumns* 只能与相同时间类型的值进行比较。\n* 频繁查询的字段适合设置为 *sortColumns*（建议不超过 4 列），且建议优先把查询频率高的字段作为 *sortColumns* 中位置靠前的列。\n* 为保证性能最优，建议每个分区内索引列的组合数（sort key）不超过 2000 个。\n* *sortColumns* 是每个分区内部 level file 内数据的排序依据，与其是否为分区字段无关。\n\n**atomic** 是一个布尔值，表示开启 Cache Engine 的情况下，是否保证文件加载的原子性。设置为 true，一个文件的加载过程视为一个完整的事务；设置为 false，加载一个文件的过程分为多个事务进行。\n\n**Note:** 如果要加载的文件超过 Cache Engine 大小，必须设置 *atomic* = false。否则，一个事务可能卡住（既不能提交，也不能回滚）。\n\n**arrayDelimiter** 是数据文件中数组向量列的分隔符。默认是逗号。由于不支持自动识别数组向量，必须同步修改 *schema* 的 type 列为数组向量类型。\n\n**containHeader** 布尔值，表示数据文件是否包含标题行，默认为空。具体请参考 [loadText](https://docs.dolphindb.cn/zh/funcs/l/loadText.html) 的 *containHeader* 参数。\n\n**arrayMarker** 包含两个字符的字符串或或 CHAR 类型数据对，两个字符分别表示数组向量左右边界的标识符。默认标识符为双引号（\"）。\n\n* 不能包含空格、Tab(`\\t`) 和换行符(`\\t`和`\\n`)。\n\n* 不能包含数字或字母。\n\n* 如果其中一个为双引号(\")，另一个也必须为双引号。\n\n* 如果标识符为 `'`，`\"` 或`\\` ，需视情况添加转义符。例如 `arrayMarker=\"\\\"\\\"\"`。\n\n* 如果 *delimiter*是单个字符，则 *arrayMarker*不能包含与其相同的字符。\n\n* 如果 *delimiter*是多个字符，则 *arrayMarker* 左边界不能与 *delimiter*的首个字符相同。\n\n#### 返回值\n\n一个表对象。\n\n#### 例子\n\n例1. 使用以下脚本生成模拟的数据文件：\n\n```\nn=10000\nID=rand(100, n)\ndates=2017.08.07..2017.08.11\ndate=rand(dates, n)\nvol=rand(1..10 join int(), n)\nt=table(ID, date, vol)\nsaveText(t, \"/home/DolphinDB/Data/t.txt\");\n```\n\n例 2. 把 t.txt 文件加载到范围分区类型的分布式数据库中，分区列为 ID。\n\n```\ndb = database(directory=\"dfs://rangedb\", partitionType=RANGE, partitionScheme=0 51 101)\npt=loadTextEx(dbHandle=db,tableName=`pt, partitionColumns=`ID, filename=\"/home/DolphinDB/Data/t.txt\");\n```\n\n例 3. 将文本文件加载到使用 TSDB 存储引擎创建的分布式数据库中。\n\n```\ndb = database(directory=\"dfs://rangedb\", partitionType=RANGE, partitionScheme=0 51 101, engine='TSDB')\npt=loadTextEx(dbHandle=db, tableName=`pt, partitionColumns=`ID, filename=\"/home/DolphinDB/Data/t.txt\", sortColumns=`ID`date);\n```\n\n例 4. 把 t.txt 文件加载到组合分区类型的分布式数据库中，分区列为 date 和 ID。\n\n```\ndbDate = database(directory=\"\", partitionType=VALUE, partitionScheme=2017.08.07..2017.08.11)\ndbID=database(directory=\"\", partitionType=RANGE, partitionScheme=0 51 101)\ndb = database(directory=\"dfs://compoDB\", partitionType=COMPO, partitionScheme=[dbDate, dbID])\npt = loadTextEx(dbHandle=db,tableName=`pt, partitionColumns=`date`ID, filename=\"/home/DolphinDB/Data/t.txt\");\n```\n\n例 5. 把 t.txt 加载到值分区类型分内存数据库中，分区列为 date。\n\n```\ndb = database(directory=\"\", partitionType=VALUE, partitionScheme=2017.08.07..2017.08.11)\npt = db.loadTextEx(tableName=\"\", partitionColumns=`date, filename=\"/home/DolphinDB/Data/t.txt\");\n\npt.sortBy!(`ID`x);\n```\n\n例 6. 加载包含数组向量列的数据\n\n导入包含数组向量的数据文件时，由于系统无法自动识别数组向量，因此需要通过 *schema* 参数修改数组向量列的类型，并使用 *arrayDelimiter* 参数指定数据文件中数组向量列的分隔符。\n\n首先，使用以下脚本模拟生成一个 csv 文本文件：\n\n```\nbid = array(DOUBLE[], 0, 20).append!([1.4799 1.479 1.4787, 1.4796 1.479 1.4784, 1.4791 1.479 1.4784])\nask = array(DOUBLE[], 0, 20).append!([1.4821 1.4825 1.4828, 1.4818 1.482 1.4821, 1.4814 1.4818 1.482])\nTradeDate = 2022.01.01 + 1..3\nSecurityID = rand(`APPL`AMZN`IBM, 3)\nt = table(SecurityID as `sid, TradeDate as `date, bid as `bid, ask as `ask)\nt;\nsaveText(t,filename=\"/home/DolphinDB/Data/t.csv\",delimiter=',',append=true)\n```\n\n然后，调用 loadTextEx 导出该文件，本例通过 *schema* 参数指定数组向量列 bid 和 ask 的数据类型为 DOUBLE\\[]。\n\n```\ndb = database(directory=\"dfs://testDB\", partitionType=VALUE, partitionScheme=`APPL`AMZN`IBM)\npath = \"/home/DolphinDB/Data/t.csv\"\nschema = extractTextSchema(path);\nupdate schema set type = \"DOUBLE[]\" where name=\"bid\" or name =\"ask\"\nt = loadTextEx(dbHandle=db, tableName=`t, partitionColumns=`sid, filename=path, schema=schema, arrayDelimiter=\",\");\nselect * from t;\n```\n\n| sid  | date       | bid                    | ask                     |\n| ---- | ---------- | ---------------------- | ----------------------- |\n| APPL | 2022.01.02 | \\[1.4799,1.479,1.4787] | \\[1.4821,1.4825,1.4828] |\n| IBM  | 2022.01.03 | \\[1.4796,1.479,1.4784] | \\[1.4818,1.482,1.4821]  |\n| IBM  | 2022.01.04 | \\[1.4791,1.479,1.4784] | \\[1.4814,1.4818,1.482]  |\n\n例 7. 使用 *transform* 参数处理导入的数据，再将其写入数据库。\n\n示例文件（由例 1 生成）的 vol 列包含空值。通过*transform* 将空值填充为0后再加载到组合分区类型的分布式数据库中。\n\n```\ndbDate = database(directory=\"\", partitionType=VALUE, partitionScheme=2017.08.07..2017.08.11)\ndbID=database(directory=\"\", partitionType=RANGE, partitionScheme=0 51 101)\ndb = database(directory=\"dfs://compoDB\", partitionType=COMPO, partitionScheme=[dbDate, dbID]);\n\npt=db.createPartitionedTable(table=t, tableName=`pt, partitionColumns=`date`ID)\npt=loadTextEx(dbHandle=db, tableName=`pt, partitionColumns=`date`ID, filename=\"/home/DolphinDB/Data/t.txt\", transform=nullFill!{,0});\n```\n\n例 8. 通过 *schema* 修改待导入字段的数据类型，同时通过 *transform* 参数，添加新的字段且调整列的顺序。\n\n在实际场景中，通常是一个股票的数据保存到一个文件，该文件以标的名称命名，且不包含标的名称列。导入需求如下：\n\n* 在导入数据时，需要将在数据表中添加一列以存储标的名称。\n\n* 调整数据文件中的字段顺序和待导入表中字段顺序一致。\n\n本例以导入一个标的的文件为例进行说明。\n\n* [sz000001.csv](https://cdn.dolphindb.cn/zh/tutorials/data/import_data_06/sz000001.csv) 文件中字段顺序是 tradetime，open，close，high，low，vol。\n\n* 待导入表的字段顺序是 symbol（需要添加的列），datetime，vol，open，close，high，low。\n\n```\ndir = \"/home/data/sz000001.csv\"\nsym = dir.split('/').tail(1).split('.')[0]\n\n// 调整 tradetime 列的类型为 DATETIME\nschema = extractTextSchema(dir)\nupdate schema set type=\"DATETIME\" where name=\"tradetime\"\n\nif(existsDatabase(\"dfs://stock_data\")) {\n\tdropDatabase(\"dfs://stock_data\")\n}\n\ndb=database(directory=\"dfs://stock_data\", partitionType=VALUE, partitionScheme=2000.01M..2019.12M)\n\ncolNames=`sym`tradetime`vol`open`close`high`low\ncolTypes=[SYMBOL, DATETIME, INT, DOUBLE, DOUBLE, DOUBLE, DOUBLE]\nt = table(1:0, colNames, colTypes)\npt = db.createPartitionedTable(t, `pt, `tradetime);\ndef mytrans(mutable t, sym, colNames){\n        t.replaceColumn!(`tradetime, datetime(t.tradetime))\n        //在中添加第一列 sym\n        t1 = select sym, * from t\n        //通过 reorderColumns! 调整表中各列的顺序 \n        t1.reorderColumns!(colNames)\n        return t1\n}\n\n// 指定 schema 和 transform 参数，对数据进行处理\nloadTextEx(db, `pt, `tradetime, dir, schema=schema, transform=mytrans{,sym, colNames})\n\nselect top 10 * from loadTable(\"dfs://stock_data\", `pt)\n```\n\n| sym      | tradetime           | vol    | open    | close   | high    | low     |\n| -------- | ------------------- | ------ | ------- | ------- | ------- | ------- |\n| sz000001 | 2010.01.01T00:00:00 | 10,732 | 35.9484 | 35.4385 | 36.3261 | 35.9569 |\n| sz000001 | 2010.01.04T00:00:00 | 97,555 | 16.4653 | 13.6348 | 16.7255 | 14.9401 |\n| sz000001 | 2010.01.05T00:00:00 | 43,992 | 51.3616 | 53.1199 | 52.2155 | 50.4782 |\n| sz000001 | 2010.01.06T00:00:00 | 85,283 | 76.3469 | 80.0076 | 76.7017 | 74.9479 |\n| sz000001 | 2010.01.07T00:00:00 | 78,837 | 38.9411 | 35.8283 | 39.5269 | 38.2178 |\n| sz000001 | 2010.01.08T00:00:00 | 13,317 | 70.8803 | 67.9027 | 71.8693 | 70.8072 |\n| sz000001 | 2010.01.11T00:00:00 | 22,958 | 96.3163 | 97.4031 | 96.5605 | 96.364  |\n| sz000001 | 2010.01.12T00:00:00 | 45,621 | 17.2699 | 18.5016 | 17.7689 | 16.5028 |\n| sz000001 | 2010.01.13T00:00:00 | 54,886 | 75.7999 | 77.0245 | 76.4588 | 75.7482 |\n| sz000001 | 2010.01.14T00:00:00 | 3,132  | 49.8656 | 49.3416 | 50.7761 | 49.7972 |\n"
    },
    "loadVocab": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/loadVocab.html",
        "signatures": [
            {
                "full": "loadVocab(filePath, vocabName)",
                "name": "loadVocab",
                "parameters": [
                    {
                        "full": "filePath",
                        "name": "filePath"
                    },
                    {
                        "full": "vocabName",
                        "name": "vocabName"
                    }
                ]
            }
        ],
        "markdown": "### [loadVocab](https://docs.dolphindb.cn/zh/funcs/l/loadVocab.html)\n\n首发版本：3.00.4，3.00.3.1\n\n\n\n#### 语法\n\nloadVocab(filePath, vocabName)\n\n#### 详情\n\n将指定路径下的词库加载到内存中，用于文本向量化处理。\n\n#### 参数\n\n**filePath** 字符串标量，词库文件的路径，可以是相对路径或绝对路径。\n\n**vocabName** 字符串标量，用于指定加载后词库的名称。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\nloadVocab(\"/home/data/vocab.txt\", \"vocab1\")\n```\n\n相关函数：[unloadVocab](https://docs.dolphindb.cn/zh/funcs/u/unloadVocab.html), [tokenizeBert](https://docs.dolphindb.cn/zh/funcs/t/tokenizeBert.html)\n"
    },
    "loc": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/loc.html",
        "signatures": [
            {
                "full": "loc(obj, rowFilter, [colFilter], [view=false])",
                "name": "loc",
                "parameters": [
                    {
                        "full": "obj",
                        "name": "obj"
                    },
                    {
                        "full": "rowFilter",
                        "name": "rowFilter"
                    },
                    {
                        "full": "[colFilter]",
                        "name": "colFilter",
                        "optional": true
                    },
                    {
                        "full": "[view=false]",
                        "name": "view",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [loc](https://docs.dolphindb.cn/zh/funcs/l/loc.html)\n\n\n\n#### 语法\n\nloc(obj, rowFilter, \\[colFilter], \\[view=false])\n\n#### 详情\n\n通过标签或布尔向量获取矩阵指定的行和列的元素，返回一个原矩阵的副本/视图。\n\n#### 参数\n\n**obj** 矩阵对象，可以是普通矩阵、索引序列以及索引矩阵。\n\n**rowFilter**/**colFilter** 可以为以下类型：\n\n* 布尔向量，只有为 true 的行/列可以被保留。其长度必须和矩阵的行数/列数相等。\n\n* 与行/列标签【类型兼容】的标量，向量或数据对（表示范围，包含左、右边界）。\n\n**Note:**\n\n* 如果 rowFilter/colFilter 为数据对，则 obj 必须是索引序列或索引矩阵。\n\n* 类型兼容：INT, SHORT, LONG, CHAR 互相兼容， FLOAT 和 DOUBLE 类型互相兼容，SYMBOL 和 STRING 类型互相兼容。\n\n**view** 布尔值，默认值是 false，表示生成一个原矩阵的副本（深拷贝）。若为 true，只会生成原矩阵的一个视图（浅拷贝），若原数据发生改变，视图的数据也会相应变化。\n\n#### 返回值\n\n一个原矩阵的副本/视图。\n\n#### 例子\n\n```\nm=rand(12, 3:4)\nm;\n```\n\n| col1 | col2 | col3 | col4 |\n| ---- | ---- | ---- | ---- |\n| 3    | 10   | 6    | 5    |\n| 4    | 11   | 6    | 0    |\n| 7    | 2    | 1    | 8    |\n\n```\na = m.loc(colFilter=[true, true, true, false], view=true)\nb = m.loc(colFilter=[true, true, true, false], view=false)\na;\n```\n\n| col1 | col2 | col3 |\n| ---- | ---- | ---- |\n| 3    | 10   | 6    |\n| 4    | 11   | 6    |\n| 7    | 2    | 1    |\n\n```\nb;\n```\n\n| col1 | col2 | col3 |\n| ---- | ---- | ---- |\n| 3    | 10   | 6    |\n| 4    | 11   | 6    |\n| 7    | 2    | 1    |\n\n```\n// 若原矩阵发生变化则视图也会改变，副本则不发生变化\nm[0,0] = -1\na;\n```\n\n| col1 | col2 | col3 |\n| ---- | ---- | ---- |\n| -1   | 10   | 6    |\n| 4    | 11   | 6    |\n| 7    | 2    | 1    |\n\n```\nb;\n```\n\n| col1 | col2 | col3 |\n| ---- | ---- | ---- |\n| 3    | 10   | 6    |\n| 4    | 11   | 6    |\n| 7    | 2    | 1    |\n\n```\nm = rand(48, 6:8)\nm;\n```\n\n| col1 | col2 | col3 | col4 | col5 | col6 | col7 | col8 |\n| ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- |\n| 27   | 31   | 47   | 21   | 12   | 43   | 22   | 11   |\n| 3    | 20   | 13   | 37   | 3    | 46   | 27   | 27   |\n| 13   | 5    | 14   | 11   | 26   | 42   | 4    | 18   |\n| 45   | 9    | 31   | 33   | 12   | 19   | 42   | 17   |\n| 2    | 19   | 30   | 25   | 36   | 27   | 21   | 6    |\n| 9    | 36   | 15   | 10   | 29   | 37   | 31   | 42   |\n\n```\n// 通过布尔值过滤\nm.loc(rowFilter=[true, true, false, false, true, false])\n```\n\n| col1 | col2 | col3 | col4 | col5 | col6 | col7 | col8 |\n| ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- |\n| 27   | 31   | 47   | 21   | 12   | 43   | 22   | 11   |\n| 3    | 20   | 13   | 37   | 3    | 46   | 27   | 27   |\n| 2    | 19   | 30   | 25   | 36   | 27   | 21   | 6    |\n\n```\nm.loc(colFilter=[true, true, false, false, true, false, false, true])\n```\n\n| col1 | col2 | col3 | col4 |\n| ---- | ---- | ---- | ---- |\n| 27   | 31   | 12   | 11   |\n| 3    | 20   | 3    | 27   |\n| 13   | 5    | 26   | 18   |\n| 45   | 9    | 12   | 17   |\n| 2    | 19   | 36   | 6    |\n| 9    | 36   | 29   | 42   |\n\n```\n// 通过标签过滤\nm.rename!(`A`A`B`A`B`B, 2022.01.01 + 0..7)\nm;\n```\n\n| label | 2022.01.01 | 2022.01.02 | 2022.01.03 | 2022.01.04 | 2022.01.05 | 2022.01.06 | 2022.01.07 | 2022.01.08 |\n| ----- | ---------- | ---------- | ---------- | ---------- | ---------- | ---------- | ---------- | ---------- |\n| A     | 27         | 31         | 47         | 21         | 12         | 43         | 22         | 11         |\n| A     | 3          | 20         | 13         | 37         | 3          | 46         | 27         | 27         |\n| B     | 13         | 5          | 14         | 11         | 26         | 42         | 4          | 18         |\n| A     | 45         | 9          | 31         | 33         | 12         | 19         | 42         | 17         |\n| B     | 2          | 19         | 30         | 25         | 36         | 27         | 21         | 6          |\n| B     | 9          | 36         | 15         | 10         | 29         | 37         | 31         | 42         |\n\n```\nm.loc(rowFilter=`A);\n```\n\n| label | 2022.01.01 | 2022.01.02 | 2022.01.03 | 2022.01.04 | 2022.01.05 | 2022.01.06 | 2022.01.07 | 2022.01.08 |\n| ----- | ---------- | ---------- | ---------- | ---------- | ---------- | ---------- | ---------- | ---------- |\n| A     | 27         | 31         | 47         | 21         | 12         | 43         | 22         | 11         |\n| A     | 3          | 20         | 13         | 37         | 3          | 46         | 27         | 27         |\n| A     | 45         | 9          | 31         | 33         | 12         | 19         | 42         | 17         |\n\n```\nm.loc(colFilter=2022.01.02);\n```\n\n| label | 2022.01.02 |\n| ----- | ---------- |\n| A     | 31         |\n| A     | 20         |\n| B     | 5          |\n| A     | 9          |\n| B     | 19         |\n| B     | 36         |\n\n```\nm.loc(rowFilter=`B, colFilter=2022.01.03)\n```\n\n| label | 2022.01.03 |\n| ----- | ---------- |\n| B     | 14         |\n| B     | 30         |\n| B     | 15         |\n\n若 *rowFilter* / *colFilter* 是数据对，则 obj 必须是索引矩阵，可通过函数 [setIndexedMatrix!](https://docs.dolphindb.cn/zh/funcs/s/setIndexedMatrix_.html) 将一个带标签的矩阵设置为索引矩阵。\n\n```\nm = rand(30, 5:6).rename!(1..5, 2022.01.01 + 0..5)\nm.setIndexedMatrix!()\nm;\n```\n\n| label | 2022.01.01 | 2022.01.02 | 2022.01.03 | 2022.01.04 | 2022.01.05 | 2022.01.06 |\n| ----- | ---------- | ---------- | ---------- | ---------- | ---------- | ---------- |\n| 1     | 5          | 27         | 26         | 18         | 29         | 3          |\n| 2     | 11         | 12         | 21         | 15         | 3          | 3          |\n| 3     | 1          | 23         | 29         | 17         | 7          | 18         |\n| 4     | 1          | 6          | 12         | 27         | 23         | 23         |\n| 5     | 15         | 7          | 3          | 19         | 4          | 8          |\n\n```\nm.loc(rowFilter=2:4, colFilter=2022.01.03:2022.01.06)\n```\n\n| label | 2022.01.03 | 2022.01.04 | 2022.01.05 | 2022.01.06 |\n| ----- | ---------- | ---------- | ---------- | ---------- |\n| 2     | 21         | 15         | 3          | 3          |\n| 3     | 29         | 17         | 7          | 18         |\n| 4     | 12         | 27         | 23         | 23         |\n\n相关函数：[at](https://docs.dolphindb.cn/zh/funcs/a/at.html)\n"
    },
    "localtime": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/localtime.html",
        "signatures": [
            {
                "full": "localtime(X)",
                "name": "localtime",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [localtime](https://docs.dolphindb.cn/zh/funcs/l/localtime.html)\n\n\n\n#### 语法\n\nlocaltime(X)\n\n#### 详情\n\n把零时区时间 *X* 转换成本地时间。\n\n#### 参数\n\n**X** 可以是 DATETIME, TIMESTAMP, NANOTIMESTAMP 类型的标量、向量或表，表示零时区时间。\n\n#### 返回值\n\n返回值的类型和形式与 *X* 保持一致。\n\n#### 例子\n\n以下例子在美国东部时区执行：\n\n```\nlocaltime(2018.01.22T15:20:26);\n// output\n2018.01.22T10:20:26\n\nlocaltime(2017.12.16T18:30:10.001);\n// output\n2017.12.16T13:30:10.001\n```\n"
    },
    "lockUser": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/lockUser.html",
        "signatures": [
            {
                "full": "lockUser(userId)",
                "name": "lockUser",
                "parameters": [
                    {
                        "full": "userId",
                        "name": "userId"
                    }
                ]
            }
        ],
        "markdown": "### [lockUser](https://docs.dolphindb.cn/zh/funcs/l/lockUser.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nlockUser(userId)\n\n#### 详情\n\n锁定用户 *userId*。该函数仅限管理员用户调用，调用时须开启配置项 *enhancedSecurityVerification*。\n\n#### 参数\n\n**userId** 是表示用户名的字符串。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\nlockUser(\"user1\")\n```\n\n相关函数：[unlockUser](https://docs.dolphindb.cn/zh/funcs/u/unlockUser.html)\n"
    },
    "loess": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/loess.html",
        "signatures": [
            {
                "full": "loess(X, Y, resampleRule, [closed='left'], [origin='start_day'], [outputX=false], [bandwidth=0.3], [robustnessIter=4], [accuracy=1e-12])",
                "name": "loess",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "resampleRule",
                        "name": "resampleRule"
                    },
                    {
                        "full": "[closed='left']",
                        "name": "closed",
                        "optional": true,
                        "default": "'left'"
                    },
                    {
                        "full": "[origin='start_day']",
                        "name": "origin",
                        "optional": true,
                        "default": "'start_day'"
                    },
                    {
                        "full": "[outputX=false]",
                        "name": "outputX",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[bandwidth=0.3]",
                        "name": "bandwidth",
                        "optional": true,
                        "default": "0.3"
                    },
                    {
                        "full": "[robustnessIter=4]",
                        "name": "robustnessIter",
                        "optional": true,
                        "default": "4"
                    },
                    {
                        "full": "[accuracy=1e-12]",
                        "name": "accuracy",
                        "optional": true,
                        "default": "1e-12"
                    }
                ]
            }
        ],
        "markdown": "### [loess](https://docs.dolphindb.cn/zh/funcs/l/loess.html)\n\n\n\n#### 语法\n\nloess(X, Y, resampleRule, \\[closed='left'], \\[origin='start\\_day'], \\[outputX=false], \\[bandwidth=0.3], \\[robustnessIter=4], \\[accuracy=1e-12])\n\n#### 详情\n\n该函数根据 *resampleRule*, *closed*, *origin* 确定的采样规则，对 *X* 进行重采样操作。并根据重采样后的 *X*，对 *Y* 按照局部回归算法进行插值（Loess Interpolatiion）。\n\n#### 参数\n\n**X** 严格递增的时间类型向量。\n\n**Y** 同 *X* 等长的数值型向量。\n\n**resampleRule** 一个字符串，可选值请参考 [resample](https://docs.dolphindb.cn/zh/funcs/r/resample.html) 的 *rule* 参数。\n\n**closed** 和 **origin** 同 [resample](https://docs.dolphindb.cn/zh/funcs/r/resample.html) 的 *closed* 和 *origin* 参数。\n\n**outputX** 布尔类型，表示是否输出 *X* 按照 *resampleRule*, *closed*, *origin* 重采样后的向量。默认值为 false。\n\n**bandwidth** 数值型标量，取值范围为(0,1]。对特定点进行 loess 拟合时，计算最小二乘回归时会考虑最接近当前点的这部分源点。\n\n**robustnessIter** 正整数，表示进行 loess 平滑处理时进行的鲁棒性迭代的次数。\n\n**accuracy** 一个大于0的数。若鲁棒性迭代过程中的中值残差小于此参数设置值，则停止迭代。\n\n#### 返回值\n\n若不指定 *outputX*，仅返回一个对 *Y* 插值后的向量。若指定 *outputX* = true，则返回一个 tuple，其第一个元素为 *X* 重采样后的向量，第二个元素为对 *Y* 插值后的向量。\n\n#### 例子\n\n**例 1**\n\n```\nloess([2016.02.14 00:00:00, 2016.02.15 00:00:00, 2016.02.16 00:00:00], [1.0, 2.0, 4.0], resampleRule=`60min, bandwidth=1)\n\n// output\n[1,1.0521,1.104,1.1558,1.2072,1.2582,1.3086,1.3584,1.4074,1.4556,\n1.5027,1.5488,1.5937,1.6374,1.6795,1.7202,1.7593,1.7966,1.832,1.8655,\n1.897,1.9263,1.9533,1.9779,2,2.0195,2.0366,2.0513,2.0637,2.0739,\n2.082,2.0882,2.0926,2.0952,2.0962,2.0957,2.0938,2.0905,2.0861,2.0806,\n2.0741,2.0667,2.0586,2.0498，2.0405,2.0308,2.0207,2.0104,2]\n```\n\n**例 2** 不同 *closed* 取值的影响。\n\n```\nX = 2022.01.01T00:00:00 + [0, 3, 6, 9] * 60\nY = [1.0, 3.0, 7.0, 13.0]\n\n// closed='left'（默认）：00:03 归入 [00:03, 00:06) 的起点\nloess(X, Y, `3min, closed=`left, outputX=true, bandwidth=1)\n\n// closed='right'：00:03 归入 (00:00, 00:03] 的终点\n// 局部回归的拟合点位置不同，输出结果不同\nloess(X, Y, `3min, closed=`right, outputX=true, bandwidth=1)\n```\n\n**例 3** 不同 *origin* 取值的影响。\n\n```\nX = 2022.01.01T00:00:30 + (0..4) * 60\nY = [2.0, 4.0, 7.0, 11.0, 16.0]\n\n// origin='start_day'（默认）：从当天零点对齐\nloess(X, Y, `1min, origin=`start_day, outputX=true, bandwidth=1)\n\n// origin='start'：从第一个数据点 00:00:30 对齐\nloess(X, Y, `1min, origin=`start, outputX=true, bandwidth=1)\n\n// origin=自定义时间戳：从 00:00:10 对齐\nloess(X, Y, `1min, origin=2022.01.01T00:00:10, outputX=true, bandwidth=1)\n```\n\n**例 4** 不同 *outputX* 取值的影响。\n\n```\nX = [2016.02.14T00:00:00, 2016.02.15T00:00:00, 2016.02.16T00:00:00]\nY = [1.0, 2.0, 4.0]\n\n// outputX=false（默认）：只返回局部回归插值后的 Y 向量\nloess(X, Y, `60min, bandwidth=1)\n\n// outputX=true：返回 tuple，[0] 为重采样后的时间戳，[1] 为插值 Y\nresult = loess(X, Y, `60min, outputX=true, bandwidth=1)\nresult[0]\nresult[1]\n```\n"
    },
    "log": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/log.html",
        "signatures": [
            {
                "full": "log(X, [Y])",
                "name": "log",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[Y]",
                        "name": "Y",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [log](https://docs.dolphindb.cn/zh/funcs/l/log.html)\n\n\n\n#### 语法\n\nlog(X, \\[Y])\n\n#### 详情\n\n若未指定 *Y*，返回 *X* 的自然对数（以常数 e 为底）；若指定了 *Y*，则返回以 *Y*为底的 *X* 的对数。\n\n与 Python 中 `numpy.log` 和 `scipy.stats.log` 的区别：`numpy.log` 计算自然对数，`scipy.stats.log` 是随机变量对数变换得到的连续分布对象；DolphinDB 的 `log` 是数值对数函数，`log` 不指定 *Y* 时计算自然对数，指定 *Y* 时可直接计算以 *Y* 为底的对数。\n\n#### 参数\n\n**X** 可以是标量、向量、数据对、矩阵或表。\n\n**Y** 可选参数。是一个正数，表示对数的底。\n\n#### 返回值\n\n返回数值类型的结果，形式与 *X* 一致。\n\n#### 例子\n\n```\nlog(2.718283);\n```\n\n输出返回：1\n\n```\nlog(0 1 2 3);\n```\n\n输出返回：\\[,0,0.693147,1.098612]\n\n```\nlog(100, 10)\n```\n\n输出返回：2\n"
    },
    "log10": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/log10.html",
        "signatures": [
            {
                "full": "log10(X)",
                "name": "log10",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [log10](https://docs.dolphindb.cn/zh/funcs/l/log10.html)\n\n\n\n#### 语法\n\nlog10(X)\n\n#### 详情\n\n求以10为底，*X* 的对数。\n\n与 Python 中 `numpy.log10` 的区别：二者都计算以 10 为底的对数；DolphinDB 支持标量、数据对、向量、矩阵和表，`numpy.log10` 是 ufunc，支持广播、复数、*out*、*where* 等参数。\n\n与 TA-Lib 中 `LOG10` 的区别：DolphinDB `log10` 支持标量、向量、数据对、矩阵和表，TA-Lib `LOG10` 仅支持一维数组。\n\n#### 参数\n\n**X** 可以是标量、向量、数据对、矩阵或表。\n\n#### 返回值\n\n返回数值类型的结果，形式和 *X* 一致。\n\n#### 例子\n\n```\nlog10(100);\n// output\n2\n\nlog10(0 10 20 30 NULL);\n// output\n[,1,1.30103,1.477121,]\n\nlog10(1..4$2:2);\n```\n\n| #0      | #1       |\n| ------- | -------- |\n| 0       | 0.477121 |\n| 0.30103 | 0.60206  |\n"
    },
    "log1p": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/log1p.html",
        "signatures": [
            {
                "full": "log1p(X)",
                "name": "log1p",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [log1p](https://docs.dolphindb.cn/zh/funcs/l/log1p.html)\n\n\n\n#### 语法\n\nlog1p(X)\n\n#### 详情\n\n返回 log(1+X) 的结果。\n\n**Note:**\n\nDolphinDB `log1p` 与 [numpy.log1p](https://numpy.org/doc/stable/reference/generated/numpy.log1p.html) 的核心功能相同，区别在于 DolphinDB `log1p` 只接受一个参数 *X*，而 `numpy.log1p` 支持更多参数，如 *out*、*where*。\n\n#### 参数\n\n**X** 可以是标量、向量、数据对、矩阵或表。\n\n#### 返回值\n\n返回数值类型的结果，形式与 *X* 一致。\n\n#### 例子\n\n```\nlog1p(2);\n// output\n1.098612\n\nlog1p(2 4 6);\n// output\n[1.098612,1.609438,1.94591]\n\nlog1p(1..4$2:2);\n```\n\n| #0       | #1       |\n| -------- | -------- |\n| 0.693147 | 1.386294 |\n| 1.098612 | 1.609438 |\n"
    },
    "log2": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/log2.html",
        "signatures": [
            {
                "full": "log2(X)",
                "name": "log2",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [log2](https://docs.dolphindb.cn/zh/funcs/l/log2.html)\n\n\n\n#### 语法\n\nlog2(X)\n\n#### 详情\n\n求以2为底，*X* 的对数。\n\n**Note:**\n\nDolphinDB `log2` 与 `numpy.log2` 的核心功能相同，区别在于 DolphinDB `log2` 只接受一个参数 *X*，而 `numpy.log2` 支持更多参数，如 *out*、*where*。\n\n#### 参数\n\n**X** 可以是标量、向量、数据对、矩阵或表。\n\n#### 返回值\n\n返回数值类型的结果，形式和 *X* 一致。\n\n#### 例子\n\n```\nlog2(4);\n// output\n2\n\nlog2(0 2 4 8 NULL);\n// output\n[,1,2,3,]\n\nlog2(1..4$2:2);\n```\n\n| #0 | #1       |\n| -- | -------- |\n| 0  | 1.584963 |\n| 1  | 2        |\n"
    },
    "login": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/login.html",
        "signatures": [
            {
                "full": "login(userId, password)",
                "name": "login",
                "parameters": [
                    {
                        "full": "userId",
                        "name": "userId"
                    },
                    {
                        "full": "password",
                        "name": "password"
                    }
                ]
            }
        ],
        "markdown": "### [login](https://docs.dolphindb.cn/zh/funcs/l/login.html)\n\n\n\n#### 语法\n\nlogin(userId, password)\n\n#### 详情\n\n用户可在控制节点或数据节点/计算节点上登录。\n\n从 2.00.10.10 开始，用户可以通过配置项 *enhancedSecurityVerification* 控制在登录时是否约束密码重试的次数。若不设置 *enhancedSecurityVerification*，则不约束；若设置 *enhancedSecurityVerification*=true，则当某个用户登录时，在1分钟内连续5次输入错误密码，系统会锁定这个用户的登录。10分钟后才允许该用户再次登录。\n\n#### 参数\n\n**userId** 是表示用户名的字符串。注：包含短横线（-）的用户名必须用双引号来包裹，不能用反引号\\`。\n\n**password** 是表示密码的字符串。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\nlogin(\"JohnSmith\", \"Qb05078.\");\n```\n"
    },
    "logisticRegression": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/logisticRegression.html",
        "signatures": [
            {
                "full": "logisticRegression(ds, yColName, xColNames, [intercept=true], [initTheta], [tolerance=1e-3], [maxIter=500], [regularizationCoeff=1.0], [numClasses=2])",
                "name": "logisticRegression",
                "parameters": [
                    {
                        "full": "ds",
                        "name": "ds"
                    },
                    {
                        "full": "yColName",
                        "name": "yColName"
                    },
                    {
                        "full": "xColNames",
                        "name": "xColNames"
                    },
                    {
                        "full": "[intercept=true]",
                        "name": "intercept",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[initTheta]",
                        "name": "initTheta",
                        "optional": true
                    },
                    {
                        "full": "[tolerance=1e-3]",
                        "name": "tolerance",
                        "optional": true,
                        "default": "1e-3"
                    },
                    {
                        "full": "[maxIter=500]",
                        "name": "maxIter",
                        "optional": true,
                        "default": "500"
                    },
                    {
                        "full": "[regularizationCoeff=1.0]",
                        "name": "regularizationCoeff",
                        "optional": true,
                        "default": "1.0"
                    },
                    {
                        "full": "[numClasses=2]",
                        "name": "numClasses",
                        "optional": true,
                        "default": "2"
                    }
                ]
            }
        ],
        "markdown": "### [logisticRegression](https://docs.dolphindb.cn/zh/funcs/l/logisticRegression.html)\n\n\n\n#### 语法\n\nlogisticRegression(ds, yColName, xColNames, \\[intercept=true], \\[initTheta], \\[tolerance=1e-3], \\[maxIter=500], \\[regularizationCoeff=1.0], \\[numClasses=2])\n\n#### 详情\n\n对数据源中的自变量（*xColNames*）和因变量（*yColName*）进行逻辑回归分析。生成的模型可以作为 `predict` 函数的输入，用于预测新数据的分类结果。\n\n#### 参数\n\n**ds** 数据源类型，通常由 [sqlDS](https://docs.dolphindb.cn/zh/funcs/s/sqlDS.html) 生成。\n\n**yColName** 字符串，指定 *ds* 中的列名，表示因变量（所属分类）列。\n\n**xColNames** 字符串标量或向量，指定 *ds* 中的列名，表示自变量列。\n\n**intercept** 可选参数。布尔类型，表示是否包含截距项。默认值为 true，系统会自动添加一列值为 1 的变量用于生成截距。\n\n**initTheta** 可选参数。DOUBLE 类型向量，指定迭代的初始参数。默认是长度为 `xColNames.size()+intercept` 的零向量。\n\n**tolerance** 可选参数。大于 0 的数值标量，指定迭代终止的边界差值 。如果在两次相邻迭代中，参数的对数似然函数的梯度的绝对值最大分量的差小于 *tolerance*，则迭代终止。默认值是0.001。\n\n**maxIter** 可选参数。正整数，指定迭代的最大次数。当迭代次数达到 *maxIter* 时，迭代终止。默认值是500.\n\n**regularizationCoeff** 可选参数。大于 0 的数值标量，指定正则项系数。默认值是1.0。\n\n**numClasses** 可选参数。大于等于 2 的整数，表示因变量的类别数量。默认值是 2。\n\n#### 返回值\n\n一个字典，包含以下键值：\n\n* modelName：字符串，表示模型的名称，即“Logistic Regression“。\n\n* tolerance：浮点数，表示迭代终止的边界差值。\n\n* xColNames：字符串标量或向量，表示自变量列名。\n\n* intercept：布尔值，表示是否包含回归中的截距项。\n\n* numClasses：正整数，表示因变量的类别数量。\n\n* coefficients：浮点类型的矩阵或向量，表示每一个因变量种类模型参数的估计值。\n\n  * 二元分类（*numClasses*= 2）时，返回向量，表示正类（即 label = 1）的参数的估计值。\n\n  * 多元分类（*numClasses*> 2）时，返回矩阵，第 i 行表示第 i 类（即 label = i）参数的估计值。\n\n* iterations：整型标量或向量，表示每一个因变量种类迭代的次数。\n\n  * 二元分类（*numClasses*= 2）时，返回一个正整数，表示正类（即 label = 1）的参数的迭代次数。\n\n  * 多元分类（*numClasses*> 2）时，返回一个向量，第 i 个数表示第 i 类（即 label = i）参数的迭代次数。\n\n* logLikelihood：浮点类型的标量或向量，表示每一个因变量种类迭代中最终的对数似然值。\n\n  * 二元分类（*numClasses*= 2）时，返回一个浮点数，表示正类（即 label = 1）的参数的对数似然值。\n\n  * 多元分类（*numClasses*> 2）时，返回一个向量，第 i 个数表示第 i 类（即 label = i）参数的对数似然值。\n\n* predict：模型的预测函数。\n\n#### 例子\n\n以下例子把两个不同中心的正态分布标记为两类，然后计算逻辑回归模型。\n\n```\nt = table(100:0, `y`x0`x1, [INT,DOUBLE,DOUBLE])\ny = take(0, 50)\nx0 = norm(-1.0, 1.0, 50)\nx1 = norm(-1.0, 1.0, 50)\ninsert into t values (y, x0, x1)\ny = take(1, 50)\nx0 = norm(1.0, 1.0, 50)\nx1 = norm(1.0, 1.0, 50)\ninsert into t values (y, x0, x1)\n\nmodel = logisticRegression(sqlDS(<select * from t>), yColName=`y, xColNames=`x0`x1);\n\n// output\nmodelName->Logistic Regression\ntolerance->0.001\nxColNames->[\"x0\",\"x1\"]\nintercept->1\nnumClasses->2\ncoefficients->[1.772463953718721,1.848711011775654,0.24896957744541]\niterations->[5]\nlogLikelihood->[15.982057280977643]\npredict->logisticRegressionPredict\n```\n\n把模型用于预测：\n\n```\npredict(model, t);\n```\n\n保存模型到磁盘：\n\n```\nsaveModel(model, \"C:/DolphinDB/data/logisticModel.txt\");\n```\n\n加载一个保存的模型：\n\n```\nloadModel(\"C:/DolphinDB/data/logisticModel.txt\");\n```\n"
    },
    "logout": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/logout.html",
        "signatures": [
            {
                "full": "logout([userId], [sessionOnly=true])",
                "name": "logout",
                "parameters": [
                    {
                        "full": "[userId]",
                        "name": "userId",
                        "optional": true
                    },
                    {
                        "full": "[sessionOnly=true]",
                        "name": "sessionOnly",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [logout](https://docs.dolphindb.cn/zh/funcs/l/logout.html)\n\n\n\n#### 语法\n\nlogout(\\[userId], \\[sessionOnly=true])\n\n#### 详情\n\n该函数可以在控制节点/数据节点/计算节点上执行。\n\n如果没有指定 *userId*，用户自己退出登录。\n\n如果 *sessionOnly* 为true，用户只退出登录当前会话。\n\n如果 *sessionOnly* 为false，用户会退出登录当前会话、所有的数据节点/计算节点以及控制节点。\n\n管理员可以使其他用户退出登录。如果管理员使用户退出登录，用户会退出登录当前会话、所有的数据节点/计算节点以及控制节点。\n\n#### 参数\n\n**userId** 是表示用户名的字符串。注：包含短横线（-）的用户名必须用双引号来包裹，不能用反引号\\`。\n\n**sessionOnly** 是表示是否退出登录当前会话的布尔值。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\nlogout();\n\nlogout(`TomFord);\n\nlogout(, false);\n```\n"
    },
    "long": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/long.html",
        "signatures": [
            {
                "full": "long(X)",
                "name": "long",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [long](https://docs.dolphindb.cn/zh/funcs/l/long.html)\n\n\n\n#### 语法\n\nlong(X)\n\n#### 详情\n\n将 *X* 的数据类型转换为 LONG。\n\n#### 参数\n\n**X** 可以是任意数据类型。\n\n#### 返回值\n\nLONG 类型的结果。\n\n#### 例子\n\n```\nx=long();\nx;\n```\n\n返回：null\n\n```\ntypestr x;\n```\n\n返回：LONG\n\n```\nlong(`10.9);\n```\n\n返回：10\n\n```\nlong(9223372036854775807l);\n```\n\n返回：9,223,372,036,854,775,807\n\n**Note:** LONG 数据类型的最大值是263-1 = 9,223,372,036,854,775,807。\n\n```\nlong(9223372036854775808l);\n```\n\n返回：9,223,372,036,854,775,807\n"
    },
    "lowDouble": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/lowDouble.html",
        "signatures": [
            {
                "full": "lowDouble(X)",
                "name": "lowDouble",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [lowDouble](https://docs.dolphindb.cn/zh/funcs/l/lowDouble.html)\n\n\n\n#### 语法\n\nlowDouble(X)\n\n#### 详情\n\n返回值为 *X* 的低位8字节的数据，为 DOUBLE 类型。\n\n#### 参数\n\n**X** 是一个标量或向量，必须是16字节的数据类型。\n\n#### 例子\n\n```\nx=1 2 3 4\ny=4 3 2 1\npoints = point(x, y)\nx1 = lowDouble(points)\n```\n\n输出返回：\\[1,2,3,4]\n\n获取一个复数的实部（实数）：\n\n```\na=complex(2, 5)\nlowDouble(a)\n```\n\n输出返回：2\n"
    },
    "lower": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/lower.html",
        "signatures": [
            {
                "full": "lower(X)",
                "name": "lower",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [lower](https://docs.dolphindb.cn/zh/funcs/l/lower.html)\n\n\n\n#### 语法\n\nlower(X)\n\n#### 详情\n\n`lower` 函数把字符串或字符串列表中的所有字符转换为小写。\n\n当 *X* 是表时，函数仅作用于其中 CHAR、STRING、SYMBOL 列，其他类型的列将被忽略。\n\n#### 参数\n\n**X** 是字符/字符串/SYMBOL 类型的标量、向量，或表。\n\n#### 返回值\n\n返回值的类型和形式与 *X* 一致，所有字符均为小写。\n\n#### 例子\n\n```\nx= `Ibm`C`AapL;\nx.lower();\n// output\n[\"ibm\",\"c\",\"aapl\"]\n\nlower(`Thl);\n// output\nthl\n```\n\n相关函数：[upper](https://docs.dolphindb.cn/zh/funcs/u/upper.html)\n"
    },
    "lowerBound": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/lowerbound.html",
        "signatures": [
            {
                "full": "lowerBound(X,Y)",
                "name": "lowerBound",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [lowerBound](https://docs.dolphindb.cn/zh/funcs/l/lowerbound.html)\n\n#### 语法\n\nlowerBound(X,Y)\n\n#### 详情\n\n对于 *Y* 中的每个元素 y，该函数返回 *X* 中第一个不小于 y 的元素下标。如果没有找到，则返回 *X* 的长度。\n\n#### 参数\n\n**X** 递增的向量、索引序列、索引矩阵\n\n**Y** 标量、向量、数组向量、元组、矩阵、字典、表\n\n#### 返回值\n\n返回数值类型的结果，形式与 *Y* 一致。\n\n#### 例子\n\n在以下例子中，X 中的部分元素大于或等于 Y 中的部分元素：\n\n```\nX = [1,3,5];\nY = [5,6,7];\nZ = lowerBound(X,Y);\nZ\n// output: [2,3,3]\n\nindex = [2023.05.04, 2023.05.06, 2023.05.07, 2023.05.10]\ns = indexedSeries(index, 1..4)\ny=[2023.05.04, 2023.05.06, 2023.05.09]\n\nlowerBound(s,y)\n```\n\n| label      | #0 |\n| ---------- | -- |\n| 2023.05.04 | 1  |\n| 2023.05.06 | 2  |\n| 2023.05.09 | 4  |\n\n"
    },
    "lowLong": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/lowlong.html",
        "signatures": [
            {
                "full": "lowLong(X)",
                "name": "lowLong",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [lowLong](https://docs.dolphindb.cn/zh/funcs/l/lowlong.html)\n\n\n\n#### 语法\n\nlowLong(X)\n\n#### 详情\n\n返回值为 *X* 的低位8字节的数据，为 LONG 类型。\n\n#### 参数\n\n**X** 是一个标量、向量、表、数据对或者字典，且必须为16字节的数据类型（支持 UUID、IPADDR、INT128、COMPLEX、POINT）。\n\n#### 例子\n\n```\nx =ipaddr(\"192.168.1.13\")\nx1 = lowLong(x)\nprint(x1)\n//output: 3232235789\n```\n\n```\nx=1 2 3 4\ny=4 3 2 1\npoints = point(x, y)\nx1 = lowLong(points)\n//output: [4607182418800017408,4611686018427387904,4613937818241073152,4616189618054758400]\n```\n\n**Related information**\n\n[highLong](https://docs.dolphindb.cn/zh/funcs/h/highlong.html)\n"
    },
    "lowRange": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/lowRange.html",
        "signatures": [
            {
                "full": "lowRange(X)",
                "name": "lowRange",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [lowRange](https://docs.dolphindb.cn/zh/funcs/l/lowRange.html)\n\n\n\n#### 语法\n\nlowRange(X)\n\n#### 详情\n\n对于 *X* 中的每个元素 *Xi*，统计 *Xi* 左侧相邻且连续大于它的元素个数。\n\n该函数常用于统计一个序列的当前值是前多少周期（日或分钟等）内的最小值。例如某只股票创几日新低等。\n\n#### 参数\n\n**X** 向量/元组/矩阵/表。\n\n#### 返回值\n\n返回 INT 类型的结果，形式与 *X* 一致。\n\n#### 例子\n\n```\nlowRange([13.5, 13.6, 13.4, 13.3, 13.5, 13.9, 13.1, 20.1, 20.2, 20.3])\n// output\n[0,0,2,3,0,0,6,0,0,0]\n\nm = matrix(1.5 2.6 3.2 1.4 2.5 2.2 3.7 2.0, 1.6 2.3 4.2 5.6 4.1 3.2 4.4 6.9)\nlowRange(m)\n```\n\n| #0 | #1 |\n| -- | -- |\n| 0  | 0  |\n| 0  | 0  |\n| 0  | 0  |\n| 3  | 0  |\n| 0  | 2  |\n| 1  | 3  |\n| 0  | 0  |\n| 3  | 0  |\n\n```\n// 模拟股票 A 8天的股价,使用 lowRange 计算股票 A 当日股价创几日新低\ntrades = table(take(`A, 8) as sym,  2022.01.01 + 1..8 as date, 39.70 39.72 39.80 39.78 39.83 39.92 40.00 40.03 as price)\nselect *, lowRange(price) from trades\n```\n\n| id | date       | price | lowRange\\_price |\n| -- | ---------- | ----- | --------------- |\n| A  | 2022.01.02 | 39.7  | 0               |\n| A  | 2022.01.03 | 39.72 | 0               |\n| A  | 2022.01.04 | 39.8  | 0               |\n| A  | 2022.01.05 | 39.78 | 1               |\n| A  | 2022.01.06 | 39.83 | 0               |\n| A  | 2022.01.07 | 39.92 | 0               |\n| A  | 2022.01.08 | 40    | 0               |\n| A  | 2022.01.09 | 40.03 | 0               |\n\n**Related information**\n\n[topRange](https://docs.dolphindb.cn/zh/funcs/t/topRange.html)\n"
    },
    "lpad": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/lpad.html",
        "signatures": [
            {
                "full": "lpad(str, length, [pattern])",
                "name": "lpad",
                "parameters": [
                    {
                        "full": "str",
                        "name": "str"
                    },
                    {
                        "full": "length",
                        "name": "length"
                    },
                    {
                        "full": "[pattern]",
                        "name": "pattern",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [lpad](https://docs.dolphindb.cn/zh/funcs/l/lpad.html)\n\n\n\n#### 语法\n\nlpad(str, length, \\[pattern])\n\n#### 详情\n\n在 *str* 的左边填充指定字符串。\n\n当 *str* 是表时，函数仅作用于其中字符串列，其他类型的列将被忽略。\n\n#### 参数\n\n**str** 是字符串类型的标量、向量，或表。它表示目标字符串。\n\n**length** 是一个不超过 65536 的非负整数，表示填充之后的字符串长度。如果 *length* 小于 *str* 的长度，*lpad* 函数相当于 [left](https://docs.dolphindb.cn/zh/funcs/l/left.html) (str, length). 如果 *length* 大于 65536，则系统会自动调整为 65536。\n\n**pattern** 是填充字符串。它是一个可选参数。如果 *pattern* 没有指定，则在 *str* 的左边填充空格。\n\n#### 返回值\n\n返回与 *str* 形式一致的字符串类型。\n\n#### 例子\n\n```\nlpad(\"Hello\",2);\n// output\nHe\n\nlpad(`Hello, 10);\n// output\nHello\n\nlpad(`Hello, 12, `0);\n// output\n0000000Hello\n```\n"
    },
    "lshift": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/lshift.html",
        "signatures": [
            {
                "full": "lshift(X, a)",
                "name": "lshift",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "a",
                        "name": "a"
                    }
                ]
            }
        ],
        "markdown": "### [lshift](https://docs.dolphindb.cn/zh/funcs/l/lshift.html)\n\n\n\n#### 语法\n\nlshift(X, a) 或 X<\\<a\n\n#### 详情\n\n`lshift` 是将 *X* 按二进制展开后整体往左移动 *a* 位数。右侧的位数用 0 填充。\n\n#### 参数\n\n**X** 可以是整数标量、数据对、向量、矩阵或表；\n\n**a** 是移动的位数。\n\n#### 返回值\n\n返回与 X 形式一致的整型。\n\n#### 例子\n\n```\nlshift(2, 10);\n// output\n2048\n\n1..10 << 1;\n// output\n[2,4,6,8,10,12,14,16,18,20]\n\n1..10 << 10;\n// output\n[1024,2048,3072,4096,5120,6144,7168,8192,9216,10240]\n\n1:10<<10;\n// output\n1024 : 10240\n```\n\n相关函数：[rshift](https://docs.dolphindb.cn/zh/funcs/r/rshift.html).\n"
    },
    "lt": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/lt.html",
        "signatures": [
            {
                "full": "lt(X, Y)",
                "name": "lt",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [lt](https://docs.dolphindb.cn/zh/funcs/l/lt.html)\n\n\n\n#### 语法\n\nlt(X, Y) 或 X\\<Y\n\n#### 详情\n\n如果 *X* 和 *Y* 都不是集合，返回逐个元素比较 *X*<*Y* 的结果。\n\n如果 *X* 和 *Y* 都是集合，则检查 *X* 是否为 *Y* 的真子集。\n\n#### 参数\n\n**X** 和 **Y** 可以是标量、数据对、向量、矩阵或集合。如果 *X* 或 *Y* 中的其中一个是数据对、向量或矩阵，另一个必须是一个标量，或具有相同长度或维度的数据对、向量或矩阵。\n\n#### 返回值\n\n返回布尔类型的标量、向量、数据对或矩阵。\n\n#### 例子\n\n```\n1 2 3 < 2;\n// output\n[1,0,0]\n\n1 2 3<0 2 4;\n// output\n[0,0,1]\n\n2:3<1:6;\n// output\n0 : 1\n\nm1=1..6$2:3;\nm1;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1  | 3  | 5  |\n| 2  | 4  | 6  |\n\n```\nm1 lt 4;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1  | 1  | 0  |\n| 1  | 0  | 0  |\n\n```\nm2=6..1$2:3;\nm2;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 6  | 4  | 2  |\n| 5  | 3  | 1  |\n\n```\nm1<m2;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1  | 1  | 0  |\n| 1  | 0  | 0  |\n\n集合操作：如果 *X*<*Y*，则 *X* 是 *Y* 的真子集。\n\n```\nx=set(4 6);\nx;\n// output\nset(6,4)\ny=set(8 9 4 6);\ny;\n// output\nset(6,4,9,8)\n\nx<y;\n// output\n1\n\ny<x;\n// output\n0\n\nx<x;\n// output\n0\n# x is not a proper subset of x\n```\n"
    },
    "ltrim": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/ltrim.html",
        "signatures": [
            {
                "full": "ltrim(X)",
                "name": "ltrim",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [ltrim](https://docs.dolphindb.cn/zh/funcs/l/ltrim.html)\n\n\n\n#### 语法\n\nltrim(X)\n\n#### 详情\n\n删除字符串或字符串向量的每个元素左边的空格。\n\n当 *X* 是表时，函数仅作用于其中字符串列，其他类型的列将被忽略。\n\n#### 参数\n\n**X** 是字符串类型的标量、向量、或表。\n\n#### 返回值\n\n返回与 *X* 形式一致的字符串类型。\n\n#### 例子\n\n```\nltrim(\"    I love this game!\");\n// output\nI love this game!\n```\n"
    },
    "lu": {
        "url": "https://docs.dolphindb.cn/zh/funcs/l/lu.html",
        "signatures": [
            {
                "full": "lu(obj, [permute=false])",
                "name": "lu",
                "parameters": [
                    {
                        "full": "obj",
                        "name": "obj"
                    },
                    {
                        "full": "[permute=false]",
                        "name": "permute",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [lu](https://docs.dolphindb.cn/zh/funcs/l/lu.html)\n\n\n\n#### 语法\n\nlu(obj, \\[permute=false])\n\n#### 详情\n\n实现矩阵的 LU 分解。\n\n**Note:**\n\nDolphinDB `lu` 与 [scipy.linalg.lu](https://docs.scipy.org/doc/scipy/reference/generated/scipy.linalg.lu.html) 的核心功能相同，区别在于 `scipy.linalg.lu` 支持更多参数，如 *overwrite\\_a*、*check\\_finite*、*p\\_indices*。\n\n#### 参数\n\n**obj** 是一个不包含 NULL 值的矩阵。\n\n**permute** 是一个布尔值。默认值为 false。\n\n#### 返回值\n\n* 如果 *permute* 为 false，返回三个矩阵，依次是 L, U, P，满足条件 *obj* = P' \\* L \\* U。P 是置换矩阵；L 是下三角矩阵，其对角线元素均为1；U 是上三角矩阵。\n* 如果 *permute* 为 true，返回两个矩阵，依次是 L,U，满足条件 *obj* = L \\* U。\n\n#### 例子\n\n```\nA = matrix([[2, 5, 8, 7], [5, 2, 2, 8], [7, 5, 6, 6], [5, 4, 4, 8]]);\n\nP, L, U = lu(A);\nP;\n```\n\n| #0 | #1 | #2 | #3 |\n| -- | -- | -- | -- |\n| 0  | 0  | 1  | 0  |\n| 0  | 0  | 0  | 1  |\n| 1  | 0  | 0  | 0  |\n| 0  | 1  | 0  | 0  |\n\n```\nL;\n```\n\n| #0    | #1   | #2       | #3 |\n| ----- | ---- | -------- | -- |\n| 1     | 0    | 0        | 0  |\n| 0.875 | 1    | 0        | 0  |\n| 0.25  | 0.72 | 1        | 0  |\n| 0.625 | 0.12 | 0.233871 | 1  |\n\n```\nU;\n```\n\n| #0 | #1   | #2   | #3       |\n| -- | ---- | ---- | -------- |\n| 8  | 2    | 6    | 4        |\n| 0  | 6.25 | 0.75 | 4.5      |\n| 0  | 0    | 4.96 | 0.76     |\n| 0  | 0    | 0    | 0.782258 |\n\n```\nL, U = lu(A, true);\nL;\n```\n\n| #0    | #1   | #2       | #3 |\n| ----- | ---- | -------- | -- |\n| 0.25  | 0.72 | 1        | 0  |\n| 0.625 | 0.12 | 0.233871 | 1  |\n| 1     | 0    | 0        | 0  |\n| 0.875 | 1    | 0        | 0  |\n\n```\nU;\n```\n\n| #0 | #1   | #2   | #3       |\n| -- | ---- | ---- | -------- |\n| 8  | 2    | 6    | 4        |\n| 0  | 6.25 | 0.75 | 4.5      |\n| 0  | 0    | 4.96 | 0.76     |\n| 0  | 0    | 0    | 0.782258 |\n"
    },
    "nanInfFill": {
        "url": "https://docs.dolphindb.cn/zh/funcs/n/nanInfFill.html",
        "signatures": [
            {
                "full": "nanInfFill(X,Y)",
                "name": "nanInfFill",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [nanInfFill](https://docs.dolphindb.cn/zh/funcs/n/nanInfFill.html)\n\n\n\n#### 语法\n\nnanInfFill(X,Y)\n\n#### 详情\n\n在 DolphinDB 中，浮点数中出现的 NaN 和 Inf 值自动替换为空值。而在外部数据导入或计算过程中，可能出现极端场景，导致上述两个特殊值的引入。该函数用于替换这两个特殊值。\n\n可使用指定 *Y* 值对 *X* 中存在的 NaN 或 Inf 值进行替换。\n\n**Note:** 当 *X* 为字典时，该函数仅对 value 值进行替换。\n\n#### 参数\n\n**X** 是除集合外任一数据形式的浮点数。\n\n**Y** 是一个浮点数。\n\n#### 返回值\n\n返回浮点型，数据形式同 *X*。\n\n#### 例子\n\n```\nx = [float(`inf), 2, 3, float(`nan), 5, 6, 7]\nnanInfFill (x, 2.2)\nx = matrix(1..3, [float(`inf), float(`nan), 1.0])\nnanInfFill(x, 1.2)\n```\n\n相关函数：[isNanInf](https://docs.dolphindb.cn/zh/funcs/i/isNanInf.html), [countNanInf](https://docs.dolphindb.cn/zh/funcs/c/countNanInf.html)\n"
    },
    "nanosecond": {
        "url": "https://docs.dolphindb.cn/zh/funcs/n/nanosecond.html",
        "signatures": [
            {
                "full": "nanosecond(X)",
                "name": "nanosecond",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [nanosecond](https://docs.dolphindb.cn/zh/funcs/n/nanosecond.html)\n\n\n\n#### 语法\n\nnanosecond(X)\n\n#### 详情\n\n返回 *X* 中的纳秒数。\n\n#### 参数\n\n**X** 可以是 TIME, TIMESTAMP, NANOTIME 或 NANOTIMESTAMP 类型的标量或向量。\n\n#### 返回值\n\nINT 类型标量或向量。\n\n#### 例子\n\n```\nnanosecond(13:30:10.008);\n// output\n8000000\n\nnanosecond([2012.12.03 01:22:01.999999999, 2012.12.03 01:25:08.000000234]);\n// output\n[999999999,234]\n```\n\n相关函数：[dayOfYear](https://docs.dolphindb.cn/zh/funcs/d/dayOfYear.html), [dayOfMonth](https://docs.dolphindb.cn/zh/funcs/d/dayOfMonth.html), [quarterOfYear](https://docs.dolphindb.cn/zh/funcs/q/quarterOfYear.html), [monthOfYear](https://docs.dolphindb.cn/zh/funcs/m/monthOfYear.html), [weekOfYear](https://docs.dolphindb.cn/zh/funcs/w/weekOfYear.html), [hourOfDay](https://docs.dolphindb.cn/zh/funcs/h/hourOfDay.html), [minuteOfHour](https://docs.dolphindb.cn/zh/funcs/m/minuteOfHour.html), [secondOfMinute](https://docs.dolphindb.cn/zh/funcs/s/secondOfMinute.html), [millisecond](https://docs.dolphindb.cn/zh/funcs/m/millisecond.html), [microsecond](https://docs.dolphindb.cn/zh/funcs/m/microsecond.html)\n"
    },
    "nanotime": {
        "url": "https://docs.dolphindb.cn/zh/funcs/n/nanotime.html",
        "signatures": [
            {
                "full": "nanotime(X)",
                "name": "nanotime",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [nanotime](https://docs.dolphindb.cn/zh/funcs/n/nanotime.html)\n\n\n\n#### 语法\n\nnanotime(X)\n\n#### 详情\n\n返回相应的纳秒。返回值类型是 NANOTIME，时间类型的变量。\n\n#### 参数\n\n**X** 可以是整型标量或向量、时间标量或向量。\n\n#### 返回值\n\nNANOTIME 类型标量或向量。\n\n#### 例子\n\n```\nnanotime(1000000000);\n```\n\n返回：00:00:01.000000000\n\n```\nnanotime(12:06:09 13:08:01);\n```\n\n返回：\\[12:06:09.000000000,13:08:01.000000000]\n\n```\nnanotime(2012.12.03 01:22:01.123456789);\n```\n\n返回：01:22:01.123456789\n\n```\nnanotime('13:30:10.008007006');\n```\n\n返回：13:30:10.008007006\n\n**Related information**\n\n[nanotimestamp](https://docs.dolphindb.cn/zh/funcs/n/nanotimestamp.html)\n"
    },
    "nanotimestamp": {
        "url": "https://docs.dolphindb.cn/zh/funcs/n/nanotimestamp.html",
        "signatures": [
            {
                "full": "nanotimestamp(X)",
                "name": "nanotimestamp",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [nanotimestamp](https://docs.dolphindb.cn/zh/funcs/n/nanotimestamp.html)\n\n\n\n#### 语法\n\nnanotimestamp(X)\n\n#### 详情\n\n返回由日期和精确到纳秒的时间组成的时间戳。返回值类型是 NANOTIMESTAMP，时间类型变量。如果参数 *X* 不是日期和时间，则返回值是 1970.01.01 00:00:00.000000000 + *X* 纳秒的时间戳。\n\n**Note:** 自 2.00.12 版本起，支持转换 MONTH 类型的数据。\n\n#### 参数\n\n**X** 可以是整型标量或向量、时间标量或向量。\n\n#### 返回值\n\nNANOTIMESTAMP 类型标量或向量。\n\n#### 例子\n\n```\nnanotimestamp(1);\n```\n\n返回：1970.01.01 00:00:00.000000001\n\n```\nnanotimestamp(1000000000);\n```\n\n返回：1970.01.01 00:00:01.000000000\n\n```\nnanotimestamp(2012.12.03 12:06:09 2012.12.03 13:08:01);\n```\n\n返回：\\[2012.12.03 12:06:09.000000000,2012.12.03 13:08:01.000000000]\n\n```\nnanotimestamp(2012.12.03 01:22:01.123456789);\n```\n\n返回：2012.12.03 01:22:01.123456789\n\n```\nnanotimestamp('2012.12.03 13:30:10.008007006');\n```\n\n返回：2012.12.03 13:30:10.008007006\n\n```\nnanotimestamp(now());\n```\n\n返回：2024.02.22 16:14:28.627000000\n\n```\nnanotimestamp(2012.01M)\n```\n\n返回：2012.01.01T00:00:00.000000000\n\n**Related information**\n\n[nanotime](https://docs.dolphindb.cn/zh/funcs/n/nanotime.html)\n"
    },
    "ne": {
        "url": "https://docs.dolphindb.cn/zh/funcs/n/ne.html",
        "signatures": [
            {
                "full": "ne(X, Y)",
                "name": "ne",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [ne](https://docs.dolphindb.cn/zh/funcs/n/ne.html)\n\n\n\n#### 语法\n\nne(X, Y) 或 X!=Y\n\n#### 详情\n\n如果 *X* 和 *Y* 都不是集合，逐个元素地比较 *X* 和 *Y*，如果不相等则返回1。\n\n如果 *X* 和 *Y* 都是集合，检查 *X* 和 *Y* 是不是同一个集合。是则返回0，不是则返回1。\n\n#### 参数\n\n**X** 和 **Y** 可以是标量、数据对、向量、矩阵或集合。如果 *X* 和 *Y* 的其中一个是数据对、向量或矩阵，另一个必须是标量或具有相同长度或维度的数据对、向量或矩阵。\n\n#### 返回值\n\nBOOL 类型标量/数据对/向量/矩阵。\n\n#### 例子\n\n```\n1 2 3 != 2;\n// output\n[1,0,1]\n\n1 2 3 ne 0 2 4;\n// output\n[1,0,1]\n\n1:2 != 1:6;\n// output\n0 : 1\n```\n\n```\nm1=1..6$2:3;\nm1;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1  | 3  | 5  |\n| 2  | 4  | 6  |\n\n```\nm1 != 4\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1  | 1  | 1  |\n| 1  | 0  | 1  |\n\n```\nm2=6..1$2:3;\nm2;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 6  | 4  | 2  |\n| 5  | 3  | 1  |\n\n```\nm1 ne m2;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1  | 1  | 1  |\n| 1  | 1  | 1  |\n\n集合操作：如果 X!=Y 则 X 和 Y 不是同一个集合。\n\n```\nx=set(4 6);\ny=set(4 6 8);\n\nx!=y;\n// output\n1\n\nx!=x;\n// output\n0\n```\n"
    },
    "neg": {
        "url": "https://docs.dolphindb.cn/zh/funcs/n/neg.html",
        "signatures": [
            {
                "full": "neg(X)",
                "name": "neg",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [neg](https://docs.dolphindb.cn/zh/funcs/n/neg.html)\n\n\n\n#### 语法\n\nneg(X) 或 neg X\n\n#### 详情\n\n返回 *X* 的相反数。\n\nneg 函数和运算符 - 在大部分场景下可以相互替代，但仍然存在一些区别：\n\n* neg 与括号结合时，被当作函数处理，具有最高优先级；\n* neg 不与括号结合时，则优先级较低，会先运算 neg 右边的表达式，再运算 neg。例如：neg 3 + 5，结果为 -8。\n* 运算符 \"-\" 则总是按照运算符优先级执行。例如：-3 + 5，结果为 2。\n\n#### 参数\n\n**X** 可以是标量、数据对、向量或矩阵。\n\n#### 返回值\n\n返回一个与输入 *X* 相同数据类型和形式的对象。\n\n#### 例子\n\n```\nx=1:2;\n-x;\n// output\n-1 : -2\n```\n\n```\nx=1 0 1;\n-x;\n// output\n[-1,0,-1]\n```\n\n```\nm=1 1 1 0 0 0 $ 2:3;\nm;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1  | 1  | 0  |\n| 1  | 0  | 0  |\n\n```\n-m\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| -1 | -1 | 0  |\n| -1 | 0  | 0  |\n"
    },
    "neville": {
        "url": "https://docs.dolphindb.cn/zh/funcs/n/neville.html",
        "signatures": [
            {
                "full": "neville(X, Y, resampleRule, [closed='left'], [origin='start_day'], [outputX=false])",
                "name": "neville",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "resampleRule",
                        "name": "resampleRule"
                    },
                    {
                        "full": "[closed='left']",
                        "name": "closed",
                        "optional": true,
                        "default": "'left'"
                    },
                    {
                        "full": "[origin='start_day']",
                        "name": "origin",
                        "optional": true,
                        "default": "'start_day'"
                    },
                    {
                        "full": "[outputX=false]",
                        "name": "outputX",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [neville](https://docs.dolphindb.cn/zh/funcs/n/neville.html)\n\n\n\n#### 语法\n\nneville(X, Y, resampleRule, \\[closed='left'], \\[origin='start\\_day'], \\[outputX=false])\n\n#### 详情\n\n该函数根据 *resampleRule*, *closed*, *origin* 确定的采样规则，对 *X* 进行重采样操作。并根据重采样后的 *X*，对 *Y* 进行 neville 插值（Neville Interpolation）。\n\n若不指定 *outputX*，仅返回一个对 *Y* 插值后的向量。若指定 *outputX* = true，则返回一个 tuple，其第一个元素为 *X* 重采样后的向量，第二个元素为对 *Y* 插值后的向量。\n\n#### 参数\n\n**X** 严格递增的时间类型向量。\n\n**Y** 同 *X* 等长的数值型向量。\n\n**resampleRule** 一个字符串，可选值请参考 [resample](https://docs.dolphindb.cn/zh/funcs/r/resample.html) 的 *rule* 参数。\n\n**closed** 和 **origin** 同 [resample](https://docs.dolphindb.cn/zh/funcs/r/resample.html) 的 *closed* 和 *origin* 参数。\n\n**outputX** 布尔类型，表示是否输出 *X* 按照 *resampleRule*, *closed*, *origin* 重采样后的向量。默认值为 false。\n\n#### 返回值\n\nDOUBLE 类型向量或元组。\n\n#### 例子\n\n**例 1**\n\n```\nneville([2016.02.14 00:00:00, 2016.02.15 00:00:00, 2016.02.16 00:00:00], [1.0, 2.0, 4.0], resampleRule=`60min);\n```\n\n输出返回：\\[1,1.0217,1.0451,1.0703,1.0972,1.1259,1.1562,1.1884,1.2222,1.2578, 1.2951,1.3342,1.375,1.4175,1.4618,1.5078,1.5556,1.605,1.6562,1.7092, 1.7639,1.8203,1.8785,1.9384,2,2.0634,2.1285,2.1953,2.2639,2.3342, 2.4062,2.48,2.5556,2.6328,2.7118,2.7925,2.875,2.9592,3.0451,3.1328, 3.2222,3.3134,3.4062,3.5009,3.5972,3.6953,3.7951,3.8967,4]\n\n**例 2** 不同 *closed* 取值的影响。\n\n```\n// 数据点精确落在 3min 整点边界上\nX = 2022.01.01T00:00:00 + [0, 3, 6, 9] * 60  // 00:00, 00:03, 00:06, 00:09\nY = [1.0, 3.0, 7.0, 13.0]\n\n// closed='left'（默认）：区间 [t, t+3min)，00:03 归入第二个桶的起点\nneville(X, Y, `3min, closed=`left, outputX=true)\n// output:([2022.01.01T00:00:00,2022.01.01T00:03:00,2022.01.01T00:06:00,2022.01.01T00:09:00],[1,3,7,13])\n\n// closed='right'：区间 (t, t+3min]，00:03 归入第一个桶的终点\n// 桶划分基准改变，插值曲线随之变化\nneville(X, Y, `3min, closed=`right, outputX=true)\n// output:([2021.12.31T23:57:00,2022.01.01T00:00:00,2022.01.01T00:03:00,2022.01.01T00:06:00],[,1,3,7])\n```\n\n**例 3** 不同 *origin* 取值的影响。\n\n```\n// 数据从 00:00:30 开始，不与整分对齐\nX = 2026.01.01T00:00:30 + (0..4) * 60  // 00:00:30, 00:01:30, ..., 00:04:30\nY = [2.0, 4.0, 7.0, 11.0, 16.0]\n\n// origin='start_day'：从当天零点 00:00:00 对齐\n// 重采样 X: 00:00:00, 00:01:00, 00:02:00, 00:03:00, 00:04:00\nneville(X, Y, `1min, origin=`start_day, outputX=true)\n// output:([2022.01.01T00:00:00,2022.01.01T00:01:00,2022.01.01T00:02:00,2022.01.01T00:03:00,2022.01.01T00:04:00],[,2.875,5.375,8.875,13.375])\n\n// origin='start'：从第一个数据点 00:00:30 对齐\n// 重采样 X: 00:00:30, 00:01:30, 00:02:30, 00:03:30, 00:04:30\nneville(X, Y, `1min, origin=`start, outputX=true)\n// output:([2022.01.01T00:00:30,2022.01.01T00:01:30,2022.01.01T00:02:30,2022.01.01T00:03:30,2022.01.01T00:04:30],[2,4,7,11,16])\n\n// origin=自定义时间戳：从 00:00:10 对齐\n// 重采样 X: 00:00:10, 00:01:10, 00:02:10, 00:03:10, 00:04:10\nneville(X, Y, `1min, origin=2026.01.01T00:00:10, outputX=true)\n//output:([2022.01.01T00:00:10,2022.01.01T00:01:10,2022.01.01T00:02:10,2022.01.01T00:03:10,2022.01.01T00:04:10],[,3.222222222222222,5.88888888888889,9.555555555555555,14.222222222222223])\n```\n\n**例 4** 不同 *outputX* 取值的影响。\n\n```\nX = [2016.02.14T00:00:00, 2016.02.15T00:00:00, 2016.02.16T00:00:00]\nY = [1.0, 2.0, 4.0]\n\n// outputX=false（默认）：只返回插值后的 Y 向量\nneville(X, Y, `60min)\n\n// outputX=true：返回 tuple，[0] 为重采样后的时间戳，[1] 为插值 Y\nresult = neville(X, Y, `60min, outputX=true)\nresult[0]  // 每小时一个时间戳，共 49 个\nresult[1]  // 对应插值 Y 值，共 49 个\n```\n"
    },
    "next": {
        "url": "https://docs.dolphindb.cn/zh/funcs/n/next.html",
        "signatures": [
            {
                "full": "next(X)",
                "name": "next",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [next](https://docs.dolphindb.cn/zh/funcs/n/next.html)\n\n\n\n#### 语法\n\nnext(X)\n\n#### 详情\n\n将 *X*向左移动一个位置。类似地：[prev](https://docs.dolphindb.cn/zh/funcs/p/prev.html) 将 *X*向右移动一个位置；[move](https://docs.dolphindb.cn/zh/funcs/m/move.html) 可以将 *X*向左或向右移动一个位置。\n\n与Python 中 next 的区别：Python 的 next 函数用于从迭代器中取下一个元素，DolphinDB 中 `next(X)` 相当于 Python 中的 `shift(X, -1)`。\n\n#### 参数\n\n**X** 可以是向量、矩阵或表。\n\n#### 返回值\n\n返回一个与输入 *X* 相同数据类型和形式的对象。\n\n#### 例子\n\n```\nx = 1..5;\nnext(x);\n// output: [2,3,4,5,]\n```\n\n```\nx = matrix(1 2 3 4 5);\nnext(x)\n```\n\n| #0 |\n| -- |\n| 2  |\n| 3  |\n| 4  |\n| 5  |\n|    |\n\n```\nt=table(1 2 3 as a, `x`y`z as b, 10.8 7.6 3.5 as c);\nnext(t)\n```\n\n| a | b | c   |\n| - | - | --- |\n| 2 | y | 7.6 |\n| 3 | z | 3.5 |\n|   |   |     |\n"
    },
    "nextState": {
        "url": "https://docs.dolphindb.cn/zh/funcs/n/nextState.html",
        "signatures": [
            {
                "full": "nextState(X)",
                "name": "nextState",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [nextState](https://docs.dolphindb.cn/zh/funcs/n/nextState.html)\n\n\n\n#### 语法\n\nnextState(X)\n\n#### 详情\n\n*X* 中连续且相同的元素标记为同一状态，空值无状态。每个元素的状态等于其元素值。对于 *X* 中的每一个元素，返回当前状态的下一个状态。若当前元素为空，则返回下一个邻近状态。\n\n*X* 是矩阵时，则在矩阵每一列进行上述计算。\n\n#### 参数\n\n**X** 时间类型，布尔类型或者数值型的向量/矩阵。\n\n#### 返回值\n\n返回一个与输入 *X* 相同数据类型和形式的对象。\n\n#### 例子\n\n```\nX = [1, 2.2, NULL, 2.2, 2.3, 1, 1.2]\nnext(X)\n// output\n[2.2,,2.2,2.3,1,1.2,]\n\nnextState(X)\n// output\n[2.2,2.2,2.2,2.3,1,1.2,]\n\nX = matrix([1.0, 1.1, 1.0, 0.9], [NULL, 1.3, 2.5, 5.5], [5.5, 4.2, 1.6, 1.8])\nnextState(X)\n```\n\n| #0  | #1  | #2  |\n| --- | --- | --- |\n| 1.1 | 1.3 | 4.2 |\n| 1   | 2.5 | 1.6 |\n| 0.9 | 5.5 | 1.8 |\n|     |     |     |\n\n相关函数： [prevState](https://docs.dolphindb.cn/zh/funcs/p/prevState.html)\n"
    },
    "norm": {
        "url": "https://docs.dolphindb.cn/zh/funcs/n/norm.html",
        "signatures": [
            {
                "full": "norm(mean, std, count)",
                "name": "norm",
                "parameters": [
                    {
                        "full": "mean",
                        "name": "mean"
                    },
                    {
                        "full": "std",
                        "name": "std"
                    },
                    {
                        "full": "count",
                        "name": "count"
                    }
                ]
            }
        ],
        "markdown": "### [norm](https://docs.dolphindb.cn/zh/funcs/n/norm.html)\n\n\n\n#### 语法\n\nnorm(mean, std, count)\n\n#### 详情\n\n返回一个长度（维度）为 *count* 的向量（矩阵），服从期望值为 *mean*，标准差为 *std* 的正态分布。\n\n与 Python 中 norm 的区别：numpy.linalg.norm 用于计算矩阵或向量的范数，scipy.stats.norm 可用于生成正态分布对象。\n\n#### 参数\n\n**mean** 数值型标量，表示正态分布的期望值。\n\n**std** 数值型标量，表示正态分布的标准差。\n\n**count** 整型标量或数据对。若为标量，表示输出向量的长度；若为数据对，表示输出矩阵的维度。\n\n#### 返回值\n\nDOUBLE 类型向量或矩阵。\n\n#### 例子\n\n```\nnorm(2.0,0.1,3);\n// output\n[2.026602,1.988621,2.101107]\n\nmean norm(3,1,10000);\n// output\n3.007866\n\n\nstd norm(3,1,10000);\n// output\n0.995806\n\n// 生成随机矩阵\nnorm(0, 1, 3:2)\n```\n\n| col1    | col2    |\n| ------- | ------- |\n| -0.5399 | -0.8475 |\n| -1.0029 | 1.811   |\n| -0.0485 | -0.4339 |\n"
    },
    "normal": {
        "url": "https://docs.dolphindb.cn/zh/funcs/n/normal.html",
        "signatures": [
            {
                "full": "norm(mean, std, count)",
                "name": "norm",
                "parameters": [
                    {
                        "full": "mean",
                        "name": "mean"
                    },
                    {
                        "full": "std",
                        "name": "std"
                    },
                    {
                        "full": "count",
                        "name": "count"
                    }
                ]
            }
        ],
        "markdown": "### [normal](https://docs.dolphindb.cn/zh/funcs/n/normal.html)\n\n是 [norm](https://docs.dolphindb.cn/zh/funcs/n/norm.html) 的别名。\n\n\n以下是 `norm` 函数的文档：\n### [norm](https://docs.dolphindb.cn/zh/funcs/n/norm.html)\n\n\n\n#### 语法\n\nnorm(mean, std, count)\n\n#### 详情\n\n返回一个长度（维度）为 *count* 的向量（矩阵），服从期望值为 *mean*，标准差为 *std* 的正态分布。\n\n与 Python 中 norm 的区别：numpy.linalg.norm 用于计算矩阵或向量的范数，scipy.stats.norm 可用于生成正态分布对象。\n\n#### 参数\n\n**mean** 数值型标量，表示正态分布的期望值。\n\n**std** 数值型标量，表示正态分布的标准差。\n\n**count** 整型标量或数据对。若为标量，表示输出向量的长度；若为数据对，表示输出矩阵的维度。\n\n#### 返回值\n\nDOUBLE 类型向量或矩阵。\n\n#### 例子\n\n```\nnorm(2.0,0.1,3);\n// output\n[2.026602,1.988621,2.101107]\n\nmean norm(3,1,10000);\n// output\n3.007866\n\n\nstd norm(3,1,10000);\n// output\n0.995806\n\n// 生成随机矩阵\nnorm(0, 1, 3:2)\n```\n\n| col1    | col2    |\n| ------- | ------- |\n| -0.5399 | -0.8475 |\n| -1.0029 | 1.811   |\n| -0.0485 | -0.4339 |\n"
    },
    "not": {
        "url": "https://docs.dolphindb.cn/zh/funcs/n/not.html",
        "signatures": [
            {
                "full": "not(X)",
                "name": "not",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [not](https://docs.dolphindb.cn/zh/funcs/n/not.html)\n\n\n\n#### 语法\n\nnot(X) 或 !(X)\n\n#### 详情\n\n返回对 *X* 应用 NOT 的值。返回值是 0, 1 或 NULL。 0 的 NOT 值是 1；NULL 的 NOT 值仍是 NULL；所有其他值的 NOT 值是 0。\n\nnot 函数和运算符 ! 在大部分场景下可以相互替代，但仍然存在一些区别：\n\n* not 与括号结合时，被当作函数处理，具有最高优先级；\n* not 不与括号结合时，则优先级较低，会先运算 not 右边的表达式，再运算 not。例如：not false and false 等价于 not(false and false)，结果为 true。\n* 运算符 \"!\" 则总是按照运算符优先级执行。例如：！false and false 等价于 (!false) and false，结果为 false。\n\n#### 参数\n\n**X** 可以是标量、数据对、向量或矩阵。\n\n#### 返回值\n\n布尔类型，其数据形式同 *X*。\n\n#### 例子\n\n```\n!1.5;\n// output\n0\n```\n\n```\nnot 0;\n// output\n1\n```\n\n```\nx=1 0 2;\nnot x;\n// output\n[0,1,0]\n```\n\n```\nm=1 1 1 1 1 0 0 0 0 0$2:5;\nm;\n```\n\n| #0 | #1 | #2 | #3 | #4 |\n| -- | -- | -- | -- | -- |\n| 1  | 1  | 1  | 0  | 0  |\n| 1  | 1  | 0  | 0  | 0  |\n\n```\nnot m;\n```\n\n| #0 | #1 | #2 | #3 | #4 |\n| -- | -- | -- | -- | -- |\n| 0  | 0  | 0  | 1  | 1  |\n| 0  | 0  | 1  | 1  | 1  |\n\n```\n(1).not();\n// output\n0\n```\n\n```\n(!NULL)==NULL;\n// output\n1\n```\n\n**Related information**\n\n[and](https://docs.dolphindb.cn/zh/funcs/a/and.html)\n\n[or](https://docs.dolphindb.cn/zh/funcs/o/or.html)\n"
    },
    "notBetween": {
        "url": "https://docs.dolphindb.cn/zh/funcs/n/notbetween.html",
        "signatures": [
            {
                "full": "notBetween(X, Y)",
                "name": "notBetween",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [notBetween](https://docs.dolphindb.cn/zh/funcs/n/notbetween.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nnotBetween(X, Y)\n\n#### 详情\n\n检查 *X* 的每个元素是否在 Y 确定的范围之外。\n\n#### 参数\n\n**X** 可以是标量、数据对、向量或矩阵；\n\n**Y** 是一个表示范围的数据对（包含两个边界）。\n\n#### 返回值\n\n布尔类型，标量或维度与 *X* 相同的向量/矩阵。\n\n#### 例子\n\n```\nnotBetween([1, 5.5, 6, 8], 1:6);\n// output: [false,false,false,true]\n\nnotBetween(1 2.4 3.6 2 3.9, 2.4:3.6);\n// output: [true,false,false,true,true]\n```\n\n`notBetween` 可以搭配 `select` 使用，检查值是否不在指定的范围之内。\n\n```\nt = table(`abb`aac`aaa as sym, 1.8 2.3 3.7 as price);\nselect * from t where price notBetween 1:3;\n```\n\n| sym | price |\n| --- | ----- |\n| aaa | 3.7   |\n\n`notBetween` 亦可应用于对分布式表的查询中：\n\n```\nlogin(`admin,`123456)\ndbName=\"dfs://database1\"\nif(existsDatabase(dbName)){\n\tdropDatabase(dbName)\n}\ndb=database(dbName,VALUE,2019.01.01..2019.01.03)\nn=100\ndatetime=take(2019.01.01 +0..100,n)\nsym = take(`C`MS`MS`MS`IBM`IBM`IBM`C`C$SYMBOL,n)\nprice= take(49.6 29.46 29.52 30.02 174.97 175.23 50.76 50.32 51.29,n)\nqty = take(2200 1900 2100 3200 6800 5400 1300 2500 8800,n)\nt=table(datetime, sym, price, qty)\ntrades=db.createPartitionedTable(t,`trades,`datetime).append!(t)\n\nselect * from trades where qty notBetween 1300:6800\n```\n\n| datetime   | sym | price | qty   |\n| ---------- | --- | ----- | ----- |\n| 2019.01.09 | C   | 51.29 | 8,800 |\n| 2019.01.18 | C   | 51.29 | 8,800 |\n| 2019.01.27 | C   | 51.29 | 8,800 |\n| 2019.02.05 | C   | 51.29 | 8,800 |\n| 2019.02.14 | C   | 51.29 | 8,800 |\n| 2019.02.23 | C   | 51.29 | 8,800 |\n| 2019.03.04 | C   | 51.29 | 8,800 |\n| 2019.03.13 | C   | 51.29 | 8,800 |\n| 2019.03.22 | C   | 51.29 | 8,800 |\n| 2019.03.31 | C   | 51.29 | 8,800 |\n| 2019.04.09 | C   | 51.29 | 8,800 |\n\n相关函数：[between](https://docs.dolphindb.cn/zh/funcs/b/between.html)\n"
    },
    "notIn": {
        "url": "https://docs.dolphindb.cn/zh/funcs/n/notin.html",
        "signatures": [
            {
                "full": "notIn(X, Y)",
                "name": "notIn",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [notIn](https://docs.dolphindb.cn/zh/funcs/n/notin.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nnotIn(X, Y)\n\n#### 详情\n\n* 若 *Y* 是标量：\n  * 当 Y 是非时间类型时，检查 *X* 和 *Y* 是否不相等；\n  * 当*Y* 是时间类型时，检查 *X* 中的每个元素是否不在 *Y* 中。\n  * 当 *Y* 是空值时，无论 *X* 为何值都返回 true。\n* 若 *Y* 是向量，检查 *X* 中的每一个元素是否不在 *Y* 中。\n* 若 *Y* 是字典，检查 *X* 中的每一个元素是否不是 *Y* 中的键。\n* 若 *Y* 是单列内存表，检查 *X* 中的每一个元素是否不是 *Y* 唯一列中的值。**注：** 表中单列的类型不能是数组向量。\n* 若 *Y* 是键值表或索引内存表，检查 *X* 中的每一个元素是否不是 *Y* 中的主键。*X* 中元素的个数必须与 *Y* 中主键列的个数一致。\n\n#### 参数\n\n**X** 可以是标量、向量、元组、矩阵、数组向量、字典、单列内存表、键值内存表或索引内存表。\n\n**Y** 可以是标量、向量、字典、单列内存表、键值内存表或索引内存表。\n\n#### 返回值\n\n布尔类型标量或向量。\n\n#### 例子\n\n```\nx=18:21:35+0..2\ny=18:21:35\nnotIn(x,y)\n// output: [false,true,true]\n\nnotIn(3 3 5 2, 2 3);\n// output: [false,false,true,false]\n\nx=dict(INT,DOUBLE);\nx[1, 2, 3]=[4.5, 6.6, 3.2];\nx;\n/* output\n3->3.2\n1->4.5\n2->6.6\n*/\n\nnotIn(1..6, x);\n// output: [false,false,false,true,true,true]\n\nt = table(1 3 5 7 9 as id)\n2 3 notIn t\n// output: [true,false]\n\nkt = keyedTable(`name`id,1000:0,`name`id`age`department,[STRING,INT,INT,STRING])\ninsert into kt values(`Tom`Sam`Cindy`Emma`Nick, 1 2 3 4 5, 30 35 32 25 30, `IT`Finance`HR`HR`IT)\nnotIn((`Tom`Cindy, 1 3), kt);\n// output: [false,false]\n\nt1 = indexedTable(`sym`side, 10000:0, `sym`side`price`qty, [SYMBOL,CHAR,DOUBLE,INT])\ninsert into t1 values(`IBM`MSFT`GOOG, ['B','S','B'], 10.01 10.02 10.03, 10 10 20)\nnotIn((`IBM`MSFT, ['S','S']), t1);\n// output: [true,false]\n```\n\n*X* 为浮点型，*Y* 为整型，数据类型不一致，会将 *X* 转换为与 *Y* 一致的类型进行比较。\n\n```\nnotIn(10, NULL)\n// output: true\n\nnotIn('a', 97)\n// output: false\n\nnotIn(1, 1.1 1.2 1.3)\n// output: true\n\nnotIn(float(1.1 2.2 3.3 4.4 5.5 6.6 7.7 8.8), 1..9)\n// output: [false,false,false,false,false,false,false,false]\n```\n\n`notIn` 可以搭配 `select` 使用，用于限定条件的筛选的范围：\n\n```\nselect * from kt where name notIn [`Tom, `Cindy];\n```\n\n| name | id | age | department |\n| ---- | -- | --- | ---------- |\n| Sam  | 2  | 35  | Finance    |\n| Emma | 4  | 25  | HR         |\n| Nick | 5  | 30  | IT         |\n\n`notIn` 亦可应用于对分布式表的查询中：\n\n```\nlogin(`admin,`123456)\ndbName=\"dfs://database1\"\nif(existsDatabase(dbName)){\n\tdropDatabase(dbName)\n}\ndb=database(dbName,VALUE,2019.01.01..2019.01.03)\nn=100\ndatetime=take(2019.01.01 +0..100,n)\nsym = take(`C`MS`MS`MS`IBM`IBM`IBM`C`C$SYMBOL,n)\nprice= take(49.6 29.46 29.52 30.02 174.97 175.23 50.76 50.32 51.29,n)\nqty = take(2200 1900 2100 3200 6800 5400 1300 2500 8800,n)\nt=table(datetime, sym, price, qty)\ntrades=db.createPartitionedTable(t,`trades,`datetime).append!(t)\n\nselect * from trades where sym notIn `IBM`C\n```\n\n相关函数：[in](https://docs.dolphindb.cn/zh/funcs/i/in.html)\n"
    },
    "notLike": {
        "url": "https://docs.dolphindb.cn/zh/funcs/n/notlike.html",
        "signatures": [
            {
                "full": "notLike(X, pattern)",
                "name": "notLike",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "pattern",
                        "name": "pattern"
                    }
                ]
            }
        ],
        "markdown": "### [notLike](https://docs.dolphindb.cn/zh/funcs/n/notlike.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nnotLike(X, pattern)\n\n#### 详情\n\n确定 *X* 是否与 *pattern* 指定的模式不匹配。比较操作区分大小写。\n\n#### 参数\n\n**X** 可以是字符串类型的标量/向量。\n\n**pattern** 是一个字符串，通常包含通配符（例如 \"%\"）。\n\n#### 返回值\n\n布尔类型标量或向量。\n\n#### 例子\n\n```\nnotLike(`DEFG, `DE);\n// output: true\n\nnotLike(`DEFG, \"%DE%\");\n// output: false\n\n\na=`IBM`ibm`MSFT`Goog;\nnotLike(a, \"%OO%\");\n// output: [true,true,true,true]\n\nprint a[notLike(a, \"%OO%\")];\n// output: [\"IBM\",\"ibm\",\"MSFT\",\"Goog\"]\n```\n\n`notLike` 可以搭配 `select` 使用，用于排除符合某些条件的记录：\n\n```\nt = table(`abb`aac`aaa as sym, 1.8 2.3 3.7 as price);\nselect * from t where sym notLike \"%aa%\";\n```\n\n| sym | price |\n| --- | ----- |\n| abb | 1.8   |\n\n`notLike` 亦可应用于对分布式表的查询中：\n\n```\n\ndbName=\"dfs://database1\"\nif(existsDatabase(dbName)){\n\tdropDatabase(dbName)\n}\ndb=database(dbName,VALUE,2019.01.01..2019.01.03)\nn=100\ndatetime=take(2019.01.01 +0..100,n)\nsym = take(`C`MS`MS`MS`IBM`IBM`IBM`C`C$SYMBOL,n)\nprice= take(49.6 29.46 29.52 30.02 174.97 175.23 50.76 50.32 51.29,n)\nqty = take(2200 1900 2100 3200 6800 5400 1300 2500 8800,n)\nt=table(datetime, sym, price, qty)\ntrades=db.createPartitionedTable(t,`trades,`datetime).append!(t)\n\nselect * from trades where sym notLike \"%IBM%\"\n```\n\n相关函数：[like](https://docs.dolphindb.cn/zh/funcs/l/like.html)\n"
    },
    "now": {
        "url": "https://docs.dolphindb.cn/zh/funcs/n/now.html",
        "signatures": [
            {
                "full": "now([nanoSecond=false])",
                "name": "now",
                "parameters": [
                    {
                        "full": "[nanoSecond=false]",
                        "name": "nanoSecond",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [now](https://docs.dolphindb.cn/zh/funcs/n/now.html)\n\n\n\n#### 语法\n\nnow(\\[nanoSecond=false])\n\n#### 详情\n\n返回当前的时间戳。\n\n**Note:** 由于 Windows 操作系统对时间精度的支持存在差异，某些版本可能无法实现纳秒级别的精度。因此，即使在调用函数时设置 *nanoSecond*=true，返回的时间戳仍可能仅精确到毫秒。\n\n#### 参数\n\n**nanoSecond** 是布尔值，表示是否精确到纳秒。它是可选参数，默认值为 false，表示精确到毫秒。\n\n#### 返回值\n\nTIMESTAMP/NANOTIMESTAMP 类型标量。\n\n#### 例子\n\n```\nnow();\n// output\n2016.05.12T19:32:49.613\n\nnow(true);\n// output\n2016.05.12T19:32:49.614243000\n```\n"
    },
    "ns": {
        "url": "https://docs.dolphindb.cn/zh/funcs/n/ns.html",
        "signatures": [
            {
                "full": "ns(maturity, yield, [method='nm'], [maxIter], [bounds], [initialGuess], [seed])",
                "name": "ns",
                "parameters": [
                    {
                        "full": "maturity",
                        "name": "maturity"
                    },
                    {
                        "full": "yield",
                        "name": "yield"
                    },
                    {
                        "full": "[method='nm']",
                        "name": "method",
                        "optional": true,
                        "default": "'nm'"
                    },
                    {
                        "full": "[maxIter]",
                        "name": "maxIter",
                        "optional": true
                    },
                    {
                        "full": "[bounds]",
                        "name": "bounds",
                        "optional": true
                    },
                    {
                        "full": "[initialGuess]",
                        "name": "initialGuess",
                        "optional": true
                    },
                    {
                        "full": "[seed]",
                        "name": "seed",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [ns](https://docs.dolphindb.cn/zh/funcs/n/ns.html)\n\n\n\n#### 语法\n\nns(maturity, yield, \\[method='nm'], \\[maxIter], \\[bounds], \\[initialGuess], \\[seed])\n\n#### 详情\n\n使用 NS 模型和指定的优化方法，拟合债券的收益率曲线。\n\n#### 参数\n\n**initialGuess** 可选参数，数值向量，表示使函数最优化的参数的初始猜测。长度为 4，每个值分别表示 β0, β1, β2, λ 的初始猜测，默认值为 \\[0.01, 0.01, 0.01, 1.0]。\n\n其余参数详见 [nss](https://docs.dolphindb.cn/zh/funcs/n/nss.html)。\n\n#### 返回值\n\n返回一个字典，详见 [nss](https://docs.dolphindb.cn/zh/funcs/n/nss.html)。\n\n#### 例子\n\n传入指定的模型名称与参数，使用 bfgs 优化方法，拟合债券的收益率曲线。\n\n```\nmaturity = [1,2,3,4,5,8,10,15,20,25,30]\nyield = [0.0039,0.0061,NULL,NULL,0.0166,NULL,0.0258,NULL,NULL,0.0332,NULL]\nmodel = ns(maturity, yield, method='bfgs');\nmodel;\n/*Output\nmodelName->ns\nparams->[0.037907009765789,-0.032345632006991,-0.048221596538028,1.48711064869407]\nfminResult->xopt->[0.037907009765789,-0.032345632006991,-0.048221596538028,1.48711064869407]\nfopt->7.682740281926149E-8\ngopt->[0.000007050477817,-0.000001557728067,8.217072418048589E-7,-7.435919702203364E-8]\niterations->29\nHinv->#0                  #1                    #2                   #3                   \n------------------- --------------------- -------------------- ---------------------\n1.046957491287936   -2.422265785994416    4.016547235964936    174.575362711334378  \n-2.422265785994413  20.767722224747515    -55.516118469836506  -1160.911707217612729\n4.016547235964929   -55.516118469836506   162.441840532431541  3127.297987855009978 \n174.575362711334378 -1160.911707217613638 3127.297987855011797 72743.950482441126951\n\nwarnFlag->0\nfcalls->165\ngcalls->33\n\npredict->nssPredict\n*/\n```\n\n若更换优化算法为 nm，返回值将发生变化。\n\n```\nmodel = ns(maturity, yield, method='nm');\nmodel;\n/*Output\nmodelName->ns\nmodelName->ns\nparams->[-0.017297505365068,0.016544815374471,0.142682692134247,14.720778706012911]\nfminResult->xopt->[-0.017297505365068,0.016544815374471,0.142682692134247,14.720778706012911]\nfopt->0.000001443427918\niterations->446\nfcalls->740\nwarnFlag->0\n\npredict->nssPredict\n*/\n```\n\n**相关函数**：[nss](https://docs.dolphindb.cn/zh/funcs/n/nss.html)\n"
    },
    "nss": {
        "url": "https://docs.dolphindb.cn/zh/funcs/n/nss.html",
        "signatures": [
            {
                "full": "nss(maturity, yield, [method='nm'], [maxIter], [bounds], [initialGuess], [seed])",
                "name": "nss",
                "parameters": [
                    {
                        "full": "maturity",
                        "name": "maturity"
                    },
                    {
                        "full": "yield",
                        "name": "yield"
                    },
                    {
                        "full": "[method='nm']",
                        "name": "method",
                        "optional": true,
                        "default": "'nm'"
                    },
                    {
                        "full": "[maxIter]",
                        "name": "maxIter",
                        "optional": true
                    },
                    {
                        "full": "[bounds]",
                        "name": "bounds",
                        "optional": true
                    },
                    {
                        "full": "[initialGuess]",
                        "name": "initialGuess",
                        "optional": true
                    },
                    {
                        "full": "[seed]",
                        "name": "seed",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [nss](https://docs.dolphindb.cn/zh/funcs/n/nss.html)\n\n\n\n#### 语法\n\nnss(maturity, yield, \\[method='nm'], \\[maxIter], \\[bounds], \\[initialGuess], \\[seed])\n\n#### 详情\n\n使用 NSS 模型和指定的优化方法，拟合债券的收益率曲线。\n\n#### 参数\n\n**maturity**值大于等于 0 的数值型向量，表示历史债券的到期时间，单位是年。\n\n**yield**与 *maturity*等长的数值型向量，表示历史债券的收益率。\n\n**method**可选参数，字符串类型，表示在拟合过程中使用的最优化算法，可选值为：\n\n* “nm“：表示使用 Nelder-Mead 单纯形算法，默认值；\n\n* “bfgs“：表示使用 bfgs 算法；\n\n* “lbfgs“ ：表示使用 lbfgs 算法；\n\n* 'slsqp'：表示顺序最小二乘编程方法(SLSQP)算法；\n\n* 'de'：表示差分进化(Differential Evolution)算法。\n\n**maxIter** 可选参数，整型标量或向量，表示拟合过程中优化算法的最大迭代次数。\n\n**bounds** 可选参数，数值类型矩阵，形状为(N,2)，其中 N 为需要优化的参数数量。每一行的两个值（min, max）定义了对应参数的边界。注意：*bounds* 参数只在 *method*取值'lbfgs'、'slsqp'或者'de'时生效。\n\n**initialGuess** 可选参数，数值向量，表示使函数最优化的参数的初始猜测。长度为 6，每个值分别表示 β0, β1, β2, β3, λ0, λ1 的初始猜测，默认值为 \\[0.01, 0.01, 0.01, 0.01, 1.0, 1.0]。\n\n**seed** 可选参数，整数标量，表示差分进化算法中使用的随机数种子，仅在 *method*='de' 时生效。若 *method*='de' 且不指定 *seed*，则采用非确定性的随机数生成器。*seed* 参数用于确保结果的可复现性。\n\n#### 返回值\n\n返回一个字典，包含以下键值对：\n\n* modelName：字符串类型，表示模型名称；\n\n* params：数值向量，表示拟合后的模型参数。对于NS模型来说，长度为4，包含；对于NSS模型来说，长度为6，包含 。\n\n* fminResult：字典类型，表示 method 对应的最优化算法的优化结果，对于不同的 method，有不同输出。\n\n  * “nm“：详情见 fmin 文档。\n\n  * “bfgs“：详情见 fminBFGS 文档。\n\n  * “lbfgs“：详情见 fminLBFGSB 文档。\n\n  * “slsqp“：详情见 fminSLSQP 文档。\n\n  * “de“：详情见 differentialEvolution 文档。\n\n* predict：模型的预测函数。其使用方法为 `model.predict(T)`，T 表示需要预测的以年为单位的到期时间。\n\n#### 例子\n\n传入指定的模型名称与参数，使用 bfgs 优化方法，拟合债券的收益率曲线。\n\n```\nmaturity = [1,2,3,4,5,8,10,15,20,25,30]\nyield = [0.0039,0.0061,NULL,NULL,0.0166,NULL,0.0258,NULL,NULL,0.0332,NULL]\nmodel = nss(maturity, yield, method='bfgs');\nmodel;\n\n/*Output\nmodelName->nss\nparams->[0.036140551464406,-0.017389058792285,-0.039552798745696,-0.039554933812457,1.001838685848857,1.000930288743548]\nfminResult->xopt->[0.036140551464406,-0.017389058792285,-0.039552798745696,-0.039554933812457,1.001838685848857,1.000930288743548]\nfopt->0.000003185056025\ngopt->[4.415407204305666E-7,8.382398277717584E-7,-2.683916591195157E-7,-4.651950860079524E-7,-0.000008569511408,-0.000008564345961]\niterations->10\nHinv->#0                 #1                 #2                 #3                 #4                 #5                \n------------------ ------------------ ------------------ ------------------ ------------------ ------------------\n0.492426526437359  0.696702464055202  -1.643864246164442 -1.644086017367336 0.08871259052824   0.037055616913674 \n0.696702464055203  9.022078200827937  -9.027640937693616 -9.027654505585944 0.659730122918773  0.302144825834614 \n-1.643864246164441 -9.027640937693616 12.179963755936533 11.180865226841653 -0.737531568671335 -0.323934330889313\n-1.644086017367337 -9.027654505585944 11.180865226841657 12.181767428775573 -0.737537584440894 -0.32392102429678 \n0.08871259052824   0.659730122918772  -0.737531568671335 -0.737537584440894 1.053013492023418  0.024560701245749 \n0.037055616913674  0.302144825834614  -0.323934330889313 -0.32392102429678  0.024560701245749  1.011692492570688 \n\nwarnFlag->0\nfcalls->84\ngcalls->12\n\npredict->nssPredict\n*/\n```\n\n若更换优化算法为 nm，返回值将发生变化。\n\n```\nmodel = ns(maturity, yield, method='nm');\nmodel;\n/*Output\nmodelName->nss\nparams->[0.038184469794996,-0.048575389082029,-0.022287414169806,0.047523360012739,1.873046195772644,0.161159907274023]\nfminResult->xopt->[0.038184469794996,-0.048575389082029,-0.022287414169806,0.047523360012739,1.873046195772644,0.161159907274023]\nfopt->5.456415848001168E-9\niterations->541\nfcalls->860\nwarnFlag->0\n\npredict->nssPredict\n*/\n```\n\n相关函数：[nsspredict](https://docs.dolphindb.cn/zh/funcs/n/nsspredict.html)\n"
    },
    "nssPredict": {
        "url": "https://docs.dolphindb.cn/zh/funcs/n/nsspredict.html",
        "signatures": [
            {
                "full": "nssPredict(model, T)",
                "name": "nssPredict",
                "parameters": [
                    {
                        "full": "model",
                        "name": "model"
                    },
                    {
                        "full": "T",
                        "name": "T"
                    }
                ]
            }
        ],
        "markdown": "### [nssPredict](https://docs.dolphindb.cn/zh/funcs/n/nsspredict.html)\n\n\n\n#### 语法\n\nnssPredict(model, T)\n\n#### 详情\n\n根据指定的 NS 模型或 NSS 模型，预测债券的收益率。\n\n#### 参数\n\n**model**字典类型，表示 Nelson-Siegel（NS） 模型或 Nelson-Siegel-Svensson（NSS）模型。字典中应至少包含 *modelName*和 *params*两个成员：\n\n* modelName 字符串类型，必须为 “ns” 或 “nss” 。\n\n* params 数值型向量，表示模型的参数：\n\n  * 对于 NS 模型，向量长度为 4，依次为 β0, β1, β2, λ 。\n\n  * 对于 NSS 模型，向量长度为 6，依次为 β0, β1, β2, β3, λ0, λ1。\n\n**T**值大于 0 的数值型向量，表示历史债券的到期时间，单位是年。\n\n#### 返回值\n\nDOUBLE 类型向量。\n\n#### 例子\n\n```\nmodel = dict(STRING, ANY)\nmodel[`modelName] = `nss\nmodel[`params] = [0.038184469794996,-0.048575389082029,-0.022287414169806,0.047523360012739,1.873046195772644,0.161159907274023]\nT = [3,1]\nnssPredict(model, T)\n//output: [0.009904201306,0.003891991292041]\n```\n\n相关函数：[nss](https://docs.dolphindb.cn/zh/funcs/n/nss.html)\n"
    },
    "nullFill": {
        "url": "https://docs.dolphindb.cn/zh/funcs/n/nullFill.html",
        "signatures": [
            {
                "full": "nullFill(X, Y)",
                "name": "nullFill",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [nullFill](https://docs.dolphindb.cn/zh/funcs/n/nullFill.html)\n\n\n\n#### 语法\n\nnullFill(X, Y)\n\n#### 详情\n\n如果 *X* 是一个标量，*Y* 只能是一个标量，使用 *Y* 填充 *X* 中的 NULL 值。\n\n如果 *X* 是一个向量或矩阵：\n\n* 如果 *Y* 是标量，使用 *Y* 填充 *X* 中的 NULL 值。\n\n* 如果 *Y* 是一个与 *X* 等长的向量或矩阵，使用 *Y* 中与 *X* 的 NULL 值对应位置的元素替换 *X* 中的 NULL 值。\n\n如果 *X* 是一个表，那么 *Y* 只能是一个标量，使用 *Y* 填充表中的 NULL 值。注意，填充 NULL 值时，系统会尝试将 *Y* 进行类型转换。如果 *Y* 不能转换为表中某列的类型，系统会抛出异常。\n\n`nullFill` 不改变输入对象的值；`nullFill!` 会改变输入对象的值。\n\n#### 参数\n\n**X** 可以是标量、向量、矩阵或表。\n\n**Y** 可以是一个标量，也可以是与 *X* 长度相同的向量或矩阵。\n\n#### 返回值\n\n返回填充空值后的对象，其类型与形式同 *X*。\n\n#### 例子\n\n例1.向量\n\n```\nx=1 NULL NULL 6 NULL 7;\nnullFill(x,0);\n// output\n[1,0,0,6,0,7]\n\ny=1..6\nnullFill(x,y);\n// output\n[1,2,3,6,5,7]\n```\n\n在 SQL 语句中对表中的一列使用 `nullFill` 函数：\n\n```\nID=take(1,6) join take(2,6)\ndate=take(2018.01.01..2018.01.06, 12)\nx=3.2 5.2 NULL 7.4 NULL NULL NULL NULL 8 NULL NULL 11\nt=table(ID, date, x)\nt;\n```\n\n| ID | date       | x   |\n| -- | ---------- | --- |\n| 1  | 2018.01.01 | 3.2 |\n| 1  | 2018.01.02 | 5.2 |\n| 1  | 2018.01.03 |     |\n| 1  | 2018.01.04 | 7.4 |\n| 1  | 2018.01.05 |     |\n| 1  | 2018.01.06 |     |\n| 2  | 2018.01.01 |     |\n| 2  | 2018.01.02 |     |\n| 2  | 2018.01.03 | 8   |\n| 2  | 2018.01.04 |     |\n| 2  | 2018.01.05 |     |\n| 2  | 2018.01.06 | 11  |\n\n```\nupdate t set x=x.nullFill(avg(x)) context by id;\nt;\n```\n\n| ID | date       | x        |\n| -- | ---------- | -------- |\n| 1  | 2018.01.01 | 3.2      |\n| 1  | 2018.01.02 | 5.2      |\n| 1  | 2018.01.03 | 5.266667 |\n| 1  | 2018.01.04 | 7.4      |\n| 1  | 2018.01.05 | 5.266667 |\n| 1  | 2018.01.06 | 5.266667 |\n| 2  | 2018.01.01 | 9.5      |\n| 2  | 2018.01.02 | 9.5      |\n| 2  | 2018.01.03 | 8        |\n| 2  | 2018.01.04 | 9.5      |\n| 2  | 2018.01.05 | 9.5      |\n| 2  | 2018.01.06 | 11       |\n\n例2.矩阵\n\n```\nx=1 NULL 2 NULL 3 4 $ 3:2;\nx;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  |    |\n|    | 3  |\n| 2  | 4  |\n\n```\nx.nullFill(0);\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 0  |\n| 0  | 3  |\n| 2  | 4  |\n\n例3.表\n\n```\nt=table(1..6 as id, 2.1 2.2 NULL NULL 2.4 2.6 as x, 4.3 NULL 3.6 6.7 8.8 NULL as y);\nnullFill(t, -999999);\n```\n\n| id | x       | y       |\n| -- | ------- | ------- |\n| 1  | 2.1     | 4.3     |\n| 2  | 2.2     | -999999 |\n| 3  | -999999 | 3.6     |\n| 4  | -999999 | 6.7     |\n| 5  | 2.4     | 8.8     |\n| 6  | 2.6     | -999999 |\n\n相关函数：[isNull](https://docs.dolphindb.cn/zh/funcs/i/isNull.html), [hasNull](https://docs.dolphindb.cn/zh/funcs/h/hasNull.html), [bfill](https://docs.dolphindb.cn/zh/funcs/b/bfill.html), [ffill](https://docs.dolphindb.cn/zh/funcs/f/ffill.html), [lfill](https://docs.dolphindb.cn/zh/funcs/l/lfill.html)\n"
    },
    "nullFill!": {
        "url": "https://docs.dolphindb.cn/zh/funcs/n/nullFill_.html",
        "signatures": [
            {
                "full": "nullFill!(X, Y)",
                "name": "nullFill!",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [nullFill!](https://docs.dolphindb.cn/zh/funcs/n/nullFill_.html)\n\n\n\n#### 语法\n\nnullFill!(X, Y)\n\n#### 详情\n\n`nullFill!` 是 [nullFill](https://docs.dolphindb.cn/zh/funcs/n/nullFill.html) 函数原地修改版本，它会改变输入对象的值。\n"
    },
    "nullIf": {
        "url": "https://docs.dolphindb.cn/zh/funcs/n/nullIf.html",
        "signatures": [
            {
                "full": "nullIf(X, Y)",
                "name": "nullIf",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [nullIf](https://docs.dolphindb.cn/zh/funcs/n/nullIf.html)\n\n#### 语法\n\nnullIf(X, Y)\n\n#### 参数\n\n**X** 和 **Y** 可以是标量或向量，也可以是返回标量或向量的表达式。\n\n#### 详情\n\n若 *X* 和 *Y* 都是标量，比较 *X* 和 *Y* 的类型和值是否相同，若相同返回 NULL 值，否则返回 X。\n\n若 *X* 和 *Y* 是等长的向量，则将 *X* 和 *Y* 的元素一一进行上述比较。\n\n若 *X* 和 *Y* 一个是标量一个是向量，则将标量和向量中的元素一一进行上述比较。\n\n#### 例子\n\n```\nt = table(`APPL`IBM`AMZN`IBM`APPL`AMZN as sym, 10.1 11.2 11.3 12 10.6 10.8 as val)\nselect nullIf(sym, `AMZN) from t\n```\n\n输出返回：\n\n| nullIf\\_sym |\n| ----------- |\n| APPL        |\n| IBM         |\n|             |\n| IBM         |\n| APPL        |\n|             |\n\n```\nselect * from t where nullIf(sym, `AMZN)!=NULL\n```\n\n输出返回：\n\n| sym  | val  |\n| ---- | ---- |\n| APPL | 10.1 |\n| IBM  | 11.2 |\n| IBM  | 12   |\n| APPL | 10.6 |\n"
    },
    "nunique": {
        "url": "https://docs.dolphindb.cn/zh/funcs/n/nunique.html",
        "signatures": [
            {
                "full": "nunique(X, [ignoreNull=false])",
                "name": "nunique",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[ignoreNull=false]",
                        "name": "ignoreNull",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [nunique](https://docs.dolphindb.cn/zh/funcs/n/nunique.html)\n\n\n\n#### 语法\n\nnunique(X, \\[ignoreNull=false])\n\n#### 详情\n\n*X* 是向量/数组向量时，计算 *X* 中唯一值的数量。\n\n*X* 是元组时，其内每个向量位于相同位置的元素组成一个 key，计算唯一 key 的数量。\n\n**注意**：在 SQL-92 中，通常使用 COUNT(DISTINCT ...) 统计唯一值的数量。DolphinDB 目前不支持这种用法，不过，可以使用 `nunique` 函数来实现相同的目的。也就是说， DolphinDB 中的 `nunique(...)` 等价于 SQL-92 中的 COUNT(DISTINCT ...)，具体可见下面例子说明。\n\n#### 参数\n\n**X** 是一个向量/数组向量，或包含多个等长向量的元组。\n\n**ignoreNull** 是一个布尔值，表示是否忽略 *X*中 NULL 值。若指定 *ignoreNull*=true，则统计唯一值时将不考虑 NULL 值；否则将会统计 NULL 值。默认值为 false。请注意，当 *X* 是元组或数组向量时，不可指定 *ignoreNull*=true。\n\n#### 返回值\n\nINT 类型标量。\n\n#### 例子\n\n```\nv = [1,3,1,-6,NULL,2,NULL,1];\nnunique(v);\n// output: 5\n\n//指定 ignorNull = true，统计唯一值时将不考虑 NULL 值\nnunique(v,true);\n// output: 4\n\na = array\\(INT\\[\\], 0, 10\\).append!\\(\\[1 2 3, 3 5, 6 8 8, 9 10\\]\\)\nnunique\\(a\\)\n// output: 8\n```\n\n```\nt=table(1 2 4 8 4 2 7 1 as id, 10 20 40 80 40 20 70 10 as val);\nselect nunique([id,val]) from t;\n```\n\n| nunique |\n| ------- |\n| 5       |\n\n```\ndbName = \"dfs://testdb\"\nif(existsDatabase(dbName)){\n   dropDatabase(dbName)\n}\n\ndb=database(\"dfs://testdb\", VALUE, 2012.01.11..2012.01.29)\n\nn=100\nt=table(take(2012.01.11..2012.01.29, n) as date, symbol(take(\"A\"+string(21..60), n)) as sym, take(100, n) as val)\n\npt=db.createPartitionedTable(t, `pt, `date).append!(t)\nselect nunique(date) from pt group by sym\n```\n\n以下分别给出 MySQL 和 DolphinDB 中统计唯一用户数的示例。\n\nMySQL 代码示例如下，返回结果为 4。\n\n```\nCREATE TABLE orders (\n    order_id INT,\n    user_id INT,\n    product_id INT,\n    order_date DATE\n);\n\nINSERT INTO orders VALUES\n(1, 1001, 101, '2026-01-01'),\n(2, 1002, 101, '2026-01-02'),\n(3, 1001, 102, '2026-01-03'),\n(4, 1003, 101, '2026-01-04'),\n(5, 1002, 102, '2026-01-05'),\n(6, 1004, 103, '2026-01-06'),\n(7, 1001, 101, '2026-01-07');\n\nSELECT count(distinct user_id) AS unique_users\nFROM orders;\n```\n\nDolphinDB 代码示例，返回结果也是 4。\n\n```\nCREATE TABLE orders (\n    order_id INT,\n    user_id INT,\n    product_id INT,\n    order_date DATE\n);\n\nINSERT INTO orders VALUES(1, 1001, 101, '2026-01-01')\nINSERT INTO orders VALUES(2, 1002, 101, '2026-01-02')\nINSERT INTO orders VALUES(3, 1001, 102, '2026-01-03')\nINSERT INTO orders VALUES(4, 1003, 101, '2026-01-04')\nINSERT INTO orders VALUES(5, 1002, 102, '2026-01-05')\nINSERT INTO orders VALUES(6, 1004, 103, '2026-01-06')\nINSERT INTO orders VALUES(7, 1001, 101, '2026-01-07')\n\nselect nunique(user_id) FROM orders;\n```\n"
    },
    "oauthLogin": {
        "url": "https://docs.dolphindb.cn/zh/funcs/o/oauthlogin.html",
        "signatures": [
            {
                "full": "oauthLogin(oauthType, params)",
                "name": "oauthLogin",
                "parameters": [
                    {
                        "full": "oauthType",
                        "name": "oauthType"
                    },
                    {
                        "full": "params",
                        "name": "params"
                    }
                ]
            }
        ],
        "markdown": "### [oauthLogin](https://docs.dolphindb.cn/zh/funcs/o/oauthlogin.html)\n\n\n\n#### 语法\n\noauthLogin(oauthType, params)\n\n#### 详情\n\n目前 DolphinDB 已支持三种 OAuth 鉴权方式：Authentication Code（授权码模式，支持 Web）、Implicit（隐式授权模式，支持 Web）、Client Credentials（客户端凭证模式，支持 API）。该函数将根据传入的鉴权方式和鉴权参数向指定的授权服务器发送登录请求，最后返回字符串类型的 token 和用户信息。\n\n#### 参数\n\n**oauthType** 字符串标量，用来指定 OAuth 的鉴权方式。可选值如下：\n\n* 'authentication code'\n\n* 'implicit'\n\n* 'client credentials'\n\n**params** 一个字典，用来指定鉴权参数。\n\n* 若 *oauthType* 为 authentication code，则 *params* 传入{ code: string }。\n\n* 若 *oauthType* 为 implicit，则 *params* 传入{ token\\_type: string, access\\_token: string, expires\\_in?: string }。\n\n* 若 *oauthType* 为 client credentials，则 *params* 传入{ … }。\n\n#### 返回值\n\n字符串类型的 token 和用户信息。\n\n#### 例子\n\n指定鉴权方式为 authentication code，同时指定对应参数，最后实现单点登录。\n\n```\noauthLogin(\"authorization\n              code\",{\"code\":\"9d823075cb151201925a\"})\n```\n\n相关信息：[单点登录](https://docs.dolphindb.cn/zh/tutorials/oauth.html)\n"
    },
    "objByName": {
        "url": "https://docs.dolphindb.cn/zh/funcs/o/objByName.html",
        "signatures": [
            {
                "full": "objByName(name, [sharedVar])",
                "name": "objByName",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "[sharedVar]",
                        "name": "sharedVar",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [objByName](https://docs.dolphindb.cn/zh/funcs/o/objByName.html)\n\n\n\n#### 语法\n\nobjByName(name, \\[sharedVar])\n\n#### 详情\n\nDolphinDB 在执行脚本之前先解析脚本。解析脚本的过程是检查变量是否在本地定义。如果没有在本地定义，则抛出异常。\n\n假设我们在本地定义一个函数，然后在远程节点上执行。这个函数会查询共享表。但是，共享表在远程节点上而不在本地节点上。如果在函数的 SQL 语句中直接调用表名，系统将不能解析脚本。\n\n为了解决这个问题，系统函数 `objByName` 在执行时会根据名称返回对象。\n\n如果没有指定 *sharedVar* 参数，系统首先搜索会话中的局部变量，再搜索共享变量。如果 *sharedVar* 为true，表示只搜索共享变量。如果 *sharedVar* 为false，表示只搜索局部变量。\n\n#### 参数\n\n**name** 是一个字符串，表示表名。\n\n**sharedVar** 是一个布尔值。\n\n#### 返回值\n\n一个对象，与 *name* 具有相同的数据类型与形式。\n\n#### 例子\n\n假设在本地节点上有一个表 EarningsDates，它包含两列：Ticker 和 date。主机名为localhost 服务器的 8081 端口上的远程节点有一个表 USPrices。它包含所有美国股票的每日价格。我们想要从远程节点取得 EarningsDates 表中所有股票在公布收益后一周的价格。\n\n在远程节点，导入数据文件创建表 USPrices，然后在所有节点间共享。\n\n```\nUSPrices = loadText(\"c:/DolphinDB/Data/USPrices.csv\")\nshare USPrices as sharedUSPrices;\n```\n\n在本地节点，创建表 EarningsDates，然后把表和脚本发送到远程节点。执行完成后，结果会发送回本地节点。\n\n```\nEarningsDates=table(`XOM`AAPL`IBM as TICKER, 2006.10.26 2006.10.19 2006.10.17 as date)\ndef loadDailyPrice(data){\n   dateDict = dict(data.TICKER, data.date)\n   return select date, TICKER, PRC from objByName(\"sharedUSPrices\") where dateDict[TICKER]<date<=dateDict[TICKER]+7\n}\nconn = xdb(\"localhost\",8081)\nprices = conn(loadDailyPrice, EarningsDates);\n\nprices;\n```\n\n| date       | TICKER | PRC   |\n| ---------- | ------ | ----- |\n| 2006.10.27 | XOM    | 71.46 |\n| 2006.10.30 | XOM    | 70.84 |\n| 2006.10.31 | XOM    | 71.42 |\n| 2006.11.01 | XOM    | 71.06 |\n| 2006.11.02 | XOM    | 71.19 |\n| 2006.10.18 | IBM    | 89.82 |\n| 2006.10.19 | IBM    | 89.86 |\n| 2006.10.20 | IBM    | 90.48 |\n| 2006.10.23 | IBM    | 91.56 |\n| 2006.10.24 | IBM    | 91.49 |\n| 2006.10.20 | AAPL   | 79.95 |\n| 2006.10.23 | AAPL   | 81.46 |\n| 2006.10.24 | AAPL   | 81.05 |\n| 2006.10.25 | AAPL   | 81.68 |\n| 2006.10.26 | AAPL   | 82.19 |\n"
    },
    "objectChecksum": {
        "url": "https://docs.dolphindb.cn/zh/funcs/o/objectChecksum.html",
        "signatures": [
            {
                "full": "objectChecksum(vector, [prev])",
                "name": "objectChecksum",
                "parameters": [
                    {
                        "full": "vector",
                        "name": "vector"
                    },
                    {
                        "full": "[prev]",
                        "name": "prev",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [objectChecksum](https://docs.dolphindb.cn/zh/funcs/o/objectChecksum.html)\n\n\n\n#### 语法\n\nobjectChecksum(vector, \\[prev])\n\n#### 详情\n\n计算向量的校验和，返回一个整数。通常用于校验数据的完整性。\n\n#### 参数\n\n**vector** 向量。用于进行校验和（checksum）计算。\n\n**prev** 整数。当 *vector* 过长时，可以通过指定 *prev* 分段迭代求完整的校验和，*prev* 表示迭代时前一段数据的校验和。\n\n#### 返回值\n\n一个整数。\n\n#### 例子\n\n```\nprint objectChecksum(take(`A`B`C, 10))\n// output\n-268298654\n\nprint objectChecksum(2.3 6.5 7.8)\n// output\n-430996932\n\n// 分段计算校验和\nprint objectChecksum(1..15)\n// output\n-1877567753\n\nt0 = objectChecksum(1..5)\nt1 = objectChecksum(6..10, t0)\nt2 = objectChecksum(11..15, t1)\nprint t2\n// output\n-1877567753\n```\n"
    },
    "objectComponent": {
        "url": "https://docs.dolphindb.cn/zh/funcs/o/objectComponent.html",
        "signatures": [
            {
                "full": "objectComponent(obj)",
                "name": "objectComponent",
                "parameters": [
                    {
                        "full": "obj",
                        "name": "obj"
                    }
                ]
            }
        ],
        "markdown": "### [objectComponent](https://docs.dolphindb.cn/zh/funcs/o/objectComponent.html)\n\n\n\n#### 语法\n\nobjectComponent(obj)\n\n#### 详情\n\n获取对象的组成信息。\n\n#### 参数\n\n**obj**任意数据类型的对象。\n\n#### 返回值\n\n一个字典：\n\n* 当 *obj* 不是 CODE 类型，字典包含 *obj* 的组成部分。\n* 当 *obj* 是 CODE 类型，字典包含 *obj* 所表征对象的组成部分。\n\n#### 例子\n\n```\nobjectComponent(<select col1,col2 from pt>)\n\n/*\noutput:\nexec->0\nselect->(< col1 >,< col2 >)\nfrom->< objByName(\"pt\") >\nwhere->()\ngroupBy->()\ngroupFlag->\ncgroups->0\ncsort->()\nhaving->\norderBy->()\nrowOffset->\nrowCount->\nhint->0\nsegment->\n*/\n```\n"
    },
    "objectType": {
        "url": "https://docs.dolphindb.cn/zh/funcs/o/objectType.html",
        "signatures": [
            {
                "full": "objectType(obj)",
                "name": "objectType",
                "parameters": [
                    {
                        "full": "obj",
                        "name": "obj"
                    }
                ]
            }
        ],
        "markdown": "### [objectType](https://docs.dolphindb.cn/zh/funcs/o/objectType.html)\n\n\n\n#### 语法\n\nobjectType(obj)\n\n#### 详情\n\n判断给定对象的类型。\n\n* 当 *obj* 不是 CODE 类型，返回 “CONSTOBJ”。\n* 当 *obj* 是 CODE 类型，返回 *obj* 所表征对象的类型，可能的结果包括：\n\n| 结果               | 含义           |\n| ---------------- | ------------ |\n| CONSTOBJ         | 常量           |\n| VAR              | 变量           |\n| GLOBAL           | 全局对象         |\n| ATTR             | 对象的属性        |\n| DIM              | 维度           |\n| TUPLE            | 元组           |\n| FUNCTION         | 函数           |\n| EXPRESSION       | 表达式          |\n| COLUMN           | 列            |\n| COLUMNDEF        | 列定义          |\n| SQLQUERY         | SQL 查询       |\n| TABLEJOINER      | 表连接          |\n| VIRTUALCONST     | 虚拟常量         |\n| MAPPEDCOL        | 经过映射的列       |\n| GLOBALTALBE      | 全局表          |\n| GROUPTASK        | 一组任务         |\n| DIMTABLE         | 维度表          |\n| METHODCALL       | 对象的方法调用      |\n| SQLUPDATE        | SQL 更新语句     |\n| SQLDELETE        | SQL 删除语句     |\n| COLSELECTOR      | 列选取器         |\n| CASEWHEN         | SQL 的条件判断语句  |\n| SQLEXISTS        | SQL 的存在判断语句  |\n| SQLWITHQUERY     | SQL 的公用表表达式  |\n| OPTOBJ           | 经过优化的对象      |\n| MULTITABLEJOINER | 多表连接         |\n| UNKNOWN          | 未知（如不属于上述情况） |\n\n#### 参数\n\n**obj** 任意数据类型的对象。\n\n#### 返回值\n\n字符串标量。\n\n#### 例子\n\n```\nobjectType(<select * from pt>)\n// output: SQLQUERY\n\nobjectType(sqlColAlias(<col1>,`col))\n// output: COLUMNDEF\n\nobjectType(<x+y>)\n// output: EXPRESSION\n```\n"
    },
    "objs": {
        "url": "https://docs.dolphindb.cn/zh/funcs/o/objs.html",
        "signatures": [
            {
                "full": "objs([shared=false])",
                "name": "objs",
                "parameters": [
                    {
                        "full": "[shared=false]",
                        "name": "shared",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [objs](https://docs.dolphindb.cn/zh/funcs/o/objs.html)\n\n\n\n#### 语法\n\nobjs(\\[shared=false])\n\n#### 参数\n\n**shared** 布尔值，默认为 false。\n\n* false：返回当前会话中所有变量的信息；\n* true：返回当前会话中所有变量的信息以及所有会话共享的变量信息；\n\n#### 详情\n\n获取内存中缓存的各变量的内存占用情况等信息。\n\n注意，该函数不返回函数定义。我们应该用 defs 检查函数定义，或通过 [memSize](https://docs.dolphindb.cn/zh/funcs/m/memSize.html) 查看函数定义的内存占用。\n\n#### 返回值\n\n一个表，它具有以下几列：\n\n* name: 变量名。\n\n* type: 变量的数据类型。\n\n* form: 变量的数据形式。\n\n* rows:\n\n  * 若 form 为向量/字典/集合，则返回所有元素（包含 NULL）的个数\n\n  * 若 form 为矩阵/表，则返回它们的行数\n\n* columns:\n\n  * 若 form 为向量/字典/集合，则返回 1\n\n  * 若 form 为矩阵/表，则返回它们的列数\n\n* bytes: 变量占用的内存大小，单位为字节\n\n* shared: 是否为共享变量\n\n* extra: 分布式表的逻辑路径，格式为 `\"dfs://dbName/tableName\"`\n\n* owner：共享变量的创建者。只有设置 shared=true 时才会显示该字段。对于本地变量，此字段值为空。\n\n#### 例子\n\n```\n// 创建分布式数据库\nif(existsDatabase(\"dfs://listdb\")){\n        dropDatabase(\"dfs://listdb\")\n}\nn=1000000\nticker = rand(`MSFT`GOOG`FB`ORCL`IBM,n);\nticker[0..5]\nx=rand(1.0, n)\nt=table(ticker, x)\ndb=database(directory=\"dfs://listdb\", partitionType=HASH, partitionScheme=[STRING, 5])\npt=db.createPartitionedTable(t, `pt, `ticker)\npt.append!(t)\n\n// 共享内存表\ntime = take(2021.08.20 00:00:00..2021.08.30 00:00:00, 40);\nid = 0..39;\nvalue = rand(100, 40);\ntmp = table(time, id, value);\nshare tmp as st\n\n// 创建 set\ns = set([1,2,3,4,5])\n\n// 创建 dict\nx=1 2 3\ny=4.5 7.8 4.3\nz=dict(x,y);\n\n// 创建 matrix\nm = matrix(1 2 3, 4 5 6)\n\n// 创建 pair\np = 1:2\n```\n\n```\nobjs(true)\n```\n\n| name   | type     | form       | rows      | columns | bytes      | shared | extra            | owner |\n| ------ | -------- | ---------- | --------- | ------- | ---------- | ------ | ---------------- | ----- |\n| n      | INT      | SCALAR     | 1         | 1       | 16         | false  |                  |       |\n| ticker | SYMBOL   | VECTOR     | 1,000,000 | 1       | 4,000,000  | false  |                  |       |\n| x      | INT      | VECTOR     | 3         | 1       | 12         | false  |                  |       |\n| t      | BASIC    | TABLE      | 1,000,000 | 2       | 12,000,312 | false  |                  |       |\n| db     | HANDLE   | SCALAR     | 1         | 1       | 24         | false  |                  |       |\n| pt     | ALIAS    | TABLE      | 0         | 2       | 12,000,000 | false  | dfs\\://listdb/pt |       |\n| time   | DATETIME | VECTOR     | 40        | 1       | 160        | false  |                  |       |\n| id     | INT      | VECTOR     | 40        | 1       | 160        | false  |                  |       |\n| value  | INT      | VECTOR     | 40        | 1       | 160        | false  |                  |       |\n| tmp    | BASIC    | TABLE      | 40        | 3       | 832        | false  |                  |       |\n| s      | INT      | SET        | 5         | 1       | 28         | false  |                  |       |\n| y      | DOUBLE   | VECTOR     | 3         | 1       | 24         | false  |                  |       |\n| z      | DOUBLE   | DICTIONARY | 3         | 1       | 199        | false  |                  |       |\n| m      | INT      | MATRIX     | 3         | 2       | 24         | false  |                  |       |\n| p      | INT      | PAIR       | 2         | 1       | 8          | false  |                  |       |\n| st     | BASIC    | TABLE      | 40        | 3       | 832        | true   |                  | admin |\n"
    },
    "ols": {
        "url": "https://docs.dolphindb.cn/zh/funcs/o/ols.html",
        "signatures": [
            {
                "full": "ols(Y, X, [intercept=true], [mode=0], [method=\"default\"], [usePinv=true])",
                "name": "ols",
                "parameters": [
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[intercept=true]",
                        "name": "intercept",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[mode=0]",
                        "name": "mode",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[method=\"default\"]",
                        "name": "method",
                        "optional": true,
                        "default": "\"default\""
                    },
                    {
                        "full": "[usePinv=true]",
                        "name": "usePinv",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [ols](https://docs.dolphindb.cn/zh/funcs/o/ols.html)\n\n\n\n#### 语法\n\nols(Y, X, \\[intercept=true], \\[mode=0], \\[method=\"default\"], \\[usePinv=true])\n\n#### 详情\n\n返回对 *X* 和 *Y* 计算普通最小二乘回归的结果。需要注意的是，该函数会将 *X* 和 *Y* 中的空值替换为0后进行计算。\n\n#### 参数\n\n**Y** 是因变量；**X** 是自变量。\n\n**Y** 是一个向量；**X** 是一个向量、元组、矩阵或表。当 *X* 是矩阵时，如果行数等于 *Y* 的长度，*X* 的每一列都是一个因子；如果行数不等于 *Y* 的长度，并且如果列数等于 *Y* 的长度，*X* 的每一行都是一个因子。\n\n**intercept** 是一个布尔变量，表示是否包含回归中的截距。默认值是 true。当它为 true 时，系统自动给 *X* 添加一列 \"1\" 以生成截距。\n\n**mode** 是一个整数，默认值为 0，可取以下 3 个值\n\n* 0：输出一个系数估计向量\n\n* 1：输出一个具有系数估计，标准差，t 统计量和 p 值的表\n\n* 2：输出一个具有 ANOVA（方差分析）、RegressionStat（回归统计）、Cofficient（系数）和 Residual（残差）的字典，具体含义见下表：\n\n键 ANOVA 对应值：\n\n| Source of Variance | 自由度（Degree of freedom） | 平方和（Sum of Square） | 均方差（Mean of square） | F统计量          | Significance  |\n| ------------------ | ---------------------- | ------------------ | ------------------- | ------------- | ------------- |\n| Regression（回归）     | 变量个数（p）                | 回归平方和（SSR）         | 回归均方差（MSR=SSR/R）    | MSR 对 MSE 的比值 | 显著性，即统计出的 P 值 |\n| Residual（残差）       | 残差自由度（n-p-1）           | 残差平方和（SSE）         | 残差均方差（MSE=MSE/E）    |               |               |\n| Total              | 样本自由度                  |                    |                     |               |               |\n| 不包括常数项（n-1）        | 总离差平方和（SST）            |                    |                     |               |               |\n\n键 RegressionStat 对应值：\n\n| item         | 统计值                                                              |\n| ------------ | ---------------------------------------------------------------- |\n| R2           | R 决定系数，描述回归曲线对真实数据点拟合程度的统计量。范围在 \\[0,1]之间，越接近1 ，说明对y的解释能力越强，拟合越好。 |\n| AdjustedR2   | 经自由度修正后的决定系数，通过样本数量与模型数量对 R-squared 进行修正。                        |\n| StdError     | 回归残差标准误差，残差经自由度修正后的标准差。                                          |\n| Observations | 观察样本个数。                                                          |\n\n键 Coefficient 对应值：\n\n| 元素       | 说明               |\n| -------- | ---------------- |\n| factor   | 自变量名称            |\n| beta     | 回归系数估计值          |\n| stdError | 回归系数标准误差。        |\n| tstat    | T统计值，衡量系数的统计显著性。 |\n\n键 Residual 对应每一个预测值和实际值之间的残差。\n\n**method**是一个字符串，表示求解最小二乘问题采用的方法。\n\n* 默认值为“default”，表示采用构造系数矩阵和逆矩阵的方式求解；\n\n* 设置为“svd”，采用奇异值分解的方式。\n\n**usePinv**一个布尔值，表示计算过程中求矩阵的逆时，是否求矩阵的伪逆。\n\n* 默认值为 true，表示求矩阵的伪逆，奇异矩阵必须指定为 true。\n\n* 若为 false，表示求矩阵的逆，只适用于非奇异矩阵。\n\n#### 返回值\n\n返回值形式由 *mode* 参数决定：\n\n* *mode*=0：返回一个系数估计向量\n* *mode*=1：返回一个表，包含系数估计，标准差，t 统计量和 p 值。\n* *mode*=2：返回一个字典，包含 ANOVA（方差分析）、RegressionStat（回归统计）、Cofficient（系数）和 Residual（残差）。\n\n#### 例子\n\n```\nx1=1 3 5 7 11 16 23\nx2=2 8 11 34 56 54 100\ny=0.1 4.2 5.6 8.8 22.1 35.6 77.2;\n\nols(y, x1);\n// output\n[-9.912821,3.378632]\n\nols(y, (x1,x2));\n// output\n[-9.494813,2.806426,0.13147]\n```\n\n```\nols(y, (x1,x2), intercept=1, mode=1);\n```\n\n| factor    | beta      | stdError | tstat     | pvalue   |\n| --------- | --------- | -------- | --------- | -------- |\n| intercept | -9.494813 | 5.233168 | -1.814353 | 0.143818 |\n| x1        | 2.806426  | 1.830782 | 1.532911  | 0.20007  |\n| x2        | 0.13147   | 0.409081 | 0.321379  | 0.764015 |\n\n```\nols(y, (x1,x2), intercept=1, mode=2);\n// output\nCoefficient->\nfactor    beta      stdError tstat     pvalue\n--------- --------- -------- --------- --------\nintercept -9.494813 5.233168 -1.814353 0.143818\nx1        2.806426  1.830782 1.532911  0.20007\nx2        0.13147   0.409081 0.321379  0.764015\n\nResidual->[6.525447,4.223774,-0.383487,-5.820153,-6.638199,-6.907387,9.000005]\nRegressionStat->\nitem         statistics\n------------ ----------\nR2           0.940241\nAdjustedR2   0.910361\nStdError     8.173444\nObservations 7\n\nANOVA->\nBreakdown  DF SS          MS          F         Significance\n---------- -- ----------- ----------- --------- ------------\nRegression 2  4204.416396 2102.208198 31.467739 0.003571\nResidual   4  267.220747  66.805187\nTotal      6  4471.637143\n```\n\n```\nx=matrix(1 4 8 2 3, 1 4 2 3 8, 1 5 1 1 5);\nx;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1  | 1  | 1  |\n| 4  | 4  | 5  |\n| 8  | 2  | 1  |\n| 2  | 3  | 1  |\n| 3  | 8  | 5  |\n\n```\nols(1..5, x);\n// output\n[1.156537,0.105505,0.91055,-0.697821]\n\nols(1..5, x.transpose());\n// output\n[1.156537,0.105505,0.91055,-0.697821]\n// 系统会调整因变量和自变量的维数，以便进行回归\n```\n\n```\nx = table([13.9782,13.4688,13.4336,12.9642,12.7905,13.4771,13.0423,12.6588,13.8933,13.9006] as col0, [195.3904,181.4090,180.4627,168.0723,163.5973,181.6342,170.1017,160.2477,193.0241,193.2270] as col1, [2731.2089,2443.3656,2424.2715,2178.9356,2092.4947,2447.9167,2218.5185,2028.5594,2681.7456,2685.9754] as col2)\ny = [-0.4002,-0.8004,-0.2002,-1.0002,-0.2001,-0.5001,-0.2501,0.0000,0.0000,0.0000]\n\nols(y, x, intercept=true, mode=0, method=\"default\")\n[2.968166,13.023638,-2.016390,0.076485]\n\nols(y, x, intercept=true, mode=0, method=\"svd\")\n[3266.457957,-722.195120,53.157806,-1.302769]\n```\n\n```\nx1=1 1 1\nx2=2 2 2\ny = 1 1 1\nols(y, (x1, x2))\n// output：[0.16666666666666669\t0.16666666666666669\t0.33333333333333326]\nols(y, (x1, x2), usePinv=false) \n// ERR: The input matrix is singular and cannot be inverted.\n```\n\n由于在求解过程中，参与求逆的矩阵是奇异的，因此 usePinv=false 时报错。\n\n相关函数：[olsEx](https://docs.dolphindb.cn/zh/funcs/o/olsEx.html), [bvls](https://docs.dolphindb.cn/zh/funcs/b/bvls.html)\n"
    },
    "olsEx": {
        "url": "https://docs.dolphindb.cn/zh/funcs/o/olsEx.html",
        "signatures": [
            {
                "full": "olsEx(ds, Y, X, [intercept=true], [mode=0])",
                "name": "olsEx",
                "parameters": [
                    {
                        "full": "ds",
                        "name": "ds"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[intercept=true]",
                        "name": "intercept",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[mode=0]",
                        "name": "mode",
                        "optional": true,
                        "default": "0"
                    }
                ]
            }
        ],
        "markdown": "### [olsEx](https://docs.dolphindb.cn/zh/funcs/o/olsEx.html)\n\n\n\n#### 语法\n\nolsEx(ds, Y, X, \\[intercept=true], \\[mode=0])\n\n#### 详情\n\n返回对 *X* 和 *Y* 计算普通最小二乘回归的结果。*X* 和 *Y* 是分布式表中的列。\n\n**Note:**\n\n* 该函数会将 *X* 和 *Y* 中的空值替换为0后进行计算。\n* 因为`olsEX` 不支持输出残差，可以通过 [residual](https://docs.dolphindb.cn/zh/funcs/r/residual.html) 获取残差。\n\n#### 参数\n\n**ds** 是存储在元组中的数据源集合。它通常是由 [sqlDS](https://docs.dolphindb.cn/zh/funcs/s/sqlDS.html) 函数生成。\n\n**Y** 是一个字符串，表示 *ds* 表中因变量的列名。\n\n**X** 是字符串标量或向量，表示 *ds* 表中自变量的列名。\n\n**intercept** 是一个布尔变量，指示是否包含回归中的截距。默认值是 true。当它为 true 时，系统自动给 *X* 添加一列 \"1\" 以生成截距。\n\n**mode** 是一个整数，默认值为 0，取以下 3 个值之一\n\n* 0：输出一个系数估计向量\n* 1：输出一个具有系数估计，标准差，t统计量和p值的表\n* 2：输出一个具有 ANOVA（方差分析）、RegressionStat（回归统计）和 Cofficient（系数）的字典，具体含义见下表：\n\n键 ANOVA 对应值：\n\n| Source of Variance | 自由度（Degree of freedom） | 平方和（Sum of Square） | 均方差（Mean of square） | F 统计量         | Significance |\n| ------------------ | ---------------------- | ------------------ | ------------------- | ------------- | ------------ |\n| Regression（回归）     | 变量个数（p）                | 回归平方和（SSR）         | 回归均方差（MSR=SSR/R）    | MSR 对 MSE 的比值 | 显著性，即统计出的P值  |\n| Residual（残差）       | 残差自由度（n-p-1）           | 残差平方和（SSE）         | 残差均方差（MSE=MSE/E）    |               |              |\n| Total              | 样本自由度                  |                    |                     |               |              |\n| 不包括常数项（n-1）        | 总离差平方和（SST）            |                    |                     |               |              |\n\n键RegressionStat对应值：\n\n| item         | 统计值                                                              |\n| ------------ | ---------------------------------------------------------------- |\n| R2           | R 决定系数，描述回归曲线对真实数据点拟合程度的统计量。范围在 \\[0,1]之间，越接近1 ，说明对y的解释能力越强，拟合越好。 |\n| AdjustedR2   | 经自由度修正后的决定系数，通过样本数量与模型数量对 R-squared 进行修正。                        |\n| StdError     | 回归残差标准误差，残差经自由度修正后的标准差。                                          |\n| Observations | 观察样本个数。                                                          |\n\n键Coefficient对应值：\n\n| 元素       | 说明                           |\n| -------- | ---------------------------- |\n| factor   | 自变量名称                        |\n| beta     | 回归系数估计值                      |\n| stdError | 回归系数标准误差。标准差越大，回归系数的估计值越不靠谱。 |\n| tstat    | T 统计值，衡量系数的统计显著性。            |\n\n#### 返回值\n\n返回值形式由 *mode* 参数决定：\n\n* *mode*=0：返回一个系数估计向量\n* *mode*=1：返回一个表，包含系数估计，标准差，t 统计量和 p 值。\n* *mode*=2：返回一个字典，包含 ANOVA（方差分析）、RegressionStat（回归统计）、Cofficient（系数）和 Residual（残差）。\n\n#### 例子\n\n```\nn=10000\nID=rand(100, n)\ndates=2017.08.07..2017.08.11\ndate=rand(dates, n)\nvol=rand(1..10 join int(), n)\nprice=rand(100,n)\nt=table(ID, date, vol,price)\nsaveText(t, \"/home/DolphinDB/Data/t.txt\");\nif(existsDatabase(\"dfs://rangedb\")){\n  dropDatabase(\"dfs://rangedb\")\n}\ndb = database(directory=\"dfs://rangedb\", partitionType=RANGE, partitionScheme=0 51 101)\nUSPrices=loadTextEx(dbHandle=db,tableName=`USPrices, partitionColumns=`ID, filename=\"/home/DolphinDB/Data/t.txt\");\n\nds=sqlDS(<select vol as VS, price as SBA from USPrices where vol>5>)\nrs=olsEx(ds=ds, Y=`VS, X=`SBA, intercept=true, mode=2)\nrs;\n\n// output\nRegressionStat->\nitem         statistics\n------------ ----------\nR2           0.000848\nAdjustedR2   0.000628\nStdError     1.404645\nObservations 4535\n\nANOVA->\nBreakdown  DF   SS          MS       F        Significance\n---------- ---- ----------- -------- -------- ------------\nRegression 1    7.592565    7.592565 3.848178 0.049861\nResidual   4533 8943.739298 1.973029\nTotal      4534 8951.331863\n\nCoefficient->\nfactor    beta     stdError tstat      pvalue\n--------- -------- -------- ---------- --------\nintercept 7.953084 0.04185  190.039423 0\nSBA       0.001422 0.000725 1.961677   0.049861\n```\n"
    },
    "oneHot": {
        "url": "https://docs.dolphindb.cn/zh/funcs/o/oneHot.html",
        "signatures": [
            {
                "full": "oneHot(obj, encodingColumns)",
                "name": "oneHot",
                "parameters": [
                    {
                        "full": "obj",
                        "name": "obj"
                    },
                    {
                        "full": "encodingColumns",
                        "name": "encodingColumns"
                    }
                ]
            }
        ],
        "markdown": "### [oneHot](https://docs.dolphindb.cn/zh/funcs/o/oneHot.html)\n\n\n\n#### 语法\n\noneHot(obj, encodingColumns)\n\n#### 详情\n\n对指定的列进行独热编码（one-hot），返回编码后的表，列的顺序为编码列，非编码列。其中，编码列的列名格式为：原字段名\\_值。\n\n#### 参数\n\n**obj** 是一个内存表。\n\n**encodingColumns** 是一个字符串或者字符串向量，指定用于编码的列名。\n\n#### 返回值\n\n一个表。\n\n#### 例子\n\n```\nt = table( take(`Tom`Lily`Jim, 10) as name, take(true false, 10) as gender, take(21..23,10) as age);\noneHot(t, `name`gender);\n```\n\n输出返回：\n\n| name\\_Tom | name\\_Lily | name\\_Jim | gender\\_1 | gender\\_0 | age |\n| --------- | ---------- | --------- | --------- | --------- | --- |\n| 1         | 0          | 0         | 1         | 0         | 21  |\n| 0         | 1          | 0         | 0         | 1         | 22  |\n| 0         | 0          | 1         | 1         | 0         | 23  |\n| 1         | 0          | 0         | 0         | 1         | 21  |\n| 0         | 1          | 0         | 1         | 0         | 22  |\n| 0         | 0          | 1         | 0         | 1         | 23  |\n| 1         | 0          | 0         | 1         | 0         | 21  |\n| 0         | 1          | 0         | 0         | 1         | 22  |\n| 0         | 0          | 1         | 1         | 0         | 23  |\n| 1         | 0          | 0         | 0         | 1         | 21  |\n"
    },
    "optionVolPredict": {
        "url": "https://docs.dolphindb.cn/zh/funcs/o/optionVolPredict.html",
        "signatures": [
            {
                "full": "optionVolPredict(volsurf, dt, strike)",
                "name": "optionVolPredict",
                "parameters": [
                    {
                        "full": "volsurf",
                        "name": "volsurf"
                    },
                    {
                        "full": "dt",
                        "name": "dt"
                    },
                    {
                        "full": "strike",
                        "name": "strike"
                    }
                ]
            }
        ],
        "markdown": "### [optionVolPredict](https://docs.dolphindb.cn/zh/funcs/o/optionVolPredict.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\noptionVolPredict(volsurf, dt, strike)\n\n#### 详情\n\n给定点位的时间和行权价，从指定的波动率曲面上预测点位对应的波动率。\n\n#### 参数\n\n**volsurf** MKTDATA 类型对象（VolatilitySurface）。\n\n**dt** DOUBLE 类型标量/向量，或 DATE 类型标量/向量。\n\n* 当类型为 DOUBLE 时，表示以“年”为单位的时间。\n\n* 当类型为 DATE 时，表示具体的日期。\n\n**strike** DOUBLE 类型标量/向量，表示执行价格。\n\n#### 返回值\n\nDOUBLE 类型矩阵，形状为size(dt) \\* size(strike)。行对应输入的 *dt*（到期时间/日期），列对应输入的 *strike*（执行价）。\n\n#### 例子\n\n```\nrefDate = 2025.08.18\nccyPair = \"USDCNY\"\nquoteTerms = ['1d', '1w', '2w', '3w', '1M', '2M', '3M', '6M', '9M', '1y', '18M', '2y', '3y']\nquoteNames = [\"ATM\", \"D25_RR\", \"D25_BF\", \"D10_RR\", \"D10_BF\"]\nquotes = [0.030000, -0.007500, 0.003500, -0.010000, 0.005500, \n          0.020833, -0.004500, 0.002000, -0.006000, 0.003800, \n          0.022000, -0.003500, 0.002000, -0.004500, 0.004100, \n          0.022350, -0.003500, 0.002000, -0.004500, 0.004150, \n          0.024178, -0.003000, 0.002200, -0.004750, 0.005500, \n          0.027484, -0.002650, 0.002220, -0.004000, 0.005650, \n          0.030479, -0.002500, 0.002400, -0.003500, 0.005750, \n          0.035752, -0.000500, 0.002750,  0.000000, 0.006950, \n          0.038108,  0.001000, 0.002800,  0.003000, 0.007550, \n          0.039492,  0.002250, 0.002950,  0.005000, 0.007550, \n          0.040500,  0.004000, 0.003100,  0.007000, 0.007850, \n          0.041750,  0.005250, 0.003350,  0.008000, 0.008400, \n          0.044750,  0.006250, 0.003400,  0.009000, 0.008550]\n\nquotes = reshape(quotes, size(quoteNames):size(quoteTerms)).transpose()\n\nspot = 7.1627\ncurveDates = [2025.08.21,\n              2025.08.27,\n              2025.09.03,\n              2025.09.10,\n              2025.09.22,\n              2025.10.20,\n              2025.11.20,\n              2026.02.24,\n              2026.05.20,\n              2026.08.20,\n              2027.02.22,\n              2027.08.20,\n              2028.08.21]\n\ndomesticCurveInfo = {\n    \"mktDataType\": \"Curve\",\n    \"curveType\": \"IrYieldCurve\",\n    \"referenceDate\": refDate,\n    \"currency\": \"CNY\",\n    \"dayCountConvention\": \"Actual365\",\n    \"compounding\": \"Continuous\",  \n    \"interpMethod\": \"Linear\",\n    \"extrapMethod\": \"Flat\",\n    \"frequency\": \"Annual\",\n    \"dates\": curveDates,\n    \"values\":[1.5113, \n              1.5402, \n              1.5660, \n              1.5574, \n              1.5556, \n              1.5655, \n              1.5703, \n              1.5934, \n              1.6040, \n              1.6020, \n              1.5928, \n              1.5842, \n              1.6068]/100\n}\nforeignCurveInfo = {\n    \"mktDataType\": \"Curve\",\n    \"curveType\": \"IrYieldCurve\",\n    \"referenceDate\": refDate,\n    \"currency\": \"USD\",\n    \"dayCountConvention\": \"Actual365\",\n    \"compounding\": \"Continuous\",  \n    \"interpMethod\": \"Linear\",\n    \"extrapMethod\": \"Flat\",\n    \"frequency\": \"Annual\",\n    \"dates\": curveDates,\n    \"values\":[4.3345, \n              4.3801, \n              4.3119, \n              4.3065, \n              4.2922, \n              4.2196, \n              4.1599, \n              4.0443, \n              4.0244, \n              3.9698, \n              3.7740, \n              3.6289, \n              3.5003]/100\n}\n\ndomesticCurve = parseMktData(domesticCurveInfo)\nforeignCurve = parseMktData(foreignCurveInfo)\n\nsurf = fxVolatilitySurfaceBuilder(refDate, ccyPair, quoteNames, quoteTerms, quotes, spot, domesticCurve, foreignCurve)\n\noptionVolPredict(surf, 2025.10.18, 7)\n```\n\n|            | 7        |\n| ---------- | -------- |\n| 2025.10.18 | 0.035427 |\n\n```\noptionVolPredict(surf, 2025.10.18, [7.1,7.2])\n```\n\n|            | 7.1                 | 7.2                 |\n| ---------- | ------------------- | ------------------- |\n| 2025.10.18 | 0.02946679951336248 | 0.02926808425498284 |\n\n```\noptionVolPredict(surf, [2025.10.18, 2026.10.18], 7)\n```\n\n|            | 7                   |\n| ---------- | ------------------- |\n| 2025.10.18 | 0.03542772267328074 |\n| 2026.10.18 | 0.04045352876306188 |\n\n```\noptionVolPredict(surf, [2025.10.18, 2026.10.18], [7.1, 7.2])\n```\n\n|            | 7.1                 | 7.2                 |\n| ---------- | ------------------- | ------------------- |\n| 2025.10.18 | 0.02946679951336248 | 0.02926808425498284 |\n| 2026.10.18 | 0.04218869392416815 | 0.04440856375512336 |\n\n**相关函数：**[parseMktData](https://docs.dolphindb.cn/zh/funcs/p/parseMktData.html)\n"
    },
    "or": {
        "url": "https://docs.dolphindb.cn/zh/funcs/o/or.html",
        "signatures": [
            {
                "full": "or(X, Y)",
                "name": "or",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [or](https://docs.dolphindb.cn/zh/funcs/o/or.html)\n\n\n\n#### 语法\n\nor(X, Y) 或 X||Y\n\n#### 详情\n\n按元素逐个返回 *X* 逻辑或 `(OR)Y`的结果。\n\n注意：若 `or` 或 `||` 的操作数包含 NULL 时，|| 返回的对应结果为 NULL，而 `or` 针对不同 server 版本，返回的结果不同。\n\n* 对于小于 2.00.9.4 的版本，`or` 返回的对应结果为 NULL。\n\n* 对于 2.00.9.4 及以上版本，`or` 返回的结果由配置项 *logicOrIgnoreNull* 控制，见下表：\n\n| 操作数  | 操作数  | 返回值（*logicOrIgnoreNull*= true 时） | 返回值（*logicOrIgnoreNull*= false 时） |\n| ---- | ---- | -------------------------------- | --------------------------------- |\n| 非零   | NULL | true                             | NULL                              |\n| 零    | NULL | true                             | NULL                              |\n| NULL | NULL | true                             | NULL                              |\n\n#### 参数\n\n**X** 和 **Y** 可以是标量、数据对、向量或矩阵。\n\n#### 返回值\n\n布尔类型，其形式与 *X*/*Y* 的形式相同。\n\n#### 例子\n\n```\n1 || 0;\n```\n\n输出返回：true\n\n```\nx=1 0 1;\nx || 0;\n```\n\n输出返回：\\[true,false,true]\n\n```\ny=0 1 0;\nx or y;\n```\n\n输出返回：\\[true,true,true]\n\n```\nt=table(1..3 as id, 4..6 as value);\nt;\n```\n\n输出返回：\n\n| id | value |\n| -- | ----- |\n| 1  | 4     |\n| 2  | 5     |\n| 3  | 6     |\n\n```\nselect id, value from t where id=2 or id=3;\n```\n\n输出返回：\n\n| id | value |\n| -- | ----- |\n| 2  | 5     |\n| 3  | 6     |\n\n相关函数：[and](https://docs.dolphindb.cn/zh/funcs/a/and.html), [not](https://docs.dolphindb.cn/zh/funcs/n/not.html)\n"
    },
    "osqp": {
        "url": "https://docs.dolphindb.cn/zh/funcs/o/osqp.html",
        "signatures": [
            {
                "full": "osqp(q, [P], [A], [lb], [ub])",
                "name": "osqp",
                "parameters": [
                    {
                        "full": "q",
                        "name": "q"
                    },
                    {
                        "full": "[P]",
                        "name": "P",
                        "optional": true
                    },
                    {
                        "full": "[A]",
                        "name": "A",
                        "optional": true
                    },
                    {
                        "full": "[lb]",
                        "name": "lb",
                        "optional": true
                    },
                    {
                        "full": "[ub]",
                        "name": "ub",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [osqp](https://docs.dolphindb.cn/zh/funcs/o/osqp.html)\n\n#### 语法\n\nosqp(q, \\[P], \\[A], \\[lb], \\[ub])\n\n#### 详情\n\n求二元目标函数在线性约束条件下的最优解。具体模型如下：\n\n![](https://docs.dolphindb.cn/zh/images/osqp.png)\n\n#### 参数\n\n* **q** 是目标函数一次项向量。\n* **P** 是目标函数的二次项矩阵，且必须是半正定矩阵。\n* **A** 是不等式约束的系数矩阵。\n* **lb** 是不等式约束的左端向量。\n* **ub** 是不等式约束的右端向量。\n\n**Note:**\n\n* *A*、*lb*、*ub* 必须同时指定或同时省略。\n* *lb* 和 *ub* 可以包含空值（NULL）,但其长度必须和A的行数匹配。 *ub/lb* 为空值时，视为正/负无穷，在计算时对应值为 ±1030。\n\n#### 返回值\n\n一个元组：\n\n* 第一个元素是字符串，表示求解状态：\n  * solved ：已解决\n  * solved inaccurate：已解决，但结果不精准\n  * primal infeasible：原问题无可行解\n  * dual infeasible：对偶问题无可行解\n  * maximum iterations reached：达到最大迭代次数\n  * run time limit reached：运行超时\n  * problem non convex：问题非凸\n  * interrupted：求解被中断\n  * unsolved：未解决\n* 第二个元素是数值型向量，表示目标函数取到最小值时的数值解。\n\n#### 例子\n\n```\nP = matrix(4e-2 6e-3 -4e-3 0.0, 6e-3 1e-2 0.0 0.0, -4e-3 0.0 2.5e-3 0.0, 0.0 0.0 0.0 0.0)\nq = [-2, -4, 2, 3]\nA = [1,2,1,1,3,-1,2,1,3,1,-1,1,-2,-4,-5,1]$4:4\nl = [,,,1.0]\nu = [3.0,2.0,-1.0,1.0]\nres = osqp(q, P, A, l, u)\n```\n\n返回：(\"solved\",\\[-64.364818313795097,368.910318139716082,-548.041799338347459,244.496302999333039])\n\n"
    },
    "pack": {
        "url": "https://docs.dolphindb.cn/zh/funcs/p/pack.html",
        "signatures": [
            {
                "full": "pack(format, args...)",
                "name": "pack",
                "parameters": [
                    {
                        "full": "format",
                        "name": "format"
                    },
                    {
                        "full": "args...",
                        "name": "args..."
                    }
                ]
            }
        ],
        "markdown": "### [pack](https://docs.dolphindb.cn/zh/funcs/p/pack.html)\n\n\n\n#### 语法\n\npack(format, args...)\n\n#### 详情\n\n将数据按照 *format* 指定的格式打包成二进制字节流。\n\n#### 参数\n\n**format** 格式字符串，用于指定数据格式。指定方式参见附录。关于格式字符串的说明：\n\n* 格式字符之前可以带有整数表示重复计数。 例如，格式字符串 '4h' 的含义与 'hhhh' 完全相同。\n* 格式之间的空白字符会被忽略；但是计数及其格式字符中不可有空白字符。\n* 对于 's' 格式字符，计数会被解析为字节的长度，而不是重复计数；例如，'10s' 表示一个 10 字节的字节串，而 '10c' 表示 10 个字符。 若未给出计数，则默认值为1。字节串会被适当地截断或填充空字节以符合要求。\n\n**args...** 表示需要进行打包的数据。参数个数与 *format* 的长度一致。每个参数的类型与对应位置的 *format* 类型一致。\n\n#### 返回值\n\n一个 bytes 对象，包含 *args* 数据按照格式字符串 *format* 打包后的值。\n\n#### 例子\n\n```\nres = pack(\"N\",1);\nres1 = unpack(\"N\", res);\nprint(res1)\n// output\n(1)\n\nres = pack(\"iii\", 1, 2, 3)\nres1 = unpack(\"iii\",  res);\nprint(res1)\n// output\n(1,2,3)\n\nres = pack(\"x\",NULL)\nres = unpack(\"x\",pack(\"x\",NULL))\ntypestr(res[0])\n// output\nVOID\n\nres = pack(\"3si\", `123, 3)\nres1 = unpack(\"3si\",  res);\nprint(res1)\n// output\n(\"123\",3)\n```\n\n相关函数：[unpack](https://docs.dolphindb.cn/zh/funcs/u/unpack.html)\n\n#### 附录\n\n##### 格式字符与类型\n\n| 格式 | C 类型               | Python 类型 | DolphinDB 类型 | 范围                       |\n| -- | ------------------ | --------- | ------------ | ------------------------ |\n| x  | 填充字节               | 无         | VOID         |                          |\n| c  | char               | 长度为1的字节串  | CHAR         | -27 +1 \\~ 27 -1          |\n| b  | signed char        | integer   | LONG         | -27 \\~ 27 -1             |\n| B  | unsigned char      | integer   | LONG         | 0 \\~ 28 -1               |\n| ?  | \\_Bool             | bool      | LONG         | -263 \\~ 263 -1           |\n| h  | short              | integer   | LONG         | -215 \\~ 215 -1           |\n| H  | unsigned short     | integer   | LONG         | 0 \\~ 216 -1              |\n| i  | int                | integer   | LONG         | -231 \\~ 231 -1           |\n| I  | unsigned int       | integer   | LONG         | 0 \\~ 232 -1              |\n| l  | long               | integer   | LONG         | -231 \\~ 231 -1           |\n| L  | unsigned long      | integer   | LONG         | 0 \\~ 232 -1              |\n| q  | long long          | integer   | LONG         | -263 \\~ 263 -1           |\n| Q  | unsigned long long | integer   | LONG         | 0 \\~ 263 -1              |\n| n  | ssize\\_t           | integer   | LONG         | -263 \\~ 263 -1           |\n| N  | size\\_t            | integer   | LONG         | 0 \\~ 263 -1              |\n| f  | float              | float     | LONG         | -3.40E+38 \\~ +3.40E+38   |\n| d  | double             | float     | LONG         | -1.79E+308 \\~ +1.79E+308 |\n| s  | char\\[]            | bytes     | STRING       |                          |\n| p  | char\\[]            | bytes     | STRING       |                          |\n| P  | void\\*             | integer   | LONG         | -263 \\~ 263 -1           |\n\n##### 首字符字节顺序，大小和对齐方式\n\n| 字符 | 字节顺序    | 大小   | 对齐方式 |\n| -- | ------- | ---- | ---- |\n| >  | 大端      | 标准   | 无    |\n| =  | 按原字节    | 标准   | 无    |\n| <  | 小端      | 标准   | 无    |\n| @  | 按原字节    | 按原字节 | 按原字节 |\n| !  | 网络（=大端） | 标准   | 无    |\n\n默认情况下，C 类型以本机格式和字节顺序表示，在必要时通过跳过填充字节进行正确对齐（根据 C 编译器使用的规则）。\n\n格式字符串的第一个字符可用于指示打包数据的字节顺序，大小和对齐方式，见首字符字节顺序，大小和对齐方式部分内容。 如果第一个字符不是其中之一，则按 '@' 处理。\n"
    },
    "pair": {
        "url": "https://docs.dolphindb.cn/zh/funcs/p/pair.html",
        "signatures": [
            {
                "full": "pair(a, b)",
                "name": "pair",
                "parameters": [
                    {
                        "full": "a",
                        "name": "a"
                    },
                    {
                        "full": "b",
                        "name": "b"
                    }
                ]
            }
        ],
        "markdown": "### [pair](https://docs.dolphindb.cn/zh/funcs/p/pair.html)\n\n\n\n#### 语法\n\npair(a, b) 或 a:b\n\n#### 详情\n\n返回一个数据对。\n\n#### 参数\n\n**a** 和 **b** 必须是标量。\n\n#### 返回值\n\n数据对标量，类型同 *a*/*b*。\n\n#### 例子\n\n```\n1:3+1;\n// output: 2:4\n\n1:3<0:6;\n// output: 0 : 1\n```\n"
    },
    "panel": {
        "url": "https://docs.dolphindb.cn/zh/funcs/p/panel.html",
        "signatures": [
            {
                "full": "panel(row, col, metrics, [rowLabel], [colLabel], [parallel=false])",
                "name": "panel",
                "parameters": [
                    {
                        "full": "row",
                        "name": "row"
                    },
                    {
                        "full": "col",
                        "name": "col"
                    },
                    {
                        "full": "metrics",
                        "name": "metrics"
                    },
                    {
                        "full": "[rowLabel]",
                        "name": "rowLabel",
                        "optional": true
                    },
                    {
                        "full": "[colLabel]",
                        "name": "colLabel",
                        "optional": true
                    },
                    {
                        "full": "[parallel=false]",
                        "name": "parallel",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [panel](https://docs.dolphindb.cn/zh/funcs/p/panel.html)\n\n\n\n#### 语法\n\npanel(row, col, metrics, \\[rowLabel], \\[colLabel], \\[parallel=false])\n\n#### 详情\n\n将指标列按给定行与列维度进行透视操作，生成一个或多个矩阵。每一个矩阵对应一个指标列（metrics）。\n\n`panel` 函数同 [pivotBy](https://docs.dolphindb.cn/zh/progr/sql/pivotBy.html) 语句类似，将数据表中的数据按照两个维度重新排列。两者的不同之处在于，SQL 中，exec... pivot by... 只能指定一个指标列， 生成一个矩阵，而 `panel` 函数可以指定一个或多个指标列，生成一个或多个矩阵。\n\n#### 参数\n\n**row** 是一个向量，其中每个元素对应结果矩阵中的一行。\n\n**col** 是一个向量，其中每个元素对应结果矩阵中的一列。\n\n**metrics** 是一个或多个指标列。每个指标列产生一个矩阵。\n\n**rowLabel** 是一个向量，为结果矩阵的行标签。必须升序排列，而且没有重复值。结果中仅包括 *rowLabel* 中指定的行。\n\n**colLabel** 是一个向量，为结果矩阵的列标签。必须升序排列，而且没有重复值。结果中仅包括 *colLabel* 中指定的列。\n\n**parallel** 是一个布尔值，表示是否并行计算。默认值为 false。\n\n#### 返回值\n\n一个或多个矩阵。\n\n#### 例子\n\n```\nt = table(1 1 2 2 2 3 3 as id, 2020.09.01 + 1 3 1 2 3 2 3 as date, 1..7 as value);\nt;\n```\n\n| id | date       | value |\n| -- | ---------- | ----- |\n| 1  | 2020.09.02 | 1     |\n| 1  | 2020.09.04 | 2     |\n| 2  | 2020.09.02 | 3     |\n| 2  | 2020.09.03 | 4     |\n| 2  | 2020.09.04 | 5     |\n| 3  | 2020.09.03 | 6     |\n| 3  | 2020.09.04 | 7     |\n\n`panel` 面板数据生成的表中，指定的 *row* 和 *col* 会自动按升序排序。\n\n```\npanel(row=t.date, col=t.id, metrics=t.value);\n```\n\n|            | 1 | 2 | 3 |\n| ---------- | - | - | - |\n| 2020.09.02 | 1 | 3 |   |\n| 2020.09.03 |   | 4 | 6 |\n| 2020.09.04 | 2 | 5 | 7 |\n\n```\npanel(row=t.date, col=t.id, metrics=t.value, rowLabel=2020.09.02 2020.09.03, colLabel=1 2);\n```\n\n|            | 1 | 2 |\n| ---------- | - | - |\n| 2020.09.02 | 1 | 3 |\n| 2020.09.03 |   | 4 |\n\n```\npanel(row=t.date, col=t.id, metrics=[t.value, t.value>0], rowLabel=2020.09.02 2020.09.03, colLabel=1 2);\n```\n\n|            | 1 | 2 |\n| ---------- | - | - |\n| 2020.09.02 | 1 | 3 |\n| 2020.09.03 |   | 4 |\n\n|            | 1 | 2 |\n| ---------- | - | - |\n| 2020.09.02 | 1 | 1 |\n| 2020.09.03 |   | 1 |\n\n利用`panel` 生成的矩阵，计算每只股票的累积最大股价。\n\n```\nsyms = \"sym\"+string(1..2)\ndates = 2021.12.07..2021.12.11\nt = table(loop(take{, size(syms)}, dates).flatten() as trade_date,  take(syms, size(syms)*size(dates)) as code, rand(1000, (size(syms)*size(dates))) as volume)\nvolume = panel(row=t.trade_date, col=t.code, metrics=t.volume, rowLabel=dates)\ncummax(volume)\n```\n"
    },
    "parseExpr": {
        "url": "https://docs.dolphindb.cn/zh/funcs/p/parseExpr.html",
        "signatures": [
            {
                "full": "parseExpr(X, [varDict], [modules], [overloadedOperators])",
                "name": "parseExpr",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[varDict]",
                        "name": "varDict",
                        "optional": true
                    },
                    {
                        "full": "[modules]",
                        "name": "modules",
                        "optional": true
                    },
                    {
                        "full": "[overloadedOperators]",
                        "name": "overloadedOperators",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [parseExpr](https://docs.dolphindb.cn/zh/funcs/p/parseExpr.html)\n\n\n\n#### 语法\n\nparseExpr(X, \\[varDict], \\[modules], \\[overloadedOperators])\n\n#### 详情\n\n把字符串转换为元代码。使用 [eval](https://docs.dolphindb.cn/zh/funcs/e/eval.html) 函数可以执行 `parseExpr` 函数生成的元代码。\n\n#### 参数\n\n**X** 是一个字符串标量或向量。\n\n**varDict** 为可选参数，是一个字典。如果指定了该参数，使用 [eval](https://docs.dolphindb.cn/zh/funcs/e/eval.html) 函数解析时，表达式中的变量会被解析成字典的 key，其值即为字典中该 key 所对应的 value。\n\n**modules** 为可选参数，是字符串或字符串数组，表示需要加载的模块名称。\n\n**overloadedOperators** 为可选参数，是一个字典。将运算符号映射为一个函数。key 必须是一个字符串标量，value 必须是一个二元函数。\n\n#### 返回值\n\n当 *X* 是标量时，返回 CODE 类型标量；当 *X* 是向量时，返回由 CODE 组成的向量。\n\n#### 例子\n\n```\na=parseExpr(\"1+2\")\na;\n// output\n< 1 + 2 >\n\ntypestr(a);\n// output\nCODE\n\na.eval();\n// output\n3\n```\n\n将 JSON 字符串解析为字典\n\n```\njson1 = '{\"f2\":10.71,\"f12\":\"000001\"},{\"f2\":7.24,\"f12\":\"000002\"}'\nparseExpr(json1).eval()\n\n/*\noutput:\nf2->10.71\nf12->000001\n*/\n```\n\n```\nt=table(1 2 3 4 as id, 5 6 7 8 as value, `IBM`MSFT`IBM`GOOG as name);\nparseExpr(\"select * from t where name='IBM'\").eval();\n```\n\n| id | value | name |\n| -- | ----- | ---- |\n| 1  | 3     | IBM  |\n| 3  | 7     | IBM  |\n\n`parseExpr` 函数解析变量时，首先搜索会话中的局部变量，再搜索共享变量，但不会搜索函数体内定义的局部变量。\n\n如下例所示，用户自定义函数 myfunc 后欲取得数据表 t3 中 ID 列1到5对应的行：\n\n```\ndef myfunc(){\n  t3 = table(1..100 as id)\n  return parseExpr(\"select * from t3 where id in 1..5\").eval()\n}\n\nmyfunc()\n```\n\n产生如下错误信息：\n\n```\nmyfunc() => myfunc: return ::evaluate(parseExpr(\"select * from t3 where id in 1..5\")) => Can't find the object with name t3\n```\n\n解决此问题可以使用 [sql](https://docs.dolphindb.cn/zh/funcs/s/sql.html) 函数动态生成 SQL 语句，如下所示：\n\n```\ndef myfunc(){\nt3 = table(1..100 as id)\nreturn sql(sqlCol(\"*\"), t3, <id in 1..5>).eval()\n}\nmyfunc();\n```\n\n| id |\n| -- |\n| 1  |\n| 2  |\n| 3  |\n| 4  |\n| 5  |\n\n表达式中的变量和值通过字典形式传入，为 dict 的 key 赋值等价于为变量赋值。\n\n```\nd = dict(`a`b`c, (1, 2, 3))\nparseExpr(\"a + b*c\", d).eval()\n// output\n7\nd[`a] = 5;\nparseExpr(\"a + b*c\", d).eval()\n// output\n11\n```\n\n下例解释表达式中使用函数的处理方式，因 dict 中未存储变量 first，first 解析时直接当作函数来处理。\n\n```\nindex = [2000.01.01, 2000.01.31, 2000.02.15, 2000.02.20, 2000.03.12, 2000.04.16, 2000.05.06, 2000.08.30]\ns = indexedSeries(index, 1..8)\nd1 =  dict(STRING, ANY)\nd1[\"S\"] = s\nparseExpr(\"resample(S, `M, first)\", d1).eval()\n```\n\n在 modules 目录下的 test 模块内定义了一个 add 函数，调用模块中的函数，同时通过 overloadedOperators 参数，将二元运算符”+”映射为一个新的函数。代码执行时，运算符”+”将按照新函数进行计算。\n\n```\nparseExpr(\"test::add(1,2)+2\", modules=\"test\", overloadedOperators={\"+\": def(a, b){return a - b}}).eval()\n// output\n1\n```\n\n相关函数：[expr](https://docs.dolphindb.cn/zh/funcs/e/expr.html), [eval](https://docs.dolphindb.cn/zh/funcs/e/eval.html)\n"
    },
    "parseInstrument": {
        "url": "https://docs.dolphindb.cn/zh/funcs/p/parseInstrument.html",
        "signatures": [
            {
                "full": "parseInstrument(obj)",
                "name": "parseInstrument",
                "parameters": [
                    {
                        "full": "obj",
                        "name": "obj"
                    }
                ]
            }
        ],
        "markdown": "### [parseInstrument](https://docs.dolphindb.cn/zh/funcs/p/parseInstrument.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\nparseInstrument(obj)\n\n#### 详情\n\n将输入的金融工具产品描述（*obj*）转换成一个 INSTRUMENT 类型对象（金融工具），用于后续建模和定价。可解析的金融工具详见下文说明。\n\n**注意：**`parseInstrument` 会在序列化或反序列化过程中保留非标准标量或向量字段（即不属于金融工具预定义属性的字段）。\n\n#### 参数\n\n**obj** 可以是字典、由字典组成的元组、内存表、字符串标量或向量，表示要解析的金融工具描述。注意，如果 *obj* 指定为表，则该表只能存储单一类型的金融工具。\n\n#### 返回值\n\n一个 INSTRUMENT 类型对象，表示金融工具。\n\n#### 例子\n\n使用字典存储付息债的描述，通过 `parseInstrument` 解析该字典，以获得该付息债的 INSTRUMENT 类型对象。\n\n```\nbond = {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Bond\",\n    \"bondType\": \"FixedRateBond\",\n    \"instrumentId\": \"230205.IB\",\n    \"start\": \"2023.03.06\",\n    \"maturity\": \"2033.03.06\",\n    \"issuePrice\": 100.0,\n    \"coupon\": 0.0302,\n    \"calendar\": \"CFET\",\n    \"frequency\": \"Annual\",\n    \"dayCountConvention\": \"ActualActualISDA\",\n    \"subType\": \"CDB_BOND\",\n    \"issuer\": \"国家开发银行\"\n}\nparseInstrument(bond)\n```\n\n通过 `parseInstrument` 解析由字典组成的元组，得到3个债券的 INSTRUMENT 类型对象。\n\n```\nbond1 = {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Bond\",\n    \"bondType\": \"DiscountBond\",\n    \"instrumentId\": \"259924.IB\",\n    \"start\": 2025.04.17,\n    \"maturity\": 2025.07.17,\n    \"issuePrice\": 99.664,\n    \"dayCountConvention\": \"ActualActualISDA\",\n    \"subType\": \"TREASURY_BOND\",\n    \"issuer\": \"中华人民共和国财政部\"\n}\n\nbond2 = {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Bond\",\n    \"bondType\": \"ZeroCouponBond\",\n    \"instrumentId\": \"250401.IB\",\n    \"start\": 2025.01.09,\n    \"maturity\": 2026.02.05,\n    \"coupon\": 0.0119,\n    \"dayCountConvention\": \"ActualActualISDA\",\n    \"subType\": \"CDB_BOND\",\n    \"issuer\": \"国家农业发展银行\"\n}\n\nparseInstrument([bond,bond1,bond2])\n```\n\n使用内存表存储金融工具描述，其每一列代表一个字段。通过 `parseInstrument` 解析该表，得到 INSTRUMENT 类型对象。\n\n注意：如果某个产品缺少内存表中某列对应的字段，则在插入该产品的数据时，该字段将被设置为 NULL。\n\n```\ncreate table t (\n    productType STRING,\n    assetType STRING,\n    bondType STRING,\n    version INT,\n    instrumentId STRING,\n    start DATE,\n    maturity DATE,\n    issuePrice DOUBLE,\n    coupon DOUBLE,\n    calendar STRING,\n    frequency STRING,\n    dayCountConvention STRING,\n    subType STRING,\n    issuer STRING\n)\ngo\n\ninsert into t values( \"Cash\", \"Bond\", \"FixedRateBond\", 0, \"230205.IB\", 2023.03.06, 2033.03.06, 100.0, 0.0302, \"CFET\", \"Annual\", \"ActualActualISDA\", \"CDB_BOND\", \"国家开发银行\")\ninsert into t values( \"Cash\", \"Bond\", \"DiscountBond\", 0, \"259924.IB\", 2025.04.17, 2025.07.17, 99.664, NULL, NULL, NULL, \"ActualActualISDA\", \"TREASURY_BOND\", \"中华人民共和国财政部\")\ninsert into t values( \"Cash\", \"Bond\", \"ZeroCouponBond\", 0, \"250401.IB\", 2025.01.09, 2026.02.05, NULL, 0.0119, NULL, NULL, \"ActualActualISDA\", \"CDB_BOND\", \"国家农业发展银行\")\n\nparseInstrument(t)\n```\n\n使用字符串描述金融工具，通过 `parseInstrument` 解析该字符串，得到 INSTRUMENT 类型对象。\n\n```\nbond1Str = '{\"productType\": \"Cash\",\"assetType\": \"Bond\",\"bondType\": \"FixedRateBond\",\"coupon\": 0.0302,\"frequency\": \"Annual\",\"version\": 0,\"instrumentId\": \"230205.IB\",\"nominal\": 100,\"start\": \"2023.03.06\",\"maturity\": \"2033.03.06\",\"dayCountConvention\": \"ActualActualISDA\",\"calendar\": \"CFET\",\"currency\": \"CNY\",\"cashflow\": [{\"paymentDate\": \"2024.03.06\",\"coupon\": 3.026804551238871,\"notional\": 0,\"total\": 3.026804551238871},{\"paymentDate\": \"2025.03.06\",\"coupon\": 3.01319544876113,\"notional\": 0,\"total\": 3.01319544876113},{\"paymentDate\": \"2026.03.06\",\"coupon\": 3.02,\"notional\": 0,\"total\": 3.02},{\"paymentDate\": \"2027.03.06\",\"coupon\": 3.02,\"notional\": 0,\"total\": 3.02},{\"paymentDate\": \"2028.03.06\",\"coupon\": 3.026804551238871,\"notional\": 0,\"total\": 3.026804551238871},{\"paymentDate\": \"2029.03.06\",\"coupon\": 3.01319544876113,\"notional\": 0,\"total\": 3.01319544876113},{\"paymentDate\": \"2030.03.06\",\"coupon\": 3.02,\"notional\": 0,\"total\": 3.02},{\"paymentDate\": \"2031.03.06\",\"coupon\": 3.02,\"notional\": 0,\"total\": 3.02},{\"paymentDate\": \"2032.03.06\",\"coupon\": 3.026804551238871,\"notional\": 0,\"total\": 3.026804551238871},{\"paymentDate\": \"2033.03.06\",\"coupon\": 3.01319544876113,\"notional\": 100,\"total\": 103.013195448761123}],\"discountCurve\": \"\",\"spreadCurve\": \"\",\"subType\": \"CDB_BOND\",\"issuePrice\": 100,\"issuer\": \"国家开发银行\"}'\n\nparseInstrument(bondStr)\n```\n\n通过 `parseInstrument` 解析该字符串向量，得到多个 INSTRUMENT 类型对象。\n\n```\nbond2Str = '{\"productType\": \"Cash\",\"assetType\": \"Bond\",\"bondType\": \"DiscountBond\",\"issuePrice\": 99.664000000000001,\"version\": 0,\"instrumentId\": \"259924.IB\",\"nominal\": 100,\"start\": \"2025.04.17\",\"maturity\": \"2025.07.17\",\"dayCountConvention\": \"ActualActualISDA\",\"calendar\": \"\",\"currency\": \"CNY\",\"cashflow\": [{\"paymentDate\": \"2025.07.17\",\"coupon\": 0,\"notional\": 100,\"total\": 100}],\"discountCurve\": \"\",\"spreadCurve\": \"\",\"subType\": \"TREASURY_BOND\",\"issuer\": \"中华人民共和国财政部\"}'\nbond3Str = '{\"productType\": \"Cash\",\"assetType\": \"Bond\",\"bondType\": \"ZeroCouponBond\",\"coupon\": 0.0119,\"version\": 0,\"instrumentId\": \"250401.IB\",\"nominal\": 100,\"start\": \"2025.01.09\",\"maturity\": \"2026.02.05\",\"dayCountConvention\": \"ActualActualISDA\",\"calendar\": \"\",\"currency\": \"CNY\",\"cashflow\": [{\"paymentDate\": \"2026.01.09\",\"coupon\": 1.190000000000002,\"notional\": 0,\"total\": 1.190000000000002},{\"paymentDate\": \"2026.02.05\",\"coupon\": 0.088027397260282,\"notional\": 100,\"total\": 100.088027397260276}],\"discountCurve\": \"\",\"spreadCurve\": \"\",\"subType\": \"CDB_BOND\",\"issuer\": \"国家农业发展银行\"}'\n\nparseInstrument([bond1Str,bond2Str,bond3Str])\n```\n\n#### 金融工具支持与字段要求\n\nINSTRUMENT 为 DophinDB 在 3.00.4 版本上新增的数据类型，用于支持金融工具的存储，为后续各类金融产品的定价与风险计量提供基础。\n\n在金融工具的描述中，需要包含若干关键字段，`parseInstrument` 将根据这些字段生成相应的金融工具对象。请注意，\"version\" 为系统保留字段，为避免冲突，请勿将此名称用于自定义字段。\n\n目前支持的金融工具类型如下：\n\n##### 贴现债\n\n<table id=\"table_wrv_4qj_ngc\"><thead><tr><th>\n\n字段名\n\n</th><th>\n\n类型\n\n</th><th>\n\n描述\n\n</th><th>\n\n是否必填\n\n</th></tr></thead><tbody><tr><td>\n\nproductType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"Cash\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nassetType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"Bond\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nbondType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"DiscountBond\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nnominal\n\n</td><td>\n\nDOUBLE\n\n</td><td>\n\n名义金额，默认值 100\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ninstrumentId\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n债券代码，如 \"259926.IB\"\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\nstart\n\n</td><td>\n\nDATE\n\n</td><td>\n\n起息日\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nmaturity\n\n</td><td>\n\nDATE\n\n</td><td>\n\n到期日\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ndayCountConvention\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n日期计数惯例，可选 \"ActualActualISDA\", \"ActualActualISMA\", \"Actual365\", \"Actual360\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nissuePrice\n\n</td><td>\n\nDOUBLE\n\n</td><td>\n\n发行价格\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ncurrency\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n货币，默认为 \"CNY\"\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ncashFlow\n\n</td><td>\n\nTABLE\n\n</td><td>\n\n债券现金流表\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ndiscountCurve\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n定价时参考的贴现曲线名称，如 \"CNY\\_TRASURY\\_BOND\"\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\nspreadCurve\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n定价时参考的利差曲线名称\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\nsubType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n债券子类型，中国债券可选值为：\n\n* \"TREASURY\\_BOND\"：国债\n\n* \"CENTRAL\\_BANK\\_BILL\"：央行票据\n\n* \"CDB\\_BOND\"：政策性金融债（国开）\n\n* \"EIBC\\_BOND\"：政策性金融债（进出口行）\n\n* \"ADBC\\_BOND\"：政策性金融债（农发行）。\n\n* \"MTN\"：中期票据\n\n* \"CORP\\_BOND\"：企业债。\n\n* \"UNSECURED\\_CORP\\_BOND\"：无担保企业债\n\n* \"SHORT\\_FIN\\_BOND\"：短期融资券\n\n* \"NCD\"：同业存单\n\n* \"LOC\\_GOV\\_BOND\"：地方政府债\n\n* \"COMM\\_BANK\\_FIN\\_BOND\"：商业银行普通金融债\n\n* \"BANK\\_SUB\\_CAP\\_BOND\"：商业银行二级资本债\n\n* \"ABS\"：资产支持证券\n\n* \"PPN\"：非公开发行债\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ncreditRating\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n信用等级类型，可选值为：\"B\", \"BB\", \"BBB\", \"BBB+\", \"A-\", \"A\", \"A+\", \"AA-\", \"AA\", \"AA+\", \"AAA-\", \"AAA\", \"AAA+\"\n\n</td><td>\n\n否\n\n</td></tr></tbody>\n</table>下例定义了一个贴现债券的 INSTRUMENT 对象。\n\n```\nbond = {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Bond\",\n    \"bondType\": \"DiscountBond\",\n    \"instrumentId\": \"259924.IB\",\n    \"start\": 2025.04.17,\n    \"maturity\": 2025.07.17,\n    \"issuePrice\": 99.664,\n    \"dayCountConvention\": \"ActualActualISDA\"\n}\ninstrument = parseInstrument(bond)\nprint(instrument)\n```\n\n##### 零息债\n\n<table id=\"table_ac5_tqj_ngc\"><thead><tr><th>\n\n字段名\n\n</th><th>\n\n类型\n\n</th><th>\n\n描述\n\n</th><th>\n\n是否必填\n\n</th></tr></thead><tbody><tr><td>\n\nproductType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"Cash\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nassetType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"Bond\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nbondType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"ZeroCouponBond\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nnominal\n\n</td><td>\n\nDOUBLE\n\n</td><td>\n\n名义金额，默认值 100\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ninstrumentId\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n债券代码，如 \"250401.IB\"\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\nstart\n\n</td><td>\n\nDATE\n\n</td><td>\n\n起息日\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nmaturity\n\n</td><td>\n\nDATE\n\n</td><td>\n\n到期日\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ncoupon\n\n</td><td>\n\nDOUBLE\n\n</td><td>\n\n票面利率，如 0.03 表示 3%\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nfrequency\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n付息频率\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ndayCountConvention\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n日期计数惯例，可选 \"ActualActualISDA\", \"ActualActualISMA\", \"Actual365\", \"Actual360\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ncurrency\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n货币，默认为 \"CNY\"\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ncashFlow\n\n</td><td>\n\nTABLE\n\n</td><td>\n\n债券现金流表\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ndiscountCurve\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n定价时参考的贴现曲线名称，如 \"CNY\\_TRASURY\\_BOND\"\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\nspreadCurve\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n定价时参考的利差曲线名称\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\nsubType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n债券子类型，中国债券可选值为：\n\n* \"TREASURY\\_BOND\"：国债\n\n* \"CENTRAL\\_BANK\\_BILL\"：央行票据\n\n* \"CDB\\_BOND\"：政策性金融债（国开）\n\n* \"EIBC\\_BOND\"：政策性金融债（进出口行）\n\n* \"ADBC\\_BOND\"：政策性金融债（农发行）。\n\n* \"MTN\"：中期票据\n\n* \"CORP\\_BOND\"：企业债。\n\n* \"UNSECURED\\_CORP\\_BOND\"：无担保企业债\n\n* \"SHORT\\_FIN\\_BOND\"：短期融资券\n\n* \"NCD\"：同业存单\n\n* \"LOC\\_GOV\\_BOND\"：地方政府债\n\n* \"COMM\\_BANK\\_FIN\\_BOND\"：商业银行普通金融债\n\n* \"BANK\\_SUB\\_CAP\\_BOND\"：商业银行二级资本债\n\n* \"ABS\"：资产支持证券\n\n* \"PPN\"：非公开发行债\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ncreditRating\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n信用等级类型，可选值为：\"B\", \"BB\", \"BBB\", \"BBB+\", \"A-\", \"A\", \"A+\", \"AA-\", \"AA\", \"AA+\", \"AAA-\", \"AAA\", \"AAA+\"\n\n</td><td>\n\n否\n\n</td></tr></tbody>\n</table>下例定义了一个零息债的 INSTRUMENT 对象。\n\n```\nbond = {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Bond\",\n    \"bondType\": \"ZeroCouponBond\",\n    \"instrumentId\": \"250401.IB\",\n    \"start\": 2025.01.09,\n    \"maturity\": 2026.02.05,\n    \"coupon\": 0.0119,\n    \"dayCountConvention\": \"ActualActualISDA\"\n}\ninstrument = parseInstrument(bond)\nprint(instrument)\n```\n\n##### 固定利率债\n\n<table id=\"table_yj1_yqj_ngc\"><thead><tr><th>\n\n字段名\n\n</th><th>\n\n类型\n\n</th><th>\n\n描述\n\n</th><th>\n\n是否必填\n\n</th></tr></thead><tbody><tr><td>\n\nproductType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"Cash\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nassetType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"Bond\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nbondType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"FixedRateBond\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nnominal\n\n</td><td>\n\nDOUBLE\n\n</td><td>\n\n名义金额，默认值 100\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ninstrumentId\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n债券代码，如 \"250401.IB\"\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\nstart\n\n</td><td>\n\nDATE\n\n</td><td>\n\n起息日\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nmaturity\n\n</td><td>\n\nDATE\n\n</td><td>\n\n到期日\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ncoupon\n\n</td><td>\n\nDOUBLE\n\n</td><td>\n\n票面利率，如0.03表示3%\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nfrequency\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n付息频率\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ndayCountConvention\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n日期计数惯例，可选 \"ActualActualISDA\", \"ActualActualISMA\", \"Actual365\", \"Actual360\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ncurrency\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n货币，默认为 \"CNY\"\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ncashFlow\n\n</td><td>\n\nTABLE\n\n</td><td>\n\n债券现金流表\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ndiscountCurve\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n定价时参考的贴现曲线名称，如 \"CNY\\_TRASURY\\_BOND\"\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\nspreadCurve\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n定价时参考的利差曲线名称\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\nsubType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n债券子类型，中国债券可选值为：\n\n* \"TREASURY\\_BOND\"：国债\n\n* \"CENTRAL\\_BANK\\_BILL\"：央行票据\n\n* \"CDB\\_BOND\"：政策性金融债（国开）\n\n* \"EIBC\\_BOND\"：政策性金融债（进出口行）\n\n* \"ADBC\\_BOND\"：政策性金融债（农发行）。\n\n* \"MTN\"：中期票据\n\n* \"CORP\\_BOND\"：企业债。\n\n* \"UNSECURED\\_CORP\\_BOND\"：无担保企业债\n\n* \"SHORT\\_FIN\\_BOND\"：短期融资券\n\n* \"NCD\"：同业存单\n\n* \"LOC\\_GOV\\_BOND\"：地方政府债\n\n* \"COMM\\_BANK\\_FIN\\_BOND\"：商业银行普通金融债\n\n* \"BANK\\_SUB\\_CAP\\_BOND\"：商业银行二级资本债\n\n* \"ABS\"：资产支持证券\n\n* \"PPN\"：非公开发行债\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ncreditRating\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n信用等级类型，可选值为：\"B\", \"BB\", \"BBB\", \"BBB+\", \"A-\", \"A\", \"A+\", \"AA-\", \"AA\", \"AA+\", \"AAA-\", \"AAA\", \"AAA+\"\n\n</td><td>\n\n否\n\n</td></tr></tbody>\n</table>下例定义了一个固定利率债的 INSTRUMENT 对象。\n\n```\nbond = {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Bond\",\n    \"bondType\": \"FixedRateBond\",\n    \"instrumentId\": \"240021.IB\",\n    \"start\": 2024.10.25,\n    \"maturity\": 2025.10.25,\n    \"issuePrice\": 100,\n    \"coupon\": 0.0133,\n    \"frequency\": \"Annual\",\n    \"dayCountConvention\": \"ActualActualISDA\"\n}\ninstrument = parseInstrument(bond)\nprint(instrument)\n```\n\n##### 含权债\n\n<table id=\"table_lsx_y2w_r3c\"><thead><tr><th>\n\n字段名\n\n</th><th>\n\n类型\n\n</th><th>\n\n描述\n\n</th><th>\n\n是否必填\n\n</th></tr></thead><tbody><tr><td>\n\nproductType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"Cash\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nassetType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"Bond\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nbondType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"OptionBond\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nnominal\n\n</td><td>\n\nDOUBLE\n\n</td><td>\n\n名义金额，默认值100\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ninstrumentId\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n债券代码，如 \"242659.SH\"\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\nstart\n\n</td><td>\n\nDATE\n\n</td><td>\n\n起息日\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nmaturity\n\n</td><td>\n\nDATE\n\n</td><td>\n\n到期日\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ncoupon\n\n</td><td>\n\nDOUBLE\n\n</td><td>\n\n票面利率，如0.03表示3%\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nfrequency\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n付息频率\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nprincipalRatio\n\n</td><td>\n\nDOUBLE 类型向量\n\n</td><td>\n\n提前偿还型债券的本金摊还比例向量。\n\n向量长度等于债券期限，各元素表示对应期间偿还的本金占初始本金的比例，且所有元素之和为1。默认为空。\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\nexerciseDates\n\n</td><td>\n\nDATE 类型向量\n\n</td><td>\n\n含权债为行权时间的向量。默认为空。\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\nhasCallOption\n\n</td><td>\n\nBOOL\n\n</td><td>\n\n该债券发行人是否有赎回权\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nhasPutOption\n\n</td><td>\n\nBOOL\n\n</td><td>\n\n该债券投资者是否有回售权\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nhasCouponAdjust\n\n</td><td>\n\nBOOL\n\n</td><td>\n\n该债券发行人是否有票面利率调整权\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nnewCoupon\n\n</td><td>\n\nDOUBLE\n\n</td><td>\n\n票面利率调整后的新利率。当 `hasCouponAdjust = true` 且已到调整时点时生效。若 newCoupon 为空（默认值），则仍使用原票面利率。\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ndayCountConvention\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n日期计数惯例，可选 \"ActualActualISDA\", \"ActualActualISMA\", \"Actual365\", \"Actual360\"，国债默认为 \"Actual365\"，其他默认为 \"ActualActualISMA\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nsubType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n债券子类型，中国债券可选值为：\n\n* \"TREASURY\\_BOND\"：国债\n* \"CENTRAL\\_BANK\\_BILL\"：央行票据\n* \"CDB\\_BOND\"：政策性金融债（国开）\n* \"EIBC\\_BOND\"：政策性金融债（进出口行）\n* \"ADBC\\_BOND\"：政策性金融债（农发行）。\n* \"MTN\"：中期票据\n* \"CORP\\_BOND\"：企业债。\n* \"UNSECURED\\_CORP\\_BOND\"：无担保企业债\n* \"SHORT\\_FIN\\_BOND\"：短期融资券\n* \"NCD\"：同业存单\n* \"LOC\\_GOV\\_BOND\"：地方政府债\n* \"COMM\\_BANK\\_FIN\\_BOND\"：商业银行普通金融债\n* \"BANK\\_SUB\\_CAP\\_BOND\"：商业银行二级资本债\n* \"ABS\"：资产支持证券\n* \"PPN\"：非公开发行债\n\n默认值为空。\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ncreditRating\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n信用等级类型，可选值为：\"B\", \"BB\", \"BBB\", \"BBB+\", \"A-\", \"A\", \"A+\", \"AA-\", \"AA\", \"AA+\", \"AAA-\", \"AAA\", \"AAA+\"。默认值为空。\n\n</td><td>\n\n否\n\n</td></tr></tbody>\n</table>下例定义了一个含权债的 INSTRUMENT 对象。\n\n```\noptionBond = {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Bond\",\n    \"bondType\": \"OptionBond\",\n    \"instrumentId\": \"242659.SH\",\n    \"nominal\": 100.0,\n    \"start\": 2025.03.26,\n    \"maturity\": 2030.03.26,\n    \"coupon\": 0.0207,\n    \"frequency\": \"Annual\",\n    \"exerciseDates\": [2028.03.26],\n    \"hasCallOption\": true,\n    \"hasPutOption\": true,\n    \"hasCouponAdjust\": true,\n    \"dayCountConvention\": \"ActualActualISMA\"\n}\ninstrument = parseInstrument(optionBond)\nprint(instrument)\n```\n\n##### 国债期货\n\n| 字段名               | 类型     | 描述                 | 是否必填 |\n| ----------------- | ------ | ------------------ | ---- |\n| productType       | STRING | 固定值为 \"Futures\"     | 是    |\n| futuresType       | STRING | 固定值为 \"BondFutures\" | 是    |\n| nominal           | DOUBLE | 名义金额，默认值 100       | 是    |\n| instrumentId      | STRING | 国债期货代码，如 \"T2509\"   | 否    |\n| maturity          | DATE   | 到期日                | 是    |\n| settlement        | DATE   | 结算日                | 是    |\n| underlying        | 字典     | 固定利率债券结构，表示标的可交割债券 | 是    |\n| nominalCouponRate | DOUBLE | 名义票面利率             | 是    |\n\n下例定义了一个国债期货的 INSTRUMENT 对象。\n\n```\nbond ={\n    \"productType\": \"Cash\",\n    \"assetType\": \"Bond\",\n    \"bondType\": \"FixedRateBond\",\n    \"instrumentId\": \"220010.IB\",\n    \"start\": 2020.12.25,\n    \"maturity\": 2031.12.25,\n    \"issuePrice\": 100.0,\n    \"coupon\": 0.0149,\n    \"frequency\": \"Annual\",\n    \"dayCountConvention\": \"ActualActualISDA\"\n}\n\nfutures =  {\n    \"productType\": \"Futures\",\n    \"futuresType\": \"BondFutures\",\n    \"instrumentId\": \"T2509\",  //期货代码\n    \"nominal\": 100.0,\n    \"maturity\": \"2022.09.09\",\n    \"settlement\": \"2022.09.11\",\n    \"underlying\": bond,\n    \"nominalCouponRate\": 0.03  //与国债期货品种匹配的名义利率，可从中金所获取\n}\ninstrument = parseInstrument(futures)\nprint(instrument)\n\n```\n\n##### 存款\n\n| 字段名                | 类型     | 描述                                                                          | 是否必填 |\n| ------------------ | ------ | --------------------------------------------------------------------------- | ---- |\n| productType        | STRING | 固定填 \"Cash\"                                                                  | 是    |\n| assetType          | STRING | 固定填 \"Deposit\"                                                               | 是    |\n| notional           | ANY 向量 | 名义本金，格式如 \\[\"USD\", 1.0]。                                                     | 是    |\n| instrumentId       | STRING | 存款参考利率指数，如 \"SHIBOR\\_3M\"                                                     | 否    |\n| start              | DATE   | 起息日                                                                         | 是    |\n| maturity           | DATE   | 到期日                                                                         | 是    |\n| rate               | DOUBLE | 存款利率                                                                        | 是    |\n| dayCountConvention | STRING | 日期计数惯例, 可选 \"ActualActualISDA\", \"ActualActualISMA\", \"Actual365\", \"Actual360\" | 是    |\n| payReceive         | STRING | 收付标识，\"Pay\" 表示支付，\"Receive\" 表示收取                                              | 是    |\n| disconutCurve      | STRING | 定价时参考的贴现曲线名称，人民币存款默认为 \"CNY\\_FR\\_007\"                                        | 否    |\n| calendar           | STRING | 交易日历                                                                        | 否    |\n\n下例定义了一个存款的 INSTRUMENT 对象。\n\n```\ndeposit =  {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Deposit\",\n    \"start\": 2025.05.15,\n    \"maturity\": 2025.08.15,\n    \"rate\": 0.02,\n    \"dayCountConvention\": \"Actual360\",\n    \"notional\":[\"CNY\", 1E6],\n    \"payReceive\": \"Receive\"\n}\ninstrument = parseInstrument(deposit)\nprint(instrument)\n```\n\n##### 利率互换\n\n<table id=\"table_o1q_jrj_ngc\"><thead><tr><th>\n\n字段名\n\n</th><th>\n\n类型\n\n</th><th>\n\n描述\n\n</th><th>\n\n是否必填\n\n</th></tr></thead><tbody><tr><td>\n\nproductType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"Swap\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nswapType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"IrSwap\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nirSwapType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"IrFixedFloatingSwap\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nnotionalAmount\n\n</td><td>\n\nDOUBLE\n\n</td><td>\n\n名义本金额\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nnotionalCurrency\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n名义本金货币\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ninstrumentId\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n利率互换名称，可填 \"CNY\\_FR\\_007 , \"CNY\\_SHIBOR\\_3M\"\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\nstart\n\n</td><td>\n\nDATE\n\n</td><td>\n\n起息日\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nmaturity\n\n</td><td>\n\nDATE\n\n</td><td>\n\n到期日\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nfixedRate\n\n</td><td>\n\nDOUBLE\n\n</td><td>\n\n固定端利率\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ncalendar\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n交易日历\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nfixedDayCountConvention\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定端日期计数惯例，可选 \"ActualActualISDA\", \"ActualActualISMA\", \"Actual365\", \"Actual360\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nfloatingDayCountConvention\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n浮动端日期计数惯例，可选 \"ActualActualISDA\", \"ActualActualISMA\", \"Actual365\", \"Actual360\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nspread\n\n</td><td>\n\nDOUBLE\n\n</td><td>\n\n利差\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\niborIndex\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n浮动端参考利率，可选FR\\_007和SHIBOR\\_3M\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nfrequency\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n付息频率\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\npayReceive\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n收付标识，可选：\n\n* \"Pay\"：本方支付固定利率、接收浮动利率（pay fixed / receive floating）\n\n* \"Receive\"：本方接收固定利率、支付浮动利率（receive fixed / pay floating）\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ndiscountCurve\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n用于现金流折现的曲线名称\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\nforwardCurve\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n用于预测浮动利率的曲线名称\n\n</td><td>\n\n否\n\n</td></tr></tbody>\n</table>下例定义了一个利率互换的 INSTRUMENT 对象。\n\n```\nswap =  {\n    \"productType\": \"Swap\",\n    \"swapType\": \"IrSwap\",\n    \"irSwapType\": \"IrFixedFloatingSwap\",\n    \"start\": 2021.05.15,\n    \"maturity\": 2023.05.15,\n    \"frequency\": \"Quarterly\",\n    \"fixedRate\": 0.02,\n    \"calendar\": \"CFET\", \n    \"fixedDayCountConvention\": \"Actual365\",\n    \"floatingDayCountConvention\": \"Actual360\",\n    \"payReceive\": \"Pay\",\n    \"iborIndex\": \"SHIBOR_3M\",\n    \"spread\": 0.0005,\n    \"notionalCurrency\": \"CNY\",\n    \"notionalAmount\": 1E8\n}\ninstrument = parseInstrument(swap)\nprint(instrument)\n```\n\n##### 外汇远期\n\n<table id=\"table_zkf_4rj_ngc\"><thead><tr><th>\n\n字段名\n\n</th><th>\n\n类型\n\n</th><th>\n\n描述\n\n</th><th>\n\n是否必填\n\n</th></tr></thead><tbody><tr><td>\n\nproductType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n产品名称，固定值为 \"Forward\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nforwardType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n远期类型，固定值为 \"FxForward\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nnotional\n\n</td><td>\n\nANY 向量\n\n</td><td>\n\n名义本金，格式如 \\[\"USD\", 1.0]\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ninstrumentId\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n金融工具 ID\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\nexpiry\n\n</td><td>\n\nDATE\n\n</td><td>\n\n到期日\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ndelivery\n\n</td><td>\n\nDATE\n\n</td><td>\n\n交割日\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ncurrencyPair\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n货币对，格式如：\"EURUSD\"，\"EUR.USD\" 或 \"EUR/USD\"。支持如下货币对：\n\n* EURUSD：欧元兑美元\n\n* USDCNY：美元兑人民币\n\n* EURCNY：欧元兑人民币\n\n* GBPCNY：英镑兑人民币\n\n* JPYCNY：日元兑人民币\n\n* HKDCNY：港币兑人民币\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ndirection\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n交易方向。可选：\"Buy\"、\"Sell\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nstrike\n\n</td><td>\n\nDOUBLE\n\n</td><td>\n\n执行价格\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ndomesticCurve\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n定价时参考的本币贴现曲线名称\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\nforeignCurve\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n定价时参考的外币贴现曲线名称\n\n</td><td>\n\n否\n\n</td></tr></tbody>\n</table>下例定义了一个外汇远期的 INSTRUMENT 对象。\n\n```\nforward =  {\n   \"productType\": \"Forward\",\n    \"forwardType\": \"FxForward\",\n    \"expiry\": 2025.09.24,\n    \"delivery\": 2025.09.26,\n    \"currencyPair\": \"USDCNY\",\n    \"direction\": \"Buy\",\n    \"notional\": [\"USD\", 1E8],\n    \"strike\": 7.2\n}\ninstrument = parseInstrument(forward)\nprint(instrument)\n```\n\n##### 外汇掉期\n\n<table id=\"table_wnz_trj_ngc\"><thead><tr><th>\n\n字段名\n\n</th><th>\n\n类型\n\n</th><th>\n\n描述\n\n</th><th>\n\n是否必填\n\n</th></tr></thead><tbody><tr><td>\n\nproductType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n产品名称，固定值为 \"Swap\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nswapType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n远期类型，固定值为 \"FxSwap\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nnotional\n\n</td><td>\n\nANY 向量\n\n</td><td>\n\n名义本金，格式如 \\[\"USD\", 1.0]\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ncurrencyPair\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n货币对，格式如：\"EURUSD\"，\"EUR.USD\" 或 \"EUR/USD\"。支持如下货币对：\n\n* EURUSD：欧元兑美元\n\n* USDCNY：美元兑人民币\n\n* EURCNY：欧元兑人民币\n\n* GBPCNY：英镑兑人民币\n\n* JPYCNY：日元兑人民币\n\n* HKDCNY：港币兑人民币\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nnearExpiry\n\n</td><td>\n\nDATE\n\n</td><td>\n\n近端到期日。\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nnearDelivery\n\n</td><td>\n\nDATE\n\n</td><td>\n\n近端交割日，实际资金交割发生的日期。\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ndirection\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n交易方向，可选值：\n\n* \"Buy\"：在近端买入外币（买 near），在远端卖出外币（卖 far）。\n\n* \"Sell\"：在近端卖出外币（卖 near），在远端买回外币（买 far）。\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nnearStrike\n\n</td><td>\n\nDOUBLE\n\n</td><td>\n\n近端行权价格\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nfarExpiry\n\n</td><td>\n\nDATE\n\n</td><td>\n\n远端到期日\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nfarDelivery\n\n</td><td>\n\nDATE\n\n</td><td>\n\n远端交割日，实际发生第二次资金交换的日期\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nfarStrike\n\n</td><td>\n\nDOUBLE\n\n</td><td>\n\n远端行权价格\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ndomesticCurve\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n定价时参考的本币贴现曲线名称\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\nforeignCurve\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n定价时参考的外币贴现曲线名称\n\n</td><td>\n\n否\n\n</td></tr></tbody>\n</table>下例定义了一个外汇掉期的 INSTRUMENT 对象。\n\n```\nswap = {\n    \"productType\": \"Swap\",\n    \"swapType\": \"FxSwap\",\n    \"currencyPair\": \"EURUSD\",\n    \"direction\": \"Buy\",\n    \"notional\": [\"EUR\", 1E6],\n    \"nearStrike\": 1.1,\n    \"nearExpiry\": 2025.12.08,\n    \"nearDelivery\": 2025.12.10,\n    \"farStrike\": 1.2,\n    \"farExpiry\": 2026.06.08,\n    \"farDelivery\": 2026.06.10\n}\ninstrument = parseInstrument(swap)\nprint(instrument)\n```\n\n##### 外汇欧式期权\n\n<table id=\"table_rxr_ckm_2hc\"><thead><tr><th>\n\n字段名\n\n</th><th>\n\n类型\n\n</th><th>\n\n描述\n\n</th><th>\n\n是否必填\n\n</th></tr></thead><tbody><tr><td>\n\nproductType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"Option\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\noptionType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"EuropeanOption\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nassetType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"FxEuropeanOption\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nnotional\n\n</td><td>\n\nANY 向量\n\n</td><td>\n\n名义本金，格式如 \\[\"USD\", 1.0]\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ninstrumentId\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n金融工具 ID\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\nmaturity\n\n</td><td>\n\nDATE\n\n</td><td>\n\n到期日\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nunderlying\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n货币对，格式如：\"EURUSD\"，\"EUR.USD\" 或 \"EUR/USD\"。支持如下货币对：\n\n* EURUSD：欧元兑美元\n\n* USDCNY：美元兑人民币\n\n* EURCNY：欧元兑人民币\n\n* GBPCNY：英镑兑人民币\n\n* JPYCNY：日元兑人民币\n\n* HKDCNY：港币兑人民币\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ndirection\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n交易方向。可选值为：\"Buy\"、\"Sell\"。\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nstrike\n\n</td><td>\n\nDOUBLE\n\n</td><td>\n\n执行价格。\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ndayCountConvention\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n日期计数惯例，可选 \"ActualActualISDA\", \"ActualActualISMA\", \"Actual365\", \"Actual360\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\npayoffType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n收益类型，可选值为 \"Call\"、 \"Put\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ndomesticCurve\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n定价时参考的本币贴现曲线名称\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\nforeignCurve\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n定价时参考的外币贴现曲线名称\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ndelivery\n\n</td><td>\n\nDATE\n\n</td><td>\n\n交割日\n\n</td><td>\n\n否\n\n</td></tr></tbody>\n</table>**注意**：delivery 字段从 version 2 版本开始支持。升级低于 version 2 的旧版本数据到 version 2 或更高版本时，原有记录中缺失的 delivery 字段将自动填充为 maturity + 2。\n\n下例定义了一个 外汇欧式期权的 INSTRUMENT 对象。\n\n```\noption =  {\n    \"productType\": \"Option\",\n    \"optionType\": \"EuropeanOption\",\n    \"assetType\": \"FxEuropeanOption\",\n    \"notional\": [\"EUR\", 1000000.0],\n    \"strike\": 1.2,\n    \"maturity\": \"2025.10.08\",\n    \"payoffType\": \"Call\",\n    \"dayCountConvention\": \"Actual365\",\n    \"underlying\": \"EURUSD\"\n}\ninstrument = parseInstrument(option)\nprint(instrument)\n```\n\n##### 商品期货美式期权\n\n| 字段名                | 类型      | 描述                                                                          | 是否必填 |\n| ------------------ | ------- | --------------------------------------------------------------------------- | ---- |\n| productType        | STRING  | 固定填 \"Option\"                                                                | 是    |\n| optionType         | STRING  | 固定填 \"AmericanOption\"                                                        | 是    |\n| assetType          | STRING  | 固定填 \"CmFutAmericanOption\"                                                   | 是    |\n| notionalAmount     | DOUBLE  | 名义本金额                                                                       | 是    |\n| notionalCurrency   | STRING  | 名义本金货币                                                                      | 是    |\n| instrumentId       | STRING  | 合约代码，标准格式为：标的期货合约代码+合约到期月份+期权类型代码+行权价格，如白糖期权为 SR2509P6300 = SR+2509+P+6300  | 否    |\n| direction          | SRTRING | 买卖方向，可选值为 Buy，Sell。默认值为 Buy。                                                | 否    |\n| maturity           | DATE    | 到期日                                                                         | 是    |\n| strike             | DOUBLE  | 执行利率                                                                        | 是    |\n| payoffType         | STRING  | 收益类型，可选 Call 和 Put                                                          | 是    |\n| underlying         | STRING  | 标的期货合约代码，如 SR2509                                                           | 是    |\n| dayCountConvention | STRING  | 日期计数惯例, 可选 \"ActualActualISDA\", \"ActualActualISMA\", \"Actual365\", \"Actual360\" | 是    |\n| discountCurve      | STRING  | 定价时参考的贴现曲线名称，人民币存款默认为 \"CNY\\_FR\\_007\"                                        | 否    |\n\n##### 商品期货欧式期权\n\n<table id=\"table_y54_djd_s3c\"><thead><tr><th>\n\n字段名\n\n</th><th>\n\n类型\n\n</th><th>\n\n描述\n\n</th><th>\n\n是否必填\n\n</th></tr></thead><tbody><tr><td>\n\nproductType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"Option\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\noptionType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"EuropeanOption\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nassetType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"CmFutEuropeanOption\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nnotionalAmount\n\n</td><td>\n\nDOUBLE\n\n</td><td>\n\n名义本金额\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nnotionalCurrency\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n名义本金货币\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ninstrumentId\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n合约代码，标准格式为：标的期货合约代码+合约到期月份+期权类型代码+行权价格，如白糖期权\n\nSR2509P6300 = SR+2509+P+6300\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ndirection\n\n</td><td>\n\nSRTRING\n\n</td><td>\n\n买卖方向 Buy Sell，默认为 Buy\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\nmaturity\n\n</td><td>\n\nDATE\n\n</td><td>\n\n到期日\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nstrike\n\n</td><td>\n\nDOUBLE\n\n</td><td>\n\n执行利率\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\npayoffType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n枚举，可选 Call 和 Put\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nunderlying\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n标的期货合约代码，如 SR2509\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ndayCountConvention\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n日期计数惯例，可选 \"ActualActualISDA\"、\"ActualActualISMA\"、\"Actual365\"、\"Actual360\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ndiscountCurve\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n定价时参考的贴现曲线名称，人民币存款默认为 \"CNY\\_FR\\_007\"\n\n</td><td>\n\n否\n\n</td></tr></tbody>\n</table>### 权益类美式期权\n\n<table id=\"table_tsy_vxd_l3c\"><thead><tr><th>\n\n**字段名**\n\n</th><th>\n\n**类型**\n\n</th><th>\n\n**描述**\n\n</th><th>\n\n**是否必填**\n\n</th></tr></thead><tbody><tr><td>\n\nproductType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"Option\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\noptionType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"AmericanOption\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nassetType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"EqAmericanOption\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nnotionalAmount\n\n</td><td>\n\nDOUBLE\n\n</td><td>\n\n名义本金额\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nnotionalCurrency\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n名义本金货币，默认为 CNY\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ninstrumentId\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n合约代码，如代码 `TCH250328C0040000`的解读如下：\n\n* `TCH`: 标的为腾讯控股\n\n* `250328`: 到期日为2025年3月28日。\n\n* `C`: 期权类型为认购（Call）\n\n* `0040000`: 行权价为400.00港元。\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ndirection\n\n</td><td>\n\nSRTRING\n\n</td><td>\n\n买卖方向 Buy Sell，默认为 Buy\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\nmaturity\n\n</td><td>\n\nDATE\n\n</td><td>\n\n到期日\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nstrike\n\n</td><td>\n\nDOUBLE\n\n</td><td>\n\n执行利率\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\npayoffType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n枚举，可选Call和Put\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nunderlying\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n标的期货合约代码，如 `TCH`\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ndayCountConvention\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n日期计数惯例, 可选 \"ActualActualISDA\", \"ActualActualISMA\", \"Actual365\", \"Actual360\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ndiscountCurve\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n定价时参考的贴现曲线名称，人民币存款默认为 \"CNY\\_FR\\_007\"\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ndividendCurve\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n定价时参考的股息曲线名称\n\n</td><td>\n\n否\n\n</td></tr></tbody>\n</table>### 权益类欧式期权\n\n<table id=\"table_w1c_vjd_s3c\"><thead><tr><th>\n\n字段名\n\n</th><th>\n\n类型\n\n</th><th>\n\n描述\n\n</th><th>\n\n是否必填\n\n</th></tr></thead><tbody><tr><td>\n\nproductType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"Option\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\noptionType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"EuropeanOption\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nassetType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 “EqEuropeanOption\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nnotionalAmount\n\n</td><td>\n\nDOUBLE\n\n</td><td>\n\n名义本金额\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nnotionalCurrency\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n名义本金货币，默认为 CNY\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ninstrumentId\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n合约代码，如中证 500ETF 期权\n\n510500C2512M04800\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ndirection\n\n</td><td>\n\nSRTRING\n\n</td><td>\n\n买卖方向 Buy Sell，默认为 Buy\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\nmaturity\n\n</td><td>\n\nDATE\n\n</td><td>\n\n到期日\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nstrike\n\n</td><td>\n\nDOUBLE\n\n</td><td>\n\n执行利率\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\npayoffType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n枚举，可选 Call 和 Put\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nunderlying\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n标的期货合约代码，如 510050\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ndayCountConvention\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n日期计数惯例，可选 \"ActualActualISDA\"、\"ActualActualISMA\"、\"Actual365\"、\"Actual360\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ndiscountCurve\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n定价时参考的贴现曲线名称，人民币存款默认为 \"CNY\\_FR\\_007\"\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ndividendCurve\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n定价时参考的股息曲线名称\n\n</td><td>\n\n否\n\n</td></tr></tbody>\n</table>### 用户自定义\n\n支持用户自定义金融工具，除 producType 外，所有字段均可自定义。\n\n| 字段名         | 类型     | 描述                | 是否必填 |\n| ----------- | ------ | ----------------- | ---- |\n| productType | STRING | 固定填 \"UserDefined\" | 是    |\n\n**相关函数：**[bondPricer](https://docs.dolphindb.cn/zh/funcs/b/bondPricer.html)（债券定价）、[irDepositPricer](https://docs.dolphindb.cn/zh/funcs/i/irDepositPricer.html)（存款定价）、[bondFuturesPricer](https://docs.dolphindb.cn/zh/funcs/b/bondFuturesPricer.html)（国债期货定价）、[fxForwardPricer](https://docs.dolphindb.cn/zh/funcs/f/fxForwardPricer.html)（外汇远期定价）、[fxSwapPricer](https://docs.dolphindb.cn/zh/funcs/f/fxSwapPricer.html)（外汇掉期定价）、[irFixedFloatingSwapPricer](https://docs.dolphindb.cn/zh/funcs/i/irFixedFloatingSwapPricer.html)（利率互换定价）、[fxEuropeanOptionPricer](https://docs.dolphindb.cn/zh/funcs/f/fxEuropeanOptionPricer.html)（外汇欧式期权定价）\n"
    },
    "parseInt": {
        "url": "https://docs.dolphindb.cn/zh/funcs/p/parseInt.html",
        "signatures": [
            {
                "full": "parseInteger(X, type, [radix=10])",
                "name": "parseInteger",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "type",
                        "name": "type"
                    },
                    {
                        "full": "[radix=10]",
                        "name": "radix",
                        "optional": true,
                        "default": "10"
                    }
                ]
            }
        ],
        "markdown": "### [parseInt](https://docs.dolphindb.cn/zh/funcs/p/parseInt.html)\n\n是 [parseInteger](https://docs.dolphindb.cn/zh/funcs/p/parseInteger.html) 的别名。\n\n\n以下是 `parseInteger` 函数的文档：\n### [parseInteger](https://docs.dolphindb.cn/zh/funcs/p/parseInteger.html)\n\n\n\n#### 语法\n\nparseInteger(X, type, \\[radix=10])\n\n别名：parseInt\n\n#### 详情\n\n按照不同进制把字符串转换为指定的整数类型。该函数从 *X* 的第一个字符开始转换，直到遇到第一个非法字符，即返回此前的转换结果。当 X 为集合时，将输出相同类型的集合。\n\n注意：\n\n* 转换时会忽略前导空格和前导 0。\n\n* 不支持转换小数，'.'字符属于非法字符。\n\n* 如果（忽略前导空格后）字符串为空，则返回 NULL。\n\n* 如果在遇到非法字符前没有遇到过合法字符，函数将抛出异常。\n\n* 前导空格后的第一个字符可以为'+'/'-'以表示正/负语义，其余位置上的'+'/'-'为非法字符。\n\n#### 参数\n\n**X** 表示待转换的字符串，支持标量、矩阵、向量和数据对。\n\n**type** 表示转换后的类型，支持 CHAR/SHORT/INT/LONG。\n\n**radix** 表示基数，可选参数，有效范围为\\[2, 16]，默认为 10。如 *radix* 为2，那么 *X* 的“合法字符”就指{“0”, “1”}；*radix* 为11，那么”合法字符”就指\\[0, 9]和 A/a（不区分大小写）。特别的，如果 *radix* 为16，那么前导的”0x”或”0X”不会被认为非法字符。\n\n#### 返回值\n\n整型标量、矩阵、向量或数据对。\n\n#### 例子\n\n以下给出几个简单示例。\n\n```\nparseInteger([\" \", \"000\", \"012\", \" 12\",\"12a\", \"1a2\",\"+12a\", \"-12\"], INT)\n//output: [ , 0, 12, 12, 12, 1, 12, -12]\n\nparseInteger(\"a12\", INT)\n//Error: 'Invalid string to parse.'\n\nparseInteger([\"012\", \" 12\",\"12a\", \"1a2\",\"1A2\", \"-1A2\"], INT, 11)\n//output: [13, 13, 153, 233, 233, -233]\n\nparseInteger([\"0x16\", \"0X16\"], INT)//output:[0, 0]\n\nparseInteger([\"0x16\", \"0X16\"], INT, 16)//output:[22, 22]\n\nparseInteger( \"9\" , INT, 8)\n//Error: 'Invalid string to parse.'\n```\n"
    },
    "parseInteger": {
        "url": "https://docs.dolphindb.cn/zh/funcs/p/parseInteger.html",
        "signatures": [
            {
                "full": "parseInteger(X, type, [radix=10])",
                "name": "parseInteger",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "type",
                        "name": "type"
                    },
                    {
                        "full": "[radix=10]",
                        "name": "radix",
                        "optional": true,
                        "default": "10"
                    }
                ]
            }
        ],
        "markdown": "### [parseInteger](https://docs.dolphindb.cn/zh/funcs/p/parseInteger.html)\n\n\n\n#### 语法\n\nparseInteger(X, type, \\[radix=10])\n\n别名：parseInt\n\n#### 详情\n\n按照不同进制把字符串转换为指定的整数类型。该函数从 *X* 的第一个字符开始转换，直到遇到第一个非法字符，即返回此前的转换结果。当 X 为集合时，将输出相同类型的集合。\n\n注意：\n\n* 转换时会忽略前导空格和前导 0。\n\n* 不支持转换小数，'.'字符属于非法字符。\n\n* 如果（忽略前导空格后）字符串为空，则返回 NULL。\n\n* 如果在遇到非法字符前没有遇到过合法字符，函数将抛出异常。\n\n* 前导空格后的第一个字符可以为'+'/'-'以表示正/负语义，其余位置上的'+'/'-'为非法字符。\n\n#### 参数\n\n**X** 表示待转换的字符串，支持标量、矩阵、向量和数据对。\n\n**type** 表示转换后的类型，支持 CHAR/SHORT/INT/LONG。\n\n**radix** 表示基数，可选参数，有效范围为\\[2, 16]，默认为 10。如 *radix* 为2，那么 *X* 的“合法字符”就指{“0”, “1”}；*radix* 为11，那么”合法字符”就指\\[0, 9]和 A/a（不区分大小写）。特别的，如果 *radix* 为16，那么前导的”0x”或”0X”不会被认为非法字符。\n\n#### 返回值\n\n整型标量、矩阵、向量或数据对。\n\n#### 例子\n\n以下给出几个简单示例。\n\n```\nparseInteger([\" \", \"000\", \"012\", \" 12\",\"12a\", \"1a2\",\"+12a\", \"-12\"], INT)\n//output: [ , 0, 12, 12, 12, 1, 12, -12]\n\nparseInteger(\"a12\", INT)\n//Error: 'Invalid string to parse.'\n\nparseInteger([\"012\", \" 12\",\"12a\", \"1a2\",\"1A2\", \"-1A2\"], INT, 11)\n//output: [13, 13, 153, 233, 233, -233]\n\nparseInteger([\"0x16\", \"0X16\"], INT)//output:[0, 0]\n\nparseInteger([\"0x16\", \"0X16\"], INT, 16)//output:[22, 22]\n\nparseInteger( \"9\" , INT, 8)\n//Error: 'Invalid string to parse.'\n```\n"
    },
    "parseJsonTable": {
        "url": "https://docs.dolphindb.cn/zh/funcs/p/parsejsontable.html",
        "signatures": [
            {
                "full": "parseJsonTable(json, [schema], [keyCaseSensitive=true])",
                "name": "parseJsonTable",
                "parameters": [
                    {
                        "full": "json",
                        "name": "json"
                    },
                    {
                        "full": "[schema]",
                        "name": "schema",
                        "optional": true
                    },
                    {
                        "full": "[keyCaseSensitive=true]",
                        "name": "keyCaseSensitive",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [parseJsonTable](https://docs.dolphindb.cn/zh/funcs/p/parsejsontable.html)\n\n#### 语法\n\nparseJsonTable(json, \\[schema], \\[keyCaseSensitive=true])\n\n#### 详情\n\n将 JSON 对象解析为内存表。\n\n* 当 *json* 是包含多个 JSON 对象的字符串时，每个对象都将转换为表的一行数据；例如，`{\"ID\":10, \"NAME\":\"Riquelme\",\"Club\":\"Boca Juniors\"}`；\n* 当 *json* 是字符串向量时，向量中每个 json 元素转换为表的一行数据。例如，\\[json1, json2, json3]。\n* 当以上两种条件中的 json 包含空值时，即 {}，在转换后的表中，该空值所在行的位置相应留空。\n\n#### 参数\n\n**json** 包含 JSON 对象的字符串标量或向量。当 *json* 是字符串标量时，可以包含1个或多个 JSON 对象。暂不支持 JSON 数组和递归 JSON 对象。\n\n**schema** 可选参数，表对象，用于指定各字段的数据类型。它可以包含以下列（必须包含 name 和 type 列）：\n\n<table id=\"table_wdv_5bs_xyb\"><thead><tr><th>\n\n列名\n\n</th><th>\n\n含义\n\n</th></tr></thead><tbody><tr><td>\n\nname\n\n</td><td>\n\n字符串，表示列名\n\n</td></tr><tr><td>\n\ntype\n\n</td><td>\n\n字符串，表示各列的数据类型。\n\n</td></tr><tr><td>\n\nformat\n\n</td><td>\n\n字符串，表示数据文件中日期或时间列的格式\n\n</td></tr></tbody>\n</table>如果不指定 *schema*，则函数将前10个 JSON 对象，自动解析表结构。\n\n**keyCaseSensitive** 可选参数，表示 key 的名称是否大小写敏感。true（默认值）表示大小写敏感，false 表示大小写不敏感。\n\n#### 返回值\n\n一个表对象。\n\n#### 例子\n\n```\njson1='{\"ID\":1, \"NAME\":\"cc\"}{\"NAME\":\"dd\"}'\nparseJsonTable(json1)\n```\n\n返回：\n\n| ID | NAME |\n| -- | ---- |\n| 1  | cc   |\n|    | dd   |\n\n```\njson2 = '{\"col_test\":\"20190522150407\"}'\nschemaTB = table([\"col_test\"] as name, [\"DATETIME\"] as type, [\"yyyyMMddHHmmss\"] as format)\nparseJsonTable(json2, schemaTB)\n\n```\n\n返回：\n\n| col\\_test           |\n| ------------------- |\n| 2019.05.22T15:04:07 |\n\n当 *json*是包含两个 JSON 对象的字符串时：\n\n```\njson3='{\"ID\":11, \"NAME\":\"dd\"}'\nschemaTB1 = table([\"ID\", \"NAME\", \"col_test\"] as name, [\"INT\", \"STRING\", \"DATETIME\"] as type, [,,\"yyyyMMddHHmmss\"] as format)\nparseJsonTable(concat([json2,json3]),schemaTB1)\n```\n\n返回：\n\n| ID | NAME | col\\_test           |\n| -- | ---- | ------------------- |\n|    |      | 2019.05.22T15:04:07 |\n| 11 | dd   |                     |\n\n当 *json* 是字符串向量时：\n\n```\nparseJsonTable([json2,json3],schemaTB1)\n```\n\n返回：\n\n| ID | NAME | col\\_test           |\n| -- | ---- | ------------------- |\n|    |      | 2019.05.22T15:04:07 |\n| 11 | dd   |                     |\n\n下例中定义了一个有三行数据的 json 对象 home，第三行数据为空（{}）。在第四行中，`parseJsonTable` 按照第三行中 *schemaLiga* 中定义的 *schema* 转换为名为 formation 的内存表。\n\n```\nhome = ['{\"Num\":10, \"Name\":\"Ronaldo\",\"Goal\":\"3\",\"MatchDay\":\"20120322\"}','{\"Num\":3, \"Name\":\"Carlos\",\"Goal\":\"1\",\"MatchDay\":\"20120322\"}','{}'];\nschemaLiga = table([\"Num\",\"Name\",\"Goal\",\"MatchDay\"] as name, [\"INT\",\"STRING\",\"INT\",\"DATE\"] as type, [,,,\"yyyyMMdd\"] as format);\nformation = parseJsonTable(home,schemaLiga);\nformation;\n```\n\n返回：\n\n| Num | Name    | Goal | MatchDay   |\n| --- | ------- | ---- | ---------- |\n| 10  | Ronaldo | 3    | 2012.03.22 |\n| 3   | Carlos  | 1    | 2012.03.22 |\n|     |         |      |            |\n\n打印结果显示，原属于 json 对象 home 的第三行显示为空。\n\n"
    },
    "parseMktData": {
        "url": "https://docs.dolphindb.cn/zh/funcs/p/parseMktData.html",
        "signatures": [
            {
                "full": "parseMktData(dict)",
                "name": "parseMktData",
                "parameters": [
                    {
                        "full": "dict",
                        "name": "dict"
                    }
                ]
            }
        ],
        "markdown": "### [parseMktData](https://docs.dolphindb.cn/zh/funcs/p/parseMktData.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\nparseMktData(dict)\n\n#### 详情\n\n将输入的字典或 JSON 字符串解析为 MKTDATA 类型。\n\n#### 参数\n\n**dict** 字典或表示该字典的 JSON 格式字符串（STRING 标量），用于指定待解析的市场数据内容。\n\n#### 返回值\n\n一个 MKTDATA 类型对象。\n\n#### 市场数据支持与字段要求\n\nMKTDATA 为 DolphinDB 新增的数据类型，为金融产品定价需要用到的市场数据提供支撑。\n\n目前支持以下类型：\n\n* 即期价格：Price（即期价格）、FxSpotRate（外汇即期汇率）\n\n* 期限结构曲线：IrYieldCurve（利率收益率曲线）， AssetPriceCurve（资产价格曲线）、DividendCurve（股息曲线）\n\n* 波动率曲面：FxVolatilitySurface（外汇波动率曲面）、VolatilitySurface（波动率曲面）\n\n各种类型数据所需字段如下（注：\"version\" 为系统保留字段，为避免冲突，请勿将此名称用于自定义字段。）\n\n##### Price\n\n| 字段名           | 类型     | 描述                                                                                                                 | 是否必填 |\n| ------------- | ------ | ------------------------------------------------------------------------------------------------------------------ | ---- |\n| mktDataType   | STRING | 固定填 \"Price\"                                                                                                        | 是    |\n| referenceDate | DATE   | 参考日期                                                                                                               | 是    |\n| priceType     | STRING | 价格类型，固定填 \"Price\"                                                                                                   | 是    |\n| value         | DOUBLE | 价格                                                                                                                 | 是    |\n| unit          | STRING | 表示 value 的计价单位，（即 value 这个数字的量纲是什么）。priceType 为 \"Price\" 时，unit 为货币代码，可选值 为\"CNY\", \"USD\", \"EUR\", \"GBP\", \"JPY\", \"HKD\" | 是    |\n\n##### FxSpotRate\n\n<table id=\"table_msg_l4j_ngc\"><thead><tr><th>\n\n字段名\n\n</th><th>\n\n类型\n\n</th><th>\n\n描述\n\n</th><th>\n\n是否必填\n\n</th></tr></thead><tbody><tr><td>\n\nmktDataType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"Price\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nreferenceDate\n\n</td><td>\n\nDATE\n\n</td><td>\n\n参考日期\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nspotDate\n\n</td><td>\n\nDATE\n\n</td><td>\n\n即期交割日，默认使用内部静态数据\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\npriceType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n即期价格类型，固定填 \"FxSpotRate\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nvalue\n\n</td><td>\n\nDOUBLE\n\n</td><td>\n\n即期价格\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nunit\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n表示 value 的计价单位，（即 value 这个数字的量纲是什么）。priceType 为 \"FxSpotRate\" 时，unit 货币对，为可选值为 \"EURUSD\", \"USDCNY\", \"EURCNY\", \"GBPCNY\", \"JPYCNY\", \"HKDCNY\"。\n\n货币对也可由 `.` 或 `/` 分隔，例如 \"EURUSD\" 也可写为 \"EUR.USD\" 或 \"EUR/USD\"。\n\n</td><td>\n\n是\n\n</td></tr></tbody>\n</table>下例定义了一个 FxSpotRate 对象：\n\n```\nFxSpotRate = {\n    \"mktDataType\": \"Price\",\n    \"referenceDate\": 2025.08.18,\n    \"spotDate\": 2025.08.20,\n    \"priceType\": \"FxSpotRate\",\n    \"value\": 7.2659,\n    \"unit\": \"USDCNY\"\n}\n\nmktData = parseMktData(FxSpotRate)\nprint(mktData)\n```\n\n##### IrYieldCurve\n\n<table id=\"table_l53_s4j_ngc\"><thead><tr><th>\n\n字段名\n\n</th><th>\n\n类型\n\n</th><th>\n\n描述\n\n</th><th>\n\n是否必填\n\n</th></tr></thead><tbody><tr><td>\n\nmktDataType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"Curve\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nreferenceDate\n\n</td><td>\n\nDATE\n\n</td><td>\n\n参考日期\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ncurveType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"IrYieldCurve\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ndayCountConvention\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n曲线的日期计数惯例，可选值为：\n\n* \"Actual360\"：实际天数除以360\n\n* \"Actual365\"：实际天数除以365（不区分闰年）\n\n* \"ActualActualISMA\"：实际天数/实际天数（ISMA规则）\n\n* \"ActualActualISDA\"：实际天数/实际天数（ISDA规则）\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ninterpMethod\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n内插方法，可选值为：\n\n* \"Linear\"：线性插值\n\n* \"CubicSpline\"：三次样条插值\n\n* \"CubicHermiteSpline\"：三次埃尔米特样条插值\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nextrapMethod\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n外插方法，可选值为：\n\n* \"Flat\"：平插\n\n* \"Linear\"：线性插值\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ndates\n\n</td><td>\n\nDATE 向量\n\n</td><td>\n\n数据点的日期\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nvalues\n\n</td><td>\n\nDOUBLE 向量\n\n</td><td>\n\n数据点的值，与 *dates* 中的元素一一对应\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ncurveName\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n曲线名称\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ncurrency\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n货币，可选值为\"CNY\", \"USD\", \"EUR\", \"GBP\", \"JPY\", \"HKD\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ncompounding\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n复利类型，可选值为：\n\n* \"Simple\"：单利\n\n* \"Compounded\"：离散复利\n\n* \"Continuous\"：连续复利\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nsettlement\n\n</td><td>\n\nDATE\n\n</td><td>\n\n结算日，如果指定了结算日，则后续期限间隔的计算都将从 *settlement* 开始，而不是 *referenceDate*\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\nfrequency\n\n</td><td>\n\nINTEGRAL或 STRING\n\n</td><td>\n\n计息频率，可选值为：\n\n* 1 或 \"Annual\"：每年付息一次\n\n* 2 或 \"Semiannual\"：每半年付息一次\n\n* 3 或 \"EveryFourthMonth\"：每四个月付息一次\n\n* 4 或 \"Quarterly\"：每季度付息一次\n\n* 6 或 \"BiMonthly\"：每两月付息一次\n\n* 12 或 \"Monthly\"：每月付息一次\n\n* 13 或 \"EveryFourthWeek\"：每四周付息一次\n\n* 26 或 \"BiWeekly\"：每两周付息一次\n\n* 52 或 \"Weekly\"：每周付息一次\n\n* 365 或 \"Daily\"：每日付息一次\n\n* 999 或 \"Other\"：其他计息频率\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ncurveModel\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n曲线构建模型，可选值为 \"Bootstrap\"（默认），\"NS\"，\"NSS\"。\n\n当取值 \"NSS\" 或 \"NS\"，无需传 *interpMethod*、*extrapMethod*、*dates*、*values*字段。\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ncurveParams\n\n</td><td>\n\nDICT\n\n</td><td>\n\n模型的参数，当 *curveModel*取值 \"NSS\" 或 \"NS\" 时必填：\n\n* curveModel = \"NS\"：应包含键 'beta0', 'beta1', 'beta2', 'lambda'\n\n* curveModel = \"NSS\"：应包含键'beta0', ‘beta1', 'beta2', 'beta3', 'lambda0', 'lambda1'\n\n</td><td>\n\n否\n\n</td></tr></tbody>\n</table>下例定义了一个 IrYieldCurve 对象：\n\n```\naod = 2025.07.01\ncurve = {\n    \"mktDataType\": \"Curve\",\n    \"curveType\": \"IrYieldCurve\",\n    \"referenceDate\": aod,\n    \"currency\": \"CNY\",\n    \"dayCountConvention\": \"Actual365\",\n    \"compounding\": \"Continuous\",\n    \"interpMethod\": \"Linear\",\n    \"extrapMethod\": \"Flat\",\n    \"dates\":[2025.07.07,2025.07.10,2025.07.17,2025.07.24,2025.08.04,2025.09.03,2025.10.09,2026.01.05,\n        2026.04.03,2026.07.03,2027.01.04,2027.07.05,2028.07.03],\n    \"values\":[0.015785,0.015931,0.016183,0.016381,0.016493,0.016503,0.016478,0.016234,0.016321,\n        0.016378,0.015508,0.015185,0.014901],\n    \"settlement\": aod+2\n}\n\nmktData = parseMktData(curve)\nprint(mktData)\n```\n\n##### AssetPriceCurve\n\n| 字段名           | 类型        | 描述                       | 是否必填 |\n| ------------- | --------- | ------------------------ | ---- |\n| mktDataType   | STRING    | 固定填 \"Curve\"              | 是    |\n| referenceDate | DATE      | 参考日期                     | 是    |\n| curveType     | STRING    | 固定填 \"AssetPriceCurve\"    | 是    |\n| dates         | DATE 向量   | 数据点的日期                   | 是    |\n| values        | DOUBLE 向量 | 数据点的值，与 *dates* 中的元素一一对应 | 是    |\n| curveName     | STRING    | 曲线名称                     | 否    |\n\n下例定义了一个 AssetPriceCurve 对象：\n\n```\ncurve = {\n    \"mktDataType\": \"Curve\",\n    \"curveType\": \"AssetPriceCurve\",\n    \"referenceDate\": 2024.06.28,\n    \"curveName\": \"PRICE_SHIBOR_3M\",\n    \"dates\": [2024.06.21, 2024.06.24, 2024.06.25, 2024.06.26,2024.06.27],\n    \"values\": [1.923, 1.922, 1.921, 1.919, 1.918]/100\n}\n\nmktData = parseMktData(curve)\nprint(mktData)\n```\n\n##### DividendCurve\n\n下例定义了一个 DividendCurve 对象：\n\n```\ncurve = {\n    \"mktDataType\": \"Curve\",\n    \"curveType\": \"DividendCurve\",\n    \"referenceDate\": 2024.06.28,\n    \"dayCountConvention\": \"Actual365\",\n    \"compounding\": \"Continuous\",\n    \"interpMethod\": \"Linear\",\n    \"extrapMethod\": \"Flat\",\n    \"dates\": [2024.07.19, 2024.08.16, 2024.09.20, 2024.12.20],\n    \"values\": [0.15347650417594424, 0.10083112893776815, 0.0693439711515692, 0.04357496515816385],\n    \"shortEndDate\": 2024.06.28\n}\n\ndividendCurve = parseMktData(curve)\n```\n\n##### FxVolatilitySurface\n\n<table id=\"table_dm2_2pj_ngc\"><thead><tr><th>\n\n字段名\n\n</th><th>\n\n类型\n\n</th><th>\n\n描述\n\n</th><th>\n\n是否必填\n\n</th></tr></thead><tbody><tr><td>\n\nmktDataType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"Surface\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nreferenceDate\n\n</td><td>\n\nDATE\n\n</td><td>\n\n参考日期\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nsurfaceType\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n固定填 \"FxVolatilitySurface\"\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nsmileMethod\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n波动率微笑方法，可选值为：\n\n* \"Linear\"：线性微笑\n\n* \"CubicSpline\"：三次样条微笑\n\n* \"SVI\"：SVI 模型微笑\n\n* \"SABR\"：SABR 模型微笑\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nvolSmiles\n\n</td><td>\n\nDICT(STRING, ANY) 向量\n\n</td><td>\n\n波动率微笑向量，向量中每个元素为一条波动率微笑。\n\n包含以下成员：\n\n* **strikes**: DOUBLE 类型向量，表示不同的行权价\n\n* **vols**: DOUBLE 类型向量，表示行权价对应的波动率，与 *strikes*等长\n\n* **curveParams**：字典DICT(STRING, DOUBLE)类型，表示波动率微笑方法的模型参数，只在 *smileMethod* 取值 \"SVI\" 或 \"SABR\" 时生效：\n\n  * smileMethod = 'SVI': 应包含键 'a', 'b', 'rho', 'm', 'sigma'\n\n  * smileMethod = 'SABR': 应包含键 'alpha', 'beta', 'rho', 'nu'\n\n* **fwd**：可选，DOUBLE 类型标量，当 *smileMethod*取值 \"SVI\" 或 \"SABR\" 时必填，表示远期值\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\ntermDates\n\n</td><td>\n\nDATE 向量\n\n</td><td>\n\n*volSmiles*中每条波动率微笑对应的期限日期\n\n</td><td>\n\n是\n\n</td></tr><tr><td>\n\nsurfaceName\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n曲面名称\n\n</td><td>\n\n否\n\n</td></tr><tr><td>\n\ncurrencyPair\n\n</td><td>\n\nSTRING\n\n</td><td>\n\n外汇的货币对，可选值为\"EURUSD\", \"USDCNY\", \"EURCNY\", \"GBPCNY\", \"JPYCNY\", \"HKDCNY\"。\n\n货币对的表示也可由 `.` 或 `/` 分隔，例如 \"EURUSD\" 也可写为 \"EUR.USD\" 或 \"EUR/USD\"。\n\n</td><td>\n\n是\n\n</td></tr></tbody>\n</table>下例定义了一个 FxVolatilitySurface 对象：\n\n```\nsurf = {\n\t\"surfaceName\": \"USDCNY\",\n\t\"mktDataType\": \"Surface\",\n\t\"surfaceType\": \"FxVolatilitySurface\",\n\t\"referenceDate\": \"2025.08.18\",\n\t\"smileMethod\": \"Linear\",\n\t\"termDates\": [\n\t\t\"2025.08.21\",\n\t\t\"2026.08.20\"\n\t],\n\t\"volSmiles\":[{\"strikes\": [6.5,7,7.5],\"vols\": [0.1,0.1,0.1]},{\"strikes\": [6.5,7,7.5],\"vols\": [0.1,0.1,0.1]}],\n\t\"currencyPair\": \"USDCNY\"\n}\n\nsurfUsdCny = parseMktData(surf)\n```\n"
    },
    "partial": {
        "url": "https://docs.dolphindb.cn/zh/funcs/p/partial.html",
        "signatures": [
            {
                "full": "partial(func, args...)",
                "name": "partial",
                "parameters": [
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "args...",
                        "name": "args..."
                    }
                ]
            }
        ],
        "markdown": "### [partial](https://docs.dolphindb.cn/zh/funcs/p/partial.html)\n\n\n\n#### 语法\n\npartial(func, args...)\n\n#### 详情\n\n创建一个部分应用。\n\n#### 参数\n\n**func** 是 DolphinDB 中的函数。\n\n**args...** 是函数的参数。\n\n#### 返回值\n\n一个 FUNCTIONDEF。\n\n#### 例子\n\n```\npartial(add,1)(2);\n// output\n3\n\ndef f(a,b):a pow b\ng=partial(f, 2)\ng(3);\n// output\n8\n```\n"
    },
    "pca": {
        "url": "https://docs.dolphindb.cn/zh/funcs/p/pca.html",
        "signatures": [
            {
                "full": "pca(ds, [colNames], [k], [normalize], [maxIter], [svdSolver], [randomState])",
                "name": "pca",
                "parameters": [
                    {
                        "full": "ds",
                        "name": "ds"
                    },
                    {
                        "full": "[colNames]",
                        "name": "colNames",
                        "optional": true
                    },
                    {
                        "full": "[k]",
                        "name": "k",
                        "optional": true
                    },
                    {
                        "full": "[normalize]",
                        "name": "normalize",
                        "optional": true
                    },
                    {
                        "full": "[maxIter]",
                        "name": "maxIter",
                        "optional": true
                    },
                    {
                        "full": "[svdSolver]",
                        "name": "svdSolver",
                        "optional": true
                    },
                    {
                        "full": "[randomState]",
                        "name": "randomState",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [pca](https://docs.dolphindb.cn/zh/funcs/p/pca.html)\n\n\n\n#### 语法\n\npca(ds, \\[colNames], \\[k], \\[normalize], \\[maxIter], \\[svdSolver], \\[randomState])\n\n#### 详情\n\n对数据源中指定列中的数据进行主成分分析。\n\n#### 参数\n\n**ds** 是一个或多个数据源，通常由 [sqlDS](https://docs.dolphindb.cn/zh/funcs/s/sqlDS.html) 函数生成。\n\n**colNames** 是字符串向量，表示数据源中的列名。默认值是数据源中所有列的列名。\n\n**k** 是一个正整数，表示需要计算的主成分的个数。默认值是数据源中的列数。\n\n**normalize** 是一个布尔值，表示是否将数据减去均值再除以标准差。默认值为 false。\n\n**maxIter** 是一个正整数，表示参数 *svdSolver* =randomized 时的迭代次数。若未指定，当 *k* <0.1\\*cols 时，*maxIter* = 7，否则 *maxIter* = 4。这里 cols 表示数据源中的列数。\n\n**svdSolver** 是一个字符串，表示如何对数据源进行 svd 运算。它的取值可以是 \"full\", \"randomized\" 或 \"auto\"。*svdSolver* = \"full\" 适合 *k* 值与数据源的列数相近的情况；*svdSolver* = \"randomized\" 适合 *k* 值与数据源的列数相差较大的情况。默认值为 \"auto\"，此时系统会自动判断使用 \"full\" 还是 \"randomized\"。\n\n**randomState** 是一个整数，表示随机数种子，仅在参数 *svdSolver* =\"randomized\" 时起作用，默认为 int(time(now()))。\n\n#### 返回值\n\n一个字典，包含以下键：\n\n* components：对应长度为 size( *colNames* )\\**k* 的主成分分析矩阵。\n* explainedVarianceRatio：对应长度为 *k* 的向量，包含前 *k* 个主成分分别解释的方差权重。\n* singularValues：对应长度为 *k* 的向量，包含主成分方差(协方差矩阵特征值)。\n\n#### 例子\n\n```\nx = [7,1,1,0,5,2]\ny = [0.7, 0.9, 0.01, 0.8, 0.09, 0.23]\nt=table(x, y)\nds = sqlDS(<select * from t>);\n\npca(ds);\n\n// output\ncomponents->\n#0        #1\n--------- ---------\n-0.999883 0.015306\n-0.015306 -0.999883\nexplainedVarianceRatio->[0.980301,0.019699]\nsingularValues->[6.110802,0.866243]\n```\n"
    },
    "pchipInterpolateFit": {
        "url": "https://docs.dolphindb.cn/zh/funcs/p/pchipInterpolateFit.html",
        "signatures": [
            {
                "full": "pchipInterpolateFit(X, Y, [extrapolate=true])",
                "name": "pchipInterpolateFit",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "[extrapolate=true]",
                        "name": "extrapolate",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [pchipInterpolateFit](https://docs.dolphindb.cn/zh/funcs/p/pchipInterpolateFit.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\npchipInterpolateFit(X, Y, \\[extrapolate=true])\n\n#### 详情\n\n对一组数值向量 *X*和*Y* 进行分段三次 Hermite 多项式插值（PCHIP）。\n\n#### 参数\n\n**X** 数值型向量，表示用于插值的点的 x 坐标（自变量）。*X* 必须严格递增，且至少包含两个元素。\n\n**Y** 与 *X*等长的数值型向量，表示用于插值的点的 y 坐标（因变量）。\n\n**extrapolate**可选参数，布尔标量，表示当预测点超出已知数据范围时是否进行外插。默认为 true。\n\n#### 返回值\n\n一个字典，包含以下键值对：\n\n* modelName：字符串“PchipInterpolate”，表示模型名称。\n* X：DOUBLE 向量，表示输入参数 *X*。\n* extrapolate：BOOL 标量，即输入参数 *extrapolate*。\n* coeffs：数值型向量，表示根据输入数据点拟合得到的多项式系数。\n* predict：模型的预测函数，可以通过 `model.predict(X)` 或 `predict(model, X)` 调用，其中：\n  * model：字典，即当前函数 `pchipInterpolateFit`的返回。\n  * X：数值型向量，表示需要求值的点的 x 坐标，`predict` 函数将返回在 *X* 点处的插值结果。\n\n#### 例子\n\n对 x 和 y 进行进行分段三次 Hermite 多项式插值。\n\n```\ndef linspace(start, end, num, endpoint=true){\n\tif(endpoint) return end$DOUBLE\\(num-1), start + end$DOUBLE\\(num-1)*0..(num-1)\n\telse return start + end$DOUBLE\\(num-1)*0..(num-1)\t\n}\n\nx_observed = linspace(0.0, 10.0, 11)[1]\ny_observed = sin(x_observed)\n\nmodel = pchipInterpolateFit(x_observed, y_observed)\nmodel;\n\n/* output:\nmodelName->PchipInterpolate\nX->[0,1,2,3,4,5,6,7,8,9,10]\ncoeffs->#0                 #1                 #2                 #3                \n------------------ ------------------ ------------------ ------------------\n-0.32911446845195  -0.057707802943105 1.228293256202952  0                 \n-0.01011863907468  -0.047589163868426 0.125534244960891  0.841470984807897 \n0.708356730424705  -1.476534149190519 0                  0.909297426825682 \n0.637878921149598  -0.707803317410469 -0.827998107106924 0.141120008059867 \n0.074275580231352  0.053570618892506  -0.329967978479069 -0.756802495307928\n-0.571482233207003 1.250991009671215  0                  -0.958924274663138\n-0.594663658922633 0.743530436118926  0.787535319721422  -0.279415498198926\n-0.174138080617811 0.015904513331029  0.490605215191374  0.656986598718789 \n0.434603140426252  -1.011842901807877 0                  0.989358246623382 \n0.046813296419378  -0.283076510213506 -0.719876382336998 0.412118485241757 \n\nextrapolate->true\npredict->cubicHermiteSplinePredict\n*/\n```\n\n**相关函数：**[predict](https://docs.dolphindb.cn/zh/funcs/p/predict.html) [cubicHermiteSplineFit](https://docs.dolphindb.cn/zh/funcs/c/cubichermitesplinefit.html)\n"
    },
    "pdfChiSquare": {
        "url": "https://docs.dolphindb.cn/zh/funcs/p/pdfChiSquare.html",
        "signatures": [
            {
                "full": "pdfChiSquare(df, X)",
                "name": "pdfChiSquare",
                "parameters": [
                    {
                        "full": "df",
                        "name": "df"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [pdfChiSquare](https://docs.dolphindb.cn/zh/funcs/p/pdfChiSquare.html)\n\n\n\n#### 语法\n\npdfChiSquare(df, X)\n\n#### 详情\n\n计算指定卡方分布在 X 处的概率密度。\n\n其功能和用法同 scipy.stats.chi2.pdf 。\n\n#### 参数\n\n**df**数值型标量，代表自由度参数。\n\n**X**数值型标量或向量，代表要计算概率密度的点。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\npdfChiSquare(df=3, X=[1,2,3])\n// output: [0.241970724519143, 0.207553748710297, 0.154180329803769]\n```\n"
    },
    "pdfF": {
        "url": "https://docs.dolphindb.cn/zh/funcs/p/pdfF.html",
        "signatures": [
            {
                "full": "pdfF(numeratorDF, denominatorDF, X)",
                "name": "pdfF",
                "parameters": [
                    {
                        "full": "numeratorDF",
                        "name": "numeratorDF"
                    },
                    {
                        "full": "denominatorDF",
                        "name": "denominatorDF"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [pdfF](https://docs.dolphindb.cn/zh/funcs/p/pdfF.html)\n\n\n\n#### 语法\n\npdfF(numeratorDF, denominatorDF, X)\n\n#### 详情\n\n计算指定 F 分布在 X 处的概率密度。\n\n其功能和用法同 scipy.stats.f.pdf 。\n\n#### 参数\n\n**numeratorDF**数值型标量，代表分子自由度。\n\n**denominatorDF**数值型标量，代表分母自由度。\n\n**X**数值型标量或向量，代表要计算概率密度的点。\n\n#### 返回值\n\nDOUBLE 类型标量或向量，表示在 *X* 处计算的概率密度。\n\n#### 例子\n\n```\npdfF(numeratorDF=2, denominatorDF=19, X=[1,2,3])\n// output: [0.34963122778983, 0.134514942963846, 0.056045754350634]\n```\n"
    },
    "pdfNormal": {
        "url": "https://docs.dolphindb.cn/zh/funcs/p/pdfNormal.html",
        "signatures": [
            {
                "full": "pdfNormal(mean, stdev, X)",
                "name": "pdfNormal",
                "parameters": [
                    {
                        "full": "mean",
                        "name": "mean"
                    },
                    {
                        "full": "stdev",
                        "name": "stdev"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [pdfNormal](https://docs.dolphindb.cn/zh/funcs/p/pdfNormal.html)\n\n\n\n#### 语法\n\npdfNormal(mean, stdev, X)\n\n#### 详情\n\n计算指定正态分布在 X 处的概率密度。\n\n其功能和用法同 scipy.stats.norm.pdf 。\n\n#### 参数\n\n**mean**数值型标量，代表正态分布的均值。\n\n**stdev**数值型标量，代表正态分布的标准差。\n\n**X**数值型标量或向量，代表要计算概率密度的点。\n\n#### 返回值\n\nDOUBLE 类型标量或向量，表示在 *X* 处计算的概率密度。\n\n#### 例子\n\n计算标准正态分布在 X=1 处的概率密度值\n\n```\npdfNormal(mean=0, stdev=1, X=1)\n// output:0.24197072451914337\n```\n\n计算均值为1，方差为 1.5 的正态分布在 X 为 1, 2, 3 处的概率密度值\n\n```\npdfNormal(mean=1, stdev=1.5, X=[1,2,3])\n// output:[0.265961520267622,0.212965337014901,0.109340049783996]\n```\n"
    },
    "peekAppend": {
        "url": "https://docs.dolphindb.cn/zh/funcs/p/peekAppend.html",
        "signatures": [
            {
                "full": "peekAppend(engine, data)",
                "name": "peekAppend",
                "parameters": [
                    {
                        "full": "engine",
                        "name": "engine"
                    },
                    {
                        "full": "data",
                        "name": "data"
                    }
                ]
            }
        ],
        "markdown": "### [peekAppend](https://docs.dolphindb.cn/zh/funcs/p/peekAppend.html)\n\n首发版本：3.00.5\n\n\n\n#### 语法\n\npeekAppend(engine, data)\n\n#### 详情\n\n在不更新流引擎状态且不向输出表写入结果的情况下，返回在引擎当前状态基础上加上指定数据后的即时计算结果。目前仅支持 TimeSeriesEngine 和ReactiveStateEngine 的部分算子，具体如下：\n\n**TimeSeriesEngine**：设置 *keyColumn* 且未设置 *useSystemTime*、*acceptedDelay*、*forceTriggerTime*。\n\n**ReactiveStateEngine**：`cumavg`、`cumsum`、`cumstd`、`cumstdp`、`cumvar`、`cumvarp`、`cumprod`、`cumcount`、`mcount`、`msum`、`mavg`、`mstd`、`mstdp`、`mvar`、`mvarp` 以及无状态算子（表达式，无状态函数等）。\n\n#### 参数\n\n**engine**流引擎。\n\n**data** 一个表或元组，表示要写入流数据引擎的消息。\n\n#### 返回值\n\n返回一个表对象，即在引擎当前状态上加上 *data* 的即时计算结果。引擎状态不会更新，也不会有输出结果到 outputTable。\n\n#### 例子\n\n**ReactiveStateEngine 示例**\n\n```\nshare streamTable(100:0, `sym`time`price, [STRING,DATETIME,DOUBLE]) as tickStream\nshare streamTable(1000:0, `sym`time`factor1, [STRING,DATETIME,DOUBLE]) as result\nrse = createReactiveStateEngine(name=\"reactiveDemo\", metrics =[<time>, <cumsum(price)>], dummyTable=tickStream, outputTable=result, keyColumn=\"sym\")\ndata = table(take([\"000001.SH\",\"000002.SH\",\"000003.SH\"], 3) as sym, take(2021.02.08T09:31:00 + 1..3, 3) as time, take(100.0, 3) as price)\nres = rse.peekAppend(data)\nrse.append!(data)\n//res和result一致\n```\n\n![](https://docs.dolphindb.cn/zh/funcs/images/peekAppend/1.png)\n\n```\nshare streamTable(100:0, `sym`time`price, [STRING,DATETIME,DOUBLE]) as tickStream\nshare streamTable(1000:0, `sym`time`factor1, [STRING,DATETIME,DOUBLE]) as result\nrse = createReactiveStateEngine(name=\"reactiveDemo\", metrics =[<time>, <cumsum(price)>], dummyTable=tickStream, outputTable=result, keyColumn=\"sym\")\n\ndata = table(take([\"000001.SH\"], 3) as sym, take(2021.02.08T09:31:00 + 1..3, 3) as time, 100 200 300 as price)\nres2 = rse.peekAppend(data)\n```\n\n![](https://docs.dolphindb.cn/zh/funcs/images/peekAppend/2.png)\n\n**TimeSeriesEngine 示例**\n\n```\nshare streamTable(1000:0, `sym`time`volume, [STRING,DATETIME,INT]) as tickStream\nshare streamTable(1000:0, `time`sym`sumVolume, [DATETIME,STRING,INT]) as result\ntse = createTimeSeriesEngine(name=\"tse\", windowSize=60, step=60, metrics=<[sum(volume)]>, dummyTable=tickStream, outputTable=result, timeColumn=\"time\", useSystemTime=false, keyColumn=\"sym\")\n\ninsert into tse values([`\"000001.SH\", 2021.02.08T09:30:00, 100])\ndata = table(take([\"000001.SH\"], 3) as sym, take(2021.02.08T09:30:00 + 1..3, 3) as time, 100 200 300 as price)\nres = tse.peekAppend(data)\n```\n\n![](https://docs.dolphindb.cn/zh/funcs/images/peekAppend/3.png)\n"
    },
    "percentChange": {
        "url": "https://docs.dolphindb.cn/zh/funcs/p/percentChange.html",
        "signatures": [
            {
                "full": "percentChange(X,[n])",
                "name": "percentChange",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[n]",
                        "name": "n",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [percentChange](https://docs.dolphindb.cn/zh/funcs/p/percentChange.html)\n\n\n\n#### 语法\n\npercentChange(X,\\[n])\n\n#### 详情\n\n计算两个元素之间的值变化比例。即，对于 *X* 中的每一个元素，计算 (Xi/ Xi-n) - 1。\n\n若 *X* 是矩阵，在每列内进行上述计算，返回一个与 *X* 维度相同的矩阵。\n\n#### 参数\n\n**X** 是一个向量或矩阵。\n\nn 为可选参数，整型，用于指定计算 X 中两个元素值变化百分比时的元素间隔数，默认值为 1。\n\n* 在不指定 n 值时，percentChange 计算相邻元素值的变化百分比；\n\n* 当 n 为大于 1 的整数时，例如，当 X = 3 4 6 9，n = 2 时，计算 X 中 6 和 3 之间、9 和 4 之间的值变化百分比，得到的结果为：\\[,,1,1.25]，即 100% 和 125%。\n\n* 当 n 为负整数时，例如， X = 3 4 6 9，n = -2 时，计算 X 中 3 和 6 之间、4 和 9 之间的值变化百分比，得到的结果为：\\[-0.5, -0.5555555555555556,,]。\n\n#### 返回值\n\nDOUBLE 类型向量或矩阵。\n\n#### 例子\n\n```\npercentChange([1,2,3]);\n//output： [,1,0.5]\n\n```\n\n```\npercentChange(85 90 95);\n//output：[,0.058824,0.055556]\n```\n\n```\nm=matrix(100 105 109 112 108 116, 200 212 208 199 206 210);\nm\n```\n\n返回：\n\n| #0  | #1  |\n| --- | --- |\n| 100 | 200 |\n| 105 | 212 |\n| 109 | 208 |\n| 112 | 199 |\n| 108 | 206 |\n| 116 | 210 |\n\n```\npercentChange(m);\n```\n\n返回：\n\n| #0                 | #1                 |\n| ------------------ | ------------------ |\n|                    |                    |\n| 0.05               | 0.06               |\n| 0.038095238095238  | -0.018867924528302 |\n| 0.027522935779817  | -0.043269230769231 |\n| -0.035714285714286 | 0.035175879396985  |\n| 0.074074074074074  | 0.019417475728155  |\n\n以下例子中，X 是一个从 1 到 10 递增的向量。n = 3，即 1 和 4 比较，2 和 5 比较， 3 和 6 比较，以此类推。\n\n```\nX = 1..10;\nn = 3;\nr = percentChange(X,n);\nprint r;\n//output: [,,,3,1.5,1,0.75,0.6,0.5,0.428571428571429]\n```\n\n以下例子中，X 是一个矩阵。\n\n```\nm=matrix(1 3 2 NULL 6 9 3, 0 8 NULL 7 6 2 8);\nn = 3;\nresult = percentChange(m,n);\nresult;\n```\n\n返回：\n\n<table id=\"table_am1_r15_x1c\"><tbody><tr><td>\n\n0\n\n</td><td>\n\n1\n\n</td></tr><tr><td>\n\n</td><td>\n\n</td></tr><tr><td>\n\n</td><td>\n\n</td></tr><tr><td>\n\n</td><td>\n\n</td></tr><tr><td>\n\n</td><td>\n\n</td></tr><tr><td>\n\n1\n\n</td><td>\n\n-0.25\n\n</td></tr><tr><td>\n\n3.5\n\n</td><td>\n\n</td></tr><tr><td>\n\n</td><td>\n\n0.14285714285714285\n\n</td></tr></tbody>\n</table>当 n 为负整数时，\n\n```\nx = 3 4 6 9\nn = -2\nr2= percentChange(x,n)\nr2\n```\n\n返回：\n\n<table id=\"table_epg_t15_x1c\"><tbody><tr><td>\n\n0\n\n</td><td>\n\n1\n\n</td><td>\n\n2\n\n</td><td>\n\n3\n\n</td></tr><tr><td>\n\n-0.5\n\n</td><td>\n\n-0.5555555555555556\n\n</td><td>\n\n</td><td>\n\n</td></tr></tbody>\n</table>\n"
    },
    "percentile": {
        "url": "https://docs.dolphindb.cn/zh/funcs/p/percentile.html",
        "signatures": [
            {
                "full": "percentile(X, percent, [interpolation='linear'])",
                "name": "percentile",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "percent",
                        "name": "percent"
                    },
                    {
                        "full": "[interpolation='linear']",
                        "name": "interpolation",
                        "optional": true,
                        "default": "'linear'"
                    }
                ]
            }
        ],
        "markdown": "### [percentile](https://docs.dolphindb.cn/zh/funcs/p/percentile.html)\n\n\n\n#### 语法\n\npercentile(X, percent, \\[interpolation='linear'])\n\n#### 详情\n\n若 *X* 是一个向量，计算其指定的百分位数。与所有其它聚合函数一致，计算时忽略 NULL 值。\n\n若 *X* 为矩阵，计算每列的指定的百分位数，返回一个向量。\n\n若 *X* 为表，计算每列的指定的百分位数，返回一个表。\n\n与 Python 中 percentile 的区别：当 *X* 为矩阵时，numpy.percentile 默认会把整个矩阵展平成一维后算一个值，DolphinDB 的 percentile 会对每列分别计算，其行为相当于 `numpy.percentile(X, percent, axis=0)`。\n\n#### 参数\n\n**X** 是一个向量、矩阵或表。\n\n**percent** 是 0 到 100 之间的整数或小数。\n\n**interpolation** 是一个字符串，表示当选中的分位点位于在 *X* 的第 i 和第 i+1 个元素之间时，采用的插值方法。它具有以下取值：\n\n* 'linear': ![](https://docs.dolphindb.cn/zh/images/linear.png), 其中 ![](https://docs.dolphindb.cn/zh/images/fraction.png)\n\n* 'lower': ![](https://docs.dolphindb.cn/zh/images/xi.png)\n\n* 'higher': ![higher](https://docs.dolphindb.cn/zh/images/higher.png)\n\n* 'nearest': ![](https://docs.dolphindb.cn/zh/images/xi.png)和 ![](https://docs.dolphindb.cn/zh/images/higher.png)之中最接近分位点的数据\n\n* 'midpoint': ![](https://docs.dolphindb.cn/zh/images/midpoint.png)\n\n如果没有指定 *interpolation*，默认采用 'linear'。\n\n#### 返回值\n\nDOUBLE 类型标量/向量，或一个包含 DOUBLE 类型结果的表。\n\n#### 例子\n\n```\na=[6, 47, 49, 15, 42, 41, 7, 39, 43, 40, 36];\n\npercentile(a,50);\n// output\n40\n\npercentile(a,54);\n// output\n40.4\n\npercentile(a,25,\"lower\");\n// output\n15\n\npercentile(a,75,\"higher\");\n// output\n43\n\npercentile(a,5,\"midpoint\");\n// output\n6.5\n\npercentile(a,5,\"nearest\");\n// output\n6\n```\n\n```\nm=matrix(1 2 5 3 4, 5 4 1 2 3);\nm;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 5  |\n| 2  | 4  |\n| 5  | 1  |\n| 3  | 2  |\n| 4  | 3  |\n\n```\npercentile(m, 75);\n[4,4]\n```\n\n相关函数：[quantile](https://docs.dolphindb.cn/zh/funcs/q/quantile.html)\n"
    },
    "percentileRank": {
        "url": "https://docs.dolphindb.cn/zh/funcs/p/percentileRank.html",
        "signatures": [
            {
                "full": "percentileRank(X, score, [method='excel'])",
                "name": "percentileRank",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "score",
                        "name": "score"
                    },
                    {
                        "full": "[method='excel']",
                        "name": "method",
                        "optional": true,
                        "default": "'excel'"
                    }
                ]
            }
        ],
        "markdown": "### [percentileRank](https://docs.dolphindb.cn/zh/funcs/p/percentileRank.html)\n\n\n\n#### 语法\n\npercentileRank(X, score, \\[method='excel'])\n\n#### 详情\n\n计算一个数值在数值向量中的百分位数（0\\~100）。计算时忽略 NULL 值。\n\n#### 参数\n\n**X** 是一个数值型向量、矩阵或表。若为矩阵，每列计算百分位，输出一个向量。若为表，每列计算百分位，输出一个表。\n\n**score** 是一个数值型标量，表示需要得到其排位的值。\n\n**method** 是一个字符串，表示计算百分位的方法，包含以下取值，默认值为 \"excel\"：\n\n* \"excel\"：小于 *score* 的元素个数占不等于 *score* 的元素个数的百分比；若 *score* 不在 *X* 中，其百分位计算公式为：\n\n![](https://docs.dolphindb.cn/zh/images/pscore.png)\n\n其中，![xi](https://docs.dolphindb.cn/zh/images/xi.png) 和 ![xp1](https://docs.dolphindb.cn/zh/images/xp1.png) 为数据集X中的紧邻score的前、后两个数值， ![pi](https://docs.dolphindb.cn/zh/images/pi.png)和 ![pi1](https://docs.dolphindb.cn/zh/images/pi1.png)分别为![xi](https://docs.dolphindb.cn/zh/images/xi.png) 和![xp1](https://docs.dolphindb.cn/zh/images/xp1.png)的百分位。\n\n* \"rank\"：小于等于 *score* 的元素个数占元素总数的百分比。当有多个值相等的 *score* 时，取它们百分位的平均值；\n\n* \"strict\"：严格小于 *score* 的元素个数占元素总数的百分比；\n\n* \"weak\"：小于等于 *score* 的元素个数占元素总数的百分比；\n\n* \"mean\"：\"strict\" 和 \"weak\" 的平均值。\n\n#### 返回值\n\nDOUBLE 类型标量/向量，或一个包含 DOUBLE 类型结果的表。\n\n#### 例子\n\n```\na = 2 3 4 4 5;\npercentileRank(a, 4);\n// output: 66.666667\npercentileRank(a, 3);\n// output: 25\npercentileRank(a, 4, \"rank\");\n// output: 70\npercentileRank(a,4,\"weak\");\n// output: 80\npercentileRank(a,5,\"strict\");\n// output: 40\npercentileRank(a,5,\"mean\");\n// output: 60\n\npercentileRank(1 5 8, 6, \"excel\")\n// output: 66.666667\n```\n"
    },
    "piecewiseLinFit": {
        "url": "https://docs.dolphindb.cn/zh/funcs/p/piecewiselinfit.html",
        "signatures": [
            {
                "full": "piecewiseLinFit(X, Y, numSegments, [XC], [YC], [bounds], [lapackDriver='gelsd'], [degree=1], [weights], [method='de'], [maxIter], [initialGuess], [seed])",
                "name": "piecewiseLinFit",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "numSegments",
                        "name": "numSegments"
                    },
                    {
                        "full": "[XC]",
                        "name": "XC",
                        "optional": true
                    },
                    {
                        "full": "[YC]",
                        "name": "YC",
                        "optional": true
                    },
                    {
                        "full": "[bounds]",
                        "name": "bounds",
                        "optional": true
                    },
                    {
                        "full": "[lapackDriver='gelsd']",
                        "name": "lapackDriver",
                        "optional": true,
                        "default": "'gelsd'"
                    },
                    {
                        "full": "[degree=1]",
                        "name": "degree",
                        "optional": true,
                        "default": "1"
                    },
                    {
                        "full": "[weights]",
                        "name": "weights",
                        "optional": true
                    },
                    {
                        "full": "[method='de']",
                        "name": "method",
                        "optional": true,
                        "default": "'de'"
                    },
                    {
                        "full": "[maxIter]",
                        "name": "maxIter",
                        "optional": true
                    },
                    {
                        "full": "[initialGuess]",
                        "name": "initialGuess",
                        "optional": true
                    },
                    {
                        "full": "[seed]",
                        "name": "seed",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [piecewiseLinFit](https://docs.dolphindb.cn/zh/funcs/p/piecewiselinfit.html)\n\n\n\n#### 语法\n\npiecewiseLinFit(X, Y, numSegments, \\[XC], \\[YC], \\[bounds], \\[lapackDriver='gelsd'], \\[degree=1], \\[weights], \\[method='de'], \\[maxIter], \\[initialGuess], \\[seed])\n\n#### 详情\n\n通过给定数据点集和给定线段数，拟合一个连续的分段线性回归函数；并使用差分进化算法通过最小化平方误差之和，找到给定数量的线段断点的最优位置。\n\n注意：由于差分进化算法的随机性，本函数每次运行结果会略有区别。\n\n#### 参数\n\n**X** 数值向量，表示数据点的 x 坐标值。仅在 *method*='de' 时生效。注意：不可传入 NULL 值。\n\n**Y** 数值向量，表示数据点的 y 坐标值。仅在 *method*='de' 时生效。注意：不可传入 NULL 值。\n\n**numSegments** 正整数，表示用于拟合的线段数量。\n\n**XC** 可选参数，数值向量，表示分段线性函数将被强制通过的数据点的 x 位置。\n\n**YC** 可选参数，数值向量，表示分段线性函数将被强制通过的数据点的 y 位置。\n\n**bounds** 可选参数，数值矩阵，表示在优化中每个断点位置的边界。形状为(numSegments - 1, 2)，每一行为对应断点的边界。\n\n**lapackDriver** 可选参数，字符串标量，表示使用具体的某个 LAPACK 程序来求解最小二乘问题。可选值为'gelsd', 'gelsy' 和 'gelss'。\n\n**degree** 可选参数，非负整数标量，表示要使用的多项式的阶数。degree=1 表示使用线性模型；degree=0 表示使用常数模型。\n\n**weights**可选参数，数值向量，表示加权最小二乘法中的权重。单个权重通常是每个数据点标准偏差的倒数，即 *weights\\[i]* 为第 i 个数据点标准差的倒数。注意：不可传入 NULL 值。\n\n**method** 可选参数，字符串标量，表示在拟合过程中使用的最优化算法。可选值为：\n\n* “nm“：表示使用 Nelder-Mead 单纯形算法。\n\n* “bfgs“：表示使用 bfgs 算法。\n\n* “lbfgs“ ：表示使用 lbfgs 算法。\n\n* 'slsqp'：表示顺序最小二乘编程方法（SLSQP）算法。\n\n* 'de'：表示差分进化(Differential Evolution)算法，默认值。\n\n**maxIter** 可选参数，整型标量或向量，表示拟合过程中优化算法的最大迭代次数。\n\n**initialGuess** 可选参数，数值向量，表示分段断点位置的初始猜测，长度为 *numSegments* - 1。\n\n**seed** 可选参数，整数标量，表示差分进化算法中使用的随机数种子，仅在 *method*='de' 或 *initialGuess* 为空时生效。若 *method*='de' 或 *initialGuess* 为空，且不指定 *seed*，则采用非确定性的随机数生成器。*seed* 参数用于确保结果的可复现性。\n\n#### 返回值\n\n返回一个字典，字典有以下成员：\n\n* breaks：浮点数向量，表示模型拟合后得到的线段断点位置。\n\n* beta：浮点数向量，表示模型拟合后的参数值。\n\n* xData：浮点数向量，表示输入的数据点的 x 坐标值。\n\n* yData：浮点数向量，表示输入的数据点的 y 坐标值。\n\n* XC：浮点数向量，表示分段线性函数将被强制通过的数据点的 x 位置。\n\n* YC：浮点数向量，表示分段线性函数将被强制通过的数据点的 y 位置。\n\n* weights：浮点数向量，表示加权最小二乘法中的权重。\n\n* degree：整数标量，表示要使用的多项式的阶数。\n\n* lapackDriver：字符串标量，表示使用的具体 LAPACK 程序来求解最小二乘问题。\n\n* numParameters：整数标量，表示模型的参数数量。\n\n* predict：模型的预测函数。其使用方法为 `model.predict(X, [beta], [breaks])`，详情见 [pwlfPredict](https://docs.dolphindb.cn/zh/funcs/p/pwlfpredict.html)。\n\n* modelName：表示模型类型，值为字符串”Piecewise Linear Regression”。\n\n#### 例子\n\n本例自定义条件，传入参数 *X*, *Y*, *numSegments*，拟合一个连续的分段线性回归函数，并找到 3 个线段断点的最优位置。\n\n```\ndef linspace(start, end, num, endpoint=true){\n\tif(endpoint) return end$DOUBLE\\(num-1), start + end$DOUBLE\\(num-1)*0..(num-1)\n\telse return start + end$DOUBLE\\(num-1)*0..(num-1)\t\n}\nX = linspace(0.0, 1.0, 10)[1]\nY = [0.41703981, 0.80028691, 0.12593987, 0.58373723, 0.77572962, 0.41156172, 0.72300284, 0.32559528, 0.21812564, 0.41776427]\nmodel = piecewiseLinFit(X, Y, 3)\nmodel;\n\n/* Output:\nbreaks->[0.0,0.258454644769,0.366954310101,1.000000000000]\nnumParameters->4\ndegree->1\nxData->[0.0,0.111111111111,0.222222222222,0.333333333333,0.444444444444,0.555555555555,0.666666666666,0.777777777777,0.888888888888,1.000000000000]\npredict->pwlfPredict\nyData->[0.417039810000,0.800286910000,0.125939870000,0.583737230000,0.775729620000,0.411561720000,0.723002840000,0.325595280000,0.218125640000,0.417764270000]\nyC->\nxC->\nweights->\nbeta->[0.593305500750,-1.309949743583,5.703647584013,-5.105351630664]\nlapackDriver->gelsd\n*/\n```\n\n承接上例，`piecewiseLinFit` 也可结合函数 `pwlfPredict` 使用。如下自定义参数，使用拟合后的连续分段线性回归模型来对输入的数据点进行预测。\n\n```\nxHat = linspace(0.0, 1.0, 20)[1]\nmodel.predict(xHat)\n\n/* Output:\n[0.593305499919518 0.524360777381737 0.455416054843957 0.386471332306177 0.317526609768396 0.368043438179296 0.529813781212159 0.691584124245021 0.69295837868457  0.655502915538459 0.618047452392347 0.580591989246236 0.543136526100125 0.505681062954014 0.468225599807903 0.430770136661792 0.393314673515681 0.35585921036957  0.318403747223459 0.280948284077348]\n*/\n```\n\n相关函数：[pwlfPredict](https://docs.dolphindb.cn/zh/funcs/p/pwlfpredict.html)\n"
    },
    "pinverse": {
        "url": "https://docs.dolphindb.cn/zh/funcs/p/pinverse.html",
        "signatures": [
            {
                "full": "pinverse(X)",
                "name": "pinverse",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [pinverse](https://docs.dolphindb.cn/zh/funcs/p/pinverse.html)\n\n#### 语法\n\npinverse(X)\n\n别名：pinv\n\n#### 详情\n\n计算矩阵 *X* 的伪逆矩阵。\n\n#### 参数\n\n`X` 是一个矩阵。\n\n#### 返回值\n\nDOUBLE 类型矩阵。\n\n#### 例子\n\n```\nx=1..42:2;\nx.pinverse()\n```\n\n<table id=\"table_wgt_2sz_x1c\"><thead><tr><th>\n\ncol1\n\n</th><th>\n\ncol2\n\n</th></tr></thead><tbody><tr><td>\n\n-2\n\n</td><td>\n\n1.5\n\n</td></tr><tr><td>\n\n1\n\n</td><td>\n\n-0.5\n\n</td></tr></tbody>\n</table>```\ny=1..82:4\ny.pinverse(); \n```\n\n<table id=\"table_hjm_hsz_x1c\"><thead><tr><th>\n\ncol1\n\n</th><th>\n\ncol2\n\n</th></tr></thead><tbody><tr><td>\n\n-1\n\n</td><td>\n\n0.85\n\n</td></tr><tr><td>\n\n-0.5\n\n</td><td>\n\n0.45\n\n</td></tr><tr><td>\n\n0\n\n</td><td>\n\n0.05\n\n</td></tr><tr><td>\n\n0.5\n\n</td><td>\n\n-0.35\n\n</td></tr></tbody>\n</table>```\ns1 = indexedSeries(2012.01.01..2012.01.04, [10, 20, 30, 40])\npinv(s1)\n```\n\n<table id=\"table_alv_jsz_x1c\"><thead><tr><th>\n\ncol1\n\n</th><th>\n\ncol2\n\n</th><th>\n\ncol3\n\n</th><th>\n\ncol4\n\n</th></tr></thead><tbody><tr><td>\n\n0.0033\n\n</td><td>\n\n0.0067\n\n</td><td>\n\n0.01\n\n</td><td>\n\n0.0133\n\n</td></tr></tbody>\n</table>```\nm=matrix(1..10, 11..20)\nm.rename!(2020.01.01..2020.01.10, `A`B);\nm.setIndexedMatrix!()\npinv(m)\n```\n\n<table id=\"table_hh5_lsz_x1c\"><thead><tr><th>\n\ncol1\n\n</th><th>\n\ncol2\n\n</th><th>\n\ncol3\n\n</th><th>\n\ncol4\n\n</th><th>\n\ncol5\n\n</th><th>\n\ncol6\n\n</th><th>\n\ncol7\n\n</th><th>\n\ncol8\n\n</th><th>\n\ncol9\n\n</th><th>\n\ncol10\n\n</th></tr></thead><tbody><tr><td>\n\n-0.0945\n\n</td><td>\n\n-0.0758\n\n</td><td>\n\n-0.057\n\n</td><td>\n\n-0.0382\n\n</td><td>\n\n-0.0194\n\n</td><td>\n\n-0.0006\n\n</td><td>\n\n0.0182\n\n</td><td>\n\n0.037\n\n</td><td>\n\n0.0558\n\n</td><td>\n\n0.0745\n\n</td></tr><tr><td>\n\n0.04\n\n</td><td>\n\n0.0333\n\n</td><td>\n\n0.0267\n\n</td><td>\n\n0.02\n\n</td><td>\n\n0.0133\n\n</td><td>\n\n0.0067\n\n</td><td>\n\n0\n\n</td><td>\n\n-0.0067\n\n</td><td>\n\n-0.0133\n\n</td><td>\n\n-0.02\n\n</td></tr></tbody>\n</table>当矩阵非满秩时，使用计算逆矩阵（inverse）会报错，此时可以计算伪逆矩阵（pinverse ）。\n\n```\nx=1 2 3 1 2 3$2:3\ninverse(x) //报错 The argument of 'inverse' must be a square matrix.\npinverse(x)\n```\n\n| col1    | col2    |\n| ------- | ------- |\n| -0.1067 | 0.2267  |\n| 0.4133  | -0.2533 |\n| -0.0667 | 0.2667  |\n\n相关函数：[inverse](https://docs.dolphindb.cn/zh/funcs/i/inverse.html)\n\n"
    },
    "pipeline": {
        "url": "https://docs.dolphindb.cn/zh/funcs/p/pipeline.html",
        "signatures": [
            {
                "full": "pipeline(initTasks, followers, [queueDepth=2])",
                "name": "pipeline",
                "parameters": [
                    {
                        "full": "initTasks",
                        "name": "initTasks"
                    },
                    {
                        "full": "followers",
                        "name": "followers"
                    },
                    {
                        "full": "[queueDepth=2]",
                        "name": "queueDepth",
                        "optional": true,
                        "default": "2"
                    }
                ]
            }
        ],
        "markdown": "### [pipeline](https://docs.dolphindb.cn/zh/funcs/p/pipeline.html)\n\n\n\n#### 语法\n\npipeline(initTasks, followers, \\[queueDepth=2])\n\n#### 详情\n\n通过多线程优化符合如下条件的任务：\n\n(1) 可分解为多个子任务。\n\n(2) 每个子任务包含多个步骤。\n\n(3) 第i个子任务的第 k 个步骤必须在第i个子任务的第 k-1 个步骤以及第 i-1 个子任务的第 k 个步骤完成后才能执行。\n\n#### 参数\n\n**initTasks** 是所有任务初始步骤的集合，其中每个任务都是由无参数的函数表示。例如，我们有10个任务，那么 *initTasks* 是一个包含10个无参数函数的元组。\n\n**followers** 是一元函数的集合，每个函数代表初始步骤之后的一个步骤。如果一个任务有 N 个步骤，*followers* 具有N-1个一元函数。*followers* 的输出是下一个 *followers* 的输入。最后一个 *followers* 有可能返回一个对象。任务的初始步骤是在主线程（接受任务的线程）中执行的，剩下的步骤在单独的线程中执行。如果 `pipeline` 函数用于执行 N 个步骤的任务，系统会创建 N-1 个线程并且这些线程会在工作完成后销毁。\n\n**queueDepth** 是队列的最大长度。每个步骤的中间结果保存在队列中，用于下一个步骤。若队列满了，执行会中止，直到下一个步骤使用了队列中的数据。队列的长度越长，下一个步骤的等待时间越短。但是，长的队列会占用更多内存。*queueDepth* 的默认值是2。\n\n#### 返回值\n\n如果最后一个步骤返回一个对象，`pipeline` 函数返回一个元组，否则不返回任何内容。\n\n#### 例子\n\n下例中，需要把分区表 stockData 转换成一个 csv 文件。该表包含了2008年到2018年的数据，超过了系统的可用内存，因此不能把整个表加载到内存后，再转换成 csv 文件。可把任务分为多个子任务，每个子任务包含两个步骤：加载一个月的数据到内存，然后将这些数据存储到 csv 文件中。每个月的数据存储到 csv 文件中时，必须保证该月数据已加载到内存，并且上个月的数据已经存储到 csv 文件中。\n\n```\nv = 2000.01M..2018.12M\ndef loadData(m){\nreturn select * from loadTable(\"dfs://stockDB\", \"stockData\") where TradingTime between datetime(date(m)) : datetime(date(m+1))\n}\n\ndef saveData(tb){\ntb.saveText(\"/hdd/hdd0/data/stockData.csv\",',', true)\n}\n\npipeline(each(partial{loadData}, v),saveData);\n```\n"
    },
    "ploadText": {
        "url": "https://docs.dolphindb.cn/zh/funcs/p/ploadText.html",
        "signatures": [
            {
                "full": "ploadText(filename, [delimiter], [schema], [skipRows=0], [arrayDelimiter], [containHeader], [arrayMarker])",
                "name": "ploadText",
                "parameters": [
                    {
                        "full": "filename",
                        "name": "filename"
                    },
                    {
                        "full": "[delimiter]",
                        "name": "delimiter",
                        "optional": true
                    },
                    {
                        "full": "[schema]",
                        "name": "schema",
                        "optional": true
                    },
                    {
                        "full": "[skipRows=0]",
                        "name": "skipRows",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[arrayDelimiter]",
                        "name": "arrayDelimiter",
                        "optional": true
                    },
                    {
                        "full": "[containHeader]",
                        "name": "containHeader",
                        "optional": true
                    },
                    {
                        "full": "[arrayMarker]",
                        "name": "arrayMarker",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [ploadText](https://docs.dolphindb.cn/zh/funcs/p/ploadText.html)\n\n\n\n#### 语法\n\nploadText(filename, \\[delimiter], \\[schema], \\[skipRows=0], \\[arrayDelimiter], \\[containHeader], \\[arrayMarker])\n\n#### 详情\n\n将数据文件并行加载到内存中。当文件大于 16MB 时，`ploadText` 返回一个顺序分区的内存表；否则返回一个普通内存表。\n\n**Note:**\n\n* `ploadText` 返回的分区表数据均匀分配到各个分区，且每个分区中的数据量介于8MB与16MB之间。\n\n* 与 [loadText](https://docs.dolphindb.cn/zh/funcs/l/loadText.html) 函数相比，进行并行加载时，`ploadText` 速度更快。\n\n* * 从 2.00.10 版本开始，`loadText` 支持加载一条记录中包含多个换行符的数据文件。\n\n#### 参数\n\n参数与 [loadText](https://docs.dolphindb.cn/zh/funcs/l/loadText.html) 相同。\n\n#### 返回值\n\n一个内存表。\n\n#### 例子\n\n```\nn=1000000\ntimestamp=09:30:00+rand(18000,n)\nID=rand(100,n)\nqty=100*(1+rand(100,n))\nprice=5.0+rand(100.0,n)\nt1 = table(timestamp,ID,qty,price)\nsaveText(t1, \"C:/DolphinDB/Data/t1.txt\");\n\ntimer tt1=loadText(\"C:/DolphinDB/Data/t1.txt\");\n// output\nTime elapsed: 437.236 ms\n\ntimer tt2=ploadText(\"C:/DolphinDB/Data/t1.txt\");\n// output\nTime elapsed: 241.126 ms\n\ntypestr(tt2);\n// output\nSEGMENTED IN-MEMORY TABLE\n```\n\n更多例子请参考 [loadText](https://docs.dolphindb.cn/zh/funcs/l/loadText.html)。\n"
    },
    "plot": {
        "url": "https://docs.dolphindb.cn/zh/funcs/p/plot.html",
        "signatures": [
            {
                "full": "plot(data, [labels], [title], [chartType=LINE], [stacking=false], [extras])",
                "name": "plot",
                "parameters": [
                    {
                        "full": "data",
                        "name": "data"
                    },
                    {
                        "full": "[labels]",
                        "name": "labels",
                        "optional": true
                    },
                    {
                        "full": "[title]",
                        "name": "title",
                        "optional": true
                    },
                    {
                        "full": "[chartType=LINE]",
                        "name": "chartType",
                        "optional": true,
                        "default": "LINE"
                    },
                    {
                        "full": "[stacking=false]",
                        "name": "stacking",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[extras]",
                        "name": "extras",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [plot](https://docs.dolphindb.cn/zh/funcs/p/plot.html)\n\n\n\n#### 语法\n\nplot(data, \\[labels], \\[title], \\[chartType=LINE], \\[stacking=false], \\[extras])\n\n#### 详情\n\n生成图表对象的系统函数。当我们在 IDE 中使用绘图功能时，GUI 将生成图表对象。\n\n#### 参数\n\n**data** 可以是向量，元组，矩阵或表。\n\n如果输入数据是一个向量，它会产生一个单一的系列图，而向量名称就是系列名称。\n\n如果输入数据是元组，则元组的每个元素被视为一个系列。元组的元素必须都是相同长度的向量。向量的名称是系列名称。\n\n如果输入数据是一个矩阵，则矩阵的每一列都是一个系列，矩阵的列标签是系列名称。如果矩阵具有行标签，则它们将被用作数据点标签。\n\n如果输入数据是一个表，那么表的每一列都是一个系列，列名是系列名。\n\n**labels** 是每个数据点的标签。所有系列的图表共享相同的数据标签。如果输入是矩阵，则可以将矩阵的行标签设置为数据点标签。否则，必须在此指定数据点标签。\n\n**title** 可以是字符串标量或字符串向量。如果标题是标量，则是图表标题; 如果是矢量，矢量的第一个元素是图表标题，第二个是X轴标题，第三个是Y轴标题，第四个是 Z 轴标题。\n\n**chartType** 表示图表类型，默认值是线性图（LINE）。其他类型还有饼图（PIE），柱形图（COLUMN），条形图（BAR），面积图（AREA）和散点图（SCATTER）和 3D 曲面（SURFACE）。\n\n**stacking** 表示图表是否堆叠。当 *chartType* 设置为LINE、BAR 或 AREA 时，该参数才有效。\n\n**extras** 为可选参数，用于扩展 `plot` 函数的属性。*extras* 必须是字典，其 key 必须是字符串类型。\n\n**Note:**\n\n* 目前仅支持 multiYAxes 属性：{multiYAxes: true}。设置为 true 表示支持多个 Y 轴，设置为 false 表示共享一个 Y 轴。若需要使用 extras 添加新的属性名称和类型，请联系我们进行报备。\n\n* *chartType*=LINE 时，必须设置该参数的 multiYAxes 属性。\n\n* chartType=SURFACE 时，*data* 必须为数值型矩阵，矩阵的行列标签将分别作为 X 轴、Y 轴的刻度，不支持设置 *labels*、*stacking* 和 *extras*\n\n#### 返回值\n\n无。\n\n#### 例子\n\nExample 1：表\n\n```\nx=0.1*(1..100)\ny=0.1*(100..1)\nt=table(x,y)\nplot(t,extras={multiYAxes: true})\n```\n\n![](https://docs.dolphindb.cn/zh/images/plot01.png)\n\n上面的图也可以用 `plot(t[`x`y],extras={multiYAxes:true})` 生成。\n\nExample 2：矩阵\n\n```\nplot([sin,cos](x),x,\"cos and sin curve\",extras={multiYAxes: false})\n```\n\n![](https://docs.dolphindb.cn/zh/images/plot02.png)\n\n请注意，把函数名作为系列名称，并且指定了数据标志和图的标题。\n\nExample 3：向量\n\n```\nplot(cumsum(x) as cumsumX, 2012.10.01+1..100, \"cumulative sum of x\")\n```\n\n![](https://docs.dolphindb.cn/zh/images/plot03.png)\n\ncumsumX 被用作系列名称。\n\nExample 4：元组\n\n```\nplot([1..10 as x, 10..1 as y], 1..10, extras={multiYAxes: false})\n```\n\n![](https://docs.dolphindb.cn/zh/images/plot04.png)\n\nx 和 y 被用作系列名称。\n\nExample 5：条形图\n\n```\nplot(1..5 as value, `IBM`MSFT`GOOG`XOM`C, `rank, BAR)\n```\n\n![](https://docs.dolphindb.cn/zh/images/plot05.png)\n\nExample 6：柱形图\n\n```\nplot(99 128 196 210 312 as sales, `IBM`MSFT`GOOG`XOM`C, `sales, COLUMN)\n```\n\n![](https://docs.dolphindb.cn/zh/images/plot06.png)\n\nExample 7：饼状图\n\n```\nplot(99 128 196 210 312 as sales, `IBM`MSFT`GOOG`XOM`C, `sales, PIE)\n```\n\n![](https://docs.dolphindb.cn/zh/images/plot07.png)\n\nExample 8：散点图\n\n```\nx=rand(1.0, 1000);\ny=x+norm(0.0, 0.2, 1000);\nplot(x, y, ,SCATTER)\n```\n\n![](https://docs.dolphindb.cn/zh/images/plot08.png)\n\nExample 9：设置 {multiYAxes : true}, y1, y2 和 y3 分别对应不同的Y轴\n\n```\nt = table(1 2 3 4 5 as y1, 1200 1300 1400 1500 1600 as y2, 100 300 500 800 900 as y3, 10 20 30 40 50 as date)\nplot([t.y1, t.y2,t.y3], t.date, , LINE, ,  {multiYAxes : true})\n```\n\n![](https://docs.dolphindb.cn/zh/images/plot09.png)\n\nExample 10: 绘制一个 3D 曲面，X、Y、Z 轴分别命名为 “a”，“b”，“c”\n\n```\nm = matrix(\n    [27.80985,49.61936,83.08067,116.6632,130.414,150.7206,220.1871,156.1536,148.6416,203.7845,206.0386,107.1618,68.36975,45.3359,49.96142,21.89279,17.02552,11.74317,14.75226,13.6671,5.677561,3.31234,1.156517,-0.147662],\n    [27.71966,48.55022,65.21374,95.27666,116.9964,133.9056,152.3412,151.934,160.1139,179.5327,147.6184,170.3943,121.8194,52.58537,33.08871,38.40972,44.24843,69.5786,4.019351,3.050024,3.039719,2.996142,2.967954,1.999594],\n    [30.4267,33.47752,44.80953,62.47495,77.43523,104.2153,102.7393,137.0004,186.0706,219.3173,181.7615,120.9154,143.1835,82.40501,48.47132,74.71461,60.0909,7.073525,6.089851,6.53745,6.666096,7.306965,5.73684,3.625628],\n    [16.66549,30.1086,39.96952,44.12225,59.57512,77.56929,106.8925,166.5539,175.2381,185.2815,154.5056,83.0433,62.61732,62.33167,60.55916,55.92124,15.17284,8.248324,36.68087,61.93413,20.26867,68.58819,46.49812,0.2360095],\n    [8.815617,18.3516,8.658275,27.5859,48.62691,60.18013,91.3286,145.7109,116.0653,106.2662,68.69447,53.10596,37.92797,47.95942,47.42691,69.20731,44.95468,29.17197,17.91674,16.25515,14.65559,17.26048,31.22245,46.71704],\n    [6.628881,10.41339,24.81939,26.08952,30.1605,52.30802,64.71007,76.30823,84.63686,99.4324,62.52132,46.81647,55.76606,82.4099,140.2647,81.26501,56.45756,30.42164,17.28782,8.302431,2.981626,2.698536,5.886086,5.268358],\n    [21.83975,6.63927,18.97085,32.89204,43.15014,62.86014,104.6657,130.2294,114.8494,106.9873,61.89647,55.55682,86.80986,89.27802,122.4221,123.9698,109.0952,98.41956,77.61374,32.49031,14.67344,7.370775,0.03711011,0.6423392],\n    [53.34303,26.79797,6.63927,10.88787,17.2044,56.18116,79.70141,90.8453,98.27675,80.87243,74.7931,75.54661,73.4373,74.11694,68.1749,46.24076,39.93857,31.21653,36.88335,40.02525,117.4297,12.70328,1.729771,0.0],\n    [25.66785,63.05717,22.1414,17.074,41.74483,60.27227,81.42432,114.444,102.3234,101.7878,111.031,119.2309,114.0777,110.5296,59.19355,42.47175,14.63598,6.944074,6.944075,27.74936,0.0,0.0,0.09449376,0.07732264],\n    [12.827,69.20554,46.76293,13.96517,33.88744,61.82613,84.74799,121.122,145.2741,153.1797,204.786,227.9242,236.3038,228.3655,79.34425,25.93483,6.944074,6.944074,6.944075,7.553681,0.0,0.0,0.0,0.0],\n    [0.0,68.66396,59.0435,33.35762,47.45282,57.8355,78.91689,107.8275,168.0053,130.9597,212.5541,165.8122,210.2429,181.1713,189.7617,137.3378,84.65395,8.677168,6.956576,8.468093,0.0,0.0,0.0,0.0],\n    [0.0,95.17499,80.03818,59.89862,39.58476,50.28058,63.81641,80.61302,66.37824,198.7651,244.3467,294.2474,264.3517,176.4082,60.21857,77.41475,53.16981,56.16393,6.949235,7.531059,3.780177,0.0,0.0,0.0],\n    [0.0,134.9879,130.3696,96.86325,75.70494,58.86466,57.20374,55.18837,78.128,108.5582,154.3774,319.1686,372.8826,275.4655,130.2632,54.93822,25.49719,8.047439,8.084393,5.115252,5.678269,0.0,0.0,0.0],\n    [0.0,48.08919,142.5558,140.3777,154.7261,87.9361,58.11092,52.83869,67.14822,83.66798,118.9242,150.0681,272.9709,341.1366,238.664,190.2,116.8943,91.48672,14.0157,42.29277,5.115252,0.0,0.0,0.0],\n    [0.0,54.1941,146.3839,99.48143,96.19411,102.9473,76.14089,57.7844,47.0402,64.36799,84.23767,162.7181,121.3275,213.1646,328.482,285.4489,283.8319,212.815,164.549,92.29631,7.244015,1.167,0.0,0.0],\n    [0.0,6.919659,195.1709,132.5253,135.2341,89.85069,89.45549,60.29967,50.33806,39.17583,59.06854,74.52159,84.93402,187.1219,123.9673,103.7027,128.986,165.1283,249.7054,95.39966,10.00284,2.39255,0.0,0.0],\n    [0.0,21.73871,123.1339,176.7414,158.2698,137.235,105.3089,86.63255,53.11591,29.03865,30.40539,39.04902,49.23405,63.27853,111.4215,101.1956,40.00962,59.84565,74.51253,17.06316,2.435141,2.287471,-0.0003636982,0.0],\n    [0.0,0.0,62.04672,136.3122,201.7952,168.1343,95.2046,58.90624,46.94091,49.27053,37.10416,17.97011,30.93697,33.39257,44.03077,55.64542,78.22423,14.42782,9.954997,7.768213,13.0254,21.73166,2.156372,0.5317867],\n    [0.0,0.0,79.62993,139.6978,173.167,192.8718,196.3499,144.6611,106.5424,57.16653,41.16107,32.12764,13.8566,10.91772,12.07177,22.38254,24.72105,6.803666,4.200841,16.46857,15.70744,33.96221,7.575688,-0.04880907],\n    [0.0,0.0,33.2664,57.53643,167.2241,196.4833,194.7966,182.1884,119.6961,73.02113,48.36549,33.74652,26.2379,16.3578,6.811293,6.63927,6.639271,8.468093,6.194273,3.591233,3.81486,8.600739,5.21889,0.0],\n    [0.0,0.0,29.77937,54.97282,144.7995,207.4904,165.3432,171.4047,174.9216,100.2733,61.46441,50.19171,26.08209,17.18218,8.468093,6.63927,6.334467,6.334467,5.666687,4.272203,0.0,0.0,0.0,0.0],\n    [0.0,0.0,31.409,132.7418,185.5796,121.8299,185.3841,160.6566,116.1478,118.1078,141.7946,65.56351,48.84066,23.13864,18.12932,10.28531,6.029663,6.044627,5.694764,3.739085,3.896037,0.0,0.0,0.0],\n    [0.0,0.0,19.58994,42.30355,96.26777,187.1207,179.6626,221.3898,154.2617,142.1604,148.5737,67.17937,40.69044,39.74512,26.10166,14.48469,8.65873,3.896037,3.571392,3.896037,3.896037,3.896037,1.077756,0.0],\n    [0.001229679,3.008948,5.909858,33.50574,104.3341,152.2165,198.1988,191.841,228.7349,168.1041,144.2759,110.7436,57.65214,42.63504,27.91891,15.41052,8.056102,3.90283,3.879774,3.936718,3.968634,0.1236256,3.985531,-0.1835741],\n    [0.0,5.626141,7.676256,63.16226,45.99762,79.56688,227.311,203.9287,172.5618,177.1462,140.4554,123.9905,110.346,65.12319,34.31887,24.5278,9.561069,3.334991,5.590495,5.487353,5.909499,5.868994,5.833817,3.568177]\n)\nm.rename!(2026.01.01+1..25)\n\nplot(data=m,title=[\"surface\",\"a\",\"b\",\"c\"],chartType = SURFACE)\n```\n\n![](https://docs.dolphindb.cn/zh/images/plot10.png)\n"
    },
    "plotHist": {
        "url": "https://docs.dolphindb.cn/zh/funcs/p/plotHist.html",
        "signatures": [
            {
                "full": "plotHist(data, [binNum], [range], [title])",
                "name": "plotHist",
                "parameters": [
                    {
                        "full": "data",
                        "name": "data"
                    },
                    {
                        "full": "[binNum]",
                        "name": "binNum",
                        "optional": true
                    },
                    {
                        "full": "[range]",
                        "name": "range",
                        "optional": true
                    },
                    {
                        "full": "[title]",
                        "name": "title",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [plotHist](https://docs.dolphindb.cn/zh/funcs/p/plotHist.html)\n\n\n\n#### 语法\n\nplotHist(data, \\[binNum], \\[range], \\[title])\n\n#### 详情\n\n生成柱状图图表对象的系统函数。\n\n#### 参数\n\n**data** 可以是向量，矩阵或表列。\n\n**binNum** 是柱状图显示的柱数。\n\n**range** 是表示柱状图的数据范围的数据对。\n\n**title** 是图表的标题。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\nx=norm(0.0, 1.0, 10000);\nplotHist(x, 10)\n```\n\n![plothist1](https://docs.dolphindb.cn/zh/images/plotHist01.png)\n\n```\nplotHist(x, 10, -2:2)\n```\n\n![plothist2](https://docs.dolphindb.cn/zh/images/plotHist02.png)\n"
    },
    "pnodeRun": {
        "url": "https://docs.dolphindb.cn/zh/funcs/p/pnodeRun.html",
        "signatures": [
            {
                "full": "pnodeRun(function, [nodes], [addNodeAlias=true])",
                "name": "pnodeRun",
                "parameters": [
                    {
                        "full": "function",
                        "name": "function"
                    },
                    {
                        "full": "[nodes]",
                        "name": "nodes",
                        "optional": true
                    },
                    {
                        "full": "[addNodeAlias=true]",
                        "name": "addNodeAlias",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [pnodeRun](https://docs.dolphindb.cn/zh/funcs/p/pnodeRun.html)\n\n\n\n#### 语法\n\npnodeRun(function, \\[nodes], \\[addNodeAlias=true])\n\n#### 详情\n\n在集群指定节点或所有数据节点/计算节点上并行调用本地函数，然后合并结果。\n\n* 当指定 *nodes* 参数时，在指定的节点上调用本地函数。\n\n* 当未指定*nodes* 参数时：若在指定了计算组的计算节点上执行该函数时，仅会在同组内的所有计算节点上调用本地函数；否则，在集群中所有的数据节点、未指定计算组的计算节点上调用本地函数。\n\n#### 参数\n\n**function** 调用的本地函数（不能使用引号）。它可以是一个没有定义参数的函数，或者是没有参数的封装了初始函数和参数的部分应用。它可以是内置函数或用户自定义函数。\n\n**nodes** 可选参数，字符串标量或向量，表示节点的别名。\n\n**addNodeAlias** 是否在结果中加入节点的别名，默认值是 true。如果返回的结果已经包含节点的别名，可设置为false。\n\n#### 返回值\n\n* 若被调用函数返回标量、字典、表， 返回一个表。\n\n* 若被调用函数返回向量， 返回一个矩阵。\n\n* 若被调用函数返回字典， 返回一个表。\n\n* 若被调用函数为命令（无返回值）， 返回空值。\n\n* 其他情况，返回一个字典。\n\n#### 例子\n\n例1. 函数 getChunksMeta 不指定参数。\n\n```\npnodeRun(getChunksMeta,,false);\n```\n\n| site      | chunkId                              | path                                                                      | dfsPath              | type | flag | size | version | state | versionList              |\n| --------- | ------------------------------------ | ------------------------------------------------------------------------- | -------------------- | ---- | ---- | ---- | ------- | ----- | ------------------------ |\n| local8848 | bd13090e-7177-01a7-4ac4-840e1b977dcf | D:130DolphinDB\\_Win64\\_Vserverlocal8848storage/CHUNKS/compo/20190605/GOOG | /compo/20190605/GOOG | 1    | 0    | 0    | 1       | 0     | cid : 40,pt2=>40:6729; # |\n| 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; # |\n| local8848 | f8ee72c9-dad3-f49e-430e-5ddb3c61ae18 | D:130DolphinDB\\_Win64\\_Vserverlocal8848storage/CHUNKS/compo/20190604/MSFT | /compo/20190604/MSFT | 1    | 0    | 0    | 1       | 0     | cid : 40,pt2=>40:6664; # |\n| local8848 | 08e26b5a-dfac-799f-4979-0dd3902eae6e | D:130DolphinDB\\_Win64\\_Vserverlocal8848storage/CHUNKS/compo/20190604/GOOG | /compo/20190604/GOOG | 1    | 0    | 0    | 1       | 0     | cid : 40,pt2=>40:6635; # |\n| local8848 | f9e53a3d-af3e-018d-4bfa-a2b4980f3561 | D:130DolphinDB\\_Win64\\_Vserverlocal8848storage/CHUNKS/compo/20190604/AAPL | /compo/20190604/AAPL | 1    | 0    | 0    | 1       | 0     | cid : 40,pt2=>40:6783; # |\n| local8848 | 417e49e9-5c61-cf9e-4b21-4b35f8e57273 | D:130DolphinDB\\_Win64\\_Vserverlocal8848storage/CHUNKS/compo/20190601/MSFT | /compo/20190601/MSFT | 1    | 0    | 0    | 1       | 0     | cid : 40,pt2=>40:6602; # |\n| local8848 | 3ee64942-1d72-bea7-4bc1-f720132d9288 | D:130DolphinDB\\_Win64\\_Vserverlocal8848storage/CHUNKS/compo/20190602/AAPL | /compo/20190602/AAPL | 1    | 0    | 0    | 1       | 0     | cid : 40,pt2=>40:6749; # |\n\n例2. 在下例中，函数 sum 和参数1..10被封装成了部分应用 sum{1..10}。\n\n```\npnodeRun(sum{1..10}, `nodeA`nodeB);\n```\n\n| Node       | Value |\n| ---------- | ----- |\n| DFS\\_NODE2 | 55    |\n| DFS\\_NODE3 | 55    |\n\n例3. `pnodeRun` 对于集群管理非常方便。例如，在一个集群中有4个节点：\"DFS\\_NODE1\", \"DFS\\_NODE2\", \"DFS\\_NODE3\" 和 \"DFS\\_NODE4\"。在每个节点上执行以下脚本：\n\n```\ndef jobDemo(n){\n  s = 0\n  for (x in 1 : n) {\n      s += sum(sin rand(1.0, 100000000)-0.5)\n      print(\"iteration \" + x + \" \" + s)\n  }\n  return s\n};\n\nsubmitJob(\"jobDemo1\",\"job demo\", jobDemo, 10);\nsubmitJob(\"jobDemo2\",\"job demo\", jobDemo, 10);\nsubmitJob(\"jobDemo3\",\"job demo\", jobDemo, 10);\n```\n\n查看集群中每个节点最近完成的两个批处理作业的状态：\n\n```\npnodeRun(getRecentJobs{2});\n```\n\n| Node       | UserID | JobID    | JobDesc  | ReceivedTime            | StartTime               | EndTime                 | ErrorMsg |\n| ---------- | ------ | -------- | -------- | ----------------------- | ----------------------- | ----------------------- | -------- |\n| DFS\\_NODE1 | root   | jobDemo2 | job demo | 2017.11.16T13:04:38.841 | 2017.11.16T13:04:38.841 | 2017.11.16T13:04:51.660 |          |\n| DFS\\_NODE1 | root   | jobDemo3 | job demo | 2017.11.16T13:04:38.841 | 2017.11.16T13:04:38.843 | 2017.11.16T13:04:51.447 |          |\n| DFS\\_NODE2 | root   | jobDemo2 | job demo | 2017.11.16T13:04:56.431 | 2017.11.16T13:04:56.432 | 2017.11.16T13:05:11.992 |          |\n| DFS\\_NODE2 | root   | jobDemo3 | job demo | 2017.11.16T13:04:56.432 | 2017.11.16T13:04:56.434 | 2017.11.16T13:05:11.670 |          |\n| DFS\\_NODE3 | root   | jobDemo2 | job demo | 2017.11.16T13:05:08.418 | 2017.11.16T13:05:08.419 | 2017.11.16T13:05:29.176 |          |\n| DFS\\_NODE3 | root   | jobDemo3 | job demo | 2017.11.16T13:05:08.419 | 2017.11.16T13:05:08.421 | 2017.11.16T13:05:29.435 |          |\n| DFS\\_NODE4 | root   | jobDemo2 | job demo | 2017.11.16T13:05:16.324 | 2017.11.16T13:05:16.325 | 2017.11.16T13:05:34.729 |          |\n| DFS\\_NODE4 | root   | jobDemo3 | job demo | 2017.11.16T13:05:16.325 | 2017.11.16T13:05:16.328 | 2017.11.16T13:05:34.716 |          |\n\n```\npnodeRun(getRecentJobs{2}, `DFS_NODE3`DFS_NODE4);\n```\n\n| Node       | UserID | JobID    | JobDesc  | ReceivedTime            | StartTime               | EndTime                 | ErrorMsg |\n| ---------- | ------ | -------- | -------- | ----------------------- | ----------------------- | ----------------------- | -------- |\n| DFS\\_NODE3 | root   | jobDemo2 | job demo | 2017.11.16T13:05:08.418 | 2017.11.16T13:05:08.419 | 2017.11.16T13:05:29.176 |          |\n| DFS\\_NODE3 | root   | jobDemo3 | job demo | 2017.11.16T13:05:08.419 | 2017.11.16T13:05:08.421 | 2017.11.16T13:05:29.435 |          |\n| DFS\\_NODE4 | root   | jobDemo2 | job demo | 2017.11.16T13:05:16.324 | 2017.11.16T13:05:16.325 | 2017.11.16T13:05:34.729 |          |\n| DFS\\_NODE4 | root   | jobDemo3 | job demo | 2017.11.16T13:05:16.325 | 2017.11.16T13:05:16.328 | 2017.11.16T13:05:34.716 |          |\n\n`pnodeRun` 合并多个节点的结果时遵循以下规则：\n\n(1) 如果 function 返回一个标量：\n\n返回一个表，它具有两列：节点别名和函数结果。\n\n紧接上面的例子：\n\n```\npnodeRun(getJobReturn{`jobDemo1});\n```\n\n| Node       | Value         |\n| ---------- | ------------- |\n| DFS\\_NODE3 | 2,123.5508    |\n| DFS\\_NODE2 | (42,883.5404) |\n| DFS\\_NODE1 | 3,337.4107    |\n| DFS\\_NODE4 | (2,267.3681)  |\n\n(2) 如果 function 返回一个向量：\n\n返回一个矩阵。矩阵中的每一列是函数在节点上返回的结果。矩阵的列标签是节点。\n\n(3) 如果 function 返回键-值形式的字典：\n\n返回一个表，每行代表函数在一个节点上的结果。\n\n(4) 如果 function 返回一个表：\n\n返回一个表，它是多个节点上的表的合并。\n\n(5) 如果 function 是一个命令（该命令不返回任何内容）：\n\n不返回任何内容。\n\n(6) 对于其他情况：\n\n返回一个字典。键是节点别名，值是函数的返回内容。\n"
    },
    "point": {
        "url": "https://docs.dolphindb.cn/zh/funcs/p/point.html",
        "signatures": [
            {
                "full": "point(X, Y)",
                "name": "point",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [point](https://docs.dolphindb.cn/zh/funcs/p/point.html)\n\n\n\n#### 语法\n\npoint(X, Y)\n\n#### 详情\n\n生成一个 POINT 类型的数据，用来存储坐标系中点的位置。\n\nPOINT 类型数据长度为16字节，其中低8位的数据存储于 *X* 中，高8位的数据存储于 *Y* 中。\n\n#### 参数\n\n**X** 和 **Y** 是数值型的标量、数据对、向量或矩阵，支持的数据类型为 INTEGRAL 类（COMPRESSED、INT128 除外）和 FLOATING 类。\n\n#### 返回值\n\nPOINT 类型标量、向量。\n\n#### 例子\n\n```\npoint(117.60972, 24.118418)\n// output:\n(117.60972, 24.118418)\n\npoint(1..5,6..10)\n// output:\n[(1, 6),(2, 7),(3, 8),(4, 9),(5, 10)]\n```\n"
    },
    "poly1d": {
        "url": "https://docs.dolphindb.cn/zh/funcs/p/poly1d.html",
        "signatures": [
            {
                "full": "polyPredict(model, X)",
                "name": "polyPredict",
                "parameters": [
                    {
                        "full": "model",
                        "name": "model"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [poly1d](https://docs.dolphindb.cn/zh/funcs/p/poly1d.html)\n\n是 [polyPredict](https://docs.dolphindb.cn/zh/funcs/p/polyPredict.html)的别名。\n\n\n以下是 `polyPredict` 函数的文档：\n### [polyPredict](https://docs.dolphindb.cn/zh/funcs/p/polyPredict.html)\n\n\n\n#### 语法\n\npolyPredict(model, X)\n\n别名：poly1d\n\n#### 详情\n\n利用给定的多项式系数 *z* 和自变量 *x*，计算因变量的值。\n\n#### 参数\n\n**model** 数值型向量，表示多项式系数，以升幂排列，不能包含空值。\n\n**x** 数值型标量或向量，表示自变量数据点，不能包含空值。\n\n#### 返回值\n\n一个和 *x* 等长的数值型向量。\n\n#### 例子\n\n#### 例子\n\n一个 3 次多项式 `2x^3 + 3x^2 + 4x + 5`，它的系数按升幂排序的向量是\\[5,4,3,2]：\n\n```\nmodel = [5,4,3,2]\nx = [2.0,5.0,3.0,3.0,4.0,5.0]\ny = poly1d(model,x)\ny\n//output: [41,350,98,98,197,350]\n```\n\n使用上述代码中的 model 和 y，通过 `polyFit` 函数可以计算出 3 次多项式的系数（按升幂排序）。\n\n```\npolyFit(x,y,3)\n//output:[5,4,3,2]\n```\n"
    },
    "polyFit": {
        "url": "https://docs.dolphindb.cn/zh/funcs/p/polyfit.html",
        "signatures": [
            {
                "full": "polyFit(X, Y, n, mode)",
                "name": "polyFit",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "n",
                        "name": "n"
                    },
                    {
                        "full": "mode",
                        "name": "mode"
                    }
                ]
            }
        ],
        "markdown": "### [polyFit](https://docs.dolphindb.cn/zh/funcs/p/polyfit.html)\n\n#### 语法\n\npolyFit(X, Y, n, mode)\n\n#### 详情\n\n使用最小二乘法基于给定的数据点 *X* 和 *Y*，计算 n 次多项式的最佳拟合系数。\n\n与 Python 中 `numpy.polyfit` 的区别：二者均进行多项式最小二乘拟合。NumPy 的 `polyfit(x, y, deg, rcond=None, full=False, w=None, cov=False)` 返回按降幂排列的系数，并支持 *rcond*、*full*、*w*、*cov* 等参数，且 *y* 可为二维数组以同时拟合多组数据；DolphinDB 的 `polyFit(X, Y, n, mode)` 要求 *X* 和 *Y* 为等长数值向量且不能包含空值，返回按升幂排列的系数。DolphinDB 可通过 *mode* 控制返回向量或包含预测函数信息的字典。\n\n#### 参数\n\n**X** 数值型向量，表示自变量数据点，不能包含空值。\n\n**Y** 与 *X*等长的数值型向量，表示因变量数据点，不能包含空值。\n\n**n** 非负整型标量，表示拟合多项式的次数。\n\n**mode** 布尔标量，用于控制返回字典或者向量，默认为 0，表示返回向量。\n\n#### 返回值\n\nDOUBLE 类型向量，是按升幂排列的系数。\n\n#### 例子\n\n```\nx = [0.0, 1.0, 2.0, 3.0, 4.0, 5.0]\ny = [0.0, 0.8, 0.9, 0.1, -0.8, -1.0]\nz = polyFit(x, y, 3)\nz\n\n[-0.0397,1.6931,-0.8135,0.087]\n\nz = polyFit(x, y, 3, 1)\n/*output: \nmodelName->polyFit\nz->[-0.039682539682536,1.693121693121692,-0.813492063492063,0.087037037037037]\npredict->polyPredict\n\n```\n\n\n\n**Related information**\n\n[poly1d](https://docs.dolphindb.cn/zh/funcs/p/poly1d.html)\n"
    },
    "polynomial": {
        "url": "https://docs.dolphindb.cn/zh/funcs/p/polynomial.html",
        "signatures": [
            {
                "full": "polynomial(X, coeffs)",
                "name": "polynomial",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "coeffs",
                        "name": "coeffs"
                    }
                ]
            }
        ],
        "markdown": "### [polynomial](https://docs.dolphindb.cn/zh/funcs/p/polynomial.html)\n\n\n\n#### 语法\n\npolynomial(X, coeffs)\n\n#### 详情\n\n对于每个 *X* 中的元素，用多项式系数计算一个值。\n\n#### 参数\n\n**X** 可以是标量或向量。\n\n**coeffs** 是表示多项式系数向量。\n\n#### 返回值\n\n返回一个和 *X* 相同长度的向量。\n\n#### 例子\n\n计算![](https://docs.dolphindb.cn/zh/images/polynomial.png)，*X* 的取值是 1..10。\n\n```\npolynomial(1..10, 1 2 3);\n// output\n[6,17,34,57,86,121,162,209,262,321]\n```\n"
    },
    "polyPredict": {
        "url": "https://docs.dolphindb.cn/zh/funcs/p/polyPredict.html",
        "signatures": [
            {
                "full": "polyPredict(model, X)",
                "name": "polyPredict",
                "parameters": [
                    {
                        "full": "model",
                        "name": "model"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [polyPredict](https://docs.dolphindb.cn/zh/funcs/p/polyPredict.html)\n\n\n\n#### 语法\n\npolyPredict(model, X)\n\n别名：poly1d\n\n#### 详情\n\n利用给定的多项式系数 *z* 和自变量 *x*，计算因变量的值。\n\n#### 参数\n\n**model** 数值型向量，表示多项式系数，以升幂排列，不能包含空值。\n\n**x** 数值型标量或向量，表示自变量数据点，不能包含空值。\n\n#### 返回值\n\n一个和 *x* 等长的数值型向量。\n\n#### 例子\n\n#### 例子\n\n一个 3 次多项式 `2x^3 + 3x^2 + 4x + 5`，它的系数按升幂排序的向量是\\[5,4,3,2]：\n\n```\nmodel = [5,4,3,2]\nx = [2.0,5.0,3.0,3.0,4.0,5.0]\ny = poly1d(model,x)\ny\n//output: [41,350,98,98,197,350]\n```\n\n使用上述代码中的 model 和 y，通过 `polyFit` 函数可以计算出 3 次多项式的系数（按升幂排序）。\n\n```\npolyFit(x,y,3)\n//output:[5,4,3,2]\n```\n"
    },
    "pop!": {
        "url": "https://docs.dolphindb.cn/zh/funcs/p/pop_.html",
        "signatures": [
            {
                "full": "pop!(X)",
                "name": "pop!",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [pop!](https://docs.dolphindb.cn/zh/funcs/p/pop_.html)\n\n\n\n#### 语法\n\npop!(X)\n\n#### 详情\n\n移除 *X* 中的最后一个元素。\n\n#### 参数\n\n**X** 是一个向量。\n\n#### 返回值\n\n一个标量，类型同 *X*，表示被移除的元素。\n\n#### 例子\n\n```\nx = 1 2 3;\npop!(x);\n// output\n3\n\nx;\n// output\n[1,2]\n```\n\n**相关函数：**[drop](https://docs.dolphindb.cn/zh/funcs/d/drop.html)、[removeHead!](https://docs.dolphindb.cn/zh/funcs/r/removeHead_.html)、[removeTail!](https://docs.dolphindb.cn/zh/funcs/r/removeTail_.html)、[remove!](https://docs.dolphindb.cn/zh/funcs/r/remove.html)\n"
    },
    "portfolioPricer": {
        "url": "https://docs.dolphindb.cn/zh/funcs/p/portfolioPricer.html",
        "signatures": [
            {
                "full": "portfolioPricer(instrument, amount, pricingDate, marketData)",
                "name": "portfolioPricer",
                "parameters": [
                    {
                        "full": "instrument",
                        "name": "instrument"
                    },
                    {
                        "full": "amount",
                        "name": "amount"
                    },
                    {
                        "full": "pricingDate",
                        "name": "pricingDate"
                    },
                    {
                        "full": "marketData",
                        "name": "marketData"
                    }
                ]
            }
        ],
        "markdown": "### [portfolioPricer](https://docs.dolphindb.cn/zh/funcs/p/portfolioPricer.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\nportfolioPricer(instrument, amount, pricingDate, marketData)\n\n#### 详情\n\n对一个资产组合进行定价。\n\n#### 参数\n\n**instrument**INSTRUMENT 类型对象，表示需要定价的金融工具。可以是单个合约，也可以是多个合约。\n\n**amount**INT 类型标量或向量，与 *instrument*等长，表示对应的合约数量。\n\n**pricingDate**DATE 类型标量，表示定价日，即计算合约价值所对应的日期。\n\n**marketData**MKTDATA 类型向量/嵌套字典/ 市场数据引擎句柄/用户自定义函数，表示市场数据。\n\n* MKTDATA 类型向量：\n\n  * 若为曲线类市场数据，需指定 curveName 字段。\n\n  * 若为曲面类市场数据，需指定 surfaceName 字段。\n\n* 嵌套字典的结构如下：\n\n  * 第一层：key 为数据类别，可选值：\"Price\", \"Curve\", \"Surface\"。\n\n  * 第二层：key 为定价日期（DATE 类型标量）。\n\n  * 第三层：key 为曲线或曲面名称，value 为对应的 MKTDATA 类型标量。\n\n* 自定义函数：参数为 (kind，date，name)。\n\n#### 返回值\n\nDOUBLE 类型标量。\n\n#### instrument 和 marketData 的匹配规则\n\n目前支持下图分类树中叶节点所示的金融工具类型：\n\n![](https://docs.dolphindb.cn/zh/funcs/images/instrumentPricer.png)\n\n在定价过程中，系统会按照以下优先级确定市场数据：\n\n1. 若 *instrument* 中已显式指定市场数据，则直接使用该数据；\n\n2. 若未指定，则系统根据预定义规则自动匹配合适的市场数据。\n\n以下将对不同类型金融工具的匹配规则进行说明。\n\n##### 债券（Bond）\n\n债券定价需要用到折现曲线。用户可以通过 discountCurve 字段指定折现曲线名称，例如：\n\n```\nbond = {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Bond\",\n    \"bondType\": \"FixedRateBond\",\n    \"instrumentId\": \"1382011.IB\",\n    \"start\": \"2013.01.14\",\n    \"maturity\": \"2028.01.14\",\n    \"issuePrice\": 100.0,\n    \"coupon\": 0.058,\n    \"frequency\": \"Annual\",\n    \"dayCountConvention\": \"ActualActualISDA\",\n    \"currency\": \"CNY\",              //可选字段 \n    \"subType\": \"MTN\",               //可选字段\n    \"creditRating\": \"AAA\",          //可选字段\n    \"discountCurve\": \"CNY_MTN_AAA\"  //可选字段\n}\n```\n\n折现曲线选择规则如下：\n\n* 如果 discountCurve 已指定，则优先使用 discountCurve 的值。\n\n* 如果 discountCurve 未指定：\n\n  * 指定了 currency，subType 和 creditRating，系统会选择名为 currency + \"\\_\" + subType + \"\\_\" + creditRating 的折现曲线。\n  * 指定了 currency，且 subType 为 `TREASURY_BOND`，`CENTRAL_BANK_BILL`，`CDB_BOND`，`EIBC_BOND`，`ADBC_BOND` 之一，则不需要 creditRating，系统会选择名为 currency + \"\\_\" + subType 的折现曲线。\n  * 指定了 currency，且 subType 不为 `TREASURY_BOND`，`CENTRAL_BANK_BILL`，`CDB_BOND`，`EIBC_BOND`，`ADBC_BOND` 之一，同时未指定 creditRating，系统会选择名为 currency + \"\\_TREASURY\\_BOND\" 的折现曲线。\n  * 指定了 currency，且未指定 subType 和 creditRating，系统会选择名为 currency + \"\\_TREASURY\\_BOND\" 的折现曲线。\n  * currency，subType 和 creditRating 均未指定，系统会选择名为 \"CNY\\_TREASURY\\_BOND\" 的折现曲线。\n\n##### 国债期货（BondFutures）\n\n无需指定 discountCurve，函数会使用其标的债券（underlying）的 dicountCurve。\n\n##### 存款（Deposit）\n\n存款定价仅需指定折现曲线 discountCurve：\n\n* 如果 discountCurve 已指定，则使用用户指定的曲线进行定价。\n\n* 如果未指定，则根据币种自动匹配折现曲线，规则如下：\n\n| currency | discountCurve |\n| -------- | ------------- |\n| CNY      | CNY\\_FR\\_007  |\n| USD      | USD\\_SOFR     |\n| EUR      | EUR\\_ESTR     |\n\n##### 利率互换（IrFixedFloatingSwap）\n\n利率互换定价需要传入三条曲线：discountCurve、forwardCurve 和 assetPriceCurve。当前版本仅支持以 FR\\_007 和 SHIBOR\\_3M 作为浮动参考利率的利率互换。\n\n* 如果用户在 *instrument* 中指定了相应曲线，则使用用户指定的曲线进行定价。\n\n* 如果未指定，则根据币种和浮动利率基准自动匹配三条默认曲线，如下表所示：\n\n| currency | iborIndex  | discountCurve | forwardCurve    | assetPriceCurve   |\n| -------- | ---------- | ------------- | --------------- | ----------------- |\n| CNY      | FR\\_007    | CNY\\_FR\\_007  | CNY\\_FR\\_007    | PRICE\\_FR\\_007    |\n| CNY      | SHIBOR\\_3M | CNY\\_FR\\_007  | CNY\\_SHIBOR\\_3M | PRICE\\_SHIBOR\\_3M |\n\n其中 assetPriceCurve 填入的是浮动参考利率的历史数据，用于计算定价日起第一笔现金流的浮动利率。\n\n##### 外汇远期（FxForward）/ 外汇掉期（FxSwap）\n\n这两类线性产品定价需要绑定 domesticCurve 和 foreignCurve，并基于 currencyPair 获取相应的 FxSpot。\n\n* 若用户在 *instrument* 中指定了 domesticCurve 和 foreignCurve，则直接使用用户指定的曲线。\n\n* 若未指定，则系统会根据货币对自动匹配默认曲线，如下表所示：\n\n| currencyPair | domesticCurve | foreignCurve    |\n| ------------ | ------------- | --------------- |\n| USDCNY       | CNY\\_FR\\_007  | USD\\_USDCNY\\_FX |\n| EURCNY       | CNY\\_FR\\_007  | EUR\\_EURCNY\\_FX |\n| EURUSD       | USD\\_SOFR     | EUR\\_EURUSD\\_FX |\n\n其中 foreignCurve 是根据外汇掉期交易，并结合利率平价公式推导得到的外币隐含即期曲线。\n\n##### 外汇欧式期权（FxEuropeanOption）\n\n外汇期权定价除需使用 domesticCurve 与 foreignCurve 外，还依赖 FxSpot 和 FxVolatilitySurface。\n\n这两个市场数据均可根据期权的 underlying（货币对） 自动匹配。\n\n* 若用户在 *instrument* 中明确指定，则优先使用用户提供的 domesticCurve、foreignCurve。\n\n* 若未指定，则系统会根据 `currencyPair` 自动匹配，规则如下：\n\n| currencyPair | fxSpot | domesticCurve | foreignCurve    | volSurf |\n| ------------ | ------ | ------------- | --------------- | ------- |\n| USDCNY       | USDCNY | CNY\\_FR\\_007  | USD\\_USDCNY\\_FX | USDCNY  |\n| EURCNY       | EURCNY | CNY\\_FR\\_007  | EUR\\_EURCNY\\_FX | EURCNY  |\n| EURUSD       | EURUSD | USD\\_SOFR     | EUR\\_EURUSD\\_FX | EURUSD  |\n\n#### 例子\n\n```\n// instrument\n\n//外汇远期\nfxFwd1 = {\n    \"productType\": \"Forward\",\n    \"forwardType\": \"FxForward\",\n    \"expiry\": 2025.10.08,\n    \"delivery\": 2025.10.10,\n    \"currencyPair\": \"USDCNY\",\n    \"direction\": \"Buy\",\n    \"notionalCurrency\": \"USD\",\n    \"notionalAmount\": 1E6,\n    \"strike\": 7.2\n}\n\nfxFwdUsdCny = parseInstrument(fxFwd1)\n\nfxFwd2 = {\n    \"productType\": \"Forward\",\n    \"forwardType\": \"FxForward\",\n    \"expiry\": 2025.10.08,\n    \"delivery\": 2025.10.10,\n    \"currencyPair\": \"EURCNY\",\n    \"direction\": \"Buy\",\n    \"notionalCurrency\": \"EUR\",\n    \"notionalAmount\": 1E6,\n    \"strike\": 8.2\n}\n\nfxFwdEurCny = parseInstrument(fxFwd2)\n\n//外汇掉期\nfxSwap1 = {\n    \"productType\": \"Swap\",\n    \"swapType\": \"FxSwap\",\n    \"currencyPair\": \"USDCNY\",\n    \"direction\": \"Buy\",\n    \"notionalCurrency\": \"USD\",\n    \"notionalAmount\": 1E6,\n    \"nearStrike\": 7.2,\n    \"nearExpiry\": 2025.12.08,\n    \"nearDelivery\": 2025.12.10,\n    \"farStrike\": 7.3,\n    \"farExpiry\": 2026.06.08,\n    \"farDelivery\": 2026.06.10\n}\n\nfxSwapUsdCny = parseInstrument(fxSwap1)\n\nfxSwap2 = {\n    \"productType\": \"Swap\",\n    \"swapType\": \"FxSwap\",\n    \"currencyPair\": \"EURCNY\",\n    \"direction\": \"Buy\",\n    \"notionalCurrency\": \"EUR\",\n    \"notionalAmount\": 1E6,\n    \"nearStrike\": 8.2,\n    \"nearExpiry\": 2025.12.08,\n    \"nearDelivery\": 2025.12.10,\n    \"farStrike\": 8.3,\n    \"farExpiry\": 2026.06.08,\n    \"farDelivery\": 2026.06.10\n}\n\nfxSwapEurCny = parseInstrument(fxSwap2)\n\n//外汇欧式期权\nfxOption1 = {\n    \"productType\": \"Option\",\n    \"optionType\": \"EuropeanOption\",\n    \"assetType\": \"FxEuropeanOption\",\n    \"notionalCurrency\": \"USD\",\n    \"notionalAmount\": 1E6,\n    \"strike\": 7.0,\n    \"maturity\": 2025.12.08,\n    \"payoffType\": \"Call\",\n    \"dayCountConvention\": \"Actual365\",\n    \"underlying\": \"USDCNY\"\n}\n\nfxOptionUsdCny = parseInstrument(fxOption1)\n\nfxOption2 = {\n    \"productType\": \"Option\",\n    \"optionType\": \"EuropeanOption\",\n    \"assetType\": \"FxEuropeanOption\",\n    \"notionalCurrency\": \"EUR\",\n    \"notionalAmount\": 1E6,\n    \"strike\": 8.0,\n    \"maturity\": 2025.12.08,\n    \"payoffType\": \"Call\",\n    \"dayCountConvention\": \"Actual365\",\n    \"underlying\": \"EURCNY\"\n}\n\nfxOptionEurCny= parseInstrument(fxOption2)\n\n//债券\nbond1 = {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Bond\",\n    \"bondType\": \"FixedRateBond\",\n    \"instrumentId\": \"220010.IB\",\n    \"start\": 2020.12.25,\n    \"maturity\": 2031.12.25,\n    \"issuePrice\": 100.0,\n    \"coupon\": 0.0149,\n    \"frequency\": \"Annual\",\n    \"dayCountConvention\": \"ActualActualISDA\",\n    \"discountCurve\": \"CNY_TREASURY_BOND\"\n}\n\nbond = parseInstrument(bond1)\n\n//国债期货\nbondFut1 = {\n    \"productType\": \"Futures\",\n    \"futuresType\": \"BondFutures\",\n    \"instrumentId\": \"T2509\",\n    \"nominal\": 100.0,\n    \"maturity\": \"2025.09.12\",\n    \"settlement\": \"2025.09.16\",\n    \"underlying\": bond1,\n    \"nominalCouponRate\": 0.03\n}\n\nbondFut = parseInstrument(bondFut1)\n\n//存款\ndeposit1 = {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Deposit\",\n    \"start\": 2025.06.15,\n    \"maturity\": 2025.12.15,\n    \"rate\": 0.02,\n    \"dayCountConvention\": \"Actual360\",\n    \"notionalCurrency\":\"CNY\",\n    \"notionalAmount\": 1E6,\n    \"payReceive\": \"Receive\"\n}\n\ndeposit = parseInstrument(deposit1)\n\n//利率互换\nirs1 =  {\n    \"productType\": \"Swap\",\n    \"swapType\": \"IrSwap\",\n    \"irSwapType\": \"IrFixedFloatingSwap\",\n    \"start\": 2025.06.16,\n    \"maturity\": 2028.06.16,\n    \"frequency\": \"Quarterly\",\n    \"fixedRate\": 0.018,\n    \"calendar\": \"CFET\", \n    \"fixedDayCountConvention\": \"Actual365\",\n    \"floatingDayCountConvention\": \"Actual365\",\n    \"payReceive\": \"Pay\",\n    \"iborIndex\": \"FR_007\",\n    \"spread\": 0.0001,\n    \"notionalCurrency\":\"CNY\",\n    \"notionalAmount\": 1E8\n}\n\nirs = parseInstrument(irs1)\n\n\n//mktData\naod = 2025.08.18\n\nfxSpot1 = {\n    \"mktDataType\": \"Price\",\n    \"priceType\": \"FxSpotRate\",\n    \"spotDate\": aod+2 ,\n    \"referenceDate\": aod ,\n    \"value\": 7.1627,\n    \"unit\": \"USDCNY\"\n}\n\nfxSpotUsdCny = parseMktData(fxSpot1)\n\nfxSpot2 = {\n    \"mktDataType\": \"Price\",\n    \"priceType\": \"FxSpotRate\",\n    \"spotDate\": aod+2 ,\n    \"referenceDate\": aod ,\n    \"value\": 8.3768,\n    \"unit\": \"EURCNY\"\n}\n\nfxSpotEurCny = parseMktData(fxSpot2)\n\ncurve1 = {\n    \"mktDataType\": \"Curve\",\n    \"curveType\": \"IrYieldCurve\",\n    \"curveName\": \"CNY_FR_007\",\n    \"referenceDate\": aod,\n    \"currency\": \"CNY\",\n    \"dayCountConvention\": \"ActualActualISDA\",\n    \"compounding\": \"Continuous\",\n    \"interpMethod\": \"Linear\",\n    \"extrapMethod\": \"Flat\",\n    \"dates\":[2025.08.21, 2025.08.27, 2025.09.03, 2025.09.10, 2025.09.22, 2025.10.20, 2025.11.20, \n             2026.02.24,2026.05.20, 2026.08.20, 2027.02.22, 2027.08.20, 2028.08.21],\n    \"values\":[1.4759, 1.5331, 1.5697, 1.5239, 1.4996, 1.5144, 1.5209, \n              1.5539, 1.5461, 1.5316, 1.5376, 1.5435, 1.5699] / 100.0\n}\n\ncurveCnyFr007 = parseMktData(curve1)\n\ncurve2 = {\n    \"mktDataType\": \"Curve\",\n    \"curveType\": \"IrYieldCurve\",\n    \"curveName\": \"USD_USDCNY_FX\",\n    \"referenceDate\": aod ,\n    \"currency\": \"USD\",\n    \"dayCountConvention\": \"ActualActualISDA\",\n    \"compounding\": \"Continuous\",\n    \"interpMethod\": \"Linear\",\n    \"extrapMethod\": \"Flat\",\n    \"dates\":[2025.08.21, 2025.08.27, 2025.09.03, 2025.09.10, 2025.09.22, 2025.10.20, 2025.11.20, \n             2026.02.24,2026.05.20, 2026.08.20, 2027.02.22, 2027.08.20, 2028.08.21],\n    \"values\":[4.3345, 4.3801, 4.3119, 4.3065, 4.2922, 4.2196, 4.1599, \n              4.0443, 4.0244, 3.9698, 3.7740, 3.6289, 3.5003] / 100.0\n}\n\ncurveUsdUsdCnyFx = parseMktData(curve2)\n\ncurve3 = {\n    \"mktDataType\": \"Curve\",\n    \"curveType\": \"IrYieldCurve\",\n    \"curveName\": \"EUR_EURCNY_FX\",\n    \"referenceDate\": aod,\n    \"currency\": \"EUR\",\n    \"dayCountConvention\": \"ActualActualISDA\",\n    \"compounding\": \"Continuous\",\n    \"interpMethod\": \"Linear\",\n    \"extrapMethod\": \"Flat\",\n    \"dates\":[2025.08.21, 2025.08.27, 2025.09.03, 2025.09.10, 2025.09.22, 2025.10.20, 2025.11.20, \n             2026.02.24,2026.05.20, 2026.08.20, 2027.02.22, 2027.08.20, 2028.08.21],\n    \"values\":[1.9165, 1.9672, 1.8576, 1.8709, 1.8867, 1.8749,1.8700,\n              1.8576, 1.9253, 1.9738, 1.9908, 1.9850, 2.0362] / 100.0\n}\n\ncurveEurEurCnyFx = parseMktData(curve3)\n\nsurf1 = {\n\t\"surfaceName\": \"USDCNY\",\n\t\"mktDataType\": \"Surface\",\n\t\"surfaceType\": \"FxVolatilitySurface\",\n\t\"referenceDate\": \"2025.08.18\",\n\t\"smileMethod\": \"Linear\",\n\t\"termDates\": [\n\t\t\"2025.08.21\",\n\t\t\"2026.08.20\"\n\t],\n\t\"volSmiles\":[{\"strikes\": [6.5,7,7.5],\"vols\": [0.1,0.1,0.1]},{\"strikes\": [6.5,7,7.5],\"vols\": [0.1,0.1,0.1]}],\n\t\"currencyPair\": \"USDCNY\"\n}\n\nsurfUsdCny = parseMktData(surf1)\n\n\nsurf2 = {\n\t\"surfaceName\": \"EURCNY\",\n\t\"mktDataType\": \"Surface\",\n\t\"surfaceType\": \"FxVolatilitySurface\",\n\t\"referenceDate\": \"2025.08.18\",\n\t\"smileMethod\": \"Linear\",\n\t\"termDates\": [\n\t\t\"2025.08.21\",\n\t\t\"2026.08.20\"\n\t],\n\t\"volSmiles\":[{\"strikes\": [7.5,8.0,8.5],\"vols\": [0.1,0.1,0.1]},{\"strikes\": [7.5,8.0,8.5],\"vols\": [0.1,0.1,0.1]}],\n\t\"currencyPair\": \"EURCNY\"\n}\n\nsurfEurCny = parseMktData(surf2)\n\nbondCurve =  {\n    \"mktDataType\": \"Curve\",\n    \"curveType\": \"IrYieldCurve\",\n    \"referenceDate\": aod,\n    \"currency\": \"CNY\",\n    \"curveName\": \"CNY_TREASURY_BOND\",\n    \"dayCountConvention\": \"ActualActualISDA\",\n    \"compounding\": \"Compounded\",\n    \"interpMethod\": \"Linear\",\n    \"extrapMethod\": \"Flat\",\n    \"frequency\": \"Annual\",\n    // 0.083 0.25 0.5 1.0 2.0 3.0 5.0 7.0 10.0 15.0 20.0 30.0 40.0 50.0\n    \"dates\":[2025.09.18, 2025.11.18, 2026.02.18, 2026.08.18, 2027.08.18, 2028.08.18, 2030.08.18,\n             2032.08.18, 2035.08.18, 2040.08.18, 2045.08.18, 2055.08.18,2065.08.18, 2075.08.18],\n    \"values\":[1.3000, 1.3700, 1.3898, 1.3865, 1.4299, 1.4471, 1.6401,\n              1.7654, 1.7966, 1.9930, 2.1834, 2.1397, 2.1987, 2.2225] / 100.0\n}\n\ncurveCnyTreasuryBond = parseMktData(bondCurve)\n\nfr007HistCurve = {\n    \"mktDataType\": \"Curve\",\n    \"curveType\": \"AssetPriceCurve\",\n    \"curveName\": \"PRICE_FR_007\",\n    \"referenceDate\": aod,\n    \"currency\": \"CNY\",\n    \"dates\":[2025.05.09, 2025.05.12, 2025.05.13, 2025.05.14, 2025.05.15, 2025.05.16, 2025.05.19, 2025.05.20, 2025.05.21, 2025.05.22,\n             2025.05.23, 2025.05.26, 2025.05.27, 2025.05.28, 2025.05.29, 2025.05.30, 2025.06.03, 2025.06.04, 2025.06.05, 2025.06.06,\n             2025.06.09, 2025.06.10, 2025.06.11, 2025.06.12, 2025.06.13, 2025.06.16, 2025.06.17, 2025.06.18, 2025.06.19, 2025.06.20,\n             2025.06.23, 2025.06.24, 2025.06.25, 2025.06.26, 2025.06.27, 2025.06.30, 2025.07.01, 2025.07.02, 2025.07.03, 2025.07.04,\n             2025.07.07, 2025.07.08, 2025.07.09, 2025.07.10, 2025.07.11, 2025.07.14, 2025.07.15, 2025.07.16, 2025.07.17, 2025.07.18,\n             2025.07.21, 2025.07.22, 2025.07.23, 2025.07.24, 2025.07.25, 2025.07.28, 2025.07.29, 2025.07.30, 2025.07.31, 2025.08.01,\n             2025.08.04, 2025.08.05, 2025.08.06, 2025.08.07, 2025.08.08, 2025.08.11, 2025.08.12, 2025.08.13, 2025.08.14, 2025.08.15\n       ],\n    \"values\":[1.6000, 1.5600, 1.5300, 1.5500, 1.5500, 1.6300, 1.6500, 1.6000, 1.5900, 1.5800, \n              1.6300, 1.7000, 1.7000, 1.7000, 1.7500, 1.7500, 1.5900, 1.5800, 1.5700, 1.5600, \n              1.5500, 1.5500, 1.5600, 1.5900, 1.5900, 1.5700, 1.5500, 1.5600, 1.5679, 1.6000, \n              1.5700, 1.8500, 1.8300, 1.8400, 1.8500, 1.9500, 1.6036, 1.5800, 1.5200, 1.5000, \n              1.5000, 1.5100, 1.5100, 1.5300, 1.5200, 1.5500, 1.6000, 1.5400, 1.5400, 1.5000, \n              1.5000, 1.4800, 1.5000, 1.6000, 1.7500, 1.6400, 1.6200, 1.6300, 1.6000, 1.5000, \n              1.4800, 1.4700, 1.4800, 1.4900, 1.4600, 1.4600, 1.4600, 1.4800, 1.4800, 1.4900  \n               ]\\100\n}\n\npriceCurveFr007 = parseMktData(fr007HistCurve)\n\ninstrument = [fxFwdUsdCny, fxFwdEurCny, fxSwapUsdCny, fxSwapEurCny, \n              fxOptionUsdCny, fxOptionEurCny, bond, bondFut, deposit, irs]\nmktData= [fxSpotUsdCny, fxSpotEurCny, curveCnyFr007, \n          curveUsdUsdCnyFx, curveEurEurCnyFx, surfUsdCny, \n          surfEurCny, curveCnyTreasuryBond, priceCurveFr007]\n\npricingDate = aod\n\namount = [1, 2, 3, 4, 5, 6, -7, -8, 9, 10]\n\n// case1: mktData is a vector\nresults1 = portfolioPricer(instrument, amount, pricingDate, mktData)\nprint(results1)\n\n// case2: mktData is a dict\nspots = dict(string, MKTDATA)\nspots[\"USDCNY\"] = fxSpotUsdCny\nspots[\"EURCNY\"] = fxSpotEurCny\ncurves = dict(string, MKTDATA)\ncurves[\"CNY_FR_007\"] = curveCnyFr007\ncurves[\"USD_USDCNY_FX\"] = curveUsdUsdCnyFx\ncurves[\"EUR_EURCNY_FX\"] = curveEurEurCnyFx\ncurves[\"CNY_TREASURY_BOND\"] = curveCnyTreasuryBond\ncurves[\"PRICE_FR_007\"] = priceCurveFr007\nsurfs = dict(string, MKTDATA)\nsurfs[\"USDCNY\"] = surfUsdCny\nsurfs[\"EURCNY\"] = surfEurCny\ndSpots = dict(DATE, ANY)\ndSpots[aod] = spots\ndCurves = dict(DATE, ANY)\ndCurves[aod] = curves\ndSurfs = dict(DATE, ANY)\ndSurfs[aod] = surfs\nmktData2 = dict(STRING, ANY)\nmktData2 = {\"Price\": dSpots,\n            \"Curve\": dCurves,\n            \"Surface\": dSurfs}\nresults2 = portfolioPricer(instrument, amount, pricingDate, mktData2)\nprint(results2)\n```\n\n使用市场数据引擎进行定价：\n\n```\ntbdata = table(1:0, `eventTime`type`subType`name`term`price, [NANOTIMESTAMP, STRING, STRING, STRING, STRING, DOUBLE])\ninsert into tbdata values(now(), \"Bond\", string(), \"0001\", \"1d\", 3.2415)\ninsert into tbdata values(now(), \"Bond\", string(), \"0002\", \"1d\", 2.1584)\nbond1 = {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Bond\",\n    \"bondType\": \"FixedRateBond\",\n    \"nominal\": 100,\n    \"instrumentId\": \"0001\",\n    \"start\": 2022.05.15,\n    \"maturity\": 2032.05.15,\n    \"dayCountConvention\": \"ActualActualISDA\",\n    \"cashflow\":[],\n    \"coupon\": 0.0276,\n    \"issuePrice\": 100.0,\n    \"frequency\": \"Semiannual\"\n}\nbond2 = {\n    \"productType\": \"Cash\",\n    \"assetType\": \"Bond\",\n    \"bondType\": \"FixedRateBond\",\n    \"nominal\": 100,\n    \"instrumentId\": \"0002\",\n    \"start\": 2023.05.15,\n    \"maturity\": 2033.05.15,\n    \"dayCountConvention\": \"ActualActualISDA\",\n    \"cashflow\":[],\n    \"coupon\": 0.0276,\n    \"issuePrice\": 100.0,\n    \"frequency\": \"Semiannual\"\n}\nbondcurveConfig = {\n\t\"name\":\"CNY_TREASURY_BOND\",\n\t\"type\": \"BondYieldCurve\",\n\t\"bonds\":[parseInstrument(bond1), parseInstrument(bond2)],\n\t\"currency\": \"CNY\",\n\t\"dayCountConvention\": \"ActualActualISDA\",\n\t\"compounding\": \"Compounded\",\n\t\"frequency\": \"Semiannual\",\n\t\"interpMethod\": \"Linear\",\n\t\"extrapMethod\": \"Flat\",\n\t\"method\": \"Bootstrap\"\n}\nengine1 = createMktDataEngine(\"engine1\", 2022.06.10, bondcurveConfig)\nengine1.append!(tbdata)\nsleep(1000)\nins = parseInstrument(bond1)\nresults3 = portfolioPricer([ins], [1], 2022.06.10, engine1)\nprint(results3)\n```\n\n**相关函数：**[instrumentPricer](https://docs.dolphindb.cn/zh/funcs/i/instrumentPricer.html), [createMktDataEngine](https://docs.dolphindb.cn/zh/funcs/c/createMktDataEngine.html)\n"
    },
    "pow": {
        "url": "https://docs.dolphindb.cn/zh/funcs/p/pow.html",
        "signatures": [
            {
                "full": "pow(X, Y)",
                "name": "pow",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [pow](https://docs.dolphindb.cn/zh/funcs/p/pow.html)\n\n#### 语法\n\npow(X, Y)\n\n#### 详情\n\n返回以 *X* 中的元素为底，以 *Y* 中元素为指数计算得到的值。当 *X* 和 *Y* 为整数时，结果仍然是 DOUBLE 类型。\n\n**Note:**\n\n* DolphinDB `pow` 与 Python 内置 [pow](https://docs.python.org/3/library/functions.html#pow)以及 [numpy.power](https://numpy.org/doc/stable/reference/generated/numpy.power.html) 的核心功能相同，区别在于：\n  * Python 内置`pow` 面向 Python 数值对象，并额外支持三参数形式 `pow(base, exp, mod)` 用于高效模幂运算\\*。\\*\n  * `numpy.power` 支持更多参数，如 *out*、*where*、*casting*。\n* [scipy.stats.power](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.power.html) 是用于模拟统计检验功效的函数，与 DolphinDB `pow` 完全不同。\n\n#### 参数\n\n**X** 和 **Y** 可以是标量、向量或矩阵。\n\n#### 返回值\n\nDOUBLE 类型标量、向量或矩阵。\n\n#### 例子\n\n```\nx=1 2 3;\npow(x,3);\n//output:[1,8,27]\n\npow(3,x);\n//output:[3,9,27]\n\ny=4.5 5.5 6.5;\npow(x,y);\n//output:[1,45.254834,1262.665039]\n\npow(y,x);\n//output: [4.5,30.25,274.625]\n```\n\n```\nm=1..10$2:5;\nm;\n```\n\n返回：\n\n| #0 | #1 | #2 | #3 | #4 |\n| -- | -- | -- | -- | -- |\n| 1  | 3  | 5  | 7  | 9  |\n| 2  | 4  | 6  | 8  | 10 |\n\n```\ntypestr(pow(3,4));\n//output: DOUBLE\n```\n\n"
    },
    "power": {
        "url": "https://docs.dolphindb.cn/zh/funcs/p/power.html",
        "signatures": [
            {
                "full": "power(X, Y)",
                "name": "power",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [power](https://docs.dolphindb.cn/zh/funcs/p/power.html)\n\n#### 语法\n\npower(X, Y)\n\n别名：pow\n\n\n\n**Related information**\n\n[pow](https://docs.dolphindb.cn/zh/funcs/p/pow.html)\n"
    },
    "predict": {
        "url": "https://docs.dolphindb.cn/zh/funcs/p/predict.html",
        "signatures": [
            {
                "full": "predict(model, X)",
                "name": "predict",
                "parameters": [
                    {
                        "full": "model",
                        "name": "model"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [predict](https://docs.dolphindb.cn/zh/funcs/p/predict.html)\n\n\n\n#### 语法\n\npredict(model, X)\n\n#### 详情\n\n用特定的模型对数据进行预测。\n\n#### 参数\n\n**model** 是用于预测的模型，一般是字典，由 [randomForestClassifier](https://docs.dolphindb.cn/zh/funcs/r/randomForestClassifier.html), [randomForestRegressor](https://docs.dolphindb.cn/zh/funcs/r/randomForestRegressor.html) 等机器学习函数生成。\n\n**X** 是用于预测的表，表的结构必须和用于训练 *model* 的表相同。\n\n#### 返回值\n\nDOUBLE 类型向量，其长度和 *X* 的行数相同，每个元素对应一行的预测值。\n\n#### 例子\n\n以下例子是将 `randomForestRegressor` 生成的模型用于预测。\n\n```\nx1 = rand(100.0, 100)\nx2 = rand(100.0, 100)\nb0 = 6\nb1 = 1\nb2 = -2\nerr = norm(0, 10, 100)\ny = b0 + b1 * x1 + b2 * x2 + err\nt = table(x1, x2, y)\nmodel = randomForestRegressor(sqlDS(<select * from t>), `y, `x1`x2)\nyhat = predict(model, t);\n// output\n[-93.733842,2.213932,5.39619,-47.817339,-38.655786,-75.772237,-45.817417,43.412841,-87.333214,-51.275368,32.41792,-45.797275,-152.075001,-83.423919,-21.154954,-65.734012,58.088571,-30.00795,-149.71085,-18.699006,-82.023643,-140.455355,-43.629218,65.832865,-79.411508,-65.625276,-17.466925,-43.469005,44.639384,31.686378...]\n\nplot(y, yhat, ,SCATTER);\n```\n\n![predict](https://docs.dolphindb.cn/zh/images/predict01.png)\n"
    },
    "prev": {
        "url": "https://docs.dolphindb.cn/zh/funcs/p/prev.html",
        "signatures": [
            {
                "full": "prev(X)",
                "name": "prev",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [prev](https://docs.dolphindb.cn/zh/funcs/p/prev.html)\n\n\n\n#### 语法\n\nprev(X)\n\n#### 详情\n\n将 *X*向右移动一个位置。类似地：[next](https://docs.dolphindb.cn/zh/funcs/n/next.html) 将 *X*向左移动一个位置；[move](https://docs.dolphindb.cn/zh/funcs/m/move.html) 可以将 *X*向左或向右移动一个位置。\n\n#### 参数\n\n**X** 可以是向量、矩阵或表。\n\n#### 返回值\n\n一个向量、矩阵或表。\n\n#### 例子\n\n```\nx=3 9 5 1 4;\nprev(x);\n// output: [,3,9,5,1]\n```\n\n```\nx = matrix(1 2 3 4 5);\nprev(x)#0\n```\n\n| #0 |\n| -- |\n|    |\n| 1  |\n| 2  |\n| 3  |\n| 4  |\n\n```\nt=table(1 2 3 as a, `x`y`z as b, 10.8 7.6 3.5 as c);\nprev(t)\n```\n\n| a | b | c    |\n| - | - | ---- |\n|   |   |      |\n| 1 | x | 10.8 |\n| 2 | y | 7.6  |\n"
    },
    "prevState": {
        "url": "https://docs.dolphindb.cn/zh/funcs/p/prevState.html",
        "signatures": [
            {
                "full": "prevState(X)",
                "name": "prevState",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [prevState](https://docs.dolphindb.cn/zh/funcs/p/prevState.html)\n\n\n\n#### 语法\n\nprevState(X)\n\n#### 详情\n\n*X* 中连续且相同的元素标记为同一状态，空值无状态。每个元素的状态等于其元素值。对于 *X* 中的每一个元素，返回当前状态的上一个状态。若当前元素为空，则返回上一个邻近状态。\n\n*X* 是矩阵时，则在矩阵每一列进行上述计算。\n\n#### 参数\n\n**X** 时间类型，布尔类型或者数值型的向量/矩阵。\n\n#### 返回值\n\n一个向量或矩阵，数据类型同 *X*。\n\n#### 例子\n\n```\nX = [1, 2.2, NULL, 2.2, 2.3, 1, 1.2]\nprev(X)\n// output\n[,1,2.2,,2.2,2.3,1]\n\nprevState(X)\n// output\n[,1,2.2,2.2,2.2,2.3,1]\n\nX = matrix([1.0, 1.1, 1.0, 0.9], [NULL, 1.3, 2.5, 5.5], [5.5, 4.2, 1.6, 1.8])\nprevState(X)\n```\n\n| #0  | #1  | #2  |\n| --- | --- | --- |\n|     |     |     |\n| 1   |     | 5.5 |\n| 1.1 | 1.3 | 4.2 |\n| 1   | 2.5 | 1.6 |\n\n相关函数： [nextState](https://docs.dolphindb.cn/zh/funcs/n/nextState.html)\n"
    },
    "print": {
        "url": "https://docs.dolphindb.cn/zh/funcs/p/print.html",
        "signatures": [
            {
                "full": "print(X)",
                "name": "print",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [print](https://docs.dolphindb.cn/zh/funcs/p/print.html)\n\n\n\n#### 语法\n\nprint(X)\n\n#### 详情\n\n打印结果和变量的内容。\n\n**Note:**\n\nDolphinDB `print` 与 Python 内置 [print](https://docs.python.org/3/library/functions.html#print) 的核心功能相同，区别在于 DolphinDB `print` 只接收一个 DolphinDB 对象，Python `print` 可接收多个对象，并支持通过 *sep*、*end*、*file* 和 *flush* 参数控制分隔符、行尾、输出位置和缓冲刷新。\n\n#### 参数\n\n**X** 可以是任意数据。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\nx=rand(10000,10);\nprint x;\n// output: [9786,9501,8116,1266,1719,789,8162,3113,2740,6323]\n```\n\n字典的输出格式为“键->值”。键的输出顺序由创建字典时指定的的 *ordered* 参数决定。\n\n```\nx=1 6 3\ny=4.5 7.8 4.3\n// 不指定 ordered 参数，默认为 false，表示无序字典\nz=dict(x,y);\n// 无序字典在输出时不保留输入顺序\nprint(z)\n/* output:\n3->4.3\n6->7.8\n1->4.5\n*/\n\n// 指定 ordered=true，表示有序字典\nz1=dict(x,y,true)\n\n// 有序字典在输出时会保留键值对的输入顺序\nprint(z1)\n/* output:\n1->4.5\n6->7.8\n3->4.3\n*/\n```\n"
    },
    "prod": {
        "url": "https://docs.dolphindb.cn/zh/funcs/p/prod.html",
        "signatures": [
            {
                "full": "prod(X)",
                "name": "prod",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [prod](https://docs.dolphindb.cn/zh/funcs/p/prod.html)\n\n\n\n#### 语法\n\nprod(X)\n\n#### 详情\n\n* 若 *X* 为向量，返回 *X* 中所有元素的乘积。\n\n* 若 *X* 为矩阵，计算每列中所有元素的乘积，返回一个向量。\n\n* 若 *X* 为表，计算每列中所有元素的乘积，返回一个表。\n\n与所有其它聚合函数一致，计算时忽略 NULL 值。\n\nDolphinDB 的 `prod` 函数对矩阵和表固定按列计算乘积；NumPy 默认将数组展平后计算全局乘积，需通过 *axis* 参数指定维度。此外，NumPy 支持指定 *axis* 参数按多轴计算，*initial* 设置初始值。\n\n#### 参数\n\n**X** 可以是标量、向量、矩阵或表。\n\n#### 返回值\n\n数值型标量、向量、矩阵或表。\n\n#### 例子\n\n```\nprod(1 2 NULL 3);\n// output\n6\n```\n\n```\nm=matrix(1 2 3, 4 5 6);\nm;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 4  |\n| 2  | 5  |\n| 3  | 6  |\n\n```\nprod(m);\n// output\n[6,120]\n```\n"
    },
    "publishMCPPrompts": {
        "url": "https://docs.dolphindb.cn/zh/funcs/p/publishMCPPrompts.html",
        "signatures": [
            {
                "full": "publishMCPPrompts([names])",
                "name": "publishMCPPrompts",
                "parameters": [
                    {
                        "full": "[names]",
                        "name": "names",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [publishMCPPrompts](https://docs.dolphindb.cn/zh/funcs/p/publishMCPPrompts.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\npublishMCPPrompts(\\[names])\n\n#### 详情\n\n发布 MCP prompt 模板。\n\n#### 参数\n\n**names** 可选参数，STRING 类型标量或向量，表示 prompt 模板的名称。\n\n#### 返回值\n\nSTRING 类型向量，表示发布成功的 prompt 模板名称。\n\n#### 例子\n\n```\npublishMCPPrompts(\"stock_summary\")\n// output:[\"stock_summary\"]\n```\n"
    },
    "publishMCPTools": {
        "url": "https://docs.dolphindb.cn/zh/funcs/p/publishMCPTools.html",
        "signatures": [
            {
                "full": "publishMCPTools([names])",
                "name": "publishMCPTools",
                "parameters": [
                    {
                        "full": "[names]",
                        "name": "names",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [publishMCPTools](https://docs.dolphindb.cn/zh/funcs/p/publishMCPTools.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\npublishMCPTools(\\[names])\n\n#### 详情\n\n发布 MCP tool 。\n\n#### 参数\n\n**names** 可选参数，STRING 类型标量或向量，表示 tool 的名称。\n\n#### 返回值\n\nSTRING 类型向量，表示发布成功的 tool 名称。\n\n#### 例子\n\n```\npublishMCPTools(\"myTool\")\n```\n"
    },
    "purgeCacheEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/p/purgeCacheEngine.html",
        "signatures": [
            {
                "full": "flushOLAPCache()",
                "name": "flushOLAPCache",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [purgeCacheEngine](https://docs.dolphindb.cn/zh/funcs/p/purgeCacheEngine.html)\n\n是 [flushOLAPCache](https://docs.dolphindb.cn/zh/funcs/f/flushOLAPCache.html) 的别名。\n\n\n以下是 `flushOLAPCache` 函数的文档：\n### [flushOLAPCache](https://docs.dolphindb.cn/zh/funcs/f/flushOLAPCache.html)\n\n\n\n#### 语法\n\nflushOLAPCache()\n\n#### 详情\n\n将 OLAP 引擎缓冲区里已经完成的事务强制写入数据库。请注意，使用该函数前，需配置 *OLAPCacheEngineSize* 和 *dataSync* = 1。\n\n#### 参数\n\n无\n\n#### 返回值\n\n无\n"
    },
    "push!": {
        "url": "https://docs.dolphindb.cn/zh/funcs/p/push_.html",
        "signatures": [
            {
                "full": "append!(obj, newData)",
                "name": "append!",
                "parameters": [
                    {
                        "full": "obj",
                        "name": "obj"
                    },
                    {
                        "full": "newData",
                        "name": "newData"
                    }
                ]
            }
        ],
        "markdown": "### [push!](https://docs.dolphindb.cn/zh/funcs/p/push_.html)\n\n是 [append!](https://docs.dolphindb.cn/zh/funcs/a/append!.html) 的别名。\n\n\n以下是 `append!` 函数的文档：\n### [append!](https://docs.dolphindb.cn/zh/funcs/a/append!.html)\n\n\n\n#### 语法\n\nappend!(obj, newData)\n\n别名：push!\n\n#### 详情\n\n将 *newData* 中的数据追加到 *obj*。在 DolphinDB 中，函数中的感叹号(!)表示直接修改数据本身（就地操作）。\n\n**Note:**\n\n1. 该函数不会检查两表中各列列名与顺序，只要两表中对应位置的列的数据类型一致，即可执行。如果两表中各列顺序有差别，该操作不会自动对齐各列。所以，对数据表进行 `append!` 操作时，请检查两表中各列列名与顺序，以免出错。绝大部分情况下两表中各列列名与顺序应当完全一致。\n2. 请注意：若数据库为分区，且分区列为字符串类型，则追加的分区列数据不能包含空格， “/t”。\n\n#### 参数\n\n**obj** 必须是本地变量：向量、元组、矩阵、表或集合。\n\n**newData** 可以是标量、向量、元组、表或集合。\n\n* 如果 *obj* 是向量，则 *newData* 必须是标量或向量、或元素类型与 *obj* 中元素类型一致的元组。结果是比 *obj* 更长的向量。\n* 如果 *obj* 是元组，则 *newData* 必须是标量、向量或元组。若 *newData* 为向量，则作为整体追加到元组；若 *newData* 为元组，当配置项 *appendTupleAsAWhole*=true 时，作为整体追加，*appendTupleAsAWhole*=false 时，将 *newData* 的每一个元素依次追加。\n* 如果 *obj* 是矩阵，则 *newData* 必须是长度为 *obj* 行数倍数的向量。结果是新的矩阵，行数和 *obj* 相同，具有更多的列数。\n* 如果 *obj* 是表，则 *newData* 必须是一个列数和 *obj* 相同的表。结果是和 *obj* 具有相同列数和列名的表，但行数比 *obj* 多。\n* 如果 *newData* 和 *obj* 的数据类型不同，`append!` 函数会尝试将 *newData* 转换为 *obj* 的数据类型。如果无法转换，将返回一个错误信息。\n\n#### 返回值\n\n数据类型和数据形式与 *obj* 一致。\n\n#### 例子\n\n```\nx = 1 2 3\nx.append!(4)\nx\n// output\n[1,2,3,4]\nappend!(x, 5 6)\nx\n// output\n[1,2,3,4,5,6]\nx.append!(7.2)\nx\n// output\n[1,2,3,4,5,6,7]\n// 7.2 的数据类型从 DOUBLE 转化为 INT，所以值变为7\nx.append!(`XOM)\n// output\nIncompatible type. Expected: INT, Actual: STRING\n\nx=array(INT, 0, 10)\n// x 是一个空的向量\nx\n// output\n[]\nx.append!(1)\nx\n// output\n[1]\nx=array(SYMBOL, 0, 100)\nappend!(x, `TEST)\nx\n// output\n[\"TEST\"]\n\nx=1..6$3:2\nx\n```\n\n| 0 | 1 |\n| - | - |\n| 1 | 4 |\n| 2 | 5 |\n| 3 | 6 |\n\n```\nx.append!(7..12)\nx\n```\n\n| 0 | 1 | 2 | 3  |\n| - | - | - | -- |\n| 1 | 4 | 7 | 10 |\n| 2 | 5 | 8 | 11 |\n| 3 | 6 | 9 | 12 |\n\n```\nx=set(1 2 3 4)\nx.append!(6)\n// output\nx\nset(6,1,2,3,4)\n\nt1=table(1 2 3 as x, 4 5 6 as y)\nt2=table(1.1 2.2 3.3 as a, 4.4 5.5 6.6 as b)\nt1.append!(t2)\nt1\n```\n\n| x | y |\n| - | - |\n| 1 | 4 |\n| 2 | 5 |\n| 3 | 6 |\n| 1 | 4 |\n| 2 | 6 |\n| 3 | 7 |\n\n使用 `append!` 把数据添加到分布式表。下面的例子需要在集群中执行。相关配置可参考：[功能配置](https://docs.dolphindb.cn/zh/db_distr_comp/cfg/function_configuration.html)。\n\n```\nn=1000000\nt=table(rand(`IBM`MS`APPL`AMZN,n) as symbol, rand(10.0, n) as value)\ndb = database(\"dfs://rangedb_tradedata\", RANGE, `A`F`M`S`ZZZZ)\nTrades = db.createPartitionedTable(t, \"Trades\", \"symbol\")\n```\n\n上面的脚本根据表 t 的结构创建了空表 Trades。接着，把表 t 的数据追加到表 Trades 中。\n\n```\nTrades.append!(t)\nselect count(*) from Trades;\n\n// output\n1000000\n```\n\n把其他表的数据追加到表 Trades 中。\n\n```\nn=500000\nt1=table(rand(`FB`GE`MSFT,n) as symbol, rand(100.0, n) as value)\nTrades.append!(t1)\nselect count(*) from Trades\n\n// output\n1500000\n```\n\n配置项 *appendTupleAsAWhole* 的不同设置值将影响追加元组的行为。\n\n```\nx = (1,\"X\")\ny = (2,\"Y\")\nx.append!(y)\nprint(x)\n// 配置参数 appendTupleAsAWhole=true 时\n(1,\"X\",(2,\"Y\"))\n// 配置参数 appendTupleAsAWhole=false 时\n(1,\"X\",2,\"Y\")\n```\n"
    },
    "pwlfPredict": {
        "url": "https://docs.dolphindb.cn/zh/funcs/p/pwlfpredict.html",
        "signatures": [
            {
                "full": "pwlfPredict(model, X, [beta], [breaks])",
                "name": "pwlfPredict",
                "parameters": [
                    {
                        "full": "model",
                        "name": "model"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[beta]",
                        "name": "beta",
                        "optional": true
                    },
                    {
                        "full": "[breaks]",
                        "name": "breaks",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [pwlfPredict](https://docs.dolphindb.cn/zh/funcs/p/pwlfpredict.html)\n\n\n\n#### 语法\n\npwlfPredict(model, X, \\[beta], \\[breaks])\n\n#### 详情\n\n本函数须结合函数 [piecewiseLinFit](https://docs.dolphindb.cn/zh/funcs/p/piecewiselinfit.html) 共同使用，即使用 `piecewiseLinFit` 拟合后的连续分段线性回归模型来对输入的数据点进行预测。\n\n#### 参数\n\n**model** 字典类型，由 `piecewiseLinFit` 函数返回的分段线性回归模型。\n\n**X** 数值向量，表示需要预测的数据点的 x 坐标。注意：不可传入 NULL 值。\n\n**beta** 可选参数，数值向量，表示分段线性回归模型的参数。注意：不可传入 NULL 值。\n\n**breaks** 可选参数，数值向量，表示每段线段终点处的 x 坐标，每段线段的终点又被称为每段线段的断点。注意：不可传入 NULL 值。\n\n#### 返回值\n\n浮点数向量，表示模型的预测值。\n\n#### 例子\n\n本例先自定义参数条件，使用 `piecewiseLinFit` 拟合生成连续分段线性回归模型；再传入预测的数据点的 x 坐标 `xHat`，最后使用 `pwlfPredict` 计算模型的预测值。\n\n```\ndef linspace(start, end, num, endpoint=true){\n\tif(endpoint) return end$DOUBLE\\(num-1), start + end$DOUBLE\\(num-1)*0..(num-1)\n\telse return start + end$DOUBLE\\(num-1)*0..(num-1)\t\n}\nX = linspace(0.0, 1.0, 10)[1]\nY = [0.41703981, 0.80028691, 0.12593987, 0.58373723, 0.77572962, 0.41156172, 0.72300284, 0.32559528, 0.21812564, 0.41776427]\nmodel = piecewiseLinFit(X, Y, 3)\nxHat = linspace(0.0, 1.0, 20)[1]\npwlfPredict(model, xHat)\n/*\noutput:\n[0.593305499919518 0.524360777381737 0.455416054843957 0.386471332306177 0.317526609768396 0.368043438179296 0.529813781212159 0.691584124245021 0.69295837868457  0.655502915538459 0.618047452392347 0.580591989246236 0.543136526100125 0.505681062954014 0.468225599807903 0.430770136661792 0.393314673515681 0.35585921036957  0.318403747223459 0.280948284077348]\n*/\n```\n\n相关函数：[piecewiseLinFit](https://docs.dolphindb.cn/zh/funcs/p/piecewiselinfit.html)\n"
    },
    "qclp": {
        "url": "https://docs.dolphindb.cn/zh/funcs/q/qclp.html",
        "signatures": [
            {
                "full": "qclp(r, V, k, [A], [b], [Aeq], [beq], [x0], [c], [eps], [alpha])",
                "name": "qclp",
                "parameters": [
                    {
                        "full": "r",
                        "name": "r"
                    },
                    {
                        "full": "V",
                        "name": "V"
                    },
                    {
                        "full": "k",
                        "name": "k"
                    },
                    {
                        "full": "[A]",
                        "name": "A",
                        "optional": true
                    },
                    {
                        "full": "[b]",
                        "name": "b",
                        "optional": true
                    },
                    {
                        "full": "[Aeq]",
                        "name": "Aeq",
                        "optional": true
                    },
                    {
                        "full": "[beq]",
                        "name": "beq",
                        "optional": true
                    },
                    {
                        "full": "[x0]",
                        "name": "x0",
                        "optional": true
                    },
                    {
                        "full": "[c]",
                        "name": "c",
                        "optional": true
                    },
                    {
                        "full": "[eps]",
                        "name": "eps",
                        "optional": true
                    },
                    {
                        "full": "[alpha]",
                        "name": "alpha",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [qclp](https://docs.dolphindb.cn/zh/funcs/q/qclp.html)\n\n\n\n#### 语法\n\nqclp(r, V, k, \\[A], \\[b], \\[Aeq], \\[beq], \\[x0], \\[c], \\[eps], \\[alpha])\n\n#### 详情\n\n用一个线性目标函数和一组包含二次约束的约束条件求解下列优化问题。\n\n![image](https://docs.dolphindb.cn/zh/images/qclp.png)\n\n结果是一个包含2个元素的元组。第一个元素是目标函数的最小值。第二个元素是目标函数值最小时的x值。\n\n#### 参数\n\n**V**，**A** 和 **Aeq** 是列数相同的矩阵。\n\n**r**，**b** 和 **beq** 是向量。\n\n**k** 是一个正标量。\n\n**x0** 向量绝对值不等式约束的系数向量。\n\n**c** 一个非负数字，表示绝对值不等式约束的右侧常量系数。\n\n**eps** 正浮点数，表示求解的精度。默认值为1e-6，范围为 \\[1e-4, 1e-9]。通过减小该参数值以获得更高精度的解。如果该参数设置值超过规定范围，则会自动调整为默认值。\n\n**alpha** 正浮点数，表示松弛参数。默认值为1.5，范围为 (0, 2)。通过增加 alpha 的值来加快求解速度。如果该参数设置值超过规定范围，则会自动调整为默认值。\n\n#### 返回值\n\n长度为2的元组。第一个元素是目标函数的最小值。第二个元素是使目标函数达到最小值的变量值。\n\n#### 例子\n\n根据每只股票的预期收益与收益率协方差矩阵，以及如下限制 (1) 投资组合的收益率波动率不超过11% (2) 每只股票的权重在10%到50%之间，以决定最优投资组合。\n\n```\nr = 0.18 0.25 0.36\nV= 0.0225 -0.003 -0.01125 -0.003 0.04 0.025 -0.01125 0.025 0.0625 $ 3:3\nk = pow(0.11, 2)\nA = (eye(3) join (-1*eye(3))).transpose()\nb = 0.5 0.5 0.5 -0.1 -0.1 -0.1\nAeq = (1 1 1)$1:3\nbeq = [1]\n\nx = qclp(-r, V, k, A, b, Aeq, beq);\n\nx[1];\n//Output: [0.5,0.1763,0.3237]\n```\n\n在上例的基础上，添加绝对值约束：| x1 - 0.35| + | x2 - 0.35 | + | x3 - 0.35 | ≤ 0.3：\n\n```\nx0 = [0.35, 0.35, 0.35];\nc = 0.3;\ny = qclp(-r, V, k, A, b, Aeq, beq, x0, c);\n\ny[1]\n//Output: [0.475,0.248,0.277]\n```\n"
    },
    "qcut": {
        "url": "https://docs.dolphindb.cn/zh/funcs/q/qcut.html",
        "signatures": [
            {
                "full": "qcut(X, q, [labels],[dropDuplicates=false])",
                "name": "qcut",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "q",
                        "name": "q"
                    },
                    {
                        "full": "[labels]",
                        "name": "labels",
                        "optional": true
                    },
                    {
                        "full": "[dropDuplicates=false]",
                        "name": "dropDuplicates",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [qcut](https://docs.dolphindb.cn/zh/funcs/q/qcut.html)\n\n首发版本：3.00.5\n\n\n\n#### 语法\n\nqcut(X, q, \\[labels],\\[dropDuplicates=false])\n\n#### 详情\n\n根据元素在数值向量中的排序位置，确定其所属的分位区间。例如，将 1000 个数值按分位数划分为 10 个区间，返回每个元素所属的分位区间。\n\nDolphinDB 与 pandas 的 `qcut` 函数虽均用于分位数离散化，但核心差异在于：前者直接操作表列，默认返回整数序号向量，适合海量数据高效分箱；后者是内存分析工具，返回保留区间信息的 Categorical 分类对象，支持指定 *retbins* 提取边界与 *precision* 控制精度，更适合交互式分析。\n\n#### 参数\n\n**X** 一个数值向量。\n\n**q** 整型标量或浮点型向量。\n\n* 当为整型标量时，表示分位区间的数量（如 10 表示十分位，4 表示四分位）。\n* 当为浮点型向量时，表示分位点，至少包含两个元素，且取值范围为 \\[0, 1]。\n\n**labels** 可选参数，一个向量，代表每个分位区间的标签。\n\n* 默认为 NULL，函数返回整型向量，代表每个元素对应的分位区间序号。\n* 如果 *q* 是标量，*labels* 的长度需要等于 *q*。\n* 如果 *q* 是向量，labels 的长度需要等于 *q* 向量长度 -1。\n\n**dropDuplicates** 布尔值，是否删除重复的区间边界。\n\n* 默认为 false，表示存在重复的区间边界时报错.\n* 如果为 true，表示删除重复的区间边界。\n\n#### 返回值\n\n一个向量，代表每个元素所属的分位区间。\n\n#### 例子\n\n```\n// 将数据划分为 4 个分位区间\nqcut([1,2,3,4,5,6,7,8,9,10], 4)\n// 输出：[0 0 0 1 1 2 2 3 3 3]\n\n// 使用自定义分位点进行划分：0–30%、30–70%、70–100%\nqcut([1,2,3,4,5,6,7,8,9,10], [0, 0.3, 0.7, 1.0])\n// 输出：[0 0 0 1 1 1 1 2 2 2]\n\n// 将数据划分为 4 个分位区间，并使用自定义标签作为区间标识\nqcut([1,2,3,4,5,6,7,8,9,10], 4, [\"Q1\", \"Q2\", \"Q3\", \"Q4\"])\n// 输出：[Q1\tQ1 Q1 Q2 Q2\tQ3 Q3 Q4 Q4\tQ4]\n\n// 启用 dropDuplicates，自动丢弃重复的区间边界\nqcut(X=[1, 1, 1, 1, 2, 3],q=4,dropDuplicates=true)\n// 输出：[0 0 0 0 2 2]\n```\n"
    },
    "qr": {
        "url": "https://docs.dolphindb.cn/zh/funcs/q/qr.html",
        "signatures": [
            {
                "full": "qr(obj, [mode='full'], [pivoting=false])",
                "name": "qr",
                "parameters": [
                    {
                        "full": "obj",
                        "name": "obj"
                    },
                    {
                        "full": "[mode='full']",
                        "name": "mode",
                        "optional": true,
                        "default": "'full'"
                    },
                    {
                        "full": "[pivoting=false]",
                        "name": "pivoting",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [qr](https://docs.dolphindb.cn/zh/funcs/q/qr.html)\n\n\n\n#### 语法\n\nqr(obj, \\[mode='full'], \\[pivoting=false])\n\n#### 详情\n\n计算矩阵的 QR（正交三角）分解，将矩阵分解成一个标准正交矩阵 Q 与上三角形矩阵 R。若输入矩阵为 A，结果满足 A=Q\\*R。\n\n假设 A 的行数为 m，列数为 n：\n\n* 若 *mode*=\"full\"，返回矩阵 Q 与 R，形状分别为 m\\*m 和 m\\*n。\n\n* 若 *mode*=\"economic\"，返回矩阵 Q 与 R，形状分别为 m\\*k 和 k\\*n，其中 k=min(m,n)。\n\n* 若 *mode*=\"r\"，仅返回矩阵 R，形状为 m\\*n。\n\n* 若 *pivoting*=true，返回结果还包含一个与输入矩阵列数相同长度的向量 P。P 为置换矩阵的秩显，表示置换矩阵中1所在列的位置。\n\nDolphinDB 与 SciPy 的 `qr` 函数功能基本相同，SciPy​ 提供了更多性能调优参数，包括 *overwrite\\_a*，*lwork*，*check\\_finite。*\n\n#### 参数\n\n**obj** 是一个矩阵。\n\n**mode** 是一个字符串，表示返回信息的类型。它的取值可以是 \"full\", \"economic\", \"raw\" 或 \"r\"。默认值是 \"full\"。\n\n**pivoting** 是一个布尔值，表示是否返回置换矩阵的秩显，默认值为 false。\n\n#### 返回值\n\n元组或矩阵。\n\n#### 例子\n\n```\nA = matrix([2,5,7,5], [5,2,5,4], [8,2,6,4]);\n\nQ,R = qr(A);\nQ;\n```\n\n| #0        | #1        | #2        | #3        |\n| --------- | --------- | --------- | --------- |\n| -0.197066 | 0.903357  | 0.300275  | 0.234404  |\n| -0.492665 | -0.418267 | 0.459245  | 0.609449  |\n| -0.68973  | -0.02475  | 0.170745  | -0.703211 |\n| -0.492665 | 0.091573  | -0.818398 | 0.281284  |\n\n```\nR;\n```\n\n| #0         | #1       | #2        |\n| ---------- | -------- | --------- |\n| -10.148892 | -7.38997 | -8.670898 |\n| 0          | 3.922799 | 6.608121  |\n| 0          | 0        | 1.071571  |\n| 0          | 0        | 0         |\n\n```\nQ,R=qr(A,mode='economic');\nQ;\n```\n\n| #0        | #1        | #2        |\n| --------- | --------- | --------- |\n| -0.197066 | 0.903357  | 0.300275  |\n| -0.492665 | -0.418267 | 0.459245  |\n| -0.68973  | -0.02475  | 0.170745  |\n| -0.492665 | 0.091573  | -0.818398 |\n\n```\nR;\n```\n\n| #0         | #1       | #2        |\n| ---------- | -------- | --------- |\n| -10.148892 | -7.38997 | -8.670898 |\n| 0          | 3.922799 | 6.608121  |\n| 0          | 0        | 1.071571  |\n\n```\nQ,T,R=qr(A,mode='raw');\nR;\n```\n\n| #0         | #1       | #2        |\n| ---------- | -------- | --------- |\n| -10.148892 | -7.38997 | -8.670898 |\n| 0.41156    | 3.922799 | 6.608121  |\n| 0.576184   | 0.3046   | 1.071571  |\n| 0.41156    | 0.156539 | 0.900419  |\n\n```\nT;\n// output\n[1.197066,1.790053,1.104512]\n\nR\n```\n\n| #0         | #1       | #2        |\n| ---------- | -------- | --------- |\n| -10.148892 | -7.38997 | -8.670898 |\n| 0          | 3.922799 | 6.608121  |\n| 0          | 0        | 1.071571  |\n\n```\nQ,T,R,P = qr(A,mode='raw',pivoting=true);\nQ;\n```\n\n| #0         | #1        | #2        |\n| ---------- | --------- | --------- |\n| -10.954451 | -8.033264 | -8.215838 |\n| 0.105516   | -6.20215  | -1.45111  |\n| 0.316548   | 0.37699   | -0.627918 |\n| 0.211032   | 0.284188  | 0.936372  |\n\n```\nT;\n// output\n[1.730297,1.635478,1.065648]\n\nR\n```\n\n| #0         | #1        | #2        |\n| ---------- | --------- | --------- |\n| -10.954451 | -8.033264 | -8.215838 |\n| 0          | -6.20215  | -1.45111  |\n| 0          | 0         | -0.627918 |\n\n```\nP;\n// output\n[2,0,1]\n```\n"
    },
    "quadprog": {
        "url": "https://docs.dolphindb.cn/zh/funcs/q/quadprog.html",
        "signatures": [
            {
                "full": "quadprog(H, f, [A], [b], [Aeq], [beq])",
                "name": "quadprog",
                "parameters": [
                    {
                        "full": "H",
                        "name": "H"
                    },
                    {
                        "full": "f",
                        "name": "f"
                    },
                    {
                        "full": "[A]",
                        "name": "A",
                        "optional": true
                    },
                    {
                        "full": "[b]",
                        "name": "b",
                        "optional": true
                    },
                    {
                        "full": "[Aeq]",
                        "name": "Aeq",
                        "optional": true
                    },
                    {
                        "full": "[beq]",
                        "name": "beq",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [quadprog](https://docs.dolphindb.cn/zh/funcs/q/quadprog.html)\n\n\n\n#### 语法\n\nquadprog(H, f, \\[A], \\[b], \\[Aeq], \\[beq])\n\n#### 详情\n\n求二元目标函数在线性约束条件下的最优解。具体模型如下：\n\n![image](https://docs.dolphindb.cn/zh/images/quadprog.png)\n\n#### 参数\n\n**H** 是二次规划中的二次项矩阵，且必须是对称正定矩阵。\n\n**f** 是二次项规划中的一次项向量。\n\n**A** 是线性不等约束的系数矩阵。\n\n**b** 是线性不等约束的右端向量。\n\n**Aeq** 是线性等式约束的系数矩阵。\n\n**beq** 是线性等式约束的右端向量。\n\n*H*, *A* 和 *Aeq* 必须是列数相同的矩阵。\n\n*f*, *b* 和 *beq* 是向量。\n\n#### 返回值\n\n长度为2的元组。第一个元素是目标函数的最小值。第二个元素是使目标函数达到最小值的变量值。\n\n#### 例子\n\n求以下目标函数的最小值。\n\n![image](https://docs.dolphindb.cn/zh/images/quadprog1.png)\n\n例1：没有约束条件\n\n```\nH=matrix([2 -2,-2 6])\nf=[-5,4]\nx=quadprog(H,f);\n\nx[0];\n// output\n-6.375\n\nx[1];\n// output\n[2.75,0.25]\n```\n\n例2：添加不等式约束条件：\n\n![image](https://docs.dolphindb.cn/zh/images/quadprog2.png)\n\n```\nH=matrix([2 -2,-2 6])\nf=[-5,4]\nA=matrix([1 -1 6, 1 3 1])\nb=[10, 8, 5]\nx=quadprog(H,f,A,b);\n\nx[0];\n// output\n-4.092975\n\nx[1];\n// output\n[0.904959, -0.429752]\n```\n\n例3：添加不等式约束条件和等式约束条件：\n\n![image](https://docs.dolphindb.cn/zh/images/quadprog3.png)\n\n```\nH=matrix([2 -2,-2 6])\nf=[-5,4]\nA=matrix([1 -1 6, 1 3 1])\nb=[10, 8, 5]\nAeq=matrix([1],[2])\nbeq=[1]\nx=quadprog(H,f,A,b,Aeq,beq);\n\nx[0];\n// output\n-3.181818\n\nx[1];\n// output\n[0.818182,0.090909]\n```\n\n目标函数在没有约束条件的情况下，最优解的值最小。约束条件越多，最优解的值越大。\n\n相关函数：[linprog](https://docs.dolphindb.cn/zh/funcs/l/linprog.html), [scs](https://docs.dolphindb.cn/zh/funcs/s/scs.html)\n"
    },
    "quantile": {
        "url": "https://docs.dolphindb.cn/zh/funcs/q/quantile.html",
        "signatures": [
            {
                "full": "quantile(X, q, [interpolation='linear'])",
                "name": "quantile",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "q",
                        "name": "q"
                    },
                    {
                        "full": "[interpolation='linear']",
                        "name": "interpolation",
                        "optional": true,
                        "default": "'linear'"
                    }
                ]
            }
        ],
        "markdown": "### [quantile](https://docs.dolphindb.cn/zh/funcs/q/quantile.html)\n\n\n\n#### 语法\n\nquantile(X, q, \\[interpolation='linear'])\n\n#### 详情\n\n计算 *X* 的分位数。\n\nDolphinDB 的 `quantile` 语法精简且原生忽略空值，适合海量数据实时计算；NumPy 的 `quantile` 专为多维数组设计，支持传入数组批量计算多个分位点；SciPy 的 `quantile` 不仅支持为每个数据切片指定不同分位数，还支持 Harrell-Davis 统计估计器及 *nan\\_policy* 参数，可以原生处理含缺失值的样本。\n\n#### 参数\n\n**X** 是一个数值型向量、矩阵或表。\n\n**q** 是0到1之间的浮点数。\n\n**interpolation** 是一个字符串，表示当选中的分位点位于 i 和 j 之间时，采用的插值方法。它具有以下取值：\n\n* 'linear': i+(j-1)\\*fraction, fraction 是 size(X)\\*q 的小数部分\n\n* 'lower':i\n\n* 'higher': j\n\n* 'nearest': i 和 j 之中最接近分位点的数据\n\n* 'midpoint': (i+j)/2\n\n如果没有指定 *interpolation*，默认采用 'linear'。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\na=[6, 47, 49, 15, 42, 41, 7, 39, 43, 40, 36];\nquantile(a,0.25);\n// output\n25.5\n\nquantile(a,0.5);\n// output\n40\n\nquantile(a,0.75);\n// output\n42.5\n\nquantile(a,0.75, 'lower');\n// output\n42\n```\n\n相关函数：[quantileSeries](https://docs.dolphindb.cn/zh/funcs/q/quantileSeries.html), [percentile](https://docs.dolphindb.cn/zh/funcs/p/percentile.html)\n"
    },
    "quantileSeries": {
        "url": "https://docs.dolphindb.cn/zh/funcs/q/quantileSeries.html",
        "signatures": [
            {
                "full": "quantileSeries(X, q, [interpolation='linear'])",
                "name": "quantileSeries",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "q",
                        "name": "q"
                    },
                    {
                        "full": "[interpolation='linear']",
                        "name": "interpolation",
                        "optional": true,
                        "default": "'linear'"
                    }
                ]
            }
        ],
        "markdown": "### [quantileSeries](https://docs.dolphindb.cn/zh/funcs/q/quantileSeries.html)\n\n\n\n#### 语法\n\nquantileSeries(X, q, \\[interpolation='linear'])\n\n#### 详情\n\n计算 *X* 的分位数。\n\n#### 参数\n\n**X** 是一个数值型向量。\n\n**q** 是0到1之间的浮点型标量或向量。\n\n**interpolation** 是一个字符串，表示当选中的分位点位于 i 和 j 之间时，采用的插值方法。它具有以下取值：\n\n* 'linear': i+(j-1)\\*fraction, fraction 是 size(X)\\*q 的小数部分\n\n* 'lower':i\n\n* 'higher': j\n\n* 'nearest': i 和 j 之中最接近分位点的数据\n\n* 'midpoint': (i+j)/2\n\n如果没有指定 *interpolation*，默认采用 'linear'。\n\n#### 返回值\n\nDOUBLE 类型向量，表示计算结果。\n\n#### 例子\n\n```\na=[6, 47, 49, 15, 42, 41, 7, 39, 43, 40, 36];\nquantileSeries(a,[0.25,0.5,0.75]);\n// output\n[25.5,40,42.5]\n\nquantileSeries(a,[0.25,0.5,0.75], 'higher');\n// output\n[36,40,43]\n```\n\n相关函数：[quantile](https://docs.dolphindb.cn/zh/funcs/q/quantile.html)\n"
    },
    "quarterBegin": {
        "url": "https://docs.dolphindb.cn/zh/funcs/q/quarterBegin.html",
        "signatures": [
            {
                "full": "quarterBegin(X, [startingMonth=1], [offset], [n=1])",
                "name": "quarterBegin",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[startingMonth=1]",
                        "name": "startingMonth",
                        "optional": true,
                        "default": "1"
                    },
                    {
                        "full": "[offset]",
                        "name": "offset",
                        "optional": true
                    },
                    {
                        "full": "[n=1]",
                        "name": "n",
                        "optional": true,
                        "default": "1"
                    }
                ]
            }
        ],
        "markdown": "### [quarterBegin](https://docs.dolphindb.cn/zh/funcs/q/quarterBegin.html)\n\n\n\n#### 语法\n\nquarterBegin(X, \\[startingMonth=1], \\[offset], \\[n=1])\n\n#### 详情\n\n返回 *X* 所在季度的第一天。\n\n默认情况下，一个周期对应一个季度，函数返回 *X* 所在季度的第一天。每个季度包含的月份由参数 *startingMonth* 决定。\n\n如果指定了 *offset* 和 *n*，且 *n* > 1，则函数按长度为 *n* 个季度的周期计算。此时，*offset* 用于确定多季度周期的对齐方式：系统会先根据 *startingMonth* 计算出 *offset*所在季度的第一天，然后以该日期为基准，每隔 *n* 个季度生成一个周期起始边界，并返回 *X* 所属周期对应的第一天。\n\n#### 参数\n\n**X** 可以是 DATE, DATETIME, DATEHOUR, TIMESTAMP 或 NANOTIMESTAMP 类型的标量或向量。\n\n**startingMonth** 是1到12之间的整数，表示一年中第一个季度的起始月份。默认值为 1，表示自然季度；例如 `startingMonth=4` 时，季度划分为 4-6 月、7-9 月、10-12 月、次年 1-3 月。\n\n**offset** 是与 *X* 类型相同的标量，并且它必须小于等于 *X* 中的最小值。它是一个可选参数。如果没有指定，*offset* 默认为 *X* 中的最小值。\n\n**n** 是一个正整数。它是一个可选参数，默认值为1。\n\n#### 返回值\n\nDATE 类型标量或向量。\n\n#### 例子\n\n```\nquarterBegin(2012.06.12);\n// output: 2012.04.01\n\nquarterBegin(2012.06.13 10:10:10.008,5);\n// output: 2012.05.01\n\ndate=2016.01.12 2016.02.25 2016.05.12 2016.06.28 2016.07.10 2016.08.18 2016.09.02 2016.10.16 2016.11.26 2016.12.30\ntime = [09:34:07,09:36:42,09:36:51,09:36:59,09:32:47,09:35:26,09:34:16,09:34:26,09:38:12,09:38:13]\nsym = take(`MSFT,10)\nprice= 49.6 29.46 29.52 30.02 174.97 175.23 50.76 50.32 51.29 52.38\nqty = 2200 1900 2100 3200 6800 5400 1300 2500 8800 4500\nt1 = table(date, time, sym, qty, price);\n\nselect avg(price),sum(qty) from t1 group by quarterBegin(date,1,2016.01.01,2)\n```\n\n| quarterBegin\\_date | avg\\_price | sum\\_qty |\n| ------------------ | ---------- | -------- |\n| 2016.01.01         | 34.65      | 9400     |\n| 2016.07.01         | 92.491667  | 29300    |\n\n相关函数：[quarterEnd](https://docs.dolphindb.cn/zh/funcs/q/quarterEnd.html), [businessQuarterBegin](https://docs.dolphindb.cn/zh/funcs/b/businessQuarterBegin.html), [businessQuarterEnd](https://docs.dolphindb.cn/zh/funcs/b/businessQuarterEnd.html)\n"
    },
    "quarterEnd": {
        "url": "https://docs.dolphindb.cn/zh/funcs/q/quarterEnd.html",
        "signatures": [
            {
                "full": "quarterEnd(X, [endingMonth=12], [offset], [n=1])",
                "name": "quarterEnd",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[endingMonth=12]",
                        "name": "endingMonth",
                        "optional": true,
                        "default": "12"
                    },
                    {
                        "full": "[offset]",
                        "name": "offset",
                        "optional": true
                    },
                    {
                        "full": "[n=1]",
                        "name": "n",
                        "optional": true,
                        "default": "1"
                    }
                ]
            }
        ],
        "markdown": "### [quarterEnd](https://docs.dolphindb.cn/zh/funcs/q/quarterEnd.html)\n\n\n\n#### 语法\n\nquarterEnd(X, \\[endingMonth=12], \\[offset], \\[n=1])\n\n#### 详情\n\n返回 *X* 所在季度的最后一天。\n\n默认情况下，一个周期对应一个季度，函数返回 *X* 所在季度的最后一天。每个季度包含的月份由参数 *endingMonth* 决定。\n\n如果指定了 *offset* 和 *n*，且 *n* > 1，则函数按长度为 *n* 个季度的周期计算。此时，*offset* 用于确定多季度周期的对齐方式：系统会先根据 *endingMonth* 计算出 *offset*所在季度的最后一天，然后以该日期为基准，每隔 *n* 个季度生成一个周期结束边界，并返回 *X* 所属周期对应的最后一天。\n\n#### 参数\n\n**X** 可以是 DATE, DATETIME, DATEHOUR, TIMESTAMP 或 NANOTIMESTAMP 类型的标量或向量。\n\n**endingMonth** 是1到12之间的整数，用于指定一年中最后一个季度的结束月份。默认值为 12，表示自然季度；例如 `endingMonth=3` 时，季度划分为 4-6 月、7-9 月、10-12 月、次年 1-3 月。\n\n**offset** 是与 *X* 类型相同的标量，并且它必须小于等于 *X* 中的最小值。它是一个可选参数。如果没有指定，*offset* 默认为 *X* 中的最小值。\n\n**n** 是一个正整数。它是一个可选参数，默认值为1。\n\n#### 返回值\n\nDATE 类型标量或向量。\n\n#### 例子\n\n```\nquarterEnd(2012.06.12);\n// output: 2012.06.30\n\nquarterEnd(2012.06.13 10:10:10.008,5);\n// output: 2012.08.31\n\ndate=2016.01.12 2016.02.25 2016.05.12 2016.06.28 2016.07.10 2016.08.18 2016.09.02 2016.10.16 2016.11.26 2016.12.30\ntime = [09:34:07,09:36:42,09:36:51,09:36:59,09:32:47,09:35:26,09:34:16,09:34:26,09:38:12,09:38:13]\nsym = take(`MSFT,10)\nprice= 49.6 29.46 29.52 30.02 174.97 175.23 50.76 50.32 51.29 52.38\nqty = 2200 1900 2100 3200 6800 5400 1300 2500 8800 4500\nt1 = table(date, time, sym, qty, price);\n\nselect avg(price),sum(qty) from t1 group by quarterEnd(date,12,2016.01.01,2)\n```\n\n| quarterEnd\\_date | avg\\_price | sum\\_qty |\n| ---------------- | ---------- | -------- |\n| 2016.03.31       | 39.53      | 4100     |\n| 2016.09.30       | 92.1       | 18800    |\n| 2017.03.31       | 51.33      | 15800    |\n\n相关函数：[quarterBegin](https://docs.dolphindb.cn/zh/funcs/q/quarterBegin.html), [businessQuarterBegin](https://docs.dolphindb.cn/zh/funcs/b/businessQuarterBegin.html), [businessQuarterEnd](https://docs.dolphindb.cn/zh/funcs/b/businessQuarterEnd.html)\n"
    },
    "quarterOfYear": {
        "url": "https://docs.dolphindb.cn/zh/funcs/q/quarterOfYear.html",
        "signatures": [
            {
                "full": "quarterOfYear(X)",
                "name": "quarterOfYear",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [quarterOfYear](https://docs.dolphindb.cn/zh/funcs/q/quarterOfYear.html)\n\n\n\n#### 语法\n\nquarterOfYear(X)\n\n#### 详情\n\n计算X在当年的第几个季度。返回的结果是整型。\n\n#### 参数\n\n**X** 可以是 DATE, MONTH, DATETIME, TIMESTAMP 或 NANOTIMESTAMP 类型的标量或向量。\n\n#### 返回值\n\n整型标量或向量。\n\n#### 例子\n\n```\nquarterOfYear(2012.07.02);\n// output: 3\n\nquarterOfYear([2012.06.12T12:30:00,2012.10.28T12:35:00,2013.01.06T12:36:47,2013.04.06T08:02:14]);\n// output: [2,4,1,2]\n```\n\n相关函数：[dayOfYear](https://docs.dolphindb.cn/zh/funcs/d/dayOfYear.html), [dayOfMonth](https://docs.dolphindb.cn/zh/funcs/d/dayOfMonth.html), [monthOfYear](https://docs.dolphindb.cn/zh/funcs/m/monthOfYear.html), [weekOfYear](https://docs.dolphindb.cn/zh/funcs/w/weekOfYear.html), [hourOfDay](https://docs.dolphindb.cn/zh/funcs/h/hourOfDay.html), [minuteOfHour](https://docs.dolphindb.cn/zh/funcs/m/minuteOfHour.html), [secondOfMinute](https://docs.dolphindb.cn/zh/funcs/s/secondOfMinute.html), [millisecond](https://docs.dolphindb.cn/zh/funcs/m/millisecond.html), [microsecond](https://docs.dolphindb.cn/zh/funcs/m/microsecond.html), [nanosecond](https://docs.dolphindb.cn/zh/funcs/n/nanosecond.html)\n"
    },
    "ma": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/ma.html",
        "signatures": [
            {
                "full": "ma(X, window, maType)",
                "name": "ma",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "maType",
                        "name": "maType"
                    }
                ]
            }
        ],
        "markdown": "### [ma](https://docs.dolphindb.cn/zh/funcs/m/ma.html)\n\n\n\n#### 语法\n\nma(X, window, maType)\n\nTA-lib 系列函数其他通用参数说明和窗口计算规则请参考：[TA-lib 系列](https://docs.dolphindb.cn/zh/funcs/themes/TAlib.html)\n\n#### 详情\n\n在给定长度（以元素个数衡量）的滑动窗口内，计算 *X* 的移动平均，计算公式由 *maType* 决定。\n\n与 TA-Lib `MA` 函数的区别在于：\n\n* DolphinDB `ma` 暂不支持 `mama`\n* 空值处理不同：DolphinDB `ma` 与 TA-Lib `MA` 在前置空值处理上基本一致：保留序列开头的空值，并从首个非空值开始进行窗口计算。二者在中间空值处理上存在差异：DolphinDB `ma` 通常会继续按其移动平均规则计算并输出结果；TA-Lib 在首个非空值之后遇到 NaN 时，部分指标可能从该位置起输出 NaN，并影响后续结果。\n\n#### 参数\n\n**maType** 计算平均线的方法。是一个0-8范围内的整数。各个整数分别表示：0= [sma](https://docs.dolphindb.cn/zh/funcs/s/sma.html) , 1= [ema](https://docs.dolphindb.cn/zh/funcs/e/ema.html) , 2= [wma](https://docs.dolphindb.cn/zh/funcs/w/wma.html) , 3= [dema](https://docs.dolphindb.cn/zh/funcs/d/dema.html) , 4= [tema](https://docs.dolphindb.cn/zh/funcs/t/tema.html) , 5= [trima](https://docs.dolphindb.cn/zh/funcs/t/trima.html) , 6= [kama](https://docs.dolphindb.cn/zh/funcs/k/kama.html) , 8= [t3](https://docs.dolphindb.cn/zh/funcs/t/t3.html)。注意：暂不支持 7 (mama)。\n\n#### 返回值\n\nDOUBLE 类型向量。\n"
    },
    "mad": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mad.html",
        "signatures": [
            {
                "full": "mad(X, [useMedian=false])",
                "name": "mad",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[useMedian=false]",
                        "name": "useMedian",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [mad](https://docs.dolphindb.cn/zh/funcs/m/mad.html)\n\n\n\n#### 语法\n\nmad(X, \\[useMedian=false])\n\n#### 详情\n\n* 若 *X* 为向量，计算 *X* 的平均绝对离差或平均绝对中位差。\n\n* 若 *X* 为矩阵，计算在每列内部进行，返回一个向量。\n\n* 若 *X* 为表，计算在每列内部进行，返回一个表。\n\n与所有其它聚合函数一致，计算时忽略 NULL 值。\n\n#### 参数\n\n**X** 是一个向量、矩阵或表。\n\n**useMedian** 是一个布尔值，默认值是 false，表示计算平均绝对离差（mean absolute deviation）。若为 true 则计算绝对中位差（median absolute deviation）。\n\n* 平均绝对离差：mean(abs(X - mean(X)))\n\n* 绝对中位差：med(abs(X - med(X)))\n\n#### 返回值\n\n* *X* 是向量时，返回一个 DOUBLE 类型标量。\n* *X* 是矩阵时，返回一个 DOUBLE 类型向量。\n* *X* 是表时，返回一个表。\n\n#### 例子\n\n```\nmad([85, 90, 95, NULL]);\n// output: 3.333333333333333\n\nm=matrix(85 90 95, 185 190 195);\nm;\n```\n\n| #0 | #1  |\n| -- | --- |\n| 85 | 185 |\n| 90 | 190 |\n| 95 | 195 |\n\n```\nmad m;\n// output: [3.333333333333333, 3.333333333333333]\n\nmad([0, 19.618568, 67.900707, 71.65218, 73.103952, 58.275308, 18.819054, 36.940571, 48.114366], false)\n// output: 22.204817\n```\n\n相关函数： [mmad](https://docs.dolphindb.cn/zh/funcs/m/mmad.html)\n"
    },
    "mahalanobis": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mahalanobis.html",
        "signatures": [
            {
                "full": "mahalanobis(X, Y, Z)",
                "name": "mahalanobis",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "Z",
                        "name": "Z"
                    }
                ]
            }
        ],
        "markdown": "### [mahalanobis](https://docs.dolphindb.cn/zh/funcs/m/mahalanobis.html)\n\n首发版本：3.00.5，3.00.4.3\n\n\n\n#### 语法\n\n```\nmahalanobis(X, Y, Z)\n```\n\n#### 详情\n\n计算两个数值向量（X 和 Y）之间的马氏距离，公式定义如下：\n\n![](https://docs.dolphindb.cn/zh/images/mahalanobis.png)\n\n其中，*V* 是协方差矩阵，参数 *Z* 是 *V* 的逆。\n\n#### 参数\n\n**X** 数值向量。\n\n**Y** 数值向量。\n\n**Z** 协方差矩阵的逆。\n\n#### 返回值\n\nDOUBLE 类型标量。\n\n#### 例子\n\n```\nlen = 50\nX = array(DOUBLE, 0).append!(take([1.2, 3.9, 0.8], len))\nY = array(DOUBLE, 0).append!(take([5.6, 0.4, 2.7], len))\nZ1 = diag(take(1, len))\nZ = inverse(Z1)\n\nmahalanobis(X, Y, Z)\n//输出：24.395286429964294\n```\n\n**相关函数**\n\n[minkowski](https://docs.dolphindb.cn/zh/funcs/m/minkowski.html)、[seuclidean](https://docs.dolphindb.cn/zh/funcs/s/seuclidean.html)\n"
    },
    "makeCall": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/makeCall.html",
        "signatures": [
            {
                "full": "makeCall(F, args...)",
                "name": "makeCall",
                "parameters": [
                    {
                        "full": "F",
                        "name": "F"
                    },
                    {
                        "full": "args...",
                        "name": "args..."
                    }
                ]
            }
        ],
        "markdown": "### [makeCall](https://docs.dolphindb.cn/zh/funcs/m/makeCall.html)\n\n\n\n#### 语法\n\nmakeCall(F, args...)\n\n#### 详情\n\n它使用指定参数调用一个函数并生成脚本。高阶函数 [call](https://docs.dolphindb.cn/zh/funcs/ho_funcs/call.html) 与 `makeCall` 的区别是，`makeCall` 不执行脚本。\n\n#### 参数\n\n**F** 是一个函数。\n\n**args** 是 *F* 需要的参数。\n\n#### 返回值\n\n一个元代码。\n\n#### 例子\n\n在下列例子中，我们创建了 `generateReport` 函数。它能够以指定格式显示表的某些列。\n\n```\ndef generateReport(tbl, colNames, colFormat): sql(sqlColAlias(each(makeCall{format},sqlCol(colNames),colFormat),colNames), tbl).eval();\n\nt = table(1..100 as id, (1..100 + 2018.01.01) as date, rand(100.0, 100) as price, rand(10000, 100) as qty, rand(`A`B`C`D`E`F`G, 100) as city);\nt;\n```\n\n| id  | date       | price   | qty  | city |\n| --- | ---------- | ------- | ---- | ---- |\n| 1   | 2018.01.02 | 77.9896 | 375  | A    |\n| 2   | 2018.01.03 | 8.1332  | 7864 | F    |\n| 3   | 2018.01.04 | 56.7185 | 4912 | B    |\n| 4   | 2018.01.05 | 72.4173 | 534  | E    |\n| 5   | 2018.01.06 | 8.2019  | 31   | B    |\n| 6   | 2018.01.07 | 74.7275 | 4139 | A    |\n| 7   | 2018.01.08 | 7.5421  | 2725 | D    |\n| 8   | 2018.01.09 | 59.1689 | 3095 | C    |\n| 9   | 2018.01.10 | 55.8454 | 5443 | D    |\n| 10  | 2018.01.11 | 32.1285 | 6998 | G    |\n| ... |            |         |      |      |\n\n```\ngenerateReport(t, [\"id\", \"date\",\"price\",\"qty\"], [\"0\", \"MM/dd/yyyy\", \"0.00\", \"#,###\"]);\n```\n\n| id  | date       | price | qty   |\n| --- | ---------- | ----- | ----- |\n| 1   | 01/02/2018 | 77.99 | 375   |\n| 2   | 01/03/2018 | 8.13  | 7,864 |\n| 3   | 01/04/2018 | 56.72 | 4,912 |\n| 4   | 01/05/2018 | 72.42 | 534   |\n| 5   | 01/06/2018 | 8.20  | 31    |\n| 6   | 1/07/2018  | 74.73 | 4,139 |\n| 7   | 01/08/2018 | 7.54  | 2,725 |\n| 8   | 01/09/2018 | 59.17 | 3,095 |\n| 9   | 01/10/2018 | 55.85 | 5,443 |\n| 10  | 01/11/2018 | 32.13 | 6,988 |\n| ... |            |       |       |\n\n与之等效的 SQL 脚本是：\n\n```\ndef generateReportSQL(tbl, colNames, colFormat): sql(sqlColAlias(each(makeCall{format},sqlCol(colNames),colFormat),colNames), tbl)\ngenerateReportSQL(t, [\"id\", \"date\",\"price\",\"qty\"], [\"0\", \"MM/dd/yyyy\", \"0.00\", \"#,###\"]);\n// output\n< select format(id, \"0\") as id,format(date, \"MM/dd/yyyy\") as date,format(price, \"0.00\") as price,format(qty, \"#,###\") as qty from t >\n```\n"
    },
    "makeKey": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/makeKey.html",
        "signatures": [
            {
                "full": "makeKey(args...)",
                "name": "makeKey",
                "parameters": [
                    {
                        "full": "args...",
                        "name": "args..."
                    }
                ]
            }
        ],
        "markdown": "### [makeKey](https://docs.dolphindb.cn/zh/funcs/m/makeKey.html)\n\n\n\n#### 语法\n\nmakeKey(args...)\n\n#### 详情\n\n对于输入的多个 *args*，将它们的值组合为一个 BLOB 标量或向量。返回的结果可用作字典或集合的 key。相较于 `makeSortedKey`，`makeKey` 不会保存组合值的排序结果。\n\n#### 参数\n\n**args** 是多个标量或长度相同的向量。\n\n#### 返回值\n\nBLOB 标量或向量。\n\n#### 例子\n\n```\nmakeKey(`a1,`b1,`c1)\n// output: a1b1c1\n\nset(makeKey(1 2, 4 5))\n\nre=makeKey(`a1`a2, `_1`_2)\ndict(re,100 200)\n\n// output\na2_2->200\na1_1->100\n```\n\n相关函数：[makeSortedKey](https://docs.dolphindb.cn/zh/funcs/m/makeSortedKey.html)\n"
    },
    "makeSortedKey": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/makeSortedKey.html",
        "signatures": [
            {
                "full": "makeSortedKey(args...)",
                "name": "makeSortedKey",
                "parameters": [
                    {
                        "full": "args...",
                        "name": "args..."
                    }
                ]
            }
        ],
        "markdown": "### [makeSortedKey](https://docs.dolphindb.cn/zh/funcs/m/makeSortedKey.html)\n\n\n\n#### 语法\n\nmakeSortedKey(args...)\n\n#### 详情\n\n对于输入的多个 *args*，将它们的值组合为一个 BLOB 标量或向量。相较于 `makeKey`，`makeSortedKey` 内部会保存组合值的排序结果，但输出结果与 `makeKey` 相同。\n\n#### 参数\n\n**args** 是多个标量或长度相同的向量。\n\n#### 返回值\n\nBLOB 标量或向量。\n\n#### 例子\n\n```\nmakeSortedKey([`b,`a,`c], [`4,`2,`1])\n// output: [\"b4\",\"a2\",\"c1\"]\n\nset(makeSortedKey(1 2, 4 5))\n```\n"
    },
    "makeUnifiedCall": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/makeUnifiedCall.html",
        "signatures": [
            {
                "full": "makeUnifiedCall(func, args)",
                "name": "makeUnifiedCall",
                "parameters": [
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "args",
                        "name": "args"
                    }
                ]
            }
        ],
        "markdown": "### [makeUnifiedCall](https://docs.dolphindb.cn/zh/funcs/m/makeUnifiedCall.html)\n\n\n\n#### 语法\n\nmakeUnifiedCall(func, args)\n\n#### 详情\n\n它使用指定参数调用一个函数并生成脚本。 高阶函数 [unifiedCall](https://docs.dolphindb.cn/zh/funcs/ho_funcs/unifiedCall.html) 与 `makeUnifiedCall` 的区别是，`makeUnifiedCall` 不执行脚本。\n\n#### 参数\n\n**func** 是一个函数。\n\n**args** 是一个 tuple, 由所调用函数的参数所构成。从版本 2.00.11.3 起，args 可以是一个元代码的标量，其代码是一个元组表达式。\n\n#### 返回值\n\n一个元代码。\n\n#### 例子\n\n```\nmc = makeUnifiedCall(matrix, (1 2 3, 4 5 6));\nmc;\n// output: < matrix([1,2,3], [4,5,6]) >\nmc.eval();\n```\n\n| col1 | col2 |\n| ---- | ---- |\n| 1    | 4    |\n| 2    | 5    |\n| 3    | 6    |\n\n从版本2.00.11.3 起， args 支持传入一个元代码标量，其代码是一个元组表达式。\n\n通过下例的对比可以看到：\n\n* 当 args 是一个元组时，会将元组中变量的值传入，此时 a 的值为 < add(3, 5) >\n\n* 当 args 是一个元组表达式的元代码时，会将变量作为函数的参数，生成元代码，此时 b 的值为 < add(x, y) >\n\n```\nx=3\ny=5\na = makeUnifiedCall(add, (x,y)) // < add(3, 5) >\nb = makeUnifiedCall(add, <(x,y)>) // < add(x, y) >\n```\n\n因此，当 x 或 y 的值改变，b 的执行结果会将 x 和 y 的值动态传入，而 a 的执行结果不会随 x 和 y 的值变化\n\n```\nx = 6\na.eval() //计算 3+5\n```\n\n结果为 8 。\n\n```\nb.eval() // 计算 6+5\n```\n\n结果为 11 。\n\n下例中，函数 `makeUnifiedCall` 以 `sqlTuple` 生成的元组表达式的元代码为参数，调用自定义函数 f，其结果作为函数 sql 的参数 select ，从而生成元代码 c 。\n\n```\n// 自定义函数\nf = def (x,y)->(x-y)/(x+y)\n\n// 定义待查询的表\nt = table(1.0 2.0 3.0 as qty1, 1.0 3.0 7.0 as qty2)\n\n// 生成查询的元代码\nc = sql(select=makeUnifiedCall(f, sqlTuple(`qty1`qty2)), from=t)\n\n// 执行对应元代码\nc.eval()\n```\n\n| \\_qty1 |\n| ------ |\n| 0      |\n| -0.2   |\n| -0.4   |\n\n**Related information**\n\n[sqlTuple](https://docs.dolphindb.cn/zh/funcs/s/sqlTuple.html)\n"
    },
    "mannWhitneyUTest": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mannWhitneyUTest.html",
        "signatures": [
            {
                "full": "mannWhitneyUTest(X, Y, [correct=true])",
                "name": "mannWhitneyUTest",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "[correct=true]",
                        "name": "correct",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [mannWhitneyUTest](https://docs.dolphindb.cn/zh/funcs/m/mannWhitneyUTest.html)\n\n\n\n#### 语法\n\nmannWhitneyUTest(X, Y, \\[correct=true])\n\n#### 详情\n\n对 *X* 和 *Y* 进行 Mann-Whitney U 检验。\n\n#### 参数\n\n**X** 是一个数值向量。\n\n**Y** 是一个数值向量。\n\n**correct** 是一个布尔值，表示在求 p 值时是否考虑连续性校正。默认值为 true。\n\n#### 返回值\n\n返回一个字典，包含以下 key：\n\n* stat：一张表，包含三种不同备择假设下的 p 值\n\n* correct：求 p 值时是否考虑连续性校正\n\n* method：字符串 \"Mann-Whitney U test\"\n\n* U：U 统计量\n\n#### 例子\n\n```\nmannWhitneyUTest(5 1 4 3 5, 2 4 7 -1 0 4);\n\n// output\nstat->\n\nalternativeHypothesis                 pValue\n------------------------------------- --------\ntrue location shift is not equal to 0 0.518023\ntrue location shift is less than 0    0.259011\ntrue location shift is greater than 0 0.797036\n\ncorrect->true\nmethod->Mann-Whitney U test\nU->11\n```\n"
    },
    "manova": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/manova.html",
        "signatures": [
            {
                "full": "manova(X, group)",
                "name": "manova",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "group",
                        "name": "group"
                    }
                ]
            }
        ],
        "markdown": "### [manova](https://docs.dolphindb.cn/zh/funcs/m/manova.html)\n\n\n\n#### 语法\n\nmanova(X, group)\n\n#### 详情\n\n对 *X* 进行多因素方差分析（MANOVA）。\n\n#### 参数\n\n**X** 是一个矩阵或所有列均为数值的表。\n\n**group** 是一个与 *X* 中每一列长度相同的向量，表示分组。\n\n#### 返回值\n\n一个字典。\n\n#### 例子\n\n```\na=29.6 24.3 1.5 20.2 2.6 44.5 2.4 20 9.5\nb=27.3 68.4 3.8 34.8 4.6 26.3 5.9 20 5.6\nc=50.8 60.2 1.0 30.1 2.1 27.9 2.3 20 8.8\ng=1 1 2 1 2 1 2 1 2\nt=table(a,b,c,g)\nmanova(select a,b,c from t, t.g);\n\n// output\ndfT->8\ndfB->1\ngnames->[1,2]\ngmdist->\n#0        #1\n--------- ---------\n0         16.458055\n16.458055 0\n\nmdist->[5.35501,5.171516,0.132336,1.335303,0.043425,5.384036,0.07295,2.844008,0.661416]\nchisq->[10.056959]\nB->\n#0          #1          #2\n----------- ----------- -----------\n1250.307556 1601.627111 1805.355556\n1601.627111 2051.662722 2312.636111\n1805.355556 2312.636111 2606.805556\n\nlambda->[0.160648]\nW->\n#0       #1        #2\n-------- --------- --------\n453.968  -151.966  16.31\n-151.966 1477.6995 1008.395\n16.31    1008.395  1182.63\n\nT->\n#0          #1          #2\n----------- ----------- -----------\n1704.275556 1449.661111 1821.665556\n1449.661111 3529.362222 3321.031111\n1821.665556 3321.031111 3789.435556\n\n\nchisqdf->[3]\nP->[0.018088]\ndfW->7\neigenval->[5.224779,2.757998E-16,-1.552556E-15]\neigenvec->\n#0       #1        #2\n-------- --------- ---------\n0.099362 0.08179   0.023313\n0.029973 -0.010892 0.107448\n0.023044 -0.046981 -0.111469\n\n\ncanon->\n#0        #1        #2\n--------- --------- ---------\n2.047837  -0.369203 -2.271294\n2.969714  -1.691977 0.973456\n-2.596193 -0.071875 0.09971\n0.861618  -0.247207 0.622822\n-2.437568 -0.042299 0.088698\n2.970655  1.936238  0.521256\n-2.413867 -0.082213 0.201424\n0.165404  0.372149  0.153761\n-1.567601 0.196387  -0.389832\n```\n"
    },
    "mask": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mask.html",
        "signatures": [
            {
                "full": "mask(X, Y)",
                "name": "mask",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [mask](https://docs.dolphindb.cn/zh/funcs/m/mask.html)\n\n\n\n#### 语法\n\nmask(X, Y)\n\n#### 详情\n\n对 *X* 中每个元素应用条件 *Y*。若结果为 false，保留该元素。若结果为 true，将其替换为 NULL。\n\n#### 参数\n\n**X** 是一个标量、向量或矩阵。\n\n**Y** 是一个布尔表达式。\n\n#### 返回值\n\n返回一个与 *X* 一致的对象（标量返回标量，向量返回同长向量，矩阵返回同形矩阵）。\n\n#### 例子\n\n```\nx=1..10\nmask(x, x>6);\n// output: [1,2,3,4,5,6,,,,]\n\nm=matrix(1 2 3, 4 5 6, 7 8 9);\nm;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1  | 4  | 7  |\n| 2  | 5  | 8  |\n| 3  | 6  | 9  |\n\n```\nmask(m, m<6);\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n|    |    | 7  |\n|    |    | 8  |\n|    | 6  | 9  |\n"
    },
    "matchAll": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/matchall.html",
        "signatures": [
            {
                "full": "matchAll(textCol, terms, [scoreColName])",
                "name": "matchAll",
                "parameters": [
                    {
                        "full": "textCol",
                        "name": "textCol"
                    },
                    {
                        "full": "terms",
                        "name": "terms"
                    },
                    {
                        "full": "[scoreColName]",
                        "name": "scoreColName",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [matchAll](https://docs.dolphindb.cn/zh/funcs/m/matchall.html)\n\n\n\n#### 语法\n\nmatchAll(textCol, terms, \\[scoreColName])\n\n#### 详情\n\n该函数结合 SQL 语句的 WHERE 子句，针对 PKEY 存储引擎中设置文本索引的列进行文本匹配，返回符合所有指定匹配词的行。\n\n#### 参数\n\n**textCol** 待查询的列，即 PKEY 存储引擎中设置了文本索引的列。\n\n**terms** STRING 类型标量，用于指定待查询的词。若需查询多个词，可将它们用空格分隔写入该字符串中。\n\n**scoreColName** 可选参数，STRING 类型标量，表示输出结果中文本匹配得分列的列名。默认值为空，此时不输出得分列。匹配得分代表数据在分区内的匹配程度，不同分区的分数不可比较。\n\n#### 返回值\n\n返回一个布尔值，表示该列是否匹配所有指定词。\n\n#### 例子\n\n```\n// 构造数据\nstringColumn = [\"There are some apples and oranges.\",\"Mike likes apples.\",\"Alice likes oranges.\",\"Mike gives Alice an apple.\",\"Alice gives Mike an orange.\",\"John likes peaches, so he does not give them to anyone.\",\"Mike, can you give me some apples?\",\"Alice, can you give me some oranges?\",\"Mike traded an orange for an apple with Alice.\"]\nt = table([1,1,1,2,2,2,3,3,3] as id1, [1,2,3,1,2,3,1,2,3] as id2, stringColumn as remark) \nif(existsDatabase(\"dfs://textDB\")) dropDatabase(\"dfs://textDB\")\ndb = database(directory=\"dfs://textDB\", partitionType=VALUE, partitionScheme=[1,2,3], engine=\"PKEY\")\npt = createPartitionedTable(dbHandle=db, table=t, tableName=\"pt\", partitionColumns=\"id1\",primaryKey=`id1`id2,indexes={\"remark\":\"textindex(parser=english, full=false, lowercase=true, stem=true)\"})\npt.tableInsert(t)\n\n// 匹配包含 apple 和 orange 的行\nselect * from pt where matchAll(textCol=remark,terms=\"apple orange\")\n```\n\n<table id=\"table_lxp_c5m_cdc\"><thead><tr><th>\n\nid1\n\n</th><th>\n\nid2\n\n</th><th>\n\nremark\n\n</th></tr></thead><tbody><tr><td>\n\n1\n\n</td><td>\n\n1\n\n</td><td>\n\nThere are some apples and oranges.\n\n</td></tr><tr><td>\n\n3\n\n</td><td>\n\n3\n\n</td><td>\n\nMike traded an orange for an apple with Alice.\n\n</td></tr></tbody>\n</table>\n"
    },
    "matchAny": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/matchany.html",
        "signatures": [
            {
                "full": "matchAny(textCol, terms, [scoreColName])",
                "name": "matchAny",
                "parameters": [
                    {
                        "full": "textCol",
                        "name": "textCol"
                    },
                    {
                        "full": "terms",
                        "name": "terms"
                    },
                    {
                        "full": "[scoreColName]",
                        "name": "scoreColName",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [matchAny](https://docs.dolphindb.cn/zh/funcs/m/matchany.html)\n\n\n\n#### 语法\n\nmatchAny(textCol, terms, \\[scoreColName])\n\n#### 详情\n\n该函数用于 SQL 语句的 WHERE 子句，针对 PKEY 存储引擎中设置文本索引的列进行文本匹配，返回符合任一指定匹配词的行。\n\n#### 参数\n\n**textCol** 待查询的列，即 PKEY 存储引擎中设置了文本索引的列。\n\n**terms** STRING 类型标量，用于指定待查询的词。若需查询多个词，可将它们用空格分隔写入该字符串中。\n\n**scoreColName** 可选参数，STRING 类型标量，表示输出结果中文本匹配得分列的列名。默认值为空，此时不输出得分列。匹配得分代表数据在分区内的匹配程度，不同分区的分数不可比较。\n\n#### 返回值\n\n返回一个布尔值。\n\n#### 例子\n\n```\n// 构造数据\nstringColumn = [\"There are some apples and oranges.\",\"Mike likes apples.\",\"Alice likes oranges.\",\"Mike gives Alice an apple.\",\"Alice gives Mike an orange.\",\"John likes peaches, so he does not give them to anyone.\",\"Mike, can you give me some apples?\",\"Alice, can you give me some oranges?\",\"Mike traded an orange for an apple with Alice.\"]\nt = table([1,1,1,2,2,2,3,3,3] as id1, [1,2,3,1,2,3,1,2,3] as id2, stringColumn as remark) \nif(existsDatabase(\"dfs://textDB\")) dropDatabase(\"dfs://textDB\")\ndb = database(directory=\"dfs://textDB\", partitionType=VALUE, partitionScheme=[1,2,3], engine=\"PKEY\")\npt = createPartitionedTable(dbHandle=db, table=t, tableName=\"pt\", partitionColumns=\"id1\",primaryKey=`id1`id2,indexes={\"remark\":\"textindex(parser=english, full=false, lowercase=true, stem=true)\"})\npt.tableInsert(t)\n\n// 匹配包含 apple 或 orange 的行\nselect * from pt where matchAny(textCol=remark,terms=\"apple orange\")\n```\n\n<table id=\"table_xc3_qtm_cdc\"><thead><tr><th>\n\nid1\n\n</th><th>\n\nid2\n\n</th><th>\n\nremark\n\n</th></tr></thead><tbody><tr><td>\n\n1\n\n</td><td>\n\n1\n\n</td><td>\n\nThere are some apples and oranges.\n\n</td></tr><tr><td>\n\n1\n\n</td><td>\n\n2\n\n</td><td>\n\nMike likes apples.\n\n</td></tr><tr><td>\n\n1\n\n</td><td>\n\n3\n\n</td><td>\n\nAlice likes oranges.\n\n</td></tr><tr><td>\n\n2\n\n</td><td>\n\n1\n\n</td><td>\n\nMike gives Alice an apple.\n\n</td></tr><tr><td>\n\n2\n\n</td><td>\n\n2\n\n</td><td>\n\nAlice gives Mike an orange.\n\n</td></tr><tr><td>\n\n3\n\n</td><td>\n\n1\n\n</td><td>\n\nMike, can you give me some apples?\n\n</td></tr><tr><td>\n\n3\n\n</td><td>\n\n2\n\n</td><td>\n\nAlice, can you give me some oranges?\n\n</td></tr><tr><td>\n\n3\n\n</td><td>\n\n3\n\n</td><td>\n\nMike traded an orange for an apple with Alice.\n\n</td></tr></tbody>\n</table>\n"
    },
    "matchedRowCount": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/matchedrowcount.html",
        "signatures": [
            {
                "full": "matchedRowCount()",
                "name": "matchedRowCount",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [matchedRowCount](https://docs.dolphindb.cn/zh/funcs/m/matchedrowcount.html)\n\n首发版本：3.00.5\n\n\n\n#### 语法\n\nmatchedRowCount()\n\n#### 详情\n\n返回当前 session 中最后一次执行的 INSERT INTO、DELETE、UPDATE 语句所影响的行数。\n\n如果当前 session 中尚未执行过这些语句，则 `matchedRowCount` 返回 0。\n\n`matchedRowCount` 计数规则由语句决定：\n\n* UPDATE：匹配到的行数，而非实际修改的行数。\n\n* DELETE：匹配到的行数，与实际修改的行数一致。\n\n* INSERT INTO：成功插入的行数，不统计更新的行。\n\n#### 参数\n\n无\n\n#### 返回值\n\n整型标量，表示受影响的行数。\n\n#### 例子\n\n```\nt=table(`XOM`GS`FB as ticker, 100 80 120 as volume);\nINSERT INTO t values(`AMZN`GS, 300 100);\nmatchedRowCount()\n// output: 2\n\nUPDATE t set volume=100 where ticker=`GS\nmatchedRowCount()\n// output: 2\n\nsym=`A`B`C`D`E\nid=5 5 3 2 1\nval=52 64 25 48 71\nt=keyedTable(`sym,sym,id,val)\n\nINSERT INTO t values(`A`K, 6 3, 20 62)\nmatchedRowCount()  \n// output: 1\n\n\nt = table(1..100 as id, rand(100, 100) as value)  \nDELETE from t where id < 50  \n\nmatchedRowCount()\n// output: 49\n\ndbName=\"dfs://matchedRowCount\"\nif(existsDatabase(dbName)){\n\tdropDatabase(dbName)\t\n}\ndb = database(dbName, VALUE, 1..10)\nt = table(1..10 as id, 1..10 as value)\npt = db.createPartitionedTable(t, `pt, `id)\n\nINSERT INTO t VALUES(11 12 13, 20 30 40)\n\nmatchedRowCount() \n// output: 3\n```\n"
    },
    "matchFuzzy": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/matchFuzzy.html",
        "signatures": [
            {
                "full": "matchFuzzy(textCol, term, minimumSimilarity, prefixLength, [scoreColName])",
                "name": "matchFuzzy",
                "parameters": [
                    {
                        "full": "textCol",
                        "name": "textCol"
                    },
                    {
                        "full": "term",
                        "name": "term"
                    },
                    {
                        "full": "minimumSimilarity",
                        "name": "minimumSimilarity"
                    },
                    {
                        "full": "prefixLength",
                        "name": "prefixLength"
                    },
                    {
                        "full": "[scoreColName]",
                        "name": "scoreColName",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [matchFuzzy](https://docs.dolphindb.cn/zh/funcs/m/matchFuzzy.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\n```\nmatchFuzzy(textCol, term, minimumSimilarity, prefixLength, [scoreColName])\n```\n\n#### 详情\n\n该函数用于 SQL 语句的 WHERE 子句，针对 PKEY 存储引擎中设置文本索引的列进行文本模糊匹配，以便在用户输入存在拼写错误或不完全匹配的情况下，依然能够返回相关度较高的查询结果。\n\n**Note:**\n\n* 当 *minimumSimilarity* 设置为 1 时，意味着单词完全匹配，相当于 `matchAny` 函数。\n\n* 仅支持对单个单词的查询，若 *term*中包含多个单词，则查询结果为空。\n\n* 当 *prefixLength*大于 *term* 的长度时，将自动调整为 *term* 的长度。\n\n#### 参数\n\n**textCol**待查询的列，即 PKEY 存储引擎中设置了文本索引的列。\n\n**term** STRING 类型标量，用于指定待查询的词。仅支持单个单词查询。\n\n**minimumSimilarity**DOUBLE 类型标量，表示匹配结果需要的最小近似度，取值范围为 \\[0,1]。\n\n**prefixLength** 非负整数，表示匹配结果需与 *term* 具有相同的前缀的长度。\n\n**scoreColName**: 可选参数，STRING 类型标量，表示输出结果中文本匹配得分列的列名。默认值为空，此时不输出得分列。匹配得分代表数据在分区内的匹配程度，不同分区的分数不可比较。\n\n#### 例子\n\n```\n// 构造数据\nstringColumn = [\"There are some apples and oranges.\",\"Mike likes apples.\",\"Alice likes oranges.\",\"Mike gives Alice an apple.\",\"Alice gives Mike an orange.\",\"John likes peaches, so he does not give them to anyone.\",\"Mike, can you give me some apples?\",\"Alice, can you give me some oranges?\",\"Alice made apple pie.\"]\nt = table([1,1,1,2,2,2,3,3,3] as id1, [1,2,3,1,2,3,1,2,3] as id2, stringColumn as remark) \nif(existsDatabase(\"dfs://textDB\")) dropDatabase(\"dfs://textDB\")\ndb = database(directory=\"dfs://textDB\", partitionType=VALUE, partitionScheme=[1,2,3], engine=\"PKEY\")\npt = createPartitionedTable(dbHandle=db, table=t, tableName=\"pt\", partitionColumns=\"id1\",primaryKey=`id1`id2,indexes={\"remark\":\"textindex(parser=english, full=false, lowercase=true, stem=true)\"})\npt.tableInsert(t)\n\n// 模糊匹配 make，前缀必须为m\nselect * from pt where matchFuzzy(textCol=remark,term=\"make\",minimumSimilarity=0.6,prefixLength=1)\n```\n\n| id1 | id2 | remark                             |\n| --- | --- | ---------------------------------- |\n| 1   | 2   | Mike likes apples.                 |\n| 2   | 1   | Mike gives Alice an apple.         |\n| 2   | 2   | Alice gives Mike an orange.        |\n| 3   | 1   | Mike, can you give me some apples? |\n| 3   | 3   | Alice made apple pie.              |\n\n```\n// 模糊匹配 make，前缀必须为 ma，将得分列输出为 score\nselect * from pt where matchFuzzy(textCol=remark,term=\"make\",minimumSimilarity=0.6,prefixLength=2,scoreColName=\"score\")\n```\n\n| id1 | id2 | remark                | score              |\n| --- | --- | --------------------- | ------------------ |\n| 3   | 3   | Alice made apple pie. | 0.7027325630187988 |\n"
    },
    "matchPhrase": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/matchphrase.html",
        "signatures": [
            {
                "full": "matchPhrase(textCol, phrase, [scoreColName])",
                "name": "matchPhrase",
                "parameters": [
                    {
                        "full": "textCol",
                        "name": "textCol"
                    },
                    {
                        "full": "phrase",
                        "name": "phrase"
                    },
                    {
                        "full": "[scoreColName]",
                        "name": "scoreColName",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [matchPhrase](https://docs.dolphindb.cn/zh/funcs/m/matchphrase.html)\n\n\n\n#### 语法\n\nmatchPhrase(textCol, phrase, \\[scoreColName])\n\n#### 详情\n\n该函数用于 SQL 语句的 WHERE 子句，针对 PKEY 存储引擎中设置文本索引的列进行文本匹配，返回包含指定短语的行。\n\n#### 参数\n\n**textCol** 待查询的列，即 PKEY 存储引擎中设置了文本索引的列。\n\n**phrase**STRING 类型标量，用于指定待查询的短语。\n\n**scoreColName** 可选参数，STRING 类型标量，表示输出结果中文本匹配得分列的列名。默认值为空，此时不输出得分列。匹配得分代表数据在分区内的匹配程度，不同分区的分数不可比较。\n\n#### 返回值\n\n返回一个布尔值。\n\n#### 例子\n\n```\n// 构造数据\nstringColumn = [\"There are some apples and oranges.\",\"Mike likes apples.\",\"Alice likes oranges.\",\"Mike gives Alice an apple.\",\"Alice gives Mike an orange.\",\"John likes peaches, so he does not give them to anyone.\",\"Mike, can you give me some apples?\",\"Alice, can you give me some oranges?\",\"Mike traded an orange for an apple with Alice.\"]\nt = table([1,1,1,2,2,2,3,3,3] as id1, [1,2,3,1,2,3,1,2,3] as id2, stringColumn as remark) \nif(existsDatabase(\"dfs://textDB\")) dropDatabase(\"dfs://textDB\")\ndb = database(directory=\"dfs://textDB\", partitionType=VALUE, partitionScheme=[1,2,3], engine=\"PKEY\")\npt = createPartitionedTable(dbHandle=db, table=t, tableName=\"pt\", partitionColumns=\"id1\",primaryKey=`id1`id2,indexes={\"remark\":\"textindex(parser=english, full=false, lowercase=true, stem=true)\"})\npt.tableInsert(t)\n\n// 匹配包含短语 give Mike 的行\nselect * from pt where matchPhrase(remark,\"give Mike\")\n```\n\n<table id=\"table_hnv_m5m_cdc\"><thead><tr><th>\n\nid1\n\n</th><th>\n\nid2\n\n</th><th>\n\nremark\n\n</th></tr></thead><tbody><tr><td>\n\n2\n\n</td><td>\n\n2\n\n</td><td>\n\nAlice gives Mike an orange\n\n</td></tr></tbody>\n</table>\n"
    },
    "matchPhraseInfix": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/matchphraseinfix.html",
        "signatures": [
            {
                "full": "matchPhraseInfix(textCol, suffix, phrase, prefix, [scoreColName])",
                "name": "matchPhraseInfix",
                "parameters": [
                    {
                        "full": "textCol",
                        "name": "textCol"
                    },
                    {
                        "full": "suffix",
                        "name": "suffix"
                    },
                    {
                        "full": "phrase",
                        "name": "phrase"
                    },
                    {
                        "full": "prefix",
                        "name": "prefix"
                    },
                    {
                        "full": "[scoreColName]",
                        "name": "scoreColName",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [matchPhraseInfix](https://docs.dolphindb.cn/zh/funcs/m/matchphraseinfix.html)\n\n\n\n#### 语法\n\nmatchPhraseInfix(textCol, suffix, phrase, prefix, \\[scoreColName])\n\n#### 详情\n\n该函数用于 SQL 语句的 WHERE 子句，针对 PKEY 存储引擎中设置文本索引的列进行文本匹配，若包含特定短语，且短语前是某一特定后缀的单词，短语后是某一特定前缀的单词，则该行匹配成功。返回所有匹配成功的行。\n\n#### 参数\n\n**textCol** 待查询的列，即 PKEY 存储引擎中设置了文本索引的列。\n\n**suffix**STRING 类型标量，用于指定待查询的后缀。\n\n**phrase**STRING 类型标量，用于指定待查询的短语。\n\n**prefix**STRING 类型标量，用于指定待查询的前缀。\n\n**scoreColName** 可选参数，STRING 类型标量，表示输出结果中文本匹配得分列的列名。默认值为空，此时不输出得分列。匹配得分代表数据在分区内的匹配程度，不同分区的分数不可比较。\n\n#### 返回值\n\n返回一个布尔值。\n\n#### 例子\n\n```\n// 构造数据\nstringColumn = [\"There are some apples and oranges.\",\"Mike likes apples.\",\"Alice likes oranges.\",\"Mike gives Alice an apple.\",\"Alice gives Mike an orange.\",\"John likes peaches, so he does not give them to anyone.\",\"Mike, can you give me some apples?\",\"Alice, can you give me some oranges?\",\"Mike traded an orange for an apple with Alice.\"]\nt = table([1,1,1,2,2,2,3,3,3] as id1, [1,2,3,1,2,3,1,2,3] as id2, stringColumn as remark) \nif(existsDatabase(\"dfs://textDB\")) dropDatabase(\"dfs://textDB\")\ndb = database(directory=\"dfs://textDB\", partitionType=VALUE, partitionScheme=[1,2,3], engine=\"PKEY\")\npt = createPartitionedTable(dbHandle=db, table=t, tableName=\"pt\", partitionColumns=\"id1\",primaryKey=`id1`id2,indexes={\"remark\":\"textindex(parser=english, full=false, lowercase=true, stem=true)\"})\npt.tableInsert(t)\n\n// 匹配包含单词 give，且 give 前为 ke 后缀单词, 后为 al 前缀单词的行\nselect * from pt where matchPhraseInfix(remark,\"ke\",\"give\",\"al\")\n```\n\n<table id=\"table_ftg_zvm_cdc\"><thead><tr><th>\n\nid1\n\n</th><th>\n\nid2\n\n</th><th>\n\nremark\n\n</th></tr></thead><tbody><tr><td>\n\n2\n\n</td><td>\n\n1\n\n</td><td>\n\nMike gives Alice an apple.\n\n</td></tr></tbody>\n</table>\n"
    },
    "matchPhrasePrefix": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/matchphraseprefix.html",
        "signatures": [
            {
                "full": "matchPhrasePrefix(textCol, phrase, prefix, [scoreColName])",
                "name": "matchPhrasePrefix",
                "parameters": [
                    {
                        "full": "textCol",
                        "name": "textCol"
                    },
                    {
                        "full": "phrase",
                        "name": "phrase"
                    },
                    {
                        "full": "prefix",
                        "name": "prefix"
                    },
                    {
                        "full": "[scoreColName]",
                        "name": "scoreColName",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [matchPhrasePrefix](https://docs.dolphindb.cn/zh/funcs/m/matchphraseprefix.html)\n\n\n\n#### 语法\n\nmatchPhrasePrefix(textCol, phrase, prefix, \\[scoreColName])\n\n#### 详情\n\n该函数用于 SQL 语句的 WHERE 子句，针对 PKEY 存储引擎中设置文本索引的列进行文本匹配，若包含特定短语，且短语后是某一特定前缀的单词，则该行匹配成功。返回所有匹配成功的行。\n\n#### 参数\n\n**textCol** 待查询的列，即 PKEY 存储引擎中设置了文本索引的列。\n\n**phrase**STRING 类型标量，用于指定待查询的短语。\n\n**prefix**STRING 类型标量，用于指定待查询的前缀。\n\n**scoreColName** 可选参数，STRING 类型标量，表示输出结果中文本匹配得分列的列名。默认值为空，此时不输出得分列。匹配得分代表数据在分区内的匹配程度，不同分区的分数不可比较。\n\n#### 返回值\n\n返回一个布尔值。\n\n#### 例子\n\n```\n// 构造数据\nstringColumn = [\"There are some apples and oranges.\",\"Mike likes apples.\",\"Alice likes oranges.\",\"Mike gives Alice an apple.\",\"Alice gives Mike an orange.\",\"John likes peaches, so he does not give them to anyone.\",\"Mike, can you give me some apples?\",\"Alice, can you give me some oranges?\",\"Mike traded an orange for an apple with Alice.\"]\nt = table([1,1,1,2,2,2,3,3,3] as id1, [1,2,3,1,2,3,1,2,3] as id2, stringColumn as remark) \nif(existsDatabase(\"dfs://textDB\")) dropDatabase(\"dfs://textDB\")\ndb = database(directory=\"dfs://textDB\", partitionType=VALUE, partitionScheme=[1,2,3], engine=\"PKEY\")\npt = createPartitionedTable(dbHandle=db, table=t, tableName=\"pt\", partitionColumns=\"id1\",primaryKey=`id1`id2,indexes={\"remark\":\"textindex(parser=english, full=false, lowercase=true, stem=true)\"})\npt.tableInsert(t)\n\n// 匹配包含单词 give，且 give 后为 mi 前缀单词的行\nselect * from pt where matchPhrasePrefix(remark,\"give\",\"mi\")\n```\n\n<table id=\"table_gnl_kvm_cdc\"><thead><tr><th>\n\nid1\n\n</th><th>\n\nid2\n\n</th><th>\n\nremark\n\n</th></tr></thead><tbody><tr><td>\n\n2\n\n</td><td>\n\n2\n\n</td><td>\n\nAlice gives Mike an orange.\n\n</td></tr></tbody>\n</table>\n"
    },
    "matchPhraseSuffix": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/matchphrasesuffix.html",
        "signatures": [
            {
                "full": "matchPhraseSuffix(textCol, suffix, phrase, [scoreColName])",
                "name": "matchPhraseSuffix",
                "parameters": [
                    {
                        "full": "textCol",
                        "name": "textCol"
                    },
                    {
                        "full": "suffix",
                        "name": "suffix"
                    },
                    {
                        "full": "phrase",
                        "name": "phrase"
                    },
                    {
                        "full": "[scoreColName]",
                        "name": "scoreColName",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [matchPhraseSuffix](https://docs.dolphindb.cn/zh/funcs/m/matchphrasesuffix.html)\n\n\n\n#### 语法\n\nmatchPhraseSuffix(textCol, suffix, phrase, \\[scoreColName])\n\n#### 详情\n\n该函数用于 SQL 语句的 WHERE 子句，针对 PKEY 存储引擎中设置文本索引的列进行文本匹配，若包含特定短语，且短语前是某一特定后缀的单词，则该行匹配成功。返回所有匹配成功的行。\n\n#### 参数\n\n**textCol** 待查询的列，即 PKEY 存储引擎中设置了文本索引的列。\n\n**suffix**STRING 类型标量，用于指定待查询的后缀。\n\n**phrase**STRING 类型标量，用于指定待查询的短语。\n\n**scoreColName** 可选参数，STRING 类型标量，表示输出结果中文本匹配得分列的列名。默认值为空，此时不输出得分列。匹配得分代表数据在分区内的匹配程度，不同分区的分数不可比较。\n\n#### 返回值\n\n返回一个布尔值。\n\n#### 例子\n\n```\n// 构造数据\nstringColumn = [\"There are some apples and oranges.\",\"Mike likes apples.\",\"Alice likes oranges.\",\"Mike gives Alice an apple.\",\"Alice gives Mike an orange.\",\"John likes peaches, so he does not give them to anyone.\",\"Mike, can you give me some apples?\",\"Alice, can you give me some oranges?\",\"Mike traded an orange for an apple with Alice.\"]\nt = table([1,1,1,2,2,2,3,3,3] as id1, [1,2,3,1,2,3,1,2,3] as id2, stringColumn as remark) \nif(existsDatabase(\"dfs://textDB\")) dropDatabase(\"dfs://textDB\")\ndb = database(directory=\"dfs://textDB\", partitionType=VALUE, partitionScheme=[1,2,3], engine=\"PKEY\")\npt = createPartitionedTable(dbHandle=db, table=t, tableName=\"pt\", partitionColumns=\"id1\",primaryKey=`id1`id2,indexes={\"remark\":\"textindex(parser=english, full=false, lowercase=true, stem=true)\"})\npt.tableInsert(t)\n\n// 匹配包含单词 give，且 give 前为 ke 后缀单词的行\nselect * from pt where matchPhraseSuffix(remark,\"ke\",\"give\")\n```\n\n<table id=\"table_n3w_tvm_cdc\"><thead><tr><th>\n\nid1\n\n</th><th>\n\nid2\n\n</th><th>\n\nremark\n\n</th></tr></thead><tbody><tr><td>\n\n2\n\n</td><td>\n\n1\n\n</td><td>\n\nMike gives Alice an apple.\n\n</td></tr></tbody>\n</table>\n"
    },
    "matchPrefix": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/matchprefix.html",
        "signatures": [
            {
                "full": "matchPrefix(textCol, prefix, [scoreColName])",
                "name": "matchPrefix",
                "parameters": [
                    {
                        "full": "textCol",
                        "name": "textCol"
                    },
                    {
                        "full": "prefix",
                        "name": "prefix"
                    },
                    {
                        "full": "[scoreColName]",
                        "name": "scoreColName",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [matchPrefix](https://docs.dolphindb.cn/zh/funcs/m/matchprefix.html)\n\n\n\n#### 语法\n\nmatchPrefix(textCol, prefix, \\[scoreColName])\n\n#### 详情\n\n该函数用于 SQL 语句的 WHERE 子句，针对 PKEY 存储引擎中设置文本索引的列进行前缀匹配，返回包含指定前缀的行。\n\n#### 参数\n\n**textCol** 待查询的列，即 PKEY 存储引擎中设置了文本索引的列。\n\n**prefix**STRING 类型标量，用于指定待查询的前缀。\n\n**scoreColName** 可选参数，STRING 类型标量，表示输出结果中文本匹配得分列的列名。默认值为空，此时不输出得分列。匹配得分代表数据在分区内的匹配程度，不同分区的分数不可比较。\n\n#### 返回值\n\n返回一个布尔值。\n\n#### 例子\n\n```\n// 构造数据\nstringColumn = [\"There are some apples and oranges.\",\"Mike likes apples.\",\"Alice likes oranges.\",\"Mike gives Alice an apple.\",\"Alice gives Mike an orange.\",\"John likes peaches, so he does not give them to anyone.\",\"Mike, can you give me some apples?\",\"Alice, can you give me some oranges?\",\"Mike traded an orange for an apple with Alice.\"]\nt = table([1,1,1,2,2,2,3,3,3] as id1, [1,2,3,1,2,3,1,2,3] as id2, stringColumn as remark) \nif(existsDatabase(\"dfs://textDB\")) dropDatabase(\"dfs://textDB\")\ndb = database(directory=\"dfs://textDB\", partitionType=VALUE, partitionScheme=[1,2,3], engine=\"PKEY\")\npt = createPartitionedTable(dbHandle=db, table=t, tableName=\"pt\", partitionColumns=\"id1\",primaryKey=`id1`id2,indexes={\"remark\":\"textindex(parser=english, full=false, lowercase=true, stem=true)\"})\npt.tableInsert(t)\n\n// 匹配包含前缀是 app 的单词的行\nselect * from pt where matchPrefix(remark,\"app\")\n```\n\n<table id=\"table_dlq_s5m_cdc\"><thead><tr><th>\n\nid1\n\n</th><th>\n\nid2\n\n</th><th>\n\nremark\n\n</th></tr></thead><tbody><tr><td>\n\n1\n\n</td><td>\n\n1\n\n</td><td>\n\nThere are some apples and oranges.\n\n</td></tr><tr><td>\n\n1\n\n</td><td>\n\n2\n\n</td><td>\n\nMike likes apples.\n\n</td></tr><tr><td>\n\n2\n\n</td><td>\n\n1\n\n</td><td>\n\nMike gives Alice an apple.\n\n</td></tr><tr><td>\n\n3\n\n</td><td>\n\n1\n\n</td><td>\n\nMike, can you give me some apples?\n\n</td></tr><tr><td>\n\n3\n\n</td><td>\n\n3\n\n</td><td>\n\nMike traded an orange for an apple with Alice.\n\n</td></tr></tbody>\n</table>\n"
    },
    "matchPrefixSuffix": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/matchprefixsuffix.html",
        "signatures": [
            {
                "full": "matchPrefixSuffix(textCol, prefix, suffix, [scoreColName])",
                "name": "matchPrefixSuffix",
                "parameters": [
                    {
                        "full": "textCol",
                        "name": "textCol"
                    },
                    {
                        "full": "prefix",
                        "name": "prefix"
                    },
                    {
                        "full": "suffix",
                        "name": "suffix"
                    },
                    {
                        "full": "[scoreColName]",
                        "name": "scoreColName",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [matchPrefixSuffix](https://docs.dolphindb.cn/zh/funcs/m/matchprefixsuffix.html)\n\n\n\n#### 语法\n\nmatchPrefixSuffix(textCol, prefix, suffix, \\[scoreColName])\n\n#### 详情\n\n该函数用于 SQL 语句的 WHERE 子句，针对 PKEY 存储引擎中设置文本索引的列进行前缀和后缀匹配，检查是否有词同时满足前缀和后缀条件，并返回匹配成功的行。\n\n#### 参数\n\n**textCol** 待查询的列，即 PKEY 存储引擎中设置了文本索引的列。\n\n**prefix**STRING 类型标量，用于指定待查询的前缀。\n\n**suffix**STRING 类型标量，用于指定待查询的后缀。\n\n**scoreColName** 可选参数，STRING 类型标量，表示输出结果中文本匹配得分列的列名。默认值为空，此时不输出得分列。匹配得分代表数据在分区内的匹配程度，不同分区的分数不可比较。\n\n#### 返回值\n\n返回一个布尔值。\n\n#### 例子\n\n```\n// 构造数据\nstringColumn = [\"There are some apples and oranges.\",\"Mike likes apples.\",\"Alice likes oranges.\",\"Mike gives Alice an apple.\",\"Alice gives Mike an orange.\",\"John likes peaches, so he does not give them to anyone.\",\"Mike, can you give me some apples?\",\"Alice, can you give me some oranges?\",\"Mike traded an orange for an apple with Alice.\"]\nt = table([1,1,1,2,2,2,3,3,3] as id1, [1,2,3,1,2,3,1,2,3] as id2, stringColumn as remark) \nif(existsDatabase(\"dfs://textDB\")) dropDatabase(\"dfs://textDB\")\ndb = database(directory=\"dfs://textDB\", partitionType=VALUE, partitionScheme=[1,2,3], engine=\"PKEY\")\npt = createPartitionedTable(dbHandle=db, table=t, tableName=\"pt\", partitionColumns=\"id1\",primaryKey=`id1`id2,indexes={\"remark\":\"textindex(parser=english, full=false, lowercase=true, stem=true)\"})\npt.tableInsert(t)\n\n// 匹配包含以 m 为前缀，ke 为后缀的单词的行\nselect * from pt where matchPrefixSuffix(remark,\"m\",\"ke\")\n```\n\n<table id=\"table_yyz_fvm_cdc\"><thead><tr><th>\n\nid1\n\n</th><th>\n\nid2\n\n</th><th>\n\nremark\n\n</th></tr></thead><tbody><tr><td>\n\n1\n\n</td><td>\n\n2\n\n</td><td>\n\nMike likes apples.\n\n</td></tr><tr><td>\n\n2\n\n</td><td>\n\n1\n\n</td><td>\n\nMike gives Alice an apple.\n\n</td></tr><tr><td>\n\n2\n\n</td><td>\n\n2\n\n</td><td>\n\nAlice gives Mike an orange.\n\n</td></tr><tr><td>\n\n3\n\n</td><td>\n\n1\n\n</td><td>\n\nMike, can you give me some apples?\n\n</td></tr><tr><td>\n\n3\n\n</td><td>\n\n3\n\n</td><td>\n\nMike traded an orange for an apple with Alice.\n\n</td></tr></tbody>\n</table>\n"
    },
    "matchSpan": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/matchspan.html",
        "signatures": [
            {
                "full": "matchSpan(textCol, span, slop, [scoreColName])",
                "name": "matchSpan",
                "parameters": [
                    {
                        "full": "textCol",
                        "name": "textCol"
                    },
                    {
                        "full": "span",
                        "name": "span"
                    },
                    {
                        "full": "slop",
                        "name": "slop"
                    },
                    {
                        "full": "[scoreColName]",
                        "name": "scoreColName",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [matchSpan](https://docs.dolphindb.cn/zh/funcs/m/matchspan.html)\n\n\n\n#### 语法\n\nmatchSpan(textCol, span, slop, \\[scoreColName])\n\n#### 详情\n\n该函数用于 SQL 语句的 WHERE 子句，针对 PKEY 存储引擎中设置文本索引的列进行文本匹配，返回包含指定短语的行。\n\n#### 参数\n\n**textCol** 待查询的列，即 PKEY 存储引擎中设置了文本索引的列。\n\n**span**STRING 类型标量，用于指定待查询的短语。\n\n**slop**非负整数，表示用户输入的词距。匹配时，若短语前、后或短语中有不多于 *slop* 个其他词语，仍视作匹配成功。\n\n**scoreColName** 可选参数，STRING 类型标量，表示输出结果中文本匹配得分列的列名。默认值为空，此时不输出得分列。匹配得分代表数据在分区内的匹配程度，不同分区的分数不可比较。\n\n#### 返回值\n\n返回一个布尔值。\n\n#### 例子\n\n```\n// 构造数据\nstringColumn = [\"There are some apples and oranges.\",\"Mike likes apples.\",\"Alice likes oranges.\",\"Mike gives Alice an apple.\",\"Alice gives Mike an orange.\",\"John likes peaches, so he does not give them to anyone.\",\"Mike, can you give me some apples?\",\"Alice, can you give me some oranges?\",\"Mike traded an orange for an apple with Alice.\"]\nt = table([1,1,1,2,2,2,3,3,3] as id1, [1,2,3,1,2,3,1,2,3] as id2, stringColumn as remark) \nif(existsDatabase(\"dfs://textDB\")) dropDatabase(\"dfs://textDB\")\ndb = database(directory=\"dfs://textDB\", partitionType=VALUE, partitionScheme=[1,2,3], engine=\"PKEY\")\npt = createPartitionedTable(dbHandle=db, table=t, tableName=\"pt\", partitionColumns=\"id1\",primaryKey=`id1`id2,indexes={\"remark\":\"textindex(parser=english, full=false, lowercase=true, stem=true)\"})\npt.tableInsert(t)\n\n// 匹配包含短语 mike apple 的行，且允许短语前后或内部有小于等于3个其他词汇（不包括停止词）\nselect * from pt where matchSpan(remark, \"mike apple\", 2)\n```\n\n<table id=\"table_cpb_fwm_cdc\"><thead><tr><th>\n\nid1\n\n</th><th>\n\nid2\n\n</th><th>\n\nremark\n\n</th></tr></thead><tbody><tr><td>\n\n1\n\n</td><td>\n\n2\n\n</td><td>\n\nMike likes apples.\n\n</td></tr><tr><td>\n\n2\n\n</td><td>\n\n1\n\n</td><td>\n\nMike gives Alice an apple.\n\n</td></tr><tr><td>\n\n3\n\n</td><td>\n\n3\n\n</td><td>\n\nMike traded an orange for an apple with Alice.\n\n</td></tr></tbody>\n</table>\n"
    },
    "matchSuffix": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/matchsuffix.html",
        "signatures": [
            {
                "full": "matchSuffix(textCol, suffix, [scoreColName])",
                "name": "matchSuffix",
                "parameters": [
                    {
                        "full": "textCol",
                        "name": "textCol"
                    },
                    {
                        "full": "suffix",
                        "name": "suffix"
                    },
                    {
                        "full": "[scoreColName]",
                        "name": "scoreColName",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [matchSuffix](https://docs.dolphindb.cn/zh/funcs/m/matchsuffix.html)\n\n\n\n#### 语法\n\nmatchSuffix(textCol, suffix, \\[scoreColName])\n\n#### 详情\n\n该函数用于 SQL 语句的 WHERE 子句，针对 PKEY 存储引擎中设置文本索引的列进行后缀匹配，返回包含指定后缀的行。\n\n#### 参数\n\n**textCol** 待查询的列，即 PKEY 存储引擎中设置了文本索引的列。\n\n**suffix**STRING 类型标量，用于指定待查询的后缀。\n\n**scoreColName** 可选参数，STRING 类型标量，表示输出结果中文本匹配得分列的列名。默认值为空，此时不输出得分列。匹配得分代表数据在分区内的匹配程度，不同分区的分数不可比较。\n\n#### 返回值\n\n返回一个布尔值。\n\n#### 例子\n\n```\n// 构造数据\nstringColumn = [\"There are some apples and oranges.\",\"Mike likes apples.\",\"Alice likes oranges.\",\"Mike gives Alice an apple.\",\"Alice gives Mike an orange.\",\"John likes peaches, so he does not give them to anyone.\",\"Mike, can you give me some apples?\",\"Alice, can you give me some oranges?\",\"Mike traded an orange for an apple with Alice.\"]\nt = table([1,1,1,2,2,2,3,3,3] as id1, [1,2,3,1,2,3,1,2,3] as id2, stringColumn as remark) \nif(existsDatabase(\"dfs://textDB\")) dropDatabase(\"dfs://textDB\")\ndb = database(directory=\"dfs://textDB\", partitionType=VALUE, partitionScheme=[1,2,3], engine=\"PKEY\")\npt = createPartitionedTable(dbHandle=db, table=t, tableName=\"pt\", partitionColumns=\"id1\",primaryKey=`id1`id2,indexes={\"remark\":\"textindex(parser=english, full=false, lowercase=true, stem=true)\"})\npt.tableInsert(t)\n\n// 匹配包含后缀是 ke 的单词的行\nselect * from pt where matchSuffix(remark,\"ke\")\n```\n\n<table id=\"table_t5m_1vm_cdc\"><thead><tr><th>\n\nid1\n\n</th><th>\n\nid2\n\n</th><th>\n\nremark\n\n</th></tr></thead><tbody><tr><td>\n\n1\n\n</td><td>\n\n2\n\n</td><td>\n\nMike likes apples.\n\n</td></tr><tr><td>\n\n1\n\n</td><td>\n\n3\n\n</td><td>\n\nAlice likes oranges.\n\n</td></tr><tr><td>\n\n2\n\n</td><td>\n\n1\n\n</td><td>\n\nMike gives Alice an apple.\n\n</td></tr><tr><td>\n\n2\n\n</td><td>\n\n2\n\n</td><td>\n\nAlice gives Mike an orange.\n\n</td></tr><tr><td>\n\n2\n\n</td><td>\n\n3\n\n</td><td>\n\nJohn likes peaches, so he does not give them to anyone.\n\n</td></tr><tr><td>\n\n3\n\n</td><td>\n\n1\n\n</td><td>\n\nMike, can you give me some apples?\n\n</td></tr><tr><td>\n\n3\n\n</td><td>\n\n3\n\n</td><td>\n\nMike traded an orange for an apple with Alice.\n\n</td></tr></tbody>\n</table>\n"
    },
    "matchUnorderedSpan": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/matchunorderedspan.html",
        "signatures": [
            {
                "full": "matchUnorderedSpan(textCol, span, slop, [scoreColName])",
                "name": "matchUnorderedSpan",
                "parameters": [
                    {
                        "full": "textCol",
                        "name": "textCol"
                    },
                    {
                        "full": "span",
                        "name": "span"
                    },
                    {
                        "full": "slop",
                        "name": "slop"
                    },
                    {
                        "full": "[scoreColName]",
                        "name": "scoreColName",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [matchUnorderedSpan](https://docs.dolphindb.cn/zh/funcs/m/matchunorderedspan.html)\n\n\n\n#### 语法\n\nmatchUnorderedSpan(textCol, span, slop, \\[scoreColName])\n\n#### 详情\n\n该函数用于 SQL 语句的 WHERE 子句，针对 PKEY 存储引擎中设置文本索引的列进行文本匹配，返回包含指定短语的行。不同于 matchSpan 的是，该函数在匹配时将忽略短语中单词的顺序。\n\n#### 参数\n\n**textCol** 待查询的列，即 PKEY 存储引擎中设置了文本索引的列。\n\n**span**STRING 类型标量，用于指定待查询的短语。\n\n**slop**非负整数，表示用户输入的词距。匹配时，若短语前、后或短语中有不多于 *slop* 个其他词语，仍视作匹配成功。\n\n**scoreColName** 可选参数，STRING 类型标量，表示输出结果中文本匹配得分列的列名。默认值为空，此时不输出得分列。匹配得分代表数据在分区内的匹配程度，不同分区的分数不可比较。\n\n#### 返回值\n\n返回一个布尔值。\n\n#### 例子\n\n```\n// 构造数据\nstringColumn = [\"There are some apples and oranges.\",\"Mike likes apples.\",\"Alice likes oranges.\",\"Mike gives Alice an apple.\",\"Alice gives Mike an orange.\",\"John likes peaches, so he does not give them to anyone.\",\"Mike, can you give me some apples?\",\"Alice, can you give me some oranges?\",\"Mike traded an orange for an apple with Alice.\"]\nt = table([1,1,1,2,2,2,3,3,3] as id1, [1,2,3,1,2,3,1,2,3] as id2, stringColumn as remark) \nif(existsDatabase(\"dfs://textDB\")) dropDatabase(\"dfs://textDB\")\ndb = database(directory=\"dfs://textDB\", partitionType=VALUE, partitionScheme=[1,2,3], engine=\"PKEY\")\npt = createPartitionedTable(dbHandle=db, table=t, tableName=\"pt\", partitionColumns=\"id1\",primaryKey=`id1`id2,indexes={\"remark\":\"textindex(parser=english, full=false, lowercase=true, stem=true)\"})\npt.tableInsert(t)\n\n// 匹配包含短语 mike apple 的行，忽略 mike 和 apple 的顺序，且允许短语前后或内部有小于等于2个其他词汇\nselect * from pt where matchUnorderedSpan(remark, \"apple mike\", 2)\n```\n\n<table id=\"table_lxq_4wm_cdc\"><thead><tr><th>\n\nid1\n\n</th><th>\n\nid2\n\n</th><th>\n\nremark\n\n</th></tr></thead><tbody><tr><td>\n\n1\n\n</td><td>\n\n2\n\n</td><td>\n\nMike likes apples.\n\n</td></tr><tr><td>\n\n2\n\n</td><td>\n\n1\n\n</td><td>\n\nMike gives Alice an apple.\n\n</td></tr><tr><td>\n\n3\n\n</td><td>\n\n3\n\n</td><td>\n\nMike traded an orange for an apple with Alice.\n\n</td></tr></tbody>\n</table>\n"
    },
    "matrix": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/matrix.html",
        "signatures": [
            {
                "full": "matrix(X1, [X2], ...)",
                "name": "matrix",
                "parameters": [
                    {
                        "full": "X1",
                        "name": "X1"
                    },
                    {
                        "full": "[X2]",
                        "name": "X2",
                        "optional": true
                    },
                    {
                        "full": "...",
                        "name": "..."
                    }
                ]
            },
            {
                "full": "matrix(dataType, rows, cols, [columnsCapacity], [defaultValue])",
                "name": "matrix",
                "parameters": [
                    {
                        "full": "dataType",
                        "name": "dataType"
                    },
                    {
                        "full": "rows",
                        "name": "rows"
                    },
                    {
                        "full": "cols",
                        "name": "cols"
                    },
                    {
                        "full": "[columnsCapacity]",
                        "name": "columnsCapacity",
                        "optional": true
                    },
                    {
                        "full": "[defaultValue]",
                        "name": "defaultValue",
                        "optional": true
                    }
                ]
            },
            {
                "full": "matrix(X)",
                "name": "matrix",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [matrix](https://docs.dolphindb.cn/zh/funcs/m/matrix.html)\n\n\n\n#### 语法\n\nmatrix(X1, \\[X2], ...)\n\n或\n\nmatrix(dataType, rows, cols, \\[columnsCapacity], \\[defaultValue])\n\n或\n\nmatrix(X)\n\n#### 详情\n\n返回一个矩阵。\n\n#### 参数\n\n* 第一种情况中，**X1**, **X2**, **...** 可以是混合类型，包括向量、矩阵、表（不能包含 SYMBOL 字段）、元组或它们的任意组合。\n\n* 第二种情况中：\n\n  **dataType** 是矩阵的数据类型，支持除 INT128、UUID、IPADDR、POINT 和 DURATION 外的其他数据类型。\n\n  **rows** 是行数。\n\n  **cols** 是列数。\n\n  **columnsCapacity** 是正整数，表示矩阵的容量，即新建该矩阵时，系统为该矩阵分配的内存（以列数为单位）。当列数超过 *capacity* 时，系统会自动扩充容量。系统首先会分配当前容量1.2\\~2倍的内存，然后复制数据到新的内存空间，最后释放原来的内存。\n\n  **defaultValue** 是矩阵的默认值。不指定默认值，对于整数或浮点数类型，矩阵中所有的元素都是 0，对于符号类型，所有元素都是 NULL。\n\n* 第三种情况下：**X** 是一个数组向量（arrayVector），且数组向量每个元素的长度必须相等。\n\n#### 例子\n\n```\nx=matrix(INT,3,2, ,1);\nx;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 1  |\n| 1  | 1  |\n| 1  | 1  |\n\n```\ny = matrix(DECIMAL32(3),2,3)\ny \n```\n\n| #0    | #1    | #2    |\n| ----- | ----- | ----- |\n| 0.000 | 0.000 | 0.000 |\n| 0.000 | 0.000 | 0.000 |\n\n```\ns=matrix(SYMBOL,2,2, ,`T);\ns;\n```\n\n| #0 | #1 |\n| -- | -- |\n| T  | T  |\n| T  | T  |\n\n```\nmatrix(table(1 2 3 as id, 4 5 6 as value));\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 4  |\n| 2  | 5  |\n| 3  | 6  |\n\n```\nmatrix([1 2 3, 4 5 6]);\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 4  |\n| 2  | 5  |\n| 3  | 6  |\n\n```\nmatrix([1 2 3, 4 5 6], 7 8 9, table(0.5 0.6 0.7 as id), 1..9$3:3);\n```\n\n| #0 | #1 | #2 | #3  | #4 | #5 | #6 |\n| -- | -- | -- | --- | -- | -- | -- |\n| 1  | 4  | 7  | 0.5 | 1  | 4  | 7  |\n| 2  | 5  | 8  | 0.6 | 2  | 5  | 8  |\n| 3  | 6  | 9  | 0.7 | 3  | 6  | 9  |\n\n```\nmatrix(`AA`BB`CC,`DD`EE`FF)\n```\n\n输出为：\n\n| #0 | #1 |\n| -- | -- |\n| AA | DD |\n| BB | EE |\n| CC | FF |\n\n当表中含有 SYMBOL 字段时，通过 matrix 进行转换时会出现报错，如下例：\n\n```\nt = table(symbol([\"a\", \"b\"]) as sym, [1, 2] as val)\nmatrix(t)\n// output: matrix(t) => Failed to append a table object to a matrix.\n```\n\n将 SYMBOL 类型转换为 STRING 类型后，可以进行转换，见如下代码：\n\n```\nt = table(string([\"a\", \"b\"]) as sym, [1, 2] as val)\nmatrix(t)\n```\n\n<table id=\"table_dss_l4y_bdc\"><thead><tr><th align=\"left\" id=\"d405106e506\">\n\n\\#1\n\n</th><th align=\"left\" id=\"d405106e512\">\n\n\\#2\n\n</th></tr></thead><tbody><tr><td>\n\na\n\n</td><td>\n\n1\n\n</td></tr><tr><td>\n\nb\n\n</td><td>\n\n2\n\n</td></tr></tbody>\n</table>**Related information**  \n\n[array](https://docs.dolphindb.cn/zh/funcs/a/array.html)\n\n[dict](https://docs.dolphindb.cn/zh/funcs/d/dict.html)\n"
    },
    "matrixRank": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/matrixRank.html",
        "signatures": [
            {
                "full": "matrixRank(A, [tol])",
                "name": "matrixRank",
                "parameters": [
                    {
                        "full": "A",
                        "name": "A"
                    },
                    {
                        "full": "[tol]",
                        "name": "tol",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [matrixRank](https://docs.dolphindb.cn/zh/funcs/m/matrixRank.html)\n\n\n\n#### 语法\n\nmatrixRank(A, \\[tol])\n\n#### 详情\n\n计算矩阵的秩。\n\n#### 参数\n\n**A**数值型矩阵，一维矩阵也可以用向量表示。\n\n**tol**数值型标量，小于 tol 的奇异值将被视为零，因此矩阵的秩为该矩阵大于 tol 的奇异值的个数。默认值为双精度浮点数的最小精度 DBL\\_EPSILON = 2.22044604925e-16。\n\n#### 返回值\n\n整型标量，表示矩阵的秩。\n\n#### 例子\n\n```\nm1 = matrix(1..4,1..4*2,3..6)\nmatrixRank(m1) \n// output：2\n```\n"
    },
    "mavg": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mavg.html",
        "signatures": [
            {
                "full": "mavg(X, window|weights, [minPeriods])",
                "name": "mavg",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window|weights",
                        "name": "window|weights"
                    },
                    {
                        "full": "[minPeriods]",
                        "name": "minPeriods",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [mavg](https://docs.dolphindb.cn/zh/funcs/m/mavg.html)\n\n\n\n#### 语法\n\nmavg(X, window|weights, \\[minPeriods])\n\n窗口计算规则请参考：[mFunctions](https://docs.dolphindb.cn/zh/funcs/themes/mFunctions.html)\n\n#### 详情\n\n计算滑动窗口内的移动平均值。支持按固定窗口长度或指定权重向量进行计算。\n\n* *window*：在给定长度（以元素个数或时间长度衡量）的滑动窗口内计算 *X* 元素的平均值。\n\n* *weights*：表示权重向量，用于在长度为 size(*weights*)的滑动窗口中计算 *X* 的加权平均值。权重顺序与窗口中数据一一对应。size(*weights*) 的有效范围是\\[0, 1024]。结果中前(size(*weights*) - 1)个元素为 NULL。若指定了*weights*，则 *minPeriods* 无效。\n\n若 *X* 为矩阵/表则在每一列进行计算。\n\n#### 参数\n\n**X** 是一个向量/矩阵/表/元组（元素为标量或等长向量）/字典。\n\n**window** 是大于等于 2 的正整型或 DURATION 标量。表示滑动窗口的长度。\n\n**Note:** 在流计算引擎中调用滑动窗口函数时，window 的上限为 102400。\n\n**minPeriods** 是一个正整数。表示滑动窗口中最少包含的非 NULL 有效观测值数量。\n\n#### 返回值\n\n当 *X* 为向量时：返回与 *X* 长度相同的向量。\n\n若 *X* 为矩阵/表，返回与输入具有相同维度的矩阵或表。\n\n#### 例子\n\n```\nX = 7 4 6 0 -5 32 9 8;\nY = 7 4 6 NULL -5 32 9 8;\nweight = 2 3 5\nmavg(X, 4);\n// output: [,,,4.25,1.25,8.25,9,11]\n\nmavg(Y, 4);\n// output: [,,,5.67,1.67,11,12,11]\n\nmavg(Y, weight);\n// output: [,,5.6,5.2,-1.8571,18.125,13.1,13.1]\n```\n\n```\nm=matrix(1 NULL 4 NULL 8 6 , 9 NULL NULL 10 NULL 2)\nm.rename!(2020.01.06 2020.01.07 2020.01.09 2020.01.11 2020.01.12 2020.01.15, `col1`col2)\nm.setIndexedMatrix!()\nmavg(m, 3d) // 等价于 mavg(m, 3)\n```\n\n| label      | col1 | col2 |\n| ---------- | ---- | ---- |\n| 2020.01.06 | 1    | 9    |\n| 2020.01.07 | 1    | 9    |\n| 2020.01.09 | 4    |      |\n| 2020.01.11 | 4    | 10   |\n| 2020.01.12 | 8    | 10   |\n| 2020.01.15 | 6    | 2    |\n\n```\nmavg(m, 1w)\n```\n\n| label      | col1   | col2 |\n| ---------- | ------ | ---- |\n| 2020.01.06 | 1      | 9    |\n| 2020.01.07 | 1      | 9    |\n| 2020.01.09 | 2.5    | 9    |\n| 2020.01.11 | 2.5    | 9.5  |\n| 2020.01.12 | 4.3333 | 9.5  |\n| 2020.01.15 | 6      | 6    |\n\n相关函数：[avg](https://docs.dolphindb.cn/zh/funcs/a/avg.html)\n"
    },
    "mavgTopN": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mavgTopN.html",
        "signatures": [
            {
                "full": "mavgTopN(X, S, window, top, [ascending=true], [tiesMethod='oldest'])",
                "name": "mavgTopN",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "S",
                        "name": "S"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "top",
                        "name": "top"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[tiesMethod='oldest']",
                        "name": "tiesMethod",
                        "optional": true,
                        "default": "'oldest'"
                    }
                ]
            }
        ],
        "markdown": "### [mavgTopN](https://docs.dolphindb.cn/zh/funcs/m/mavgTopN.html)\n\n\n\n#### 语法\n\nmavgTopN(X, S, window, top, \\[ascending=true], \\[tiesMethod='oldest'])\n\n参数说明和窗口计算规则请参考：[mTopN](https://docs.dolphindb.cn/zh/funcs/themes/TopN.html)\n\n#### 详情\n\n在给定长度（以元素个数衡量）的滑动窗口内，根据 *ascending* 指定的排序方式将 *X* 按照 *S* 进行稳定排序后，取前 *top* 个元素计算平均值。\n\n#### 返回值\n\n当 *X* 为向量时：返回与 *X* 长度相同的向量。\n\n若 *X* 为矩阵/表，返回与输入具有相同维度的矩阵或表。\n\n#### 例子\n\n```\nX = 1..7\nS = 0.3 0.5 0.1 0.1 0.5 0.2 0.4\nmavgTopN(X, S, 4, 2)\n// output: [1,1.5,2,3.5,3.5,3.5,5]\n\nX = NULL 1 2 3 4 NULL 5\nS = 3 5 1 1 5 2 4\nmavgTopN(X, S, 4, 2)\n// output: [,1,2,2.5,2.5,2.5,3]\n\nX = matrix(1..5, 6..10)\nS = 2022.01.01 2022.02.03 2022.01.23 2022.04.06 2021.12.29\nmavgTopN(X, S, 3, 2)\n```\n\n| #0  | #1  |\n| --- | --- |\n| 1   | 6   |\n| 1.5 | 6.5 |\n| 2   | 7   |\n| 2.5 | 7.5 |\n| 4   | 9   |\n\n```\nX = matrix(1..5, 6..10)\nS = matrix(2022.01.01 2022.02.03 2022.01.23 NULL 2021.12.29,NULL 2022.02.03 2022.01.23 2022.04.06 NULL)\nmavgTopN(X, S, 3, 2)\n```\n\n| #0  | #1  |\n| --- | --- |\n| 1   |     |\n| 1.5 | 7   |\n| 2   | 7.5 |\n| 2.5 | 7.5 |\n| 4   | 8.5 |\n\n某行情数据的数据表，包含四列：股票代码 code，交易日期 date，收盘价 close 和交易量 volume。\n\n```\nt = table(take(`IBM`APPL, 20) as code, 2020.01.01 + 1..20 as date, rand(100,20) + 20 as volume, rand(10,20) + 100.0 as close)\n```\n\n| code | date       | volume | close |\n| ---- | ---------- | ------ | ----- |\n| IBM  | 2020.01.02 | 114    | 107   |\n| APPL | 2020.01.03 | 66     | 106   |\n| IBM  | 2020.01.04 | 36     | 106   |\n| APPL | 2020.01.05 | 52     | 101   |\n| IBM  | 2020.01.06 | 28     | 100   |\n| APPL | 2020.01.07 | 55     | 108   |\n| IBM  | 2020.01.08 | 54     | 106   |\n| APPL | 2020.01.09 | 103    | 106   |\n| IBM  | 2020.01.10 | 94     | 104   |\n| APPL | 2020.01.11 | 82     | 102   |\n| IBM  | 2020.01.12 | 98     | 103   |\n| APPL | 2020.01.13 | 118    | 101   |\n| IBM  | 2020.01.14 | 61     | 105   |\n| APPL | 2020.01.15 | 43     | 105   |\n| IBM  | 2020.01.16 | 41     | 104   |\n| APPL | 2020.01.17 | 111    | 106   |\n| IBM  | 2020.01.18 | 119    | 103   |\n| APPL | 2020.01.19 | 24     | 107   |\n| IBM  | 2020.01.20 | 22     | 109   |\n| APPL | 2020.01.21 | 26     | 103   |\n\n计算每只股票窗口期内交易量最大的3条记录的的平均收盘价。\n\n```\nselect code, date, mavgTopN(close, volume, 5, 3, false) from t context by code\n```\n\n| code | date       | mavgTopN\\_close |\n| ---- | ---------- | --------------- |\n| APPL | 2020.01.03 | 106             |\n| APPL | 2020.01.05 | 103.5           |\n| APPL | 2020.01.07 | 105             |\n| APPL | 2020.01.09 | 106.6667        |\n| APPL | 2020.01.11 | 104.6667        |\n| APPL | 2020.01.13 | 103             |\n| APPL | 2020.01.15 | 103             |\n| APPL | 2020.01.17 | 104.3333        |\n| APPL | 2020.01.19 | 103             |\n| APPL | 2020.01.21 | 104             |\n| IBM  | 2020.01.02 | 107             |\n| IBM  | 2020.01.04 | 106.5           |\n| IBM  | 2020.01.06 | 104.3333        |\n| IBM  | 2020.01.08 | 106.3333        |\n| IBM  | 2020.01.10 | 105.6667        |\n| IBM  | 2020.01.12 | 104.3333        |\n| IBM  | 2020.01.14 | 104             |\n| IBM  | 2020.01.16 | 104             |\n| IBM  | 2020.01.18 | 103.3333        |\n| IBM  | 2020.01.20 | 103.6667        |\n\n相关函数：[mavg](https://docs.dolphindb.cn/zh/funcs/m/mavg.html)\n"
    },
    "max": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/max.html",
        "signatures": [
            {
                "full": "max(X, [Y])",
                "name": "max",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[Y]",
                        "name": "Y",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [max](https://docs.dolphindb.cn/zh/funcs/m/max.html)\n\n\n\n#### 语法\n\nmax(X, \\[Y])\n\n#### 详情\n\n返回输入数据中的最大值。\n\n支持以下两种调用方式：\n\n* 仅输入一个参数 *X*，用于计算 *X* 的最大值。比较时忽略 NULL 值。\n\n* 输入两个参数，用于按元素比较两个数据对象，返回较大值。比较时不忽略 NULL 值。\n\n请注意，从 2.00.8 版本开始，`max` 处理时间类型数据的行为（之前版本统一转换为长整型）修改为：\n\n* 若 *X* 和 *Y* 是时间类型标量，系统会将时间类型统一为两者中较高精度对应的类型，再比较大小。\n\n* 若 *X* 或 *Y* 是向量、矩阵或表，则必须具有相同的时间类型。\n\nDolphinDB、NumPy 与 Python 内置的 max 函数虽均用于返回最大值，但存在以下差异：\n\n* DolphinDB 支持标量、向量、矩阵、表及时间类型；NumPy 支持多维数组；Python 内置支持任意可迭代对象。\n* DolphinDB 支持双参数调用；Python 内置支持多参数比较；NumPy 不支持多参数比较。\n* Python 内置 max 函数支持指定 *key* 自定义排序规则。\n\nDolphinDB `max` 与 TA-Lib `MAX` 函数在语义上存在区别。DolphinDB `max` 函数计算全局最大值或逐元素最大值，而 TA-Lib `MAX` 函数则计算指定窗口内的滚动最大值。\n\n#### 参数\n\n**X** 可以是标量、向量、矩阵或表。\n\n**Y** 为可选参数，可以是标量或者是和 *X* 长度相同的向量或者矩阵。\n\n#### 返回值\n\n**单参数调用：**\n\n* 若 *X* 是向量，返回一个标量。\n\n* 若 *X* 为矩阵，返回一个向量。\n\n* 若 *X* 为表，返回一个表。\n\n**双参数调用：**\n\n* 若 *Y* 是标量，返回与 *X* 维度相同的对象，每个元素为 `max(X[i], Y)`。\n\n* 若 *Y* 和 *X* 类型和长度一致，返回对应位置较大值组成的对象。\n\n#### 例子\n\n```\nmax(1 2 3);\n// output: 3\n\nmax(7.8 9 5.4);\n// output: 9\n\n(5 8 2 7).max();\n// output: 8\n\nm=matrix(1 2 3, 4 5 6);\nm;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 4  |\n| 2  | 5  |\n| 3  | 6  |\n\n```\nmax(m);\n// output: [3,6]\n```\n\n```\nmax(1 2 3, 2)\n// output: 2 2 3\n\nn = matrix(1 1 1, 5 5 5)\nn;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 5  |\n| 1  | 5  |\n| 1  | 5  |\n\n```\nmax(m, n);\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 5  |\n| 2  | 5  |\n| 3  | 6  |\n\n`max` 可以搭配 select 使用, 返回某列的最大值：\n\n```\nt = table(`abb`aac`aaa as sym, 1.8 2.3 3.7 as price);\nselect max price from t;\n```\n\n| max\\_price |\n| ---------- |\n| 3.7        |\n\nmax 可以应用于字符串，返回字典序最大的字符串：\n\n```\nselect max sym from t;\n```\n\n| max\\_sym |\n| -------- |\n| abb      |\n\n相关函数：[mmax](https://docs.dolphindb.cn/zh/funcs/m/mmax.html)\n"
    },
    "maxDrawdown": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/maxdrawdown.html",
        "signatures": [
            {
                "full": "maxDrawdown(X, [ratio=true])",
                "name": "maxDrawdown",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[ratio=true]",
                        "name": "ratio",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [maxDrawdown](https://docs.dolphindb.cn/zh/funcs/m/maxdrawdown.html)\n\n\n\n#### 语法\n\nmaxDrawdown(X, \\[ratio=true])\n\n聚合函数，别名 mdd。\n\n#### 详情\n\n计算传入向量数据的最大回撤（Maximum Drawdown，简称 MDD）或最大回撤率（Maximum Drawdown Rate）。\n\n#### 参数\n\n**X** 数值向量，表示用于计算最大回撤的输入数据，一般指累积的收益或收益率。注意：不可为空。\n\n**ratio**布尔标量，表示是否返回最大回撤率。默认值为 true。\n\n* 若为 true，表示返回最大回撤率，即相对于峰值的最大下降百分比，计算公式为：\n\n  ![](https://docs.dolphindb.cn/zh/funcs/images/mdd1.png)\n\n* 若为 false，表示返回基于下降金额绝对值的最大回撤，计算公式为：\n\n  ![](https://docs.dolphindb.cn/zh/funcs/images/mdd2.png)\n\n注意：计算时将忽略空值。\n\n#### 返回值\n\n一个 DOUBLE 类型标量，表示 *X* 的最大回撤或最大回撤率。\n\n#### 例子\n\n假设有一个投资组合在一段时间内的累积收益变化如下（以天为单位）：\n\n<table id=\"table_h24_4zx_bdc\"><thead><tr><th align=\"left\">\n\n日期\n\n</th><th align=\"left\">\n\n累积收益\n\n</th></tr></thead><tbody><tr><td>\n\n2024-10-01\n\n</td><td>\n\n36\n\n</td></tr><tr><td>\n\n2024-10-02\n\n</td><td>\n\n96\n\n</td></tr><tr><td>\n\n2024-10-03\n\n</td><td>\n\n42\n\n</td></tr><tr><td>\n\n2024-10-04\n\n</td><td>\n\n100\n\n</td></tr><tr><td>\n\n2024-10-05\n\n</td><td>\n\n59\n\n</td></tr><tr><td>\n\n2024-10-06\n\n</td><td>\n\n86\n\n</td></tr><tr><td>\n\n2024-10-07\n\n</td><td>\n\n25\n\n</td></tr><tr><td>\n\n2024-10-08\n\n</td><td>\n\n72\n\n</td></tr></tbody>\n</table>使用 `maxDrawdown` 计算该数据的最大回撤率和最大回撤。\n\n```\nx = [36,96,42,100,59,86,25,64,72]\n\nmaxDrawdown(x)\n// Output: 0.75\nmaxDrawdown(x, false)\n// Output: 75\n```\n\n相关函数：[cummdd](https://docs.dolphindb.cn/zh/funcs/c/cummdd.html)\n"
    },
    "maxIgnoreNull": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/maxignorenull.html",
        "signatures": [
            {
                "full": "maxIgnoreNull(X, Y)",
                "name": "maxIgnoreNull",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [maxIgnoreNull](https://docs.dolphindb.cn/zh/funcs/m/maxignorenull.html)\n\n#### 语法\n\n```\nmaxIgnoreNull(X, Y)\n```\n\n#### 详情\n\n一个二元标量函数，返回两个数（*X* 和 *Y*）中的最大值。\n\n它与 `max` 作为二元标量函数区别在于对空值的处理：\n\n* `max`：当配置项 \\*nullAsMinValueForComparison=\\*true 时，空值被视为最小值进行比较；否则空值不参与比较，结果返回空值。\n\n* `maxIgnoreNull`：不受配置项 *nullAsMinValueForComparison* 的影响。返回 *X* 或 *Y* 中的非空值，或者如果两者都非空，返回最大值。\n\n#### 参数\n\n**X** 和 **Y** 是数值型、LITERAL 或 TEMPORAL 型的标量/数据对/向量/矩阵。\n\n#### 返回值\n\n* 当输入是标量时，返回标量。\n* 当输入是向量时，返回向量（逐元素比较）。\n* 当输入是矩阵时，返回矩阵（逐元素比较）。\n* 当输入是数据对时，返回数据对。\n\n#### 例子\n\n```\nmaxIgnoreNull(2,matrix(1  NULL 4,-1 4  0)) \n```\n\n| #0 | #1 |\n| -- | -- |\n| 2  | 2  |\n| 2  | 4  |\n| 4  | 2  |\n\n```\nmaxIgnoreNull(matrix(10 3 NULL, 1 7 4),matrix(1  NULL 4,-1 4  0))\n```\n\n| #0 | #1 |\n| -- | -- |\n| 10 | 1  |\n| 3  | 7  |\n| 4  | 4  |\n\n使用 `reduce` 结合 `maxIgNoreNull`，计算元组中存储的同形状矩阵每个位置的最小值，忽略空值。\n\n```\nn1 = matrix(1 1 1, 5 5 5)\nn2 = matrix(10 11 12, 0 NULL -5)\nn3 = matrix(-1 1 NULL, -3 0 10)\nreduce(maxIgnoreNull, [n1,n2,n3])\n```\n\n| #0 | #1 |\n| -- | -- |\n| 10 | 5  |\n| 11 | 5  |\n| 12 | 10 |\n\n相关函数：[max](https://docs.dolphindb.cn/zh/funcs/m/max.html), [minIgnoreNull](https://docs.dolphindb.cn/zh/funcs/m/minignorenull.html)\n\n"
    },
    "maxPositiveStreak": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/maxPositiveStreak.html",
        "signatures": [
            {
                "full": "maxPositiveStreak(X)",
                "name": "maxPositiveStreak",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [maxPositiveStreak](https://docs.dolphindb.cn/zh/funcs/m/maxPositiveStreak.html)\n\n\n\n#### 语法\n\nmaxPositiveStreak(X)\n\n#### 详情\n\n如果 *X* 是向量，返回 *X* 中连续的正数之和的最大值。\n\n如果 *X* 是矩阵，返回 *X* 中每列连续的正数之和的最大值。\n\nmaxPositiveStreak(X) = max(cumPositiveStreak(X))\n\n#### 参数\n\n**X** 可以是标量、向量或矩阵。*X* 中的元素必须是 INTEGRAL 或 LOGICAL 类型。\n\n#### 返回值\n\n整型标量或向量。\n\n#### 例子\n\n```\nx=1 0 -1 1 2 2 2 1 0 -1 0 2;\ncumPositiveStreak x;\n// output: [1,0,0,1,3,5,7,8,0,0,0,2]\nmaxPositiveStreak x;\n// output: 8\n\ny=x$6:2;\ny;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 2  |\n| 0  | 1  |\n| -1 | 0  |\n| 1  | -1 |\n| 2  | 0  |\n| 2  | 2  |\n\n```\ncumPositiveStreak(y);\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 2  |\n| 0  | 3  |\n| 0  | 0  |\n| 1  | 0  |\n| 3  | 0  |\n| 5  | 2  |\n\n```\nmaxPositiveStreak(y);\n// output: [5,3]\n```\n\n相关函数：[cumPositiveStreak](https://docs.dolphindb.cn/zh/funcs/c/cumPositiveStreak.html)\n"
    },
    "mbeta": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mbeta.html",
        "signatures": [
            {
                "full": "mbeta(Y, X, window, [minPeriods])",
                "name": "mbeta",
                "parameters": [
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "[minPeriods]",
                        "name": "minPeriods",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [mbeta](https://docs.dolphindb.cn/zh/funcs/m/mbeta.html)\n\n\n\n#### 语法\n\nmbeta(Y, X, window, \\[minPeriods])\n\n窗口计算规则请参考：[mFunctions](https://docs.dolphindb.cn/zh/funcs/themes/mFunctions.html)\n\n#### 详情\n\n在给定长度（以元素个数或时间长度衡量）的移动窗口中，计算 *Y* 在 *X* 上的回归系数的最小二乘估计。\n\n#### 参数\n\n**X** 是一个向量/矩阵/表/元组（元素为标量或等长向量）/字典。\n\n**Y** 是一个向量/矩阵/表/元组（元素为标量或等长向量）/字典。\n\n**window** 是大于等于 2 的正整型或 DURATION 标量。表示滑动窗口的长度。\n\n**Note:** 在流计算引擎中调用滑动窗口函数时，window 的上限为 102400。\n\n**minPeriods** 是一个正整数。表示滑动窗口中最少包含的非 NULL 有效观测值数量。\n\n#### 返回值\n\n计算结果为 DOUBLE 类型，形式同输入参数。\n\n#### 例子\n\n```\nx=0.011 0.006 -0.008 0.012 -0.016 -0.023 0.018\ny=0.016 0.009 -0.012 0.022 0.003 -0.056 0.002\nmbeta(y, x, 5);\n// output: [,,,,0.818182,1.692379,1.188532]\n\nmbeta(y, x, 5, 3);\n// output: [,,1.479381,1.594701,0.818182,1.692379,1.188532]\n```\n\n```\nx1 = indexedSeries(date(2020.06.05)+1..7, x)\ny1 = indexedSeries(date(2020.06.05)+1..7, y)\nmbeta(y1, x1, 5d);\n```\n\n| label      | col1   |\n| ---------- | ------ |\n| 2020.06.06 |        |\n| 2020.06.07 | 1.4    |\n| 2020.06.08 | 1.4794 |\n| 2020.06.09 | 1.5947 |\n| 2020.06.10 | 0.8182 |\n| 2020.06.11 | 1.6924 |\n| 2020.06.12 | 1.1885 |\n\n```\nmbeta(y1, x1, 1w);\n```\n\n| label      | col1   |\n| ---------- | ------ |\n| 2020.06.06 |        |\n| 2020.06.07 | 1.4    |\n| 2020.06.08 | 1.4794 |\n| 2020.06.09 | 1.5947 |\n| 2020.06.10 | 0.8182 |\n| 2020.06.11 | 1.6924 |\n| 2020.06.12 | 1.2659 |\n\n相关函数：[beta](https://docs.dolphindb.cn/zh/funcs/b/beta.html)\n"
    },
    "mbetaTopN": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mbetaTopN.html",
        "signatures": [
            {
                "full": "mbetaTopN(X, Y, S, window, top, [ascending=true], [tiesMethod='oldest'])",
                "name": "mbetaTopN",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "S",
                        "name": "S"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "top",
                        "name": "top"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[tiesMethod='oldest']",
                        "name": "tiesMethod",
                        "optional": true,
                        "default": "'oldest'"
                    }
                ]
            }
        ],
        "markdown": "### [mbetaTopN](https://docs.dolphindb.cn/zh/funcs/m/mbetaTopN.html)\n\n\n\n#### 语法\n\nmbetaTopN(X, Y, S, window, top, \\[ascending=true], \\[tiesMethod='oldest'])\n\n参数说明和窗口计算规则请参考：[mTopN](https://docs.dolphindb.cn/zh/funcs/themes/TopN.html)\n\n#### 详情\n\n在给定长度（以元素个数衡量）的滑动窗口内，根据 *ascending* 指定的排序方式将 *X* 和 *Y* 按照 *S* 进行稳定排序后，取前 *top* 个元素，然后计算 *Y* 在 *X* 上的回归系数的最小二乘估计。\n\n#### 返回值\n\n计算结果为 DOUBLE 类型，形式同输入参数。\n\n#### 例子\n\n以 IBM 股票为例，构造连续 6 个交易日的指数收益率、个股收益率和成交量数据：\n\n```\nsymbol = take(`IBM, 6)\ntradeDate = 2024.01.02 2024.01.03 2024.01.04 2024.01.05 2024.01.08 2024.01.09\nindexRet = [0.6, 1.1, -0.2, 0.9, 1.3, 0.4]\nstockRet = [0.9, 1.7, -0.1, 1.4, 1.9, 0.8]\ntradeVolume = [520, 860, 610, 940, 650, 880]\n\nstockDaily = table(symbol, tradeDate, indexRet, stockRet, tradeVolume)\nstockDaily;\n```\n\n输出结果：\n\n| symbol | tradeDate  | indexRet | stockRet | tradeVolume |\n| ------ | ---------- | -------- | -------- | ----------- |\n| IBM    | 2024.01.02 | 0.6      | 0.9      | 520         |\n| IBM    | 2024.01.03 | 1.1      | 1.7      | 860         |\n| IBM    | 2024.01.04 | -0.2     | -0.1     | 610         |\n| IBM    | 2024.01.05 | 0.9      | 1.4      | 940         |\n| IBM    | 2024.01.08 | 1.3      | 1.9      | 650         |\n| IBM    | 2024.01.09 | 0.4      | 0.8      | 880         |\n\n在最近 4 个交易日内，选取成交量最高的前 2 个交易日，用最小二乘法估计指数收益率（indexRet）对个股收益率（stockRet）的回归系数：\n\n```\nmbetaTopN(X=stockRet, Y=indexRet, S=tradeVolume, window=4, top=2, ascending=false)\n// 输出: [ , 1.6, 1.3846, 1.5, 1.5, 1.2]\n```\n\n* stockRet 是回归自变量，indexRet 是回归因变量；\n\n* tradeVolume 用于筛选成交最活跃的交易日；\n\n* 对 2024.01.09 的数据而言，最近 4 日窗口中成交量最高的两个交易日对应样本为 (0.9, 1.4) 和 (0.4, 0.8)；\n\n* 基于这两个样本，用最小二乘法估计 indexRet 对 stockRet 的回归系数，结果为 1.2。\n\n相关函数：[mbeta](https://docs.dolphindb.cn/zh/funcs/m/mbeta.html)\n"
    },
    "mcorr": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mcorr.html",
        "signatures": [
            {
                "full": "mcorr(X, Y, window, [minPeriods])",
                "name": "mcorr",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "[minPeriods]",
                        "name": "minPeriods",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [mcorr](https://docs.dolphindb.cn/zh/funcs/m/mcorr.html)\n\n\n\n#### 语法\n\nmcorr(X, Y, window, \\[minPeriods])\n\n窗口计算规则请参考：[mFunctions](https://docs.dolphindb.cn/zh/funcs/themes/mFunctions.html)\n\n#### 详情\n\n在给定长度（以元素个数或时间长度衡量）的滑动窗口内，计算 *X* 和 *Y* 元素的相关性。\n\n#### 参数\n\n**X** 是一个向量/矩阵/表/元组（元素为标量或等长向量）/字典。\n\n**Y** 是一个向量/矩阵/表/元组（元素为标量或等长向量）/字典。\n\n**window** 是大于等于 2 的正整型或 DURATION 标量。表示滑动窗口的长度。\n\n**Note:** 在流计算引擎中调用滑动窗口函数时，window 的上限为 102400。\n\n**minPeriods** 是一个正整数。表示滑动窗口中最少包含的非 NULL 有效观测值数量。\n\n#### 返回值\n\n计算结果为 DOUBLE 类型，形式同输入参数。\n\n#### 例子\n\n```\nx=1..8\ny=9 5 3 4 5 4 7 1\nmcorr(x,y,5);\n\n// output: [,,,,-0.624038,0,0.834058,-0.29173]\n\nmcorr(x,y,5,3);\n// output: [,,-0.981981,-0.834497,-0.624038,0,0.834058,-0.29173]\n\nx1 = indexedSeries(date(2020.06.05)+1..8, x)\ny1 = indexedSeries(date(2020.06.05)+1..6 join 2020.06.15 join 2020.06.16, y)\nmcorr(x1,y1,5d)\n```\n\n| label      | col1    |\n| ---------- | ------- |\n| 2020.06.06 |         |\n| 2020.06.07 | -1      |\n| 2020.06.08 | -0.982  |\n| 2020.06.09 | -0.8345 |\n| 2020.06.10 | -0.624  |\n| 2020.06.11 | 0       |\n| 2020.06.12 | 0.6325  |\n| 2020.06.13 | 0       |\n\n```\nmcorr(x1,y1,1w)\n```\n\n| label      | col1    |\n| ---------- | ------- |\n| 2020.06.06 |         |\n| 2020.06.07 | -1      |\n| 2020.06.08 | -0.982  |\n| 2020.06.09 | -0.8345 |\n| 2020.06.10 | -0.624  |\n| 2020.06.11 | -0.6116 |\n| 2020.06.12 | -0.6116 |\n| 2020.06.13 | 0       |\n\n相关函数：[corr](https://docs.dolphindb.cn/zh/funcs/c/corr.html), [mmin](https://docs.dolphindb.cn/zh/funcs/m/mmin.html), [mmax](https://docs.dolphindb.cn/zh/funcs/m/mmax.html), [mavg](https://docs.dolphindb.cn/zh/funcs/m/mavg.html), [msum](https://docs.dolphindb.cn/zh/funcs/m/msum.html), [mstd](https://docs.dolphindb.cn/zh/funcs/m/mstd.html), [mvar](https://docs.dolphindb.cn/zh/funcs/m/mvar.html)\n"
    },
    "mcorrTopN": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mcorrTopN.html",
        "signatures": [
            {
                "full": "mcorrTopN(X, Y, S, window, top, [ascending=true], [tiesMethod='oldest'])",
                "name": "mcorrTopN",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "S",
                        "name": "S"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "top",
                        "name": "top"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[tiesMethod='oldest']",
                        "name": "tiesMethod",
                        "optional": true,
                        "default": "'oldest'"
                    }
                ]
            }
        ],
        "markdown": "### [mcorrTopN](https://docs.dolphindb.cn/zh/funcs/m/mcorrTopN.html)\n\n\n\n#### 语法\n\nmcorrTopN(X, Y, S, window, top, \\[ascending=true], \\[tiesMethod='oldest'])\n\n参数说明和窗口计算规则请参考：[mTopN](https://docs.dolphindb.cn/zh/funcs/themes/TopN.html)\n\n#### 详情\n\n在给定长度（以元素个数衡量）的滑动窗口内，根据 *ascending* 指定的排序方式将 *X* 和 *Y* 按照 *S* 进行稳定排序后，取前 *top* 个元素，然后计算 *Y* 和 *X* 的相关性。\n\n#### 返回值\n\n计算结果为 DOUBLE 类型，形式同输入参数。\n\n#### 例子\n\n以 IBM 股票为例，构造连续 6 个交易日的指数收益率、个股收益率和成交量数据：\n\n```\nsymbol = take(`IBM, 6)\ntradeDate = 2024.01.02 2024.01.03 2024.01.04 2024.01.05 2024.01.08 2024.01.09\nindexRet = [0.6, 1.1, -0.2, 0.9, 1.3, 0.4]\nstockRet = [0.9, 1.6, 0.4, 0.2, 0.2, 0.4]\ntradeVolume = [520, 860, 610, 940, 650, 880]\n\nstockDaily = table(symbol, tradeDate, indexRet, stockRet, tradeVolume)\nstockDaily;\n```\n\n输出结果：\n\n| symbol | tradeDate  | indexRet | stockRet | tradeVolume |\n| ------ | ---------- | -------- | -------- | ----------- |\n| IBM    | 2024.01.02 | 0.6      | 0.9      | 520         |\n| IBM    | 2024.01.03 | 1.1      | 1.6      | 860         |\n| IBM    | 2024.01.04 | -0.2     | 0.4      | 610         |\n| IBM    | 2024.01.05 | 0.9      | 0.2      | 940         |\n| IBM    | 2024.01.08 | 1.3      | 0.2      | 650         |\n| IBM    | 2024.01.09 | 0.4      | 0.4      | 880         |\n\n在最近 4 个交易日内，选取成交量最高的前 2 个交易日，计算指数收益率（indexRet）和个股收益率（stockRet）的相关性：\n\n```\nmcorrTopN(X=indexRet, Y=stockRet, S=tradeVolume, window=4, top=2, ascending=false)\n// output: [ , 1, 1, 1, 1, -1]\n```\n\n* `tradeVolume` 用于筛选成交最活跃的交易日；\n\n* 对 2024.01.09 的数据而言，最近 4 日窗口中成交量最高的两个交易日对应样本为 (0.9, 0.2) 和 (0.4, 0.4)，它们的相关系数为 -1。\n\n相关函数：[mcorr](https://docs.dolphindb.cn/zh/funcs/m/mcorr.html)\n"
    },
    "mcount": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mcount.html",
        "signatures": [
            {
                "full": "mcount(X, window, [minPeriods=1])",
                "name": "mcount",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "[minPeriods=1]",
                        "name": "minPeriods",
                        "optional": true,
                        "default": "1"
                    }
                ]
            }
        ],
        "markdown": "### [mcount](https://docs.dolphindb.cn/zh/funcs/m/mcount.html)\n\n\n\n#### 语法\n\nmcount(X, window, \\[minPeriods=1])\n\n窗口计算规则请参考：[mFunctions](https://docs.dolphindb.cn/zh/funcs/themes/mFunctions.html)\n\n#### 详情\n\n在给定长度（以元素个数或时间长度衡量）的滑动窗口内统计 *X* 中的非 NULL 元素个数。\n\n#### 参数\n\n**X** 是一个向量/矩阵/表/元组（元素为标量或等长向量）/字典。\n\n**window** 是大于等于 2 的正整型或 DURATION 标量。表示滑动窗口的长度。\n\n**Note:** 在流计算引擎中调用滑动窗口函数时，window 的上限为 102400。\n\n**minPeriods** 是一个正整数。表示滑动窗口中最少包含的非 NULL 有效观测值数量。\n\n#### 返回值\n\n计算结果为整型，形式同输入参数。\n\n#### 例子\n\n```\nx = 7 4 5 8 9;\n\nmcount(x, 3);\n// output: [1,2,3,3,3]\n\nmcount(x, 3, minPeriods=2);\n// output: [,2,3,3,3]\n\nx1 =1 2 3 NULL 5;\n\nmcount(x1, 3);\n// output: [1,2,3,2,2]\n\nmcount(x1, 3, minPeriods=3);\n// output: [,,3,,]\n\nm=matrix(1 2 NULL 4 5, 6 7 8 9 NULL);\nm;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 6  |\n| 2  | 7  |\n|    | 8  |\n| 4  | 9  |\n| 5  |    |\n\n```\nmcount(m,3);\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 1  |\n| 2  | 2  |\n| 2  | 3  |\n| 2  | 3  |\n| 2  | 2  |\n\n```\ns=indexedSeries(date(2020.05.26)+1..8, 3 4 9 NULL 4 6 NULL 8)\nmcount(s,4d)\n```\n\n| label      | col1 |\n| ---------- | ---- |\n| 2020.05.27 | 1    |\n| 2020.05.28 | 2    |\n| 2020.05.29 | 3    |\n| 2020.05.30 | 3    |\n| 2020.05.31 | 3    |\n| 2020.06.01 | 3    |\n| 2020.06.02 | 2    |\n| 2020.06.03 | 3    |\n\n```\nmcount(s,1w)\n```\n\n| label      | col1 |\n| ---------- | ---- |\n| 2020.05.27 | 1    |\n| 2020.05.28 | 2    |\n| 2020.05.29 | 3    |\n| 2020.05.30 | 3    |\n| 2020.05.31 | 4    |\n| 2020.06.01 | 5    |\n| 2020.06.02 | 5    |\n| 2020.06.03 | 5    |\n\n相关函数：[count](https://docs.dolphindb.cn/zh/funcs/c/count.html)\n"
    },
    "mcovar": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mcovar.html",
        "signatures": [
            {
                "full": "mcovar(X, Y, window, [minPeriods])",
                "name": "mcovar",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "[minPeriods]",
                        "name": "minPeriods",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [mcovar](https://docs.dolphindb.cn/zh/funcs/m/mcovar.html)\n\n\n\n#### 语法\n\nmcovar(X, Y, window, \\[minPeriods])\n\n参数说明和窗口计算规则请参考：[mFunctions](https://docs.dolphindb.cn/zh/funcs/themes/mFunctions.html)\n\n#### 详情\n\n在给定长度（以元素个数或时间长度衡量）的滑动窗口内，计算 *X* 和 *Y* 元素的协方差。\n\n#### 参数\n\n**X** 是一个向量/矩阵/表/元组（元素为标量或等长向量）/字典。\n\n**Y** 是一个向量/矩阵/表/元组（元素为标量或等长向量）/字典。\n\n**window** 是大于等于 2 的正整型或 DURATION 标量。表示滑动窗口的长度。\n\n**Note:** 在流计算引擎中调用滑动窗口函数时，window 的上限为 102400。\n\n**minPeriods** 是一个正整数。表示滑动窗口中最少包含的非 NULL 有效观测值数量。\n\n#### 返回值\n\n计算结果为 DOUBLE 类型，形式同输入参数。\n\n#### 例子\n\n```\nx=1..10;\ny=9 5 3 4 5 4 7 1 3 4;\nmcovar(x,y,5);\n// output: [,,,,-2.25,0,2,-1,-1.75,-1]\n\nmcovar(x, y, 5, 3);\n// output: [,,-3,-2.833333,-2.25,0,2,-1,-1.75,-1]\n\nx1 = indexedSeries(date(2020.06.05)+1..10, x)\ny1 = indexedSeries(date(2020.06.05)+1..10, y)\nmcovar(x1,y1,5d)\n```\n\n| label      | col1    |\n| ---------- | ------- |\n| 2020.06.06 |         |\n| 2020.06.07 | -2      |\n| 2020.06.08 | -3      |\n| 2020.06.09 | -2.8333 |\n| 2020.06.10 | -2.25   |\n| 2020.06.11 | 0       |\n| 2020.06.12 | 2       |\n| 2020.06.13 | -1      |\n| 2020.06.14 | -1.75   |\n| 2020.06.15 | -1      |\n\n```\nmcovar(x1,y1,1w)\n```\n\n| label      | col1    |\n| ---------- | ------- |\n| 2020.06.06 |         |\n| 2020.06.07 | -2      |\n| 2020.06.08 | -3      |\n| 2020.06.09 | -2.8333 |\n| 2020.06.10 | -2.25   |\n| 2020.06.11 | -2.4    |\n| 2020.06.12 | -1      |\n| 2020.06.13 | -0.6667 |\n| 2020.06.14 | -0.6667 |\n| 2020.06.15 | -1.6667 |\n\n相关函数：[covar](https://docs.dolphindb.cn/zh/funcs/c/covar.html)\n"
    },
    "mcovarp": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mcovarp.html",
        "signatures": [
            {
                "full": "mcovarp(X, Y, window, [minPeriods])",
                "name": "mcovarp",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "[minPeriods]",
                        "name": "minPeriods",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [mcovarp](https://docs.dolphindb.cn/zh/funcs/m/mcovarp.html)\n\n首发版本：3.00.5\n\n\n\n#### 语法\n\nmcovarp(X, Y, window, \\[minPeriods])\n\n参数说明和窗口计算规则请参考：[mFunctions](https://docs.dolphindb.cn/zh/funcs/themes/mFunctions.html)\n\n#### 详情\n\n在给定长度（以元素个数或时间长度衡量）的滑动窗口内，计算 *X* 和 *Y* 元素的总体协方差。\n\n#### 参数\n\n**X** 是一个向量/矩阵/表/元组（元素为标量或等长向量）/字典。\n\n**Y** 是一个向量/矩阵/表/元组（元素为标量或等长向量）/字典。\n\n**window** 是大于等于 2 的正整型或 DURATION 标量。表示滑动窗口的长度。\n\n**Note:** 在流计算引擎中调用滑动窗口函数时，window 的上限为 102400。\n\n**minPeriods** 是一个正整数。表示滑动窗口中最少包含的非 NULL 有效观测值数量。\n\n#### 返回值\n\n计算结果为 DOUBLE 类型，形式同输入参数。\n\n#### 例子\n\n```\nx=1..10;\ny=9 5 3 4 5 4 7 1 3 4;\nmcovarp(x,y,5);\n// output: [,,,,-1.8,0,1.6,-0.8,-1.4,-0.8]\n\nmcovarp(x, y, 5, 3);\n// output: [,,-2,-2.13,-1.8,0,1.6,-0.8,-1.4,-0.8]\n\nx1 = indexedSeries(date(2026.01.05)+1..10, x)\ny1 = indexedSeries(date(2026.01.05)+1..10, y)\nmcovarp(x1,y1,5d)\n```\n\n|            | 0      |\n| ---------- | ------ |\n| 2026.01.06 | 0      |\n| 2026.01.07 | -1     |\n| 2026.01.08 | -2     |\n| 2026.01.09 | -2.125 |\n| 2026.01.10 | -1.8   |\n| 2026.01.11 | 0      |\n| 2026.01.12 | 1.6    |\n| 2026.01.13 | -0.8   |\n| 2026.01.14 | -1.4   |\n| 2026.01.15 | -0.8   |\n\n相关函数：[covarp](https://docs.dolphindb.cn/zh/funcs/c/covarp.html)\n"
    },
    "mcovarpTopN": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mcovarpTopN.html",
        "signatures": [
            {
                "full": "mcovarpTopN(X, Y, S, window, top, [ascending=true], [tiesMethod='oldest'])",
                "name": "mcovarpTopN",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "S",
                        "name": "S"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "top",
                        "name": "top"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[tiesMethod='oldest']",
                        "name": "tiesMethod",
                        "optional": true,
                        "default": "'oldest'"
                    }
                ]
            }
        ],
        "markdown": "### [mcovarpTopN](https://docs.dolphindb.cn/zh/funcs/m/mcovarpTopN.html)\n\n首发版本：3.00.5\n\n\n\n#### 语法\n\nmcovarpTopN(X, Y, S, window, top, \\[ascending=true], \\[tiesMethod='oldest'])\n\n参数说明和窗口计算规则请参考：[mTopN](https://docs.dolphindb.cn/zh/funcs/themes/TopN.html)\n\n#### 详情\n\n在给定长度（以元素个数衡量）的滑动窗口内，根据 *ascending* 指定的排序方式将 *X* 和 *Y* 按照 *S* 进行稳定排序后，取前 *top* 个元素，然后计算 *Y* 和 *X* 的总体协方差。\n\n#### 返回值\n\n计算结果为 DOUBLE 类型，形式同输入参数。\n\n#### 例子\n\n以 IBM 股票为例，构造连续 6 个交易日的指数收益率、个股收益率和成交量数据：\n\n```\nsymbol = take(`IBM, 6)\ntradeDate = 2024.01.02 2024.01.03 2024.01.04 2024.01.05 2024.01.08 2024.01.09\nindexRet = [0.6, 1.1, -0.2, 0.9, 1.3, 0.4]\nstockRet = [0.9, 1.7, -0.1, 1.4, 1.9, 0.8]\ntradeVolume = [520, 860, 610, 940, 650, 880]\n\nstockDaily = table(symbol, tradeDate, indexRet, stockRet, tradeVolume)\nstockDaily;\n```\n\n输出结果：\n\n| symbol | tradeDate  | indexRet | stockRet | tradeVolume |\n| ------ | ---------- | -------- | -------- | ----------- |\n| IBM    | 2024.01.02 | 0.6      | 0.9      | 520         |\n| IBM    | 2024.01.03 | 1.1      | 1.7      | 860         |\n| IBM    | 2024.01.04 | -0.2     | -0.1     | 610         |\n| IBM    | 2024.01.05 | 0.9      | 1.4      | 940         |\n| IBM    | 2024.01.08 | 1.3      | 1.9      | 650         |\n| IBM    | 2024.01.09 | 0.4      | 0.8      | 880         |\n\n在最近 4 个交易日内，选取成交量最高的前 2 个交易日，计算个股收益率（stockRet ）和指数收益率（indexRet）的总体协方差：\n\n```\nmcovarTopN(X=indexRet, Y=stockRet, S=tradeVolume, window=4, top=2, ascending=false)\n// 输出: [ , 0.2, 1.17, 0.03, 0.03, 0.15]\n```\n\n* tradeVolume 用于筛选成交最活跃的交易日；\n\n* 对 2024.01.09 的数据而言，最近 4 日窗口中成交量最高的两个交易日对应样本为 (0.9, 1.4) 和 (0.4, 0.8)，它们的总体协方差为 0.075。\n\n相关函数：[covarp](https://docs.dolphindb.cn/zh/funcs/c/covarp.html)\n"
    },
    "mcovarTopN": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mcovarTopN.html",
        "signatures": [
            {
                "full": "mcovarTopN(X, Y, S, window, top, [ascending=true], [tiesMethod='oldest'])",
                "name": "mcovarTopN",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "S",
                        "name": "S"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "top",
                        "name": "top"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[tiesMethod='oldest']",
                        "name": "tiesMethod",
                        "optional": true,
                        "default": "'oldest'"
                    }
                ]
            }
        ],
        "markdown": "### [mcovarTopN](https://docs.dolphindb.cn/zh/funcs/m/mcovarTopN.html)\n\n\n\n#### 语法\n\nmcovarTopN(X, Y, S, window, top, \\[ascending=true], \\[tiesMethod='oldest'])\n\n参数说明和窗口计算规则请参考：[mTopN](https://docs.dolphindb.cn/zh/funcs/themes/TopN.html)\n\n#### 详情\n\n在给定长度（以元素个数衡量）的滑动窗口内，根据 *ascending* 指定的排序方式将 *X* 和 *Y* 按照 *S* 进行稳定排序后，取前 *top* 个元素，然后计算 *Y* 和 *X* 的协方差。\n\n#### 返回值\n\n计算结果为 DOUBLE 类型，形式同输入参数。\n\n#### 例子\n\n以 IBM 股票为例，构造连续 6 个交易日的指数收益率、个股收益率和成交量数据：\n\n```\nsymbol = take(`IBM, 6)\ntradeDate = 2024.01.02 2024.01.03 2024.01.04 2024.01.05 2024.01.08 2024.01.09\nindexRet = [0.6, 1.1, -0.2, 0.9, 1.3, 0.4]\nstockRet = [0.9, 1.7, -0.1, 1.4, 1.9, 0.8]\ntradeVolume = [520, 860, 610, 940, 650, 880]\n\nstockDaily = table(symbol, tradeDate, indexRet, stockRet, tradeVolume)\nstockDaily;\n```\n\n输出结果：\n\n| symbol | tradeDate  | indexRet | stockRet | tradeVolume |\n| ------ | ---------- | -------- | -------- | ----------- |\n| IBM    | 2024.01.02 | 0.6      | 0.9      | 520         |\n| IBM    | 2024.01.03 | 1.1      | 1.7      | 860         |\n| IBM    | 2024.01.04 | -0.2     | -0.1     | 610         |\n| IBM    | 2024.01.05 | 0.9      | 1.4      | 940         |\n| IBM    | 2024.01.08 | 1.3      | 1.9      | 650         |\n| IBM    | 2024.01.09 | 0.4      | 0.8      | 880         |\n\n在最近 4 个交易日内，选取成交量最高的前 2 个交易日，计算个股收益率（stockRet ）和指数收益率（indexRet）的协方差：\n\n```\nmcovarTopN(X=indexRet, Y=stockRet, S=tradeVolume, window=4, top=2, ascending=false)\n// 输出: [ , 0.2, 1.17, 0.03, 0.03, 0.15]\n```\n\n* tradeVolume 用于筛选成交最活跃的交易日；\n\n* 对 2024.01.09 的数据而言，最近 4 日窗口中成交量最高的两个交易日对应样本为 (0.9, 1.4) 和 (0.4, 0.8)，它们的协方差为 0.15。\n\n相关函数：[mcovar](https://docs.dolphindb.cn/zh/funcs/m/mcovar.html)\n"
    },
    "md5": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/md5.html",
        "signatures": [
            {
                "full": "md5(X)",
                "name": "md5",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [md5](https://docs.dolphindb.cn/zh/funcs/m/md5.html)\n\n\n\n#### 语法\n\nmd5(X)\n\n#### 详情\n\n根据 MD5 算法，对字符串进行哈希，生成 INT128 类型的数据。\n\n#### 参数\n\n**X** 是一个字符串标量或向量。\n\n#### 返回值\n\nINT128 类型标量或向量。\n\n#### 例子\n\n```\na=md5(`e`f);\na;\n// output: [e1671797c52e15f763380b45e841ec32,8fa14cdd754f91cc6554c9e71929cce7]\n\ntypestr(a);\n// output: INT128\n```\n"
    },
    "mdd": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mdd.html",
        "signatures": [
            {
                "full": "maxDrawdown(X, [ratio=true])",
                "name": "maxDrawdown",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[ratio=true]",
                        "name": "ratio",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [mdd](https://docs.dolphindb.cn/zh/funcs/m/mdd.html)\n\n是 \\[maxDrawdown]\\(maxdrawdown.md) 的别名。\n\n\n以下是 `maxDrawdown` 函数的文档：\n### [maxDrawdown](https://docs.dolphindb.cn/zh/funcs/m/maxdrawdown.html)\n\n\n\n#### 语法\n\nmaxDrawdown(X, \\[ratio=true])\n\n聚合函数，别名 mdd。\n\n#### 详情\n\n计算传入向量数据的最大回撤（Maximum Drawdown，简称 MDD）或最大回撤率（Maximum Drawdown Rate）。\n\n#### 参数\n\n**X** 数值向量，表示用于计算最大回撤的输入数据，一般指累积的收益或收益率。注意：不可为空。\n\n**ratio**布尔标量，表示是否返回最大回撤率。默认值为 true。\n\n* 若为 true，表示返回最大回撤率，即相对于峰值的最大下降百分比，计算公式为：\n\n  ![](https://docs.dolphindb.cn/zh/funcs/images/mdd1.png)\n\n* 若为 false，表示返回基于下降金额绝对值的最大回撤，计算公式为：\n\n  ![](https://docs.dolphindb.cn/zh/funcs/images/mdd2.png)\n\n注意：计算时将忽略空值。\n\n#### 返回值\n\n一个 DOUBLE 类型标量，表示 *X* 的最大回撤或最大回撤率。\n\n#### 例子\n\n假设有一个投资组合在一段时间内的累积收益变化如下（以天为单位）：\n\n<table id=\"table_h24_4zx_bdc\"><thead><tr><th align=\"left\">\n\n日期\n\n</th><th align=\"left\">\n\n累积收益\n\n</th></tr></thead><tbody><tr><td>\n\n2024-10-01\n\n</td><td>\n\n36\n\n</td></tr><tr><td>\n\n2024-10-02\n\n</td><td>\n\n96\n\n</td></tr><tr><td>\n\n2024-10-03\n\n</td><td>\n\n42\n\n</td></tr><tr><td>\n\n2024-10-04\n\n</td><td>\n\n100\n\n</td></tr><tr><td>\n\n2024-10-05\n\n</td><td>\n\n59\n\n</td></tr><tr><td>\n\n2024-10-06\n\n</td><td>\n\n86\n\n</td></tr><tr><td>\n\n2024-10-07\n\n</td><td>\n\n25\n\n</td></tr><tr><td>\n\n2024-10-08\n\n</td><td>\n\n72\n\n</td></tr></tbody>\n</table>使用 `maxDrawdown` 计算该数据的最大回撤率和最大回撤。\n\n```\nx = [36,96,42,100,59,86,25,64,72]\n\nmaxDrawdown(x)\n// Output: 0.75\nmaxDrawdown(x, false)\n// Output: 75\n```\n\n相关函数：[cummdd](https://docs.dolphindb.cn/zh/funcs/c/cummdd.html)\n"
    },
    "mean": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mean.html",
        "signatures": [
            {
                "full": "mean(X)",
                "name": "mean",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [mean](https://docs.dolphindb.cn/zh/funcs/m/mean.html)\n\n\n\n#### 语法\n\nmean(X)\n\n#### 详情\n\n若 *X* 为向量，计算 *X* 的平均值。\n\n若 *X* 为矩阵，计算每列的平均值。\n\n若 *X* 为表，计算每列的平均值。\n\n该函数与 [avg](https://docs.dolphindb.cn/zh/funcs/a/avg.html) 函数完全相同。\n\n与所有其它聚合函数一致，计算时忽略 NULL 值。\n\nDolphinDB `mean` 函数面向向量、矩阵和表。对于矩阵和表，默认按列计算均值，不存在“全局均值”概念，若需全局均值必须手动展平数据。NumPy 的 `mean` 函数面向多维数组。默认将输入展平为1维数组后计算全局均值；需显式指定 *axis* 参数才能按行、列或多轴计算。\n\n#### 参数\n\n**X** 可以是标量、数据对、向量、矩阵或表。\n\n#### 返回值\n\n若 *X* 为向量，返回一个 DOUBLE 标量。\n\n若 *X* 为矩阵，返回一个 DOUBLE 向量。\n\n若 *X* 为表，返回一个表。\n\n#### 例子\n\n```\nx=1 5 9;\nmean(x);\n// output: 5\n\nx=1 5 9 NULL;\nmean(x);\n// output\n5\n\navg(x);\n// output\n5\n\nm=matrix(1 2 3, 4 5 6);\nm;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 4  |\n| 2  | 5  |\n| 3  | 6  |\n\n```\nmean(m);\n// output\n[2,5]\n```\n\n相关的中心趋势函数：[mode](https://docs.dolphindb.cn/zh/funcs/m/mode.html), [med](https://docs.dolphindb.cn/zh/funcs/m/med.html)\n"
    },
    "med": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/med.html",
        "signatures": [
            {
                "full": "med(X)",
                "name": "med",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [med](https://docs.dolphindb.cn/zh/funcs/m/med.html)\n\n\n\n#### 语法\n\nmed(X)\n\n#### 详情\n\n如果 *X* 是向量，返回 *X* 中所有元素的中值。\n\n若 *X* 为矩阵，计算每列的中值，返回一个向量。\n\n与所有其它聚合函数一致，计算时忽略 NULL 值。\n\n#### 参数\n\n**X** 可以是标量、向量或矩阵。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\nx=3 6 1 5 9;\nmed x;\n// output: 5\n\nm=matrix(1 2 10, 4 5 NULL);\nm;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 4  |\n| 2  | 5  |\n| 10 |    |\n\n```\nmed m;\n// output: [2,4.5]\n```\n\n相关的中心趋势函数：[mean](https://docs.dolphindb.cn/zh/funcs/m/mean.html) 和 [mode](https://docs.dolphindb.cn/zh/funcs/m/mode.html)\n"
    },
    "mem": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mem.html",
        "signatures": [
            {
                "full": "mem([freeUnusedBlocks=false])",
                "name": "mem",
                "parameters": [
                    {
                        "full": "[freeUnusedBlocks=false]",
                        "name": "freeUnusedBlocks",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [mem](https://docs.dolphindb.cn/zh/funcs/m/mem.html)\n\n\n\n#### 语法\n\nmem(\\[freeUnusedBlocks=false])\n\n#### 详情\n\n显示本地节点内存使用情况。\n\n结果中，allocatedBytes 为已分配内存；freeBytes 是可用内存。两者之差为已占用内存。\n\n如果 *freeUnusedBlocks* =true，系统将会释放未使用的内存块。\n\n#### 参数\n\n**freeUnusedBlocks** 为 DOUBLE 类型，取值范围为 0\\~1，表示释放的百分比。默认值为 false。\n\n#### 返回值\n\n一个字典。\n\n#### 例子\n\n```\nundef all;\n\nt1=table(1 2 3 as a, `x`y`z as b, 10.8 7.6 3.5 as c)\nmem();\n\n// output\nfreeBytes->492904\nallocatedBytes->8454144\n\n\nx=bigarray(INT,100000,10000000)\nmem();\n\n// output\nfreeBytes->491056\nallocatedBytes->12648448\n\n\nundef all;\nmem();\n\n// output\nfreeBytes->4687936\nallocatedBytes->12648448\n```\n"
    },
    "member": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/member.html",
        "signatures": [
            {
                "full": "member(X, Y)",
                "name": "member",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [member](https://docs.dolphindb.cn/zh/funcs/m/member.html)\n\n\n\n#### 语法\n\nmember(X, Y) 或 X.Y\n\n#### 详情\n\n返回对象的指定成员/属性。\n\n#### 参数\n\n**X** 可以是表或字典。\n\n**Y** 是 *X* 的一个成员或属性。若使用 member(X, Y) 方式，*Y* 必须是字符串。\n\n#### 例子\n\n```\nx=1 2 3\ny=4 5 6\nt=table(x,y);\n\nt.x;\n// output: [1,2,3]\nt.y;\n// output: [4,5,6]\n\nt.rows();\n// output: 3\nt.cols();\n// output: 2\nt.size();\n// output: 3\n// 表的 size 定义为它的行数\n\nd = dict(1 2 3, 4 5 6);\nd;\n// output\n3->6\n1->4\n2->5\n\nd.2;\n// output: 5\n```\n"
    },
    "memberModify!": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/membermodify.html",
        "signatures": [
            {
                "full": "memberModify!(obj, function, indices, parameters)",
                "name": "memberModify!",
                "parameters": [
                    {
                        "full": "obj",
                        "name": "obj"
                    },
                    {
                        "full": "function",
                        "name": "function"
                    },
                    {
                        "full": "indices",
                        "name": "indices"
                    },
                    {
                        "full": "parameters",
                        "name": "parameters"
                    }
                ]
            }
        ],
        "markdown": "### [memberModify!](https://docs.dolphindb.cn/zh/funcs/m/membermodify.html)\n\n\n\n#### 语法\n\nmemberModify!(obj, function, indices, parameters)\n\n#### 详情\n\n修改元组或 ANY 字典的成员对象，也可修改面向对象的编程（OOP）中的对象。\n\n#### 参数\n\n**obj** 一个元组或值为 ANY 类型的字典，或者一个 OOP 对象。\n\n**function**一个内置的系统函数，该函数的第一个参数是可修改的，例如 append!。\n\n**indices** 标量、向量或元组，表示指向一个或多个成员对象的索引或键值。\n\n* 若是一个元组，用于表示多维度索引。元组的长度表示索引的深度。\n\n* 若是一个向量，表示对多个成员进行修改。\n\n**parameters** *function* 除第一个参数外的其它参数。*parameters* 的维度必须与 *indices*, *function* 的参数个数匹配。\n\n#### 返回值\n\n无\n\n#### 例子\n\n##### 例 1\n\n创建元组 a，修改其中的一个元素，可见前后对比。\n\n```\na = (1 2, 3 4 5)\nmemberModify!(a, append!, 0, 3 4)\na\n//output: a = (1 2 3 4, 3 4 5)\n```\n\n创建字典 d，修改其中的两个元素，可见前后对比。\n\n```\nd = dict(`A`B`C, (1 2, 3 4, 5 6))\nd\n/*output:\nA->[1,2]\nB->[3,4]\nC->[5,6]\n*/\n\nd.memberModify!(append!,`A`B, 3 4) \nd\n/*output:\nA->[1,2,3]\nB->[3,4,4]\nC->[5,6]\n */\n```\n\n创建元组 c，其包含基于表 t，字典 d 和一个元组。\n\n```\nt = table(1 2 3 as val1, 4 5 6 as val2)\nd = dict(`A`B`C, (1 2, 3 4, 5 6))\nc = (t, d, [1 2 3, 4 5 6])\nc\n/*output: \n(val1 val2\n---- ----\n1    4   \n2    5   \n3    6   \n,C->[5,6]\nA->[1,2]\nB->[3,4]\n,([1,2,3],[4,5,6]))\n*/\n```\n\n调用 `memberModify!` 对元组第 3 个元素 `[1 2 3, 4 5 6]` 的第 1 个元素 \\[1, 2, 3] 添加元素 4 和 5。要修改的对象需要用两个维度来指定，因此 indices 使用元组 (2, 0) 来表示。\n\n```\nc.memberModify!(append!, (2, 0), 4 5)\n/*output: \n(val1 val2\n---- ----\n1    4   \n2    5   \n3    6   \n,C->[5,6]\nA->[1,2]\nB->[3,4]\n,([1,2,3,4,5],[4,5,6]))\n*/\n```\n\n在该基础上，继续向元组的第 2 个元素（字典）的键值 B 指定的对象写入新数据 5 和 7。indices 仍然使用元组 （1，\\`B) 来表示。\n\n```\nc.memberModify!(append!, (1,`B), 5 7)\nc\n/*output: \n(val1 val2\n---- ----\n1    4   \n2    5   \n3    6   \n,C->[5,6]\nA->[1,2]\nB->[3,4,5,7]\n,([1,2,3,4,5],[4,5,6]))\n*/\n```\n\n##### 例 2\n\n约定名为 A 的类并进行实例化，使用 `memberModify!` 进行写入操作，打印向量 a 的数据，可得预期结果。\n\n```\nclass A {\n\ta :: INT VECTOR\n\tdef A() {\n\t\ta = []\n\t}\n}\n\nv = A()\nmemberModify!(v, append!, \"a\", 1)\nprint v.a \n//output: [1]\n\nmemberModify!(v, append!, \"a\", 11)\nprint v.a \n//output: [1,11]\n```\n"
    },
    "memSize": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/memSize.html",
        "signatures": [
            {
                "full": "memSize(obj)",
                "name": "memSize",
                "parameters": [
                    {
                        "full": "obj",
                        "name": "obj"
                    }
                ]
            }
        ],
        "markdown": "### [memSize](https://docs.dolphindb.cn/zh/funcs/m/memSize.html)\n\n\n\n#### 语法\n\nmemSize(obj)\n\n#### 详情\n\n返回本地对象或共享对象占用内存大小，单位为字节。\n\n#### 参数\n\n**obj** 一个对象。\n\n#### 返回值\n\n整型标量。\n\n#### 例子\n\n```\nn=100\nID=rand(100, n)\ndate=rand(2017.08.07..2017.08.11, n)\nx=rand(10.0, n)\nt=table(ID, date, x);\nshare t as tt\nmemSize(t)\n// output: 1952\nmemSize(tt)\n// output: 1952\nmemSize(t[`x])\n// output: 800\nmemSize(select avg(x) as avgx from t)\n// output: 280\n```\n\n相关函数：[objs](https://docs.dolphindb.cn/zh/funcs/o/objs.html)\n"
    },
    "merge": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/merge.html",
        "signatures": [
            {
                "full": "merge(left, right, [how='inner'])",
                "name": "merge",
                "parameters": [
                    {
                        "full": "left",
                        "name": "left"
                    },
                    {
                        "full": "right",
                        "name": "right"
                    },
                    {
                        "full": "[how='inner']",
                        "name": "how",
                        "optional": true,
                        "default": "'inner'"
                    }
                ]
            }
        ],
        "markdown": "### [merge](https://docs.dolphindb.cn/zh/funcs/m/merge.html)\n\n\n\n#### 语法\n\nmerge(left, right, \\[how='inner'])\n\n#### 详情\n\n联结两个索引序列或两个索引矩阵。\n\nDolphinDB 的 `merge` 函数与 Python Pandas 的 `merge` 函数在核心功能上相似，区别在于：\n\n| 对比维度   | DolphinDB `merge`                                                   | Python Pandas `merge`                                                                               |\n| ------ | ------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------- |\n| 核心功能   | 联结两个索引序列或索引矩阵。基于行标签进行对齐和合并。                                         | 联结两个 DataFrame。基于一个或多个列（或索引）进行数据库风格的合并。                                                             |\n| 主要设计目的 | 处理面板数据，实现时间序列或截面数据的对齐运算。                                            | 实现关系型数据库的 JOIN 操作（如 inner, left, right, outer join）。                                                |\n| 输入对象   | *left*, *right*：必须均为索引序列或索引矩阵。                                      | *left*, *right*：DataFrame 或带有名称的 Series。                                                            |\n| 关键参数   | 支持 *how*（'inner', 'outer', 'left', 'right', 'asof''（DolphinDB 特有））。 | 支持 *how*, *on*, *left\\_on*, *right\\_on*, *left\\_index*, *right\\_index*, *sort*, *suffixes* 等。功能更丰富。 |\n\n#### 参数\n\n**left** 与 **right** 均为索引序列，或均为索引矩阵。\n\n**how** 是字符串，表示如何对数据进行联结。可取值为 'inner', 'outer', 'left', 'right' 与 'asof'。默认值为 ‘inner’。\n\n#### 返回值\n\n一个矩阵。\n\n#### 例子\n\n```\na = indexedSeries(2012.01.01..2012.01.04, 1..4)\nb = indexedSeries([2012.01.01, 2012.01.03, 2012.01.05, 2012.01.06], 5..8)\nmerge(a, b);\n```\n\n|            | series1 | series2 |\n| ---------- | ------- | ------- |\n| 2012.01.01 | 1       | 5       |\n| 2012.01.03 | 3       | 6       |\n\n```\nmerge(a, b, 'left');\n```\n\n|            | series1 | series2 |\n| ---------- | ------- | ------- |\n| 2012.01.01 | 1       | 5       |\n| 2012.01.02 | 2       |         |\n| 2012.01.03 | 3       | 6       |\n| 2012.01.04 | 4       |         |\n\n```\nm1 = matrix([1.2, 7.8, 4.6, 5.1, 9.5], [0.15, 1.26, 0.45, 1.02, 0.33]).rename!([2012.01.01, 2015.02.01, 2015.03.01, 2015.04.01, 2015.05.01], `x1`x2).setIndexedMatrix!()\nm2 = matrix([1.0, 2.0, 3.0, 4.0], [0.14, 0.26, 0.35, 0.48]).rename!([2015.02.01, 2015.02.16, 2015.05.01, 2015.05.02], `y1`y2).setIndexedMatrix!()\nm = merge(m1, m2, 'asof');\n```\n\n|            | x1  | x2   | y1 | y2   |\n| ---------- | --- | ---- | -- | ---- |\n| 2012.01.01 | 1.2 | 0.15 |    |      |\n| 2015.02.01 | 7.8 | 1.26 | 1  | 0.14 |\n| 2015.03.01 | 4.6 | 0.45 | 2  | 0.26 |\n| 2015.04.01 | 5.1 | 1.02 | 2  | 0.26 |\n| 2015.05.01 | 9.5 | 0.33 | 3  | 0.35 |\n"
    },
    "mfirst": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mfirst.html",
        "signatures": [
            {
                "full": "mfirst(X, window, [minPeriods])",
                "name": "mfirst",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "[minPeriods]",
                        "name": "minPeriods",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [mfirst](https://docs.dolphindb.cn/zh/funcs/m/mfirst.html)\n\n\n\n#### 语法\n\nmfirst(X, window, \\[minPeriods])\n\n窗口计算规则请参考：[mFunctions](https://docs.dolphindb.cn/zh/funcs/themes/mFunctions.html)\n\n#### 详情\n\n在给定长度（以元素个数或时间长度衡量）的滑动窗口内计算 *X* 的第一个元素。\n\n#### 参数\n\n**X** 是一个向量/矩阵/表/元组（元素为标量或等长向量）/字典。\n\n**window** 是大于等于 2 的正整型或 DURATION 标量。表示滑动窗口的长度。\n\n**Note:** 在流计算引擎中调用滑动窗口函数时，window 的上限为 102400。\n\n**minPeriods** 是一个正整数。表示滑动窗口中最少包含的非 NULL 有效观测值数量。\n\n#### 返回值\n\n* 当 *X* 是向量时，返回一个向量。\n\n* 当 *X* 是矩阵时，返回一个矩阵。\n\n* 当 *X* 是表时，对表的每列进行计算，返回相应的结果。\n\n* 当 *X* 是元组时，对元组中的每个向量分别计算，返回相应的结果。\n\n#### 例子\n\n```\nindex = second(08:20:00)+1..7\nx = 2 1 3 NULL 6 5 4\nx = index.indexedSeries(x)\nmfirst(x,3s)\n```\n\n| label    | col1 |\n| -------- | ---- |\n| 08:20:01 | 2    |\n| 08:20:02 | 2    |\n| 08:20:03 | 2    |\n| 08:20:04 | 1    |\n| 08:20:05 | 3    |\n| 08:20:06 |      |\n| 08:20:07 | 6    |\n\n```\nm = matrix(1 5 9 0 2, 9 10 2 NULL 2)\nm.rename!((date(2020.09.08)+1..3) join 2020.09.16 join 2020.09.26, `A`B)\nm.setIndexedMatrix!()\nmfirst(m, 3d)\n```\n\n| label      | A | B |\n| ---------- | - | - |\n| 2020.09.09 | 1 | 9 |\n| 2020.09.10 | 1 | 9 |\n| 2020.09.11 | 1 | 9 |\n| 2020.09.16 | 0 |   |\n| 2020.09.26 | 2 | 2 |\n\n```\nmfirst(m, 1w)\n```\n\n| label      | A | B  |\n| ---------- | - | -- |\n| 2020.09.09 | 1 | 9  |\n| 2020.09.10 | 1 | 9  |\n| 2020.09.11 | 1 | 9  |\n| 2020.09.16 | 5 | 10 |\n| 2020.09.26 | 2 | 2  |\n\n相关函数：[first](https://docs.dolphindb.cn/zh/funcs/f/first.html), [last](https://docs.dolphindb.cn/zh/funcs/l/last.html)\n"
    },
    "mfirstNot": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mfirstnot.html",
        "signatures": [
            {
                "full": "mfirstNot(X, window, [k=NULL], [minPeriods=1])",
                "name": "mfirstNot",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "[k=NULL]",
                        "name": "k",
                        "optional": true,
                        "default": "NULL"
                    },
                    {
                        "full": "[minPeriods=1]",
                        "name": "minPeriods",
                        "optional": true,
                        "default": "1"
                    }
                ]
            }
        ],
        "markdown": "### [mfirstNot](https://docs.dolphindb.cn/zh/funcs/m/mfirstnot.html)\n\n\n\n#### 语法\n\nmfirstNot(X, window, \\[k=NULL], \\[minPeriods=1])\n\n窗口计算规则请参考：[mFunctions](https://docs.dolphindb.cn/zh/funcs/themes/mFunctions.html)\n\n#### 详情\n\n若 *X* 是向量：\n\n* 如果没有指定 *k*，计算给定长度（以元素个数或时间长度衡量）的滑动窗口内 *X* 中第一个不为 NULL 的元素。\n\n* 如果指定 *k*，计算给定长度（以元素个数或时间长度衡量）的滑动窗口内 *X* 中第一个不为 *k* 或 NULL 的元素。\n\n若 *X* 是矩阵或表，则在每列内进行上述计算。\n\n#### 参数\n\n**X** 是一个向量/矩阵/表/元组（元素为标量或等长向量）/字典。\n\n**window** 是大于等于 2 的正整型或 DURATION 标量。表示滑动窗口的长度。\n\n**Note:** 在流计算引擎中调用滑动窗口函数时，window 的上限为 102400。\n\n**k** 可选参数，是一个数值或字符串类型的标量，表示用于匹配的数据。\n\n**minPeriods** 是一个正整数。表示滑动窗口中最少包含的非 NULL 有效观测值数量。\n\n#### 返回值\n\n* 当 *X* 是向量时，返回一个向量。\n\n* 当 *X* 是矩阵时，返回一个矩阵。\n\n* 当 *X* 是表时，对表的每列进行计算，返回相应的结果。\n\n* 当 *X* 是元组时，对元组中的每个向量分别计算，返回相应的结果。\n\n#### 例子\n\n例 1\n\n```\nX = NULL 2 NULL 4 5\nmfirstNot(X=X, window=2)\n// output: [,2,2,4,4]\n```\n\n例 2\n\n```\nx = matrix(1..5,2..6,3..7)\nmfirstNot(X=x, window=3, k=1, minPeriods=2)\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n|    |    |    |\n| 2  | 2  | 3  |\n| 2  | 2  | 3  |\n| 2  | 3  | 4  |\n| 3  | 4  | 5  |\n\n例 3\n\n```\nx=table([\"s1\", \"s2\", \"\", \"s4\", \"s5\"] as col1, [\"s1\", \"\", \"s3\", \"\", \"s5\"] as col2)\nmfirstNot(X=x, window=2)\n```\n\n| #0 | #1 |\n| -- | -- |\n|    |    |\n| s1 | s1 |\n| s2 | s3 |\n| s4 | s3 |\n| s4 | s5 |\n\n例 4\n\n```\nT = [2022.01.01, 2022.01.02, 2022.01.03, 2022.01.06, 2022.01.07, 2022.01.08, 2022.01.10, 2022.01.11]\nX = 1..8\nX1 = indexedSeries(T, X)\nmfirstNot(X=X1, window=3, k=1, minPeriods=1)\n```\n\n|            | #0 |\n| ---------- | -- |\n| 2022.01.01 |    |\n| 2022.01.02 | 2  |\n| 2022.01.03 | 2  |\n| 2022.01.06 | 4  |\n| 2022.01.07 | 4  |\n| 2022.01.08 | 4  |\n| 2022.01.10 | 6  |\n| 2022.01.11 | 7  |\n\n**Related information**\n\n[mlastNot](https://docs.dolphindb.cn/zh/funcs/m/mlastnot.html)\n"
    },
    "microsecond": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/microsecond.html",
        "signatures": [
            {
                "full": "microsecond(X)",
                "name": "microsecond",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [microsecond](https://docs.dolphindb.cn/zh/funcs/m/microsecond.html)\n\n\n\n#### 语法\n\nmicrosecond(X)\n\n#### 详情\n\n返回 *X* 中的微秒数。\n\n#### 参数\n\n**X** 可以是 TIME, TIMESTAMP, NANOTIME 或 NANOTIMESTAMP 类型的标量或向量。\n\n#### 返回值\n\n整型标量或向量。\n\n#### 例子\n\n```\nmicrosecond(13:30:10.008);\n// output: 8000\n\nmicrosecond([2012.12.03 01:22:01.999999000, 2012.12.03 01:22:01.000456000, 2012.12.03 01:25:08.000000234]);\n// output: [999999,456,0]\n```\n\n相关函数：[dayOfYear](https://docs.dolphindb.cn/zh/funcs/d/dayOfYear.html), [dayOfMonth](https://docs.dolphindb.cn/zh/funcs/d/dayOfMonth.html), [quarterOfYear](https://docs.dolphindb.cn/zh/funcs/q/quarterOfYear.html), [monthOfYear](https://docs.dolphindb.cn/zh/funcs/m/monthOfYear.html), [weekOfYear](https://docs.dolphindb.cn/zh/funcs/w/weekOfYear.html), [hourOfDay](https://docs.dolphindb.cn/zh/funcs/h/hourOfDay.html), [minuteOfHour](https://docs.dolphindb.cn/zh/funcs/m/minuteOfHour.html), [secondOfMinute](https://docs.dolphindb.cn/zh/funcs/s/secondOfMinute.html), [millisecond](https://docs.dolphindb.cn/zh/funcs/m/millisecond.html), [nanosecond](https://docs.dolphindb.cn/zh/funcs/n/nanosecond.html)\n"
    },
    "mifirstNot": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mifirstNot.html",
        "signatures": [
            {
                "full": "mifirstNot(X, window, [minPeriods])",
                "name": "mifirstNot",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "[minPeriods]",
                        "name": "minPeriods",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [mifirstNot](https://docs.dolphindb.cn/zh/funcs/m/mifirstNot.html)\n\n#### 语法\n\nmifirstNot(X, window, \\[minPeriods])\n\n窗口计算规则请参考：[mFunctions](https://docs.dolphindb.cn/zh/funcs/themes/mFunctions.html)\n\n#### 详情\n\n在给定长度（以元素个数或时间长度衡量）的滑动窗口内计算 *X* 的第一个非空元素的下标。\n\n#### 参数\n\n**X** 是一个向量/矩阵/表/元组（元素为标量或等长向量）/字典。\n\n**window** 是大于等于 2 的正整型或 DURATION 标量。表示滑动窗口的长度。\n\n**Note:** 在流计算引擎中调用滑动窗口函数时，window 的上限为 102400。\n\n**minPeriods** 是一个正整数。表示滑动窗口中最少包含的非 NULL 有效观测值数量。\n\n#### 返回值\n\n* 当 *X* 是向量时，返回一个向量。\n\n* 当 *X* 是矩阵时，返回一个矩阵。\n\n* 当 *X* 是表时，对表的每列进行计算，返回相应的结果。\n\n* 当 *X* 是元组时，对元组中的每个向量分别计算，返回相应的结果。\n\n#### 例子\n\n```\nv = NULL NULL 2 3 4 8 NULL 5 -2 3 -1 0 NULL\nmifirstNot(v, 3)\n// output: [,,2,1,0,0,0,0,1,0,0,0,0]\n\nm = matrix(NULL 1 2 3, 1 NULL 2 3, NULL NULL 3 4, 1 2 3 4)\nn = mifirstNot(m, 2)\nn\n```\n\n| #1 | #2 | #3 | #4 |\n| -- | -- | -- | -- |\n|    |    |    |    |\n| 1  | 0  | -1 | 0  |\n| 0  | 1  | 1  | 0  |\n| 0  | 0  | 0  | 0  |\n\n```\nT = [2022.01.01, 2022.01.02, 2022.01.03, 2022.01.06, 2022.01.07]\nX = NULL 2 NULL 4 5\nX1 = indexedSeries(T, X)\nmifirstNot(X1, 2, 1)\n```\n\n|            | #1 |\n| ---------- | -- |\n| 2022.01.01 | -1 |\n| 2022.01.02 | 1  |\n| 2022.01.03 | 0  |\n| 2022.01.06 | 0  |\n| 2022.01.07 | 0  |\n\n\n\n**Related information**\n\n[milastNot](https://docs.dolphindb.cn/zh/funcs/m/milastNot.html)\n\n[mFunctions](https://docs.dolphindb.cn/zh/funcs/themes/mFunctions.html)\n"
    },
    "migrate": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/migrate.html",
        "signatures": [
            {
                "full": "migrate(backupDir, [backupDBPath], [backupTableName], [newDBPath=backupDBPath], [newTableName=backupTableName], [keyPath])",
                "name": "migrate",
                "parameters": [
                    {
                        "full": "backupDir",
                        "name": "backupDir"
                    },
                    {
                        "full": "[backupDBPath]",
                        "name": "backupDBPath",
                        "optional": true
                    },
                    {
                        "full": "[backupTableName]",
                        "name": "backupTableName",
                        "optional": true
                    },
                    {
                        "full": "[newDBPath=backupDBPath]",
                        "name": "newDBPath",
                        "optional": true,
                        "default": "backupDBPath"
                    },
                    {
                        "full": "[newTableName=backupTableName]",
                        "name": "newTableName",
                        "optional": true,
                        "default": "backupTableName"
                    },
                    {
                        "full": "[keyPath]",
                        "name": "keyPath",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [migrate](https://docs.dolphindb.cn/zh/funcs/m/migrate.html)\n\n\n\n#### 语法\n\nmigrate(backupDir, \\[backupDBPath], \\[backupTableName], \\[newDBPath=backupDBPath], \\[newTableName=backupTableName], \\[keyPath])\n\n#### 详情\n\n恢复数据库中已备份的数据。该函数必须要用户登录后才能执行。\n\n**migrate 函数有以下三种用法**：\n\n* migrate(backupDir): 恢复该目录下所有数据库的备份数据。恢复后的数据库名称、表名称与原数据库、原表一致。\n\n* migrate(backupDir, backupDBPath): 恢复该目录下指定数据库的备份数据。恢复后的数据库名称、表名称与原数据库、原表一致。\n\n* migrate(backupDir, backupDBPath, backupTableName, \\[newDBPath], \\[newTableName]): 恢复该目录下指定数据库指定表的备份数据。如果没有指定 *newDBPath* 和 *newTableName*，恢复后的数据库名称、表名称与原数据库、原表一致。如果指定了 *newDBPath* 和 *newTableName*，恢复后的数据库名称为 *newDBPath*，表名为 *newTableName*。\n\n#### 参数\n\n**backupDir** 字符串，表示存放已备份数据的目录。\n\n**backupDBPath** 字符串，表示已备份的数据库的名称。\n\n**backupTableName** 字符串，表示已备份的表的名称。\n\n**newDBPath** 字符串，表示新数据库的名称。如果没有指定，默认值为 *backupDBPath*。 若指定该参数，则需要确保备份数据与 *newDBPath* 的引擎类型（engine）一致，且 partitionScheme（VALUE 除外）也保持一致。 当采用 VALUE 分区时，须保证备份数据中的分区方案是待恢复数据库的分区方案的子集。\n\n**newTableName** 字符串，表示新表的名称。如果没有指定，默认值为 *backupTableName*。\n\n**keyPath** 字符串标量，指定恢复加密表备份的密钥路径。仅 Linux 系统支持该参数。恢复数据使用的密钥必须与备份时指定的密钥版本一致。注意恢复加密表时，备份表与目标表必须指定相同的加密方式（即建表时指定相同的 *encryptMode*参数）。\n\n#### 返回值\n\n返回的结果是一个表，包含了每个表恢复数据的结果。\n\n#### 例子\n\n创建两个示例数据库，并将它们备份到相同的目录中：\n\n```\nbackupDir=\"/home/DolphinDB/backup\"\n\nn = 1000000\nt1 = table(rand(2012.12.01..2012.12.10, n) as date, rand(`AAPL`IBM`GOOG`MSFT, n) as sym, rand(1000.0,n) as price)\nt2 = table(rand(2012.12.01..2012.12.10, n) as date, rand(`AAPL`IBM`GOOG`MSFT, n) as sym, rand(1000,n) as qty)\ndb1 = database(directory=\"dfs://db1\", partitionType=VALUE, partitionScheme=2012.12.01..2012.12.10)\ntrades1 = db1.createPartitionedTable(t1, `trades1, `date).append!(t1)\ntrades2 = db1.createPartitionedTable(t2, `trades2, `date).append!(t2)\n\nn = 1000000\nt1 = table(rand(2012.12.01..2012.12.10, n) as date, rand(`AAPL`IBM`GOOG`MSFT, n) as sym, rand(1000.0,n) as price)\nt2 = table(rand(2012.12.01..2012.12.10, n) as date, rand(`AAPL`IBM`GOOG`MSFT, n) as sym, rand(1000,n) as qty)\ndb1 = database(directory=\"dfs://db2\", partitionType=VALUE, partitionScheme=`AAPL`IBM`GOOG`MSFT)\nquotes1 = db1.createPartitionedTable(t1, `quotes1, `sym).append!(t1)\nquotes2 = db1.createPartitionedTable(t2, `quotes2, `sym).append!(t2)\n\nbackup(backupDir=backupDir, sqlObj=<select * from trades1>, force=true)\nbackup(backupDir=backupDir, sqlObj=<select * from trades2>, force=true)\nbackup(backupDir=backupDir, sqlObj=<select * from quotes1>, force=true)\nbackup(backupDir=backupDir, sqlObj=<select * from quotes2>, force=true)\n```\n\n删除原来的数据库：\n\n```\ndropDatabase(\"dfs://db1\")\ndropDatabase(\"dfs://db2\")\n```\n\n例1. 恢复所有数据库的数据\n\n```\nmigrate(backupDir);\n```\n\n| dbName     | tableName | success | errorMsg |\n| ---------- | --------- | ------- | -------- |\n| dfs\\://db1 | trades1   | 1       |          |\n| dfs\\://db1 | trades2   | 1       |          |\n| dfs\\://db2 | quotes2   | 1       |          |\n| dfs\\://db2 | quotes1   | 1       |          |\n\n例2. 恢复数据库 `dfs://db1`中所有表的数据\n\n```\nmigrate(backupDir=backupDir, backupDBPath=\"dfs://db1\");\n```\n\n| dbName     | tableName | success | errorMsg |\n| ---------- | --------- | ------- | -------- |\n| dfs\\://db1 | trades1   | 1       |          |\n| dfs\\://db1 | trades2   | 1       |          |\n\n例3. 恢复数据库 `dfs://db1` 中表 trades1 的数据\n\n例3.1 不指定新数据库名称和表名称\n\n```\nmigrate(backupDir=backupDir, backupDBPath=\"dfs://db1\", backupTableName=\"trades1\");\n```\n\n| dbName     | tableName | success | errorMsg |\n| ---------- | --------- | ------- | -------- |\n| dfs\\://db1 | trades1   | 1       |          |\n\n例3.2 指定新数据库名称和表名称\n\n```\nmigrate(backupDir=backupDir, backupDBPath=\"dfs://db1\", backupTableName=\"trades1\", newDBPath=\"dfs://db3\", newTableName=\"trades\");\n```\n\n| dbName     | tableName | success | errorMsg |\n| ---------- | --------- | ------- | -------- |\n| dfs\\://db1 | trades1   | 1       |          |\n\n```\nexec count(*) from loadTable(\"dfs://db3\", \"trades\")\n// output\n1000000\n```\n\n相关函数：[backup](https://docs.dolphindb.cn/zh/funcs/b/backup.html), [backupDB](https://docs.dolphindb.cn/zh/funcs/b/backupDB.html), [backupTable](https://docs.dolphindb.cn/zh/funcs/b/backupTable.html), [restore](https://docs.dolphindb.cn/zh/funcs/r/restore.html), [restoreDB](https://docs.dolphindb.cn/zh/funcs/r/restoreDB.html), [restoreTable](https://docs.dolphindb.cn/zh/funcs/r/restoreTable.html)\n"
    },
    "milastNot": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/milastNot.html",
        "signatures": [
            {
                "full": "milastNot(X, window, [minPeriods])",
                "name": "milastNot",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "[minPeriods]",
                        "name": "minPeriods",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [milastNot](https://docs.dolphindb.cn/zh/funcs/m/milastNot.html)\n\n#### 语法\n\nmilastNot(X, window, \\[minPeriods])\n\n窗口计算规则请参考：[mFunctions](https://docs.dolphindb.cn/zh/funcs/themes/mFunctions.html)\n\n#### 详情\n\n在给定长度（以元素个数或时间长度衡量）的滑动窗口内计算 *X* 的最后一个非空元素的下标。\n\n#### 参数\n\n**X** 是一个向量/矩阵/表/元组（元素为标量或等长向量）/字典。\n\n**window** 是大于等于 2 的正整型或 DURATION 标量。表示滑动窗口的长度。\n\n**Note:** 在流计算引擎中调用滑动窗口函数时，window 的上限为 102400。\n\n**minPeriods** 是一个正整数。表示滑动窗口中最少包含的非 NULL 有效观测值数量。\n\n#### 返回值\n\n* 当 *X* 是向量时，返回一个向量。\n\n* 当 *X* 是矩阵时，返回一个矩阵。\n\n* 当 *X* 是表时，对表的每列进行计算，返回相应的结果。\n\n* 当 *X* 是元组时，对元组中的每个向量分别计算，返回相应的结果。\n\n#### 例子\n\n```\nv = NULL NULL 2 3 4 8 NULL 5 -2 3 -1 0 NULL\nmilastNot(v, 3)\n// output: [,,2,2,2,2,1,2,2,2,2,2,1]\n\nm = matrix(1 2 3 NULL, 1 2 NULL 3, 1 3 NULL NULL, 1 2 3 4)\nmilastNot(m, 2)\n```\n\n| #0 | #1 | #2 | #3 |\n| -- | -- | -- | -- |\n|    |    |    |    |\n| 1  | 1  | 1  | 1  |\n| 1  | 0  | 0  | 1  |\n| 0  | 1  | -1 | 1  |\n\n```\nT = [2022.01.01, 2022.01.02, 2022.01.03, 2022.01.06, 2022.01.07]\nX = NULL 2 NULL 4 5\nX1 = indexedSeries(T, X)\nmilastNot(X1, 2, 1)\n```\n\n|            | #0 |\n| ---------- | -- |\n| 2022.01.01 | -1 |\n| 2022.01.02 | 1  |\n| 2022.01.03 | 0  |\n| 2022.01.06 | 0  |\n| 2022.01.07 | 1  |\n\n\n\n**Related information**\n\n[mifirstNot](https://docs.dolphindb.cn/zh/funcs/m/mifirstNot.html)\n\n[mFunctions](https://docs.dolphindb.cn/zh/funcs/themes/mFunctions.html)\n"
    },
    "millisecond": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/millisecond.html",
        "signatures": [
            {
                "full": "millisecond(X)",
                "name": "millisecond",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [millisecond](https://docs.dolphindb.cn/zh/funcs/m/millisecond.html)\n\n\n\n#### 语法\n\nmillisecond(X)\n\n#### 详情\n\n返回 *X* 中的毫秒数。\n\n#### 参数\n\n**X** 可以是 TIME, TIMESTAMP, NANOTIME 或 NANOTIMESTAMP 类型的标量或向量。\n\n#### 返回值\n\n整型标量或向量。\n\n#### 例子\n\n```\nmillisecond(13:30:10.008);\n// output: 8\n\nmillisecond([2012.12.03 01:22:01.456120300, 2012.12.03 01:25:08.000234000]);\n// output: [456,0]\n```\n\n相关函数：[dayOfYear](https://docs.dolphindb.cn/zh/funcs/d/dayOfYear.html), [dayOfMonth](https://docs.dolphindb.cn/zh/funcs/d/dayOfMonth.html), [quarterOfYear](https://docs.dolphindb.cn/zh/funcs/q/quarterOfYear.html), [monthOfYear](https://docs.dolphindb.cn/zh/funcs/m/monthOfYear.html), [weekOfYear](https://docs.dolphindb.cn/zh/funcs/w/weekOfYear.html), [hourOfDay](https://docs.dolphindb.cn/zh/funcs/h/hourOfDay.html), [minuteOfHour](https://docs.dolphindb.cn/zh/funcs/m/minuteOfHour.html), [secondOfMinute](https://docs.dolphindb.cn/zh/funcs/s/secondOfMinute.html), [microsecond](https://docs.dolphindb.cn/zh/funcs/m/microsecond.html), [nanosecond](https://docs.dolphindb.cn/zh/funcs/n/nanosecond.html)\n"
    },
    "mimax": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mimax.html",
        "signatures": [
            {
                "full": "mimax(X, window, [minPeriods])",
                "name": "mimax",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "[minPeriods]",
                        "name": "minPeriods",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [mimax](https://docs.dolphindb.cn/zh/funcs/m/mimax.html)\n\n\n\n#### 语法\n\nmimax(X, window, \\[minPeriods])\n\n窗口计算规则请参考：[mFunctions](https://docs.dolphindb.cn/zh/funcs/themes/mFunctions.html)\n\n#### 详情\n\n在给定长度（以元素个数或时间长度衡量）的滑动窗口内计算 *X* 中最大元素的位置。如果窗口内存在多个相同的最大值，则返回左起第一个最大值的位置。与所有其它聚合函数一致，计算时忽略 NULL 值。\n\n#### 参数\n\n**X** 是一个向量/矩阵/表/元组（元素为标量或等长向量）/字典。\n\n**window** 是大于等于 2 的正整型或 DURATION 标量。表示滑动窗口的长度。\n\n**Note:** 在流计算引擎中调用滑动窗口函数时，window 的上限为 102400。\n\n**minPeriods** 是一个正整数。表示滑动窗口中最少包含的非 NULL 有效观测值数量。\n\n#### 返回值\n\n* 当 *X* 是向量时，返回一个整型向量，长度与输入向量相同。\n\n* 当 *X* 是矩阵时，返回一个整型矩阵，形状与输入矩阵相同。\n\n* 当 *X* 是表时，对表的每列进行计算，返回相应的结果。\n\n* 当 *X* 是元组时，对元组中的每个向量分别计算，返回相应的结果。\n\n#### 例子\n\n```\nx = 1.2 2 NULL 6 -1 6\nmimax(x, 3);\n//output: [,,1,2,1,0]\n\nmimax(x, 3, 1);\n//output: [0,1,1,2,1,0]\n\nm=matrix(1 6 2 9 10 3, 9 10 2 6 6 6);\nm;\n```\n\n返回：\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 9  |\n| 6  | 10 |\n| 2  | 2  |\n| 9  | 6  |\n| 10 | 6  |\n| 3  | 6  |\n\n```\nmimax(m,3);\n```\n\n| #0 | #1 |\n| -- | -- |\n|    |    |\n|    |    |\n| 1  | 1  |\n| 2  | 0  |\n| 2  | 1  |\n| 1  | 0  |\n\n```\nT = [2022.01.01, 2022.01.02, 2022.01.03, 2022.01.06, 2022.01.07, 2022.01.08, 2022.01.10, 2022.01.11]\nX = 1..8\nX1 = indexedSeries(T, X)\nmimax(X1,3)\n```\n\n|            | #0 |\n| ---------- | -- |\n| 2022.01.01 | 0  |\n| 2022.01.02 | 1  |\n| 2022.01.03 | 2  |\n| 2022.01.06 | 0  |\n| 2022.01.07 | 1  |\n| 2022.01.08 | 2  |\n| 2022.01.10 | 1  |\n| 2022.01.11 | 1  |\n\n```\nt= 2021.01.02 2021.01.05  2021.01.06  2021.01.09 2021.01.10 2021.01.12\nm=matrix(5 4 NULL -1 2 4, 3 2 8 1 0 5)\nm1=m.rename!(t, `a`b).setIndexedMatrix!()\nmimax(m1,3)\n```\n\n返回结果：\n\n|            | a | b |\n| ---------- | - | - |\n| 2021.01.02 | 0 | 0 |\n| 2021.01.05 | 0 | 0 |\n| 2021.01.06 | 0 | 1 |\n| 2021.01.09 | 0 | 0 |\n| 2021.01.10 | 1 | 0 |\n| 2021.01.12 | 1 | 1 |\n\n**Related information**\n\n[imax](https://docs.dolphindb.cn/zh/funcs/i/imax.html)\n\n[mimin](https://docs.dolphindb.cn/zh/funcs/m/mimin.html)\n\n[mimaxLast](https://docs.dolphindb.cn/zh/funcs/m/mimaxlast.html)\n"
    },
    "mimaxLast": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mimaxlast.html",
        "signatures": [
            {
                "full": "mimaxLast(X, window, [minPeriods])",
                "name": "mimaxLast",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "[minPeriods]",
                        "name": "minPeriods",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [mimaxLast](https://docs.dolphindb.cn/zh/funcs/m/mimaxlast.html)\n\n\n\n#### 语法\n\nmimaxLast(X, window, \\[minPeriods])\n\n#### 详情\n\n在给定长度（以元素个数或时间长度衡量）的滑动窗口内计算 *X* 中最大元素的位置。如果窗口内存在多个相同的最大值，则返回右起第一个最大值的位置。与所有其它聚合函数一致，计算时忽略 NULL 值。\n\n#### 参数\n\n**X** 是一个向量/矩阵/表/元组（元素为标量或等长向量）/字典。\n\n**window** 是大于等于 2 的正整型或 DURATION 标量。表示滑动窗口的长度。\n\n**Note:** 在流计算引擎中调用滑动窗口函数时，window 的上限为 102400。\n\n**minPeriods** 是一个正整数。表示滑动窗口中最少包含的非 NULL 有效观测值数量。\n\n#### 返回值\n\n* 当 *X* 是向量时，返回一个整型向量，长度与输入向量相同。\n\n* 当 *X* 是矩阵时，返回一个整型矩阵，形状与输入矩阵相同。\n\n* 当 *X* 是表时，对表的每列进行计算，返回相应的结果。\n\n* 当 *X* 是元组时，对元组中的每个向量分别计算，返回相应的结果。\n\n#### 例子\n\n```\nx = 1.2 2 NULL -1 6 -1\nmimaxLast(x,3);\n// output: [,,1,0,2,1]\n\nm=matrix(3 2 4 4 2, 1 4 2 4 3);\nmimaxLast(m,3) \n```\n\n| #0 | #1 |\n| -- | -- |\n|    |    |\n|    |    |\n| 2  | 1  |\n| 2  | 2  |\n| 1  | 1  |\n\n```\nt=table(3 3 2 as c1, 1 4 4 as c2)\nmimaxLast(t,3)\n```\n\n| #0 | #1 |\n| -- | -- |\n|    |    |\n|    |    |\n| 1  | 2  |\n\n```\nx = [NULL, 2, NULL, NULL, 3.2]\ndate = [0, 1, 3,  8, 9] + 2020.01.01\nX = indexedSeries(date, x) \nmimaxLast(X, 3d)\n```\n\n|            | #0 |\n| ---------- | -- |\n| 2020.01.01 | -1 |\n| 2020.01.02 | 1  |\n| 2020.01.04 | 0  |\n| 2020.01.09 | -1 |\n| 2020.01.10 | 1  |\n\n相关函数：[mimax](https://docs.dolphindb.cn/zh/funcs/m/mimax.html)\n"
    },
    "mimin": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mimin.html",
        "signatures": [
            {
                "full": "mimin(X, window, [minPeriods])",
                "name": "mimin",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "[minPeriods]",
                        "name": "minPeriods",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [mimin](https://docs.dolphindb.cn/zh/funcs/m/mimin.html)\n\n\n\n#### 语法\n\nmimin(X, window, \\[minPeriods])\n\n窗口计算规则请参考：[mFunctions](https://docs.dolphindb.cn/zh/funcs/themes/mFunctions.html)\n\n#### 详情\n\n在给定长度（以元素个数或时间长度衡量）的滑动窗口内计算 *X* 中最小元素的位置。如果窗口内存在多个相同的最小值，则返回左起第一个最小值的位置。与所有其它聚合函数一致，计算时忽略 NULL 值。\n\n#### 参数\n\n**X** 是一个向量/矩阵/表/元组（元素为标量或等长向量）/字典。\n\n**window** 是大于等于 2 的正整型或 DURATION 标量。表示滑动窗口的长度。\n\n**Note:** 在流计算引擎中调用滑动窗口函数时，window 的上限为 102400。\n\n**minPeriods** 是一个正整数。表示滑动窗口中最少包含的非 NULL 有效观测值数量。\n\n#### 返回值\n\n* 当 *X* 是向量时，返回一个整型向量，长度与输入向量相同。\n\n* 当 *X* 是矩阵时，返回一个整型矩阵，形状与输入矩阵相同。\n\n* 当 *X* 是表时，对表的每列进行计算，返回相应的结果。\n\n* 当 *X* 是元组时，对元组中的每个向量分别计算，返回相应的结果。\n\n#### 例子\n\n```\nx = 1.2 2 NULL 6 -1 -1\nmimin(x, 3);\n//output: [,,0,0,2,1]\n\nmimin(x, 3, 1);\n//output: [0,0,0,0,2,1]\n\nm=matrix(1 6 2 9 10 3, 9 10 2 6 6 6);\nm;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 9  |\n| 6  | 10 |\n| 2  | 2  |\n| 9  | 6  |\n| 10 | 6  |\n| 3  | 6  |\n\n```\nmimin(m,3);\n```\n\n| #0 | #1 |\n| -- | -- |\n|    |    |\n|    |    |\n| 0  | 2  |\n| 1  | 1  |\n| 0  | 0  |\n| 2  | 0  |\n\n```\nT = [2022.01.01, 2022.01.02, 2022.01.03, 2022.01.06, 2022.01.07, 2022.01.08, 2022.01.10, 2022.01.11]\nX = 1..8\nX1 = indexedSeries(T, X)\nmimin(X1,3)\n```\n\n|            | #0 |\n| ---------- | -- |\n| 2022.01.01 | 0  |\n| 2022.01.02 | 0  |\n| 2022.01.03 | 0  |\n| 2022.01.06 | 0  |\n| 2022.01.07 | 0  |\n| 2022.01.08 | 0  |\n| 2022.01.10 | 0  |\n| 2022.01.11 | 0  |\n\n```\nt= 2021.01.02 2021.01.05  2021.01.06  2021.01.09 2021.01.10 2021.01.12\nm=matrix(5 4 NULL -1 2 4, 3 2 8 1 0 5)\nm1=m.rename!(t, `a`b).setIndexedMatrix!()\nmimin(m1,3)\n```\n\n|            | a | b |\n| ---------- | - | - |\n| 2021.01.02 | 0 | 0 |\n| 2021.01.05 | 0 | 0 |\n| 2021.01.06 | 0 | 0 |\n| 2021.01.09 | 0 | 0 |\n| 2021.01.10 | 0 | 1 |\n| 2021.01.12 | 0 | 0 |\n\n**Related information**\n\n[imin](https://docs.dolphindb.cn/zh/funcs/i/imin.html)\n\n[mimax](https://docs.dolphindb.cn/zh/funcs/m/mimax.html)\n\n[miminLast](https://docs.dolphindb.cn/zh/funcs/m/miminlast.html)\n"
    },
    "miminLast": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/miminlast.html",
        "signatures": [
            {
                "full": "miminLast(X, window, [minPeriods])",
                "name": "miminLast",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "[minPeriods]",
                        "name": "minPeriods",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [miminLast](https://docs.dolphindb.cn/zh/funcs/m/miminlast.html)\n\n\n\n#### 语法\n\nmiminLast(X, window, \\[minPeriods])\n\n窗口计算规则请参考: [滑动窗口系列（m 系列）](https://docs.dolphindb.cn/zh/funcs/themes/mFunctions.html)\n\n#### 详情\n\n在给定长度（以元素个数衡量或时间长度）的滑动窗口内计算 *X* 中最小元素的位置。如果窗口内存在多个相同的最小值，则返回右起第一个最小值的位置。与所有其它聚合函数一致，计算时忽略 NULL 值。\n\n#### 参数\n\n**X** 是一个向量/矩阵/表/元组（元素为标量或等长向量）/字典。\n\n**window** 是大于等于 2 的正整型或 DURATION 标量。表示滑动窗口的长度。\n\n**Note:** 在流计算引擎中调用滑动窗口函数时，window 的上限为 102400。\n\n**minPeriods** 是一个正整数。表示滑动窗口中最少包含的非 NULL 有效观测值数量。\n\n#### 返回值\n\n* 当 *X* 是向量时，返回一个整型向量，长度与输入向量相同。\n\n* 当 *X* 是矩阵时，返回一个整型矩阵，形状与输入矩阵相同。\n\n* 当 *X* 是表时，对表的每列进行计算，返回相应的结果。\n\n* 当 *X* 是元组时，对元组中的每个向量分别计算，返回相应的结果。\n\n#### 例子\n\n```\nx = 1.2 2 NULL -1 6 -1\nmiminLast(x,3)\n// output: [,,0,2,1,2]\n\nm=matrix(3 2 2 4 2, 1 4 2 1 3);\nmiminLast(m,3) \n```\n\n| #0 | #1 |\n| -- | -- |\n|    |    |\n|    |    |\n| 2  | 0  |\n| 1  | 2  |\n| 2  | 1  |\n\n```\nt=table(3 2 2 as c1, 1 1 4 as c2)\nmiminLast(t,3)\n```\n\n| #0 | #1 |\n| -- | -- |\n|    |    |\n|    |    |\n| 2  | 1  |\n\n```\nx = [NULL, 2, NULL, NULL, 3.2]\ndate = [0, 1, 3,  8, 9] + 2020.01.01\nX = indexedSeries(date, x) \nmiminLast(X, 3d)\n```\n\n|            | #0 |\n| ---------- | -- |\n| 2020.01.01 | -1 |\n| 2020.01.02 | 1  |\n| 2020.01.04 | 0  |\n| 2020.01.09 | -1 |\n| 2020.01.10 | 1  |\n\n相关函数：[mimin](https://docs.dolphindb.cn/zh/funcs/m/mimin.html)\n"
    },
    "min": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/min.html",
        "signatures": [
            {
                "full": "min(X, [Y])",
                "name": "min",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[Y]",
                        "name": "Y",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [min](https://docs.dolphindb.cn/zh/funcs/m/min.html)\n\n\n\n#### 语法\n\nmin(X, \\[Y])\n\n#### 详情\n\n返回输入数据中的最小值。\n\n支持以下两种调用方式：\n\n* 仅输入一个参数 *X*，用于计算 *X* 的最小值。比较时忽略 NULL 值。\n\n* 输入两个参数，用于按元素比较两个数据对象，返回较小值。比较时不忽略 NULL 值。\n\n请注意，从 2.00.8 版本开始，min 处理时间类型数据的行为（之前版本统一转换为长整型）修改为：\n\n* 若 *X* 和 *Y* 是时间类型标量，系统会将时间类型统一为两者中较高精度对应的类型，再比较大小。\n\n* 若 *X* 或 *Y* 是向量、矩阵或表，则必须具有相同的时间类型。\n\nDolphinDB `min` 函数和 `numpy.min` 函数的功能一样，区别在于计算方式和空值处理不同：\n\n* DolphinDB 支持双参数，可以逐元素比较；而 Numpy 不支持双参数。\n* 当 DolphinDB `min` 输入单参数时，对于矩阵/表按列计算最小值，按行计算需要使用 `rowMin` 函数；而 Numpy 则可以通过 *axis* 参数控制计算轴。\n* DolphinDB 单参数时忽略 NULL 值，双参数时 NULL 值参与比较；Numpy 默认不忽略 NaN 值。\n\n与 Python TA-Lib 中 `MIN` 的区别：TA-Lib 的 `MIN(close, timeperiod=30)` 是 Math Operator 指标，用于计算指定窗口内的最低值，返回与输入等长的序列。DolphinDB 的 `min(X, [Y])` 不是滚动窗口指标；单参数形式计算输入数据的最小值，双参数形式按元素返回较小值。若需要滚动窗口最小值，可使用 `mmin`。\n\n#### 参数\n\n**X** 可以是标量、向量、矩阵或表。\n\n**Y** 为可选参数，可以是标量或者是和 *X* 长度相同的向量或者矩阵。\n\n#### 返回值\n\n**单参数调用：**\n\n* 若 *X* 是向量，返回一个标量。\n\n* 若 *X* 为矩阵，返回一个向量。\n\n* 若 *X* 为表，返回一个表。\n\n**双参数调用：**\n\n* 若 *Y* 是标量，返回与 *X* 维度相同的对象，每个元素为 `min(X[i], Y)`。\n\n* 若 *Y* 和 *X* 类型和长度一致，返回对应位置较小值组成的对象。\n\n#### 例子\n\n```\nmin(1 2 3);\n// output\n1;\n\nmin(2.0 1.1 0.1 NULL);\n// output\n0.1\n\nm=matrix(1 2 3, 4 5 6);\nm;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 4  |\n| 2  | 5  |\n| 3  | 6  |\n\n```\nmin(m);\n// output\n[1,4]\n```\n\n```\nmin(1 2 3, 2)\n// output\n1 2 2\n\nn = matrix(1 1 1, 5 5 5)\nn;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 5  |\n| 1  | 5  |\n| 1  | 5  |\n\n```\nmin(m, n);\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 4  |\n| 1  | 5  |\n| 1  | 5  |\n\n`min` 可以搭配 select 使用, 返回某列的最小值：\n\n```\nt = table(`abb`aac`aaa as sym, 1.8 2.3 3.7 as price);\nselect min price from t;\n```\n\n| min\\_price |\n| ---------- |\n| 1.8        |\n\n`min` 可以应用于字符串，返回字典序最小的字符串：\n\n```\nselect min sym from t;\n```\n\n| min\\_sym |\n| -------- |\n| aaa      |\n\n相关函数：[mmin](https://docs.dolphindb.cn/zh/funcs/m/mmin.html)\n"
    },
    "minIgnoreNull": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/minignorenull.html",
        "signatures": [
            {
                "full": "minIgnoreNull(X, Y)",
                "name": "minIgnoreNull",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [minIgnoreNull](https://docs.dolphindb.cn/zh/funcs/m/minignorenull.html)\n\n#### 语法\n\nminIgnoreNull(X, Y)\n\n#### 详情\n\n一个二元标量函数，返回两个数（*X* 和 *Y*）中的最小值。\n\n它与 `min` 作为二元标量函数区别在于对空值的处理：\n\n* `min`：当配置项 \\*nullAsMinValueForComparison=\\*true 时，空值被视为最小值进行比较；否则空值不参与比较，结果返回空值。\n\n* `minIgnoreNull`：不受配置项 *nullAsMinValueForComparison* 的影响。返回 *X* 或 *Y* 中的非空值，或者如果两者都非空，返回最小值。\n\n#### 参数\n\n**X** 和 **Y** 是数值型、LITERAL 或 TEMPORAL 型的标量/数据对/向量/矩阵。\n\n#### 返回值\n\n* 输入标量时，返回标量。\n* 输入向量时，返回向量（逐元素比较）。\n* 输入矩阵时，返回矩阵（逐元素比较）。\n* 输入数据对时，返回数据对。\n\n#### 例子\n\n```\nminIgnoreNull(2,matrix(1  NULL -4,-1 -4  0)) \n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | -1 |\n| 2  | -4 |\n| -4 | 0  |\n\n```\nminIgnoreNull(matrix(10 3 NULL, 1 7 4),matrix(1  NULL -4,-1 -4  0))\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | -1 |\n| 3  | -4 |\n| -4 | 0  |\n\n使用 `reduce` 结合 `minIgNoreNull`，计算元组中存储的同形状矩阵每个位置的最小值，忽略空值。\n\n```\nn1 = matrix(1 1 1, 5 5 5)\nn2 = matrix(10 11 12, 0 NULL -5)\nn3 = matrix(-1 1 NULL, -3 0 10)\nreduce(minIgnoreNull, [n1,n2,n3])\n```\n\n相关函数：[min](https://docs.dolphindb.cn/zh/funcs/m/min.html), [maxIgnoreNull](https://docs.dolphindb.cn/zh/funcs/m/maxignorenull.html)\n\n"
    },
    "minkowski": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/minkowski.html",
        "signatures": [
            {
                "full": "minkowski(X, Y, p, [weights])",
                "name": "minkowski",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "p",
                        "name": "p"
                    },
                    {
                        "full": "[weights]",
                        "name": "weights",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [minkowski](https://docs.dolphindb.cn/zh/funcs/m/minkowski.html)\n\n首发版本：3.00.5，3.00.4.3\n\n\n\n#### 语法\n\n```\nminkowski(X, Y, p, [weights])\n```\n\n#### 详情\n\n计算两个数值向量（X 和 Y）之间的闵可夫斯基距离，公式定义如下：\n\n![](https://docs.dolphindb.cn/zh/images/minkowski.png)\n\n#### 参数\n\n**X** 数值向量。\n\n**Y** 数值向量。\n\n**p** 数值标量，取值范围为 (0, +∞)，NULL 代表+∞。 *p* 的特殊取值如下：\n\n* *p*=1 时表示求曼哈顿距离。\n* *p*=2 时表示求欧式距离。\n\n**weights** 可选参数，非负数值向量，用于指定 *X* 和 *Y* 中各元素的权重。其元素的默认值为 1。\n\n**Note:** *X*、*Y*、*weights* 三者的长度必须相等。\n\n#### 返回值\n\nDOUBLE 类型标量。\n\n#### 例子\n\n假设有两个向量：\n\n```\nX=[1,2]\nY=[4,6]\n```\n\n* p=1，计算曼哈顿距离：\n\n  ```\n  minkowski(X,Y,p)\n  // 输出：7\n  ```\n\n* p=2，计算欧式距离：\n\n  ```\n  minkowski(X,Y,p)\n  // 输出：5\n  ```\n\n**相关函数**\n\n[seuclidean](https://docs.dolphindb.cn/zh/funcs/s/seuclidean.html)、[mahalanobis](https://docs.dolphindb.cn/zh/funcs/m/mahalanobis.html)\n"
    },
    "minute": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/minute.html",
        "signatures": [
            {
                "full": "minute(X)",
                "name": "minute",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [minute](https://docs.dolphindb.cn/zh/funcs/m/minute.html)\n\n\n\n#### 语法\n\nminute(X)\n\n#### 详情\n\n返回对应的分钟数。\n\n#### 参数\n\n**X** 可以是整数标量或向量、时间标量或向量。\n\n#### 返回值\n\nMINUTE 类型标量或向量。\n\n#### 例子\n\n```\nminute();\n```\n\n返回：null\n\n```\nminute(1)\n```\n\n返回：00:01m\n\n```\nminute(now());\n```\n\n返回：16:02m\n\n**Related information**\n\n[second](https://docs.dolphindb.cn/zh/funcs/s/second.html)\n\n[month](https://docs.dolphindb.cn/zh/funcs/m/month.html)\n\n[date](https://docs.dolphindb.cn/zh/funcs/d/date.html)\n\n[year](https://docs.dolphindb.cn/zh/funcs/y/year.html)\n"
    },
    "minuteOfHour": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/minuteOfHour.html",
        "signatures": [
            {
                "full": "minuteOfHour(X)",
                "name": "minuteOfHour",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [minuteOfHour](https://docs.dolphindb.cn/zh/funcs/m/minuteOfHour.html)\n\n\n\n#### 语法\n\nminuteOfHour(X)\n\n#### 详情\n\n返回 *X* 中的分钟数。\n\n#### 参数\n\n**X** 可以是 TIME, MINUTE, SECOND, DATETIME, TIMESTAMP, NANOTIME 或 NANOTIMESTAMP 类型的标量或向量。\n\n#### 返回值\n\n整型标量或向量。\n\n#### 例子\n\n```\nminuteOfHour(12:32:00);\n// output: 32\n\nminuteOfHour([2012.06.12T12:30:00,2012.10.28T12:35:00,2013.01.06T12:36:47,2013.04.06T08:02:14]);\n// output: [30,35,36,2]\n```\n\n相关函数：[dayOfYear](https://docs.dolphindb.cn/zh/funcs/d/dayOfYear.html), [dayOfMonth](https://docs.dolphindb.cn/zh/funcs/d/dayOfMonth.html), [quarterOfYear](https://docs.dolphindb.cn/zh/funcs/q/quarterOfYear.html), [monthOfYear](https://docs.dolphindb.cn/zh/funcs/m/monthOfYear.html), [weekOfYear](https://docs.dolphindb.cn/zh/funcs/w/weekOfYear.html), [hourOfDay](https://docs.dolphindb.cn/zh/funcs/h/hourOfDay.html), [secondOfMinute](https://docs.dolphindb.cn/zh/funcs/s/secondOfMinute.html), [millisecond](https://docs.dolphindb.cn/zh/funcs/m/millisecond.html), [microsecond](https://docs.dolphindb.cn/zh/funcs/m/microsecond.html), [nanosecond](https://docs.dolphindb.cn/zh/funcs/n/nanosecond.html)\n"
    },
    "mkdir": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mkdir.html",
        "signatures": [
            {
                "full": "mkdir(directory)",
                "name": "mkdir",
                "parameters": [
                    {
                        "full": "directory",
                        "name": "directory"
                    }
                ]
            }
        ],
        "markdown": "### [mkdir](https://docs.dolphindb.cn/zh/funcs/m/mkdir.html)\n\n\n\n#### 语法\n\nmkdir(directory)\n\n#### 详情\n\n创建一个目录。该函数必须要用户登录后才能执行。\n\n#### 参数\n\n**directory** 为要创建的目录的名字。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\nfiles(\"/home/test\");\n```\n\n| filename | isDir | fileSize | lastAccessed            | lastModified            |\n| -------- | ----- | -------- | ----------------------- | ----------------------- |\n| dir3     | 1     | 0        | 2017.06.05 08:06:39.597 | 2017.06.05 08:06:39.597 |\n\n```\nmkdir(\"/home/test/dir1\");\nmkdir(\"/home/test/dir2\");\nmkdir(\"/home/test/dir3\");\n// output\nThe directory [/home/test/dir3] already exists.\n```\n\n```\nfiles(\"/home/test\");\n```\n\n| filename | isDir | fileSize | lastAccessed            | lastModified            |\n| -------- | ----- | -------- | ----------------------- | ----------------------- |\n| dir1     | 1     | 0        | 2017.06.05 08:33:48.372 | 2017.06.05 08:33:48.372 |\n| dir2     | 1     | 0        | 2017.06.05 08:34:05.598 | 2017.06.05 08:34:05.598 |\n| dir3     | 1     | 0        | 2017.06.05 08:06:39.597 | 2017.06.05 08:06:39.597 |\n"
    },
    "mkurtosis": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mkurtosis.html",
        "signatures": [
            {
                "full": "mkurtosis(X, window, [biased=true], [minPeriods])",
                "name": "mkurtosis",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "[biased=true]",
                        "name": "biased",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[minPeriods]",
                        "name": "minPeriods",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [mkurtosis](https://docs.dolphindb.cn/zh/funcs/m/mkurtosis.html)\n\n\n\n#### 语法\n\nmkurtosis(X, window, \\[biased=true], \\[minPeriods])\n\n窗口计算规则请参考：[mFunctions](https://docs.dolphindb.cn/zh/funcs/themes/mFunctions.html)\n\n#### 详情\n\n在给定长度（以元素个数或时间长度衡量）的滑动窗口内计算 *X* 的峰度。\n\n#### 参数\n\n**X** 是一个向量/矩阵/表/元组（元素为标量或等长向量）/字典。\n\n**window** 是大于等于 2 的正整型或 DURATION 标量。表示滑动窗口的长度。\n\n**Note:** 在流计算引擎中调用滑动窗口函数时，window 的上限为 102400。\n\n**biased** 是一个布尔值，表示是否是有偏估计。默认值为 true，表示有偏估计。\n\n**minPeriods** 是一个正整数。表示滑动窗口中最少包含的非 NULL 有效观测值数量。\n\n#### 返回值\n\n* 输入为向量时，返回一个与输入等长的 DOUBLE 类型向量。\n* 输入为矩阵时，返回一个与输入矩阵同维度的矩阵。\n* 输入为表时，返回一个与输入表结构相同的表。\n* 输入为元组时，返回对应的元组结构。\n\n#### 例子\n\n```\nm=matrix(1 9 3 100 3 2 1 -100 9 10000, 1 2 3 4 5 6 7 8 9 100);\nm.mkurtosis(8);\n```\n\n| #0                | #1                |\n| ----------------- | ----------------- |\n|                   |                   |\n|                   |                   |\n|                   |                   |\n|                   |                   |\n|                   |                   |\n|                   |                   |\n|                   |                   |\n| 3.989653641279048 | 1.761904761904762 |\n| 3.989840910744778 | 1.761904761904762 |\n| 6.140237905908072 | 6.101712240467206 |\n\n```\nm.rename!(date(2020.04.06)+1..10, `col1`col2)\nm.setIndexedMatrix!()\nmkurtosis(m, 8d)\n```\n\n| label      | col1   | col2   |\n| ---------- | ------ | ------ |\n| 2020.04.07 |        |        |\n| 2020.04.08 |        |        |\n| 2020.04.09 | 1.5    | 1.5    |\n| 2020.04.10 | 2.3195 | 1.64   |\n| 2020.04.11 | 3.2251 | 1.7    |\n| 2020.04.12 | 4.163  | 1.7314 |\n| 2020.04.13 | 5.1141 | 1.75   |\n| 2020.04.14 | 3.9897 | 1.7619 |\n| 2020.04.15 | 3.9898 | 1.7619 |\n| 2020.04.16 | 6.1402 | 6.1017 |\n\n```\nmkurtosis(m, 1w)\n```\n\n| label      | col1   | col2   |\n| ---------- | ------ | ------ |\n| 2020.04.07 |        |        |\n| 2020.04.08 |        |        |\n| 2020.04.09 | 1.5    | 1.5    |\n| 2020.04.10 | 2.3195 | 1.64   |\n| 2020.04.11 | 3.2251 | 1.7    |\n| 2020.04.12 | 4.163  | 1.7314 |\n| 2020.04.13 | 5.1141 | 1.75   |\n| 2020.04.14 | 3.4937 | 1.75   |\n| 2020.04.15 | 3.4937 | 1.75   |\n| 2020.04.16 | 5.1645 | 5.145  |\n\nDolphinDB 的 `kurtosis` 默认情况（当 *biased*=true 时）存在偏差，而 pandas 的 kurt 默认为无偏估计，且减去正态分布的峰值3。下面例子示意了使用滑动窗口时，两者的等价转换关系：\n\n```\npython\nm = [[1111,2], [323,9], [43,12], [51,32], [6,400]]\ndf = pandas.DataFrame(m)\ny = df.rolling(4).kurt()\n\ndolphindb\nm=matrix(1111 323 43 51 6, 2 9 12 32 400)\nm.mkurtosis(4, false)-3\n```\n\n| #0       | #1       |\n| -------- | -------- |\n|          |          |\n|          |          |\n|          |          |\n| 2.504252 | 2.366838 |\n| 3.675552 | 3.941262 |\n\n相关函数：[kurtosis](https://docs.dolphindb.cn/zh/funcs/k/kurtosis.html)\n"
    },
    "mkurtosisTopN": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mkurtosisTopN.html",
        "signatures": [
            {
                "full": "mkurtosisTopN(X, S, window, top, [biased=true], [ascending=true], [tiesMethod='latest'])",
                "name": "mkurtosisTopN",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "S",
                        "name": "S"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "top",
                        "name": "top"
                    },
                    {
                        "full": "[biased=true]",
                        "name": "biased",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[tiesMethod='latest']",
                        "name": "tiesMethod",
                        "optional": true,
                        "default": "'latest'"
                    }
                ]
            }
        ],
        "markdown": "### [mkurtosisTopN](https://docs.dolphindb.cn/zh/funcs/m/mkurtosisTopN.html)\n\n\n\n#### 语法\n\nmkurtosisTopN(X, S, window, top, \\[biased=true], \\[ascending=true], \\[tiesMethod='latest'])\n\n参数说明和窗口计算规则请参考：[mTopN](https://docs.dolphindb.cn/zh/funcs/themes/TopN.html)\n\n#### 详情\n\n在给定长度（以元素个数衡量）的滑动窗口内，根据 *ascending* 指定的排序方式将 *X* 按照 *S* 进行稳定排序后，取前 *top* 个元素计算峰度。\n\n返回值：DOUBLE 类型。\n\n#### 参数\n\n**biased** 是一个布尔值，表示是否是有偏估计。默认值为 true，表示有偏估计。\n\n#### 返回值\n\n* 输入为向量时，返回一个与输入等长的 DOUBLE 类型向量。\n* 输入为矩阵时，返回一个与输入矩阵同维度的矩阵。\n* 输入为表时，返回一个与输入表结构相同的表。\n* 输入为元组时，返回对应的元组结构。\n\n#### 例子\n\n```\nX=1 2 3 10 100 4 3\nS = 0.3 0.5 0.1 0.1 0.5 0.2 0.4\nmkurtosisTopN(X, S, 6, 4)\n// output\n[,,1.49,2.23,2.31,2.11,2.27]\n\nX = matrix(1..10, 11..20)\nS = matrix(2022.01.01 2022.02.03 2022.01.23 NULL 2021.12.29 2022.01.20 2022.01.23 2022.01.22 2022.01.24 2022.01.24, NULL 2022.02.03 2022.01.23 2022.04.06 NULL 2022.02.03 2022.02.03 2022.02.05 2022.02.08 2022.02.03)\nmkurtosisTopN(X, S, 6, 4)\n```\n\n| col1   | col2   |\n| :----- | :----- |\n|        |        |\n|        |        |\n| 1.5    |        |\n| 1.5    | 1.5    |\n| 1.8457 | 1.5    |\n| 1.5734 | 1.8457 |\n| 1.8457 | 1.2215 |\n| 1.64   | 2      |\n| 1.64   | 1.64   |\n| 1.64   | 1.8457 |\n\n```\nsymbol = [\"A\",\"A\",\"A\",\"B\",\"A\",\"A\",\"B\",\"A\",\"A\",\"B\",\"B\",\"B\",\"A\",\"B\",\"A\",\"B\",\"B\",\"A\",\"B\",\"A\"]\ntime = temporalAdd(2023.07.05T09:30:00.000,[10,20,40,60,70,80,90,140,160,170,180,190,200,210,220,230,250,360,390,400],\"ms\")\nprice = [28.11,28.25,28.44,52.31,28.98,28.89,52.22,28.16,28.52,52.62,52.56,52.2,28.01,52.43,28.57,52.42,52.19,28.16,52.84,28.18]\nqty = [5000,400,3100,100,2400,3700,700,3700,4600,4700,3100,3300,3900,3500,3000,3000,4000,4700,2000,4400]\nBSFlag = [1,0,0,0,1,1,0,1,0,0,0,1,0,0,1,1,1,0,1,0]\nt = table(time, symbol, price, qty, BSFlag)\nselect time,symbol,mkurtosisTopN(price, qty, 8, 5) as mskewTop5price from t context by symbol\n```\n\n| time                    | symbol | mskewTop5price |\n| ----------------------- | ------ | -------------- |\n| 2023.07.05T09:30:00.010 | A      |                |\n| 2023.07.05T09:30:00.020 | A      |                |\n| 2023.07.05T09:30:00.040 | A      | 1.5            |\n| 2023.07.05T09:30:00.070 | A      | 2.0147         |\n| 2023.07.05T09:30:00.080 | A      | 1.3355         |\n| 2023.07.05T09:30:00.140 | A      | 1.2976         |\n| 2023.07.05T09:30:00.160 | A      | 1.2976         |\n| 2023.07.05T09:30:00.200 | A      | 1.2976         |\n| 2023.07.05T09:30:00.220 | A      | 2.2021         |\n| 2023.07.05T09:30:00.360 | A      | 1.656          |\n| 2023.07.05T09:30:00.400 | A      | 1.351          |\n| 2023.07.05T09:30:00.060 | B      |                |\n| 2023.07.05T09:30:00.090 | B      |                |\n| 2023.07.05T09:30:00.170 | B      | 1.5            |\n| 2023.07.05T09:30:00.180 | B      | 1.1993         |\n| 2023.07.05T09:30:00.190 | B      | 1.289          |\n| 2023.07.05T09:30:00.210 | B      | 1.7383         |\n| 2023.07.05T09:30:00.230 | B      | 1.8183         |\n| 2023.07.05T09:30:00.250 | B      | 1.8183         |\n| 2023.07.05T09:30:00.390 | B      | 1.923          |\n\n相关函数：[mkurtosis](https://docs.dolphindb.cn/zh/funcs/m/mkurtosis.html)\n"
    },
    "mlast": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mlast.html",
        "signatures": [
            {
                "full": "mlast(X, window, [minPeriods])",
                "name": "mlast",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "[minPeriods]",
                        "name": "minPeriods",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [mlast](https://docs.dolphindb.cn/zh/funcs/m/mlast.html)\n\n\n\n#### 语法\n\nmlast(X, window, \\[minPeriods])\n\n窗口计算规则请参考：[mFunctions](https://docs.dolphindb.cn/zh/funcs/themes/mFunctions.html)\n\n#### 详情\n\n在给定长度（以元素个数或时间长度衡量）的滑动窗口内计算 *X* 的最后一个元素。\n\n#### 参数\n\n**X** 是一个向量/矩阵/表/元组（元素为标量或等长向量）/字典。\n\n**window** 是大于等于 2 的正整型或 DURATION 标量。表示滑动窗口的长度。\n\n**Note:** 在流计算引擎中调用滑动窗口函数时，window 的上限为 102400。\n\n**minPeriods** 是一个正整数。表示滑动窗口中最少包含的非 NULL 有效观测值数量。\n\n#### 返回值\n\n* 输入为向量时，返回一个与输入等长的向量。\n* 输入为矩阵时，返回一个与输入矩阵同维度的矩阵。\n* 输入为表时，返回一个与输入表结构相同的表。\n* 输入为元组时，返回对应的元组结构。\n\n#### 例子\n\n```\nindex = second(08:20:00)+1..7\nx = 2 1 3 NULL 6 5 4\nx = index.indexedSeries(x)\nmlast(x,3s)\n```\n\n| label    | col1 |\n| -------- | ---- |\n| 08:20:01 | 2    |\n| 08:20:02 | 1    |\n| 08:20:03 | 3    |\n| 08:20:04 |      |\n| 08:20:05 | 6    |\n| 08:20:06 | 5    |\n| 08:20:07 | 4    |\n\n```\nm = matrix(1 5 9 0 2, 9 10 2 NULL 2)\nm.rename!((date(2020.09.08)+1..3) join 2020.09.16 join 2020.09.26, `A`B)\nm.setIndexedMatrix!()\nmlast(m, 3d)\n```\n\n| label      | A | B  |\n| ---------- | - | -- |\n| 2020.09.09 | 1 | 9  |\n| 2020.09.10 | 5 | 10 |\n| 2020.09.11 | 9 | 2  |\n| 2020.09.16 | 0 |    |\n| 2020.09.26 | 2 | 2  |\n\n```\nmlast(m, 1w)\n```\n\n| label      | A | B  |\n| ---------- | - | -- |\n| 2020.09.09 | 1 | 9  |\n| 2020.09.10 | 5 | 10 |\n| 2020.09.11 | 9 | 2  |\n| 2020.09.16 | 0 |    |\n| 2020.09.26 | 2 | 2  |\n\n相关函数：[last](https://docs.dolphindb.cn/zh/funcs/l/last.html), [first](https://docs.dolphindb.cn/zh/funcs/f/first.html)\n"
    },
    "mlastNot": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mlastnot.html",
        "signatures": [
            {
                "full": "mlastNot(X, window, [k=NULL], [minPeriods=1])",
                "name": "mlastNot",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "[k=NULL]",
                        "name": "k",
                        "optional": true,
                        "default": "NULL"
                    },
                    {
                        "full": "[minPeriods=1]",
                        "name": "minPeriods",
                        "optional": true,
                        "default": "1"
                    }
                ]
            }
        ],
        "markdown": "### [mlastNot](https://docs.dolphindb.cn/zh/funcs/m/mlastnot.html)\n\n\n\n#### 语法\n\nmlastNot(X, window, \\[k=NULL], \\[minPeriods=1])\n\n窗口计算规则请参考：[mFunctions](https://docs.dolphindb.cn/zh/funcs/themes/mFunctions.html)\n\n#### 详情\n\n若 *X* 是向量：\n\n* 如果没有指定 *k*，计算给定长度（以元素个数或时间长度衡量）的滑动窗口内 *X* 中最后一个不为 NULL 的元素。\n\n* 如果指定 *k*，计算给定长度（以元素个数或时间长度衡量）的滑动窗口内 *X* 中最后一个不为 *k* 或 NULL 的元素。\n\n若 *X* 是矩阵或表，则在每列内进行上述计算。\n\n#### 参数\n\n**X** 是一个向量/矩阵/表/元组（元素为标量或等长向量）/字典。\n\n**window** 是大于等于 2 的正整型或 DURATION 标量。表示滑动窗口的长度。\n\n**Note:** 在流计算引擎中调用滑动窗口函数时，window 的上限为 102400。\n\n**k** 可选参数，是一个数值或字符串类型的标量，表示用于匹配的数据。\n\n**minPeriods** 是一个正整数。表示滑动窗口中最少包含的非 NULL 有效观测值数量。\n\n#### 返回值\n\n* 当 *X* 是向量时，返回一个向量。\n\n* 当 *X* 是矩阵时，返回一个矩阵。\n\n* 当 *X* 是表时，对表的每列进行计算，返回相应的结果。\n\n* 当 *X* 是元组时，对元组中的每个向量分别计算，返回相应的结果。\n\n#### 例子\n\n例 1\n\n```\nmlastNot(NULL 2 NULL 4 5, 2)\n// output: [,2,2,4,5]\n```\n\n例 2\n\n```\nmlastNot(X=matrix(1..5,2..6,3..7), window=2, k=4, minPeriods=2)\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n|    |    |    |\n| 2  | 3  | 3  |\n| 3  | 3  | 5  |\n| 3  | 5  | 6  |\n| 5  | 6  | 7  |\n\n例 3\n\n```\nx=table([\"s1\", \"s2\", \"\", \"s4\", \"s5\"] as col1, [\"s1\", \"\", \"s3\", \"\", \"s5\"] as col2)\nmlastNot(X=x, window=2)\n```\n\n| #0 | #1 |\n| -- | -- |\n|    |    |\n| s2 | s1 |\n| s2 | s3 |\n| s4 | s3 |\n| s5 | s5 |\n\n例 4\n\n```\nT = [2022.01.01, 2022.01.02, 2022.01.03, 2022.01.06, 2022.01.07, 2022.01.08, 2022.01.10, 2022.01.11]\nX = 1..8\nX1 = indexedSeries(T, X)\nmlastNot(X=X1, window=3, k=1, minPeriods=1)\n```\n\n|            | #0 |\n| ---------- | -- |\n| 2022.01.01 |    |\n| 2022.01.02 | 2  |\n| 2022.01.03 | 3  |\n| 2022.01.06 | 4  |\n| 2022.01.07 | 5  |\n| 2022.01.08 | 6  |\n| 2022.01.10 | 7  |\n| 2022.01.11 | 8  |\n\n**Related information**\n\n[mfirstNot](https://docs.dolphindb.cn/zh/funcs/m/mfirstnot.html)\n"
    },
    "mLowRange": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mlowrange.html",
        "signatures": [
            {
                "full": "mLowRange(X, window, [minPeriods])",
                "name": "mLowRange",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "[minPeriods]",
                        "name": "minPeriods",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [mLowRange](https://docs.dolphindb.cn/zh/funcs/m/mlowrange.html)\n\n#### 语法\n\nmLowRange(X, window, \\[minPeriods])\n\n窗口计算规则请参考：[mFunctions](https://docs.dolphindb.cn/zh/funcs/themes/mFunctions.html)\n\n#### 详情\n\n在给定长度（以元素个数或时间长度衡量）的滑动窗口内，统计每个元素 Xi 左侧相邻且连续大于它的元素个数。NULL 被视为最小值。\n\n若 *X* 是矩阵，在每列内进行上述计算。\n\n#### 参数\n\n**X** 是一个向量/矩阵/表/元组（元素为标量或等长向量）/字典。\n\n**window** 是大于等于 2 的正整型或 DURATION 标量。表示滑动窗口的长度。\n\n**Note:** 在流计算引擎中调用滑动窗口函数时，window 的上限为 102400。\n\n**minPeriods** 是一个正整数。表示滑动窗口中最少包含的非 NULL 有效观测值数量。\n\n#### 返回值\n\n* 输入为向量时，返回一个与输入等长的 INT 类型向量。\n* 输入为矩阵时，返回一个与输入矩阵同维度的矩阵。\n* 输入为表时，返回一个与输入表结构相同的表。\n* 输入为元组时，返回对应的元组结构。\n\n#### 例子\n\n```\nx = [NULL, 3.1, NULL, 3.0, 2.9, 2.8, 3.1, NULL, 3.2]\nmLowRange(x, window=3) \n// output: [,,1,0,1,2,0,2,0]\n\nmLowRange(x, window=3, minPeriods=1) \n// output: [,0,1,0,1,2,0,2,0]\n\nmLowRange(x, window=3, minPeriods=2) \n// output: [,,,0,1,2,0,2,0]\n\ndate = [0, 1, 2, 3, 7, 8, 9, 10, 11] + 2020.01.01\nX = indexedSeries(date, x)\nmLowRange(X, 3d)\n```\n\n|            | #0 |\n| ---------- | -- |\n| 2020.01.01 |    |\n| 2020.01.02 | 0  |\n| 2020.01.03 | 1  |\n| 2020.01.04 | 0  |\n| 2020.01.08 | 0  |\n| 2020.01.09 | 1  |\n| 2020.01.10 | 0  |\n| 2020.01.11 | 2  |\n| 2020.01.12 | 0  |\n\n```\nm = matrix(1 2 3 NULL, 1 2 NULL 3, 1 3 NULL NULL, 1 2 3 4)\nmLowRange(m, 2)\n```\n\n| #0 | #1 | #2 | #3 |\n| -- | -- | -- | -- |\n|    |    |    |    |\n| 0  | 0  | 0  | 0  |\n| 0  | 1  | 1  | 0  |\n| 1  | 0  |    | 0  |\n\n"
    },
    "mmad": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mmad.html",
        "signatures": [
            {
                "full": "mmad(X, window, [useMedian=false], [minPeriods])",
                "name": "mmad",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "[useMedian=false]",
                        "name": "useMedian",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[minPeriods]",
                        "name": "minPeriods",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [mmad](https://docs.dolphindb.cn/zh/funcs/m/mmad.html)\n\n\n\n#### 语法\n\nmmad(X, window, \\[useMedian=false], \\[minPeriods])\n\n窗口计算规则请参考：[mFunctions](https://docs.dolphindb.cn/zh/funcs/themes/mFunctions.html)\n\n#### 详情\n\n在给定长度（以元素个数衡量）的滑动窗口内，计算 *X* 的平均绝对离差或绝对中位差。\n\n#### 参数\n\n**X** 是一个向量/矩阵/表/元组（元素为标量或等长向量）/字典。\n\n**window** 是大于等于 2 的正整型或 DURATION 标量。表示滑动窗口的长度。\n\n**Note:** 在流计算引擎中调用滑动窗口函数时，window 的上限为 102400。\n\n**useMedian** 是一个布尔值，默认值是 false，表示计算平均绝对离差（mean absolute deviation）。若为 true 则计算绝对中位差（median absolute deviation）。\n\n* 平均绝对离差：mean(abs(X - mean(X)))\n\n* 绝对中位差：med(abs(X - med(X)))\n\n**minPeriods** 是一个正整数。表示滑动窗口中最少包含的非 NULL 有效观测值数量。\n\n#### 返回值\n\n* 输入为向量时，返回一个与输入等长的 DOUBLE 类型向量。\n* 输入为矩阵时，返回一个与输入矩阵同维度的矩阵。\n* 输入为表时，返回一个与输入表结构相同的表。\n* 输入为元组时，返回对应的元组结构。\n\n#### 例子\n\n```\nx = 7 4 6 0 -5 32;\nmmad(x, window=3);\n// output: [,,1.111111111111111,2.222222222222222,3.777777777777777,15.333333333333333]\n\nmmad(x, window=3, useMedian=true)\n// output: [,,1,2,5,5]\n\ny = NULL NULL 2 5 1 7 -3 0\nmmad(y, window=3, minPeriods=2);\n// output: [,,,1.5,1.555555555555555,2.222222222222222,3.555555555555556,3.777777777777778]\n```\n\n```\nm=matrix(85 90 95, 185 190 195);\nm;\n```\n\n| #0 | #1  |\n| -- | --- |\n| 85 | 185 |\n| 90 | 190 |\n| 95 | 195 |\n\n```\nmmad(x, 2)\n```\n\n| #0  | #1  |\n| --- | --- |\n|     |     |\n| 2.5 | 2.5 |\n| 2.5 | 2.5 |\n\n相关函数： [mad](https://docs.dolphindb.cn/zh/funcs/m/mad.html)\n"
    },
    "mmax": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mmax.html",
        "signatures": [
            {
                "full": "mmax(X, window, [minPeriods])",
                "name": "mmax",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "[minPeriods]",
                        "name": "minPeriods",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [mmax](https://docs.dolphindb.cn/zh/funcs/m/mmax.html)\n\n\n\n#### 语法\n\nmmax(X, window, \\[minPeriods])\n\n窗口计算规则请参考：[mFunctions](https://docs.dolphindb.cn/zh/funcs/themes/mFunctions.html)\n\n#### 详情\n\n在给定长度（以元素个数或时间长度衡量）的滑动窗口内计算 *X* 元素的最大值。\n\n#### 参数\n\n**X** 是一个向量/矩阵/表/元组（元素为标量或等长向量）/字典。\n\n**window** 是大于等于 2 的正整型或 DURATION 标量。表示滑动窗口的长度。\n\n**Note:** 在流计算引擎中调用滑动窗口函数时，window 的上限为 102400。\n\n**minPeriods** 是一个正整数。表示滑动窗口中最少包含的非 NULL 有效观测值数量。\n\n#### 返回值\n\n* 输入为向量时，返回一个与输入等长的向量。\n* 输入为矩阵时，返回一个与输入矩阵同维度的矩阵，每列分别计算。\n* 输入为表时，返回一个与输入表结构相同的表。\n* 输入为元组时，返回对应的元组结构。\n\n#### 例子\n\n```\nX = 2 1 3 7 6 5 4\nY = 2 1 3 NULL 6 5 4\n\nmmax(X, 3);\n// output\n[,,3,7,7,7,6]\n\nmmax(Y, 3);\n// output\n[,,3,3,6,6,6]\n\nmmax(Y, 3, minPeriods=1);\n// output\n[2,2,3,3,6,6,6]\n```\n\n```\nm = matrix(1 5 9 0 2, 9 10 2 NULL 2)\nm.rename!(date(2020.09.08)+1..5, `A`B)\nm.setIndexedMatrix!()\nm.mmax(3d)\n```\n\n| label      | col1 | col2 |\n| ---------- | ---- | ---- |\n| 2020.09.09 | 1    | 9    |\n| 2020.09.10 | 5    | 10   |\n| 2020.09.11 | 9    | 10   |\n| 2020.09.12 | 9    | 10   |\n| 2020.09.13 | 9    | 2    |\n\n```\nm.mmax(1w)\n```\n\n| label      | col1 | col2 |\n| ---------- | ---- | ---- |\n| 2020.09.09 | 1    | 9    |\n| 2020.09.10 | 5    | 10   |\n| 2020.09.11 | 9    | 10   |\n| 2020.09.12 | 9    | 10   |\n| 2020.09.13 | 9    | 10   |\n\n相关函数：[max](https://docs.dolphindb.cn/zh/funcs/m/max.html)\n"
    },
    "mmaxPositiveStreak": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mmaxPositiveStreak.html",
        "signatures": [
            {
                "full": "mmaxPositiveStreak(X, window)",
                "name": "mmaxPositiveStreak",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    }
                ]
            }
        ],
        "markdown": "### [mmaxPositiveStreak](https://docs.dolphindb.cn/zh/funcs/m/mmaxPositiveStreak.html)\n\n\n\n#### 语法\n\nmmaxPositiveStreak(X, window)\n\n窗口计算规则请参考：[mFunctions](https://docs.dolphindb.cn/zh/funcs/themes/mFunctions.html)\n\n#### 详情\n\n在给定长度（以元素个数衡量）的滑动窗口内统计 *X* 中连续正数之和的最大值。\n\n#### 参数\n\n**X** 是一个向量/矩阵/表/元组（元素为标量或等长向量）/字典。\n\n**window** 是大于等于 2 的正整型或 DURATION 标量。表示滑动窗口的长度。\n\n**Note:** 在流计算引擎中调用滑动窗口函数时，window 的上限为 102400。\n\n#### 返回值\n\n返回值类型与形式与 *X* 相同。\n\n#### 例子\n\n```\nx = 1 -1 1 -2 10 3 3 9 0 6 5\nw = 5\nmmaxPositiveStreak(x, w)\n// output: [,,,,10,13,16,25,25,15,12]\n\nx = 5 NULL 3 2 1 5 10 9 NULL 9 10 -1 NULL\nw = 5\nmmaxPositiveStreak(x, w)\n// output: [,,,,6,11,21,27,25,24,19,19,19]\n\n// 搭配 signum 函数用于统计向量中出现的连续正数的最大个数\nmmaxPositiveStreak(signum(x), w)\n// output: [,,,,3,4,5,5,4,3,2,2,2]\n```\n"
    },
    "mmed": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mmed.html",
        "signatures": [
            {
                "full": "mmed(X, window, [minPeriods])",
                "name": "mmed",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "[minPeriods]",
                        "name": "minPeriods",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [mmed](https://docs.dolphindb.cn/zh/funcs/m/mmed.html)\n\n\n\n#### 语法\n\nmmed(X, window, \\[minPeriods])\n\n窗口计算规则请参考：[mFunctions](https://docs.dolphindb.cn/zh/funcs/themes/mFunctions.html)\n\n#### 详情\n\n在给定长度（以元素个数或时间长度衡量）的滑动窗口内计算 *X* 元素的中位数。\n\n#### 参数\n\n**X** 是一个向量/矩阵/表/元组（元素为标量或等长向量）/字典。\n\n**window** 是大于等于 2 的正整型或 DURATION 标量。表示滑动窗口的长度。\n\n**Note:** 在流计算引擎中调用滑动窗口函数时，window 的上限为 102400。\n\n**minPeriods** 是一个正整数。表示滑动窗口中最少包含的非 NULL 有效观测值数量。\n\n#### 返回值\n\nDOUBLE 类型，数据形式与 *X* 相同。\n\n#### 例子\n\n```\nX = 2 1 3 7 6 5 4\nY = 2 1 3 NULL 6 5 4\n\nmmed(X, 3);\n// output\n[,,2,3,6,6,5]\n\nmmed(Y, 3);\n// output\n[,,2,2,4.5,5.5,5]\n\nmmed(Y, 3, minPeriods=1);\n// output\n[2,1.5,2,2,4.5,5.5,5]\n```\n\n```\nm = matrix(1 5 9 0 2, 9 10 2 NULL 2)\nm.rename!(date(2020.09.08)+1..5, `A`B)\nm.setIndexedMatrix!()\nm.mmed(3d)\n```\n\n| label      | col1 | col2 |\n| ---------- | ---- | ---- |\n| 2020.09.09 | 1    | 9    |\n| 2020.09.10 | 3    | 9.5  |\n| 2020.09.11 | 5    | 9    |\n| 2020.09.12 | 5    | 6    |\n| 2020.09.13 | 2    | 2    |\n\n```\nm.mmed(1w)\n```\n\n| label      | col1 | col2 |\n| ---------- | ---- | ---- |\n| 2020.09.09 | 1    | 9    |\n| 2020.09.10 | 3    | 9.5  |\n| 2020.09.11 | 5    | 9    |\n| 2020.09.12 | 3    | 9    |\n| 2020.09.13 | 2    | 5.5  |\n\n相关函数：[med](https://docs.dolphindb.cn/zh/funcs/m/med.html)\n"
    },
    "mmin": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mmin.html",
        "signatures": [
            {
                "full": "mmin(X, window, [minPeriods])",
                "name": "mmin",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "[minPeriods]",
                        "name": "minPeriods",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [mmin](https://docs.dolphindb.cn/zh/funcs/m/mmin.html)\n\n\n\n#### 语法\n\nmmin(X, window, \\[minPeriods])\n\n窗口计算规则请参考：[mFunctions](https://docs.dolphindb.cn/zh/funcs/themes/mFunctions.html)\n\n#### 详情\n\n在给定长度（以元素个数或时间长度衡量）的滑动窗口内计算 *X* 元素的最小值。\n\n#### 参数\n\n**X** 是一个向量/矩阵/表/元组（元素为标量或等长向量）/字典。\n\n**window** 是大于等于 2 的正整型或 DURATION 标量。表示滑动窗口的长度。\n\n**Note:** 在流计算引擎中调用滑动窗口函数时，window 的上限为 102400。\n\n**minPeriods** 是一个正整数。表示滑动窗口中最少包含的非 NULL 有效观测值数量。\n\n#### 返回值\n\n* 输入为向量时，返回一个与输入等长的向量。\n* 输入为矩阵时，返回一个与输入矩阵同维度的矩阵。\n* 输入为表时，返回一个与输入表结构相同的表。\n* 输入为元组时，返回对应的元组结构。\n\n#### 例子\n\n```\nX = 2 1 3 7 6 5 4\nY = 2 1 3 NULL 6 5 4\n\nmmin(X, 3);\n// output\n[,,1,1,3,5,4]\n\nmmin(Y, 3);\n// output\n[,,1,1,3,5,4]\n\nmmin(Y, 3, minPeriods=1);\n// output\n[2,1,1,1,3,5,4]\n```\n\n```\nm = matrix(1 5 9 0 2 8 -1 5, 9 10 2 NULL -1 10 2 3)\nm.rename!(date(2020.09.10)+1..8, `A`B)\nm.setIndexedMatrix!()\nm.mmin(3d)\n```\n\n| label      | col1 | col2 |\n| ---------- | ---- | ---- |\n| 2020.09.11 | 1    | 9    |\n| 2020.09.12 | 1    | 9    |\n| 2020.09.13 | 1    | 2    |\n| 2020.09.14 | 0    | 2    |\n| 2020.09.15 | 0    | (1)  |\n| 2020.09.16 | 0    | (1)  |\n| 2020.09.17 | (1)  | (1)  |\n| 2020.09.18 | (1)  | 2    |\n\n```\nm.mmin(1w)\n```\n\n| label      | col1 | col2 |\n| ---------- | ---- | ---- |\n| 2020.09.11 | 1    | 9    |\n| 2020.09.12 | 1    | 9    |\n| 2020.09.13 | 1    | 2    |\n| 2020.09.14 | 0    | 2    |\n| 2020.09.15 | 0    | (1)  |\n| 2020.09.16 | 0    | (1)  |\n| 2020.09.17 | (1)  | (1)  |\n| 2020.09.18 | (1)  | (1)  |\n\n相关函数：[min](https://docs.dolphindb.cn/zh/funcs/m/min.html)\n"
    },
    "mmse": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mmse.html",
        "signatures": [
            {
                "full": "mmse(Y, X, window, [minPeriods])",
                "name": "mmse",
                "parameters": [
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "[minPeriods]",
                        "name": "minPeriods",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [mmse](https://docs.dolphindb.cn/zh/funcs/m/mmse.html)\n\n\n\n#### 语法\n\nmmse(Y, X, window, \\[minPeriods])\n\n#### 详情\n\n在给定长度（以元素个数衡量）的滑动窗口内，将因变量 *Y* 与自变量 *X* 进行普通最小二乘回归的系数估计并计算均方误差。计算公式如下：\n\n![](https://docs.dolphindb.cn/zh/images/mmse.png)\n\n#### 参数\n\n**Y** 是一个向量，表示因变量。\n\n**X** 是一个向量，表示自变量。\n\n**window** 是一个正整数，表示滑动窗口的长度。\n\n**minPeriods** 是一个正整数。如果一个滑动窗口中的非 NULL 有效观测值数量小于 *minPeriods*，那么该窗口的结果为 NULL。\n\n#### 返回值\n\n返回一个包含两个向量的元组，第一个向量是普通最小二乘回归的系数估计，第二个向量是均方误差。\n\n#### 例子\n\n```\nx=0.011 0.006 -0.008 0.012 -0.016 -0.023 0.018\ny=0.016 0.009 -0.012 0.022 0.003 -0.056 0.002;\n\nmmse(y, x, 5)[0];\n\n//output: [,,,,0.818182,1.692379,1.188532]\n\nmmse(y, x, 5)[1];\n\n//output: [,,,,0.000055,0.000231,0.000332]\n\nselect y, x, mmse(y,x,5,3) as `mbeta`mmse from table(x,y);\n```\n\n返回：\n\n| y      | x      | mbeta    | mmse        |\n| ------ | ------ | -------- | ----------- |\n| 0.016  | 0.011  |          |             |\n| 0.009  | 0.006  |          |             |\n| -0.012 | -0.008 | 1.479381 | 2.806415E-8 |\n| 0.022  | 0.012  | 1.594701 | 0.000003    |\n| 0.003  | -0.016 | 0.818182 | 0.000055    |\n| -0.056 | -0.023 | 1.692379 | 0.000231    |\n| 0.002  | 0.018  | 1.188532 | 0.000332    |\n"
    },
    "mod": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mod.html",
        "signatures": [
            {
                "full": "mod(X, Y)",
                "name": "mod",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [mod](https://docs.dolphindb.cn/zh/funcs/m/mod.html)\n\n\n\n#### 语法\n\nmod(X, Y)\n\n#### 详情\n\n`mod` 表示取模运算。它返回 *X* 和 *Y* 逐个元素相除得到的余数。\n\n* 当 *Y* 是正整数时，结果总是非负的，例如，-10%3 的结果是 2；\n* 当 *Y* 是负整数时，结果总是非正的，例如，-10%-3 的结果是 -1。\n\n`mod` 函数常用于数据分组。比如，\\[5,4,3,3,5,6]%3 是 \\[2,1,0,0,2,0]，于是数据被分成了三组。\n\n#### 参数\n\n**X** 和 **Y** 可以是标量、数据对、向量或矩阵。如果 *X* 或 *Y* 的其中一个是数据对、向量或矩阵，另一个必须是具有相同长度或维度的数据对、向量或矩阵。\n\n#### 返回值\n\n当 *X* 和 *Y* 都是标量时，返回一个整型标量。\n\n当 *X* 或 *Y* 是向量时，返回一个整型向量。\n\n当输入是矩阵时，返回一个整型矩阵。\n\n#### 例子\n\n```\nx=1 2 3;\nx % 2;\n// output: [1,0,1]\n\n2 % x;\n// output: [0,0,2]\n\ny=4 5 6;\nx mod y;\n// output: [1,2,3]\n\nmod(y, x);\n// output: [0,1,0]\n\nm=1..6$2:3;\nm;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1  | 3  | 5  |\n| 2  | 4  | 6  |\n\n```\nm mod 3;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1  | 0  | 2  |\n| 2  | 1  | 0  |\n\n```\nx=-1 2 3;\nx%-5;\n// output: [-1,-3,-2]\n\n-1%5;\n// output: 4\n```\n"
    },
    "mode": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mode.html",
        "signatures": [
            {
                "full": "mode(X)",
                "name": "mode",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [mode](https://docs.dolphindb.cn/zh/funcs/m/mode.html)\n\n\n\n#### 语法\n\nmode(X)\n\n#### 详情\n\n若 *X* 为向量，计算 *X* 中出现次数最多的值。\n\n若 *X* 为矩阵/表，计算其每列中出现次数最多的值，返回一个向量/表。\n\n该函数通过 hash table 统计 *X* 中唯一值（key）出现的次数，当有多个次数最多的 key 时，返回 hash table 中的第一个 key。与所有其它聚合函数一致，该函数在计算时忽略 NULL 值。\n\n**Note:** 对于不同数据类型，该函数采用的 hash 算法不相同，因此输出结果可能不同。\n\nDolphinDB `mode` 函数和 `scipy.stats.mode` 功能上相同，但存在以下差异：\n\n* DolphinDB 支持单参数 `mode(x)`，用于直接计算向量/矩阵/表中数据的众数； SciPy 的 `scipy.stats.mode` 支持多维数组，并可通过 `axis` 参数指定计算维度。\n* DolphinDB `mode` 仅返回 mode，不返回频率信息；SciPy `mode` 返回结构化结果 `ModeResult(mode, count)`，同时返回众数及其出现次数。\n* 当有多个众数时，DolphinDB 返回 hash table 中的第一个 key；而 `scipy.stats.mode` 默认返回最小的众数。\n* DolphinDB `mode` 中，空值不参与计算，而SciPy `mode` 会忽略或单独处理 NaN（通过参数 *nan\\_policy* 控制）。\n\n#### 参数\n\n**X** 可以是标量、向量、矩阵或表。\n\n#### 返回值\n\n当 *X* 是标量或向量时，返回一个整型标量。\n\n当 *X* 是矩阵时，返回一个整型向量。\n\n当*X* 是表时，返回一个表。\n\n#### 例子\n\n```\nmode 2;\n// output: 2\n\nmode 1 3 3 3 4 5 5;\n// output: 3\n\nmode `test;\n// output: test\n\nm=matrix(1 1 2 2 2 3, 4 4 5 6 6 6);\nm;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 4  |\n| 1  | 4  |\n| 2  | 5  |\n| 2  | 6  |\n| 2  | 6  |\n| 3  | 6  |\n\n```\nmode m;\n// output: [2,6]\n```\n\n相关的中心趋势函数：[mean](https://docs.dolphindb.cn/zh/funcs/m/mean.html) 和 [med](https://docs.dolphindb.cn/zh/funcs/m/med.html)\n"
    },
    "month": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/month.html",
        "signatures": [
            {
                "full": "month(X)",
                "name": "month",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [month](https://docs.dolphindb.cn/zh/funcs/m/month.html)\n\n\n\n#### 语法\n\nmonth(X)\n\n#### 详情\n\n返回对应的月份。\n\n#### 参数\n\n**X** 可以是时间标量或向量。\n\n#### 返回值\n\nMONTH 类型标量或向量。\n\n#### 例子\n\n```\nmonth();\n```\n\n返回：null\n\n```\nmonth(`2012.12);\n```\n\n返回：2012.12M\n\n```\nmonth(2012.12.23);  // 把一个 DATE 类型的数据转换成 MONTH 类型。\n```\n\n返回：2012.12M\n\n```\nmonth(now());  // 把一个 TIMESTAMP 类型的数据转换成 MONTH 类型。\n```\n\n返回：2024.02M\n\n**Related information**\n\n[second](https://docs.dolphindb.cn/zh/funcs/s/second.html)\n\n[minute](https://docs.dolphindb.cn/zh/funcs/m/minute.html)\n\n[hour](https://docs.dolphindb.cn/zh/funcs/h/hour.html)\n\n[date](https://docs.dolphindb.cn/zh/funcs/d/date.html)\n\n[year](https://docs.dolphindb.cn/zh/funcs/y/year.html)\n"
    },
    "monthBegin": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/monthBegin.html",
        "signatures": [
            {
                "full": "monthBegin(X, [offset], [n=1])",
                "name": "monthBegin",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[offset]",
                        "name": "offset",
                        "optional": true
                    },
                    {
                        "full": "[n=1]",
                        "name": "n",
                        "optional": true,
                        "default": "1"
                    }
                ]
            }
        ],
        "markdown": "### [monthBegin](https://docs.dolphindb.cn/zh/funcs/m/monthBegin.html)\n\n\n\n#### 语法\n\nmonthBegin(X, \\[offset], \\[n=1])\n\n别名：monthStart\n\n#### 详情\n\n用于计算 *X* 所在月份的第一天。\n\n默认情况下，函数按一个月的周期计算。如果指定了 *offset* 和 *n*，且 *n* > 1，则函数按长度为 *n* 个月的周期计算。此时，*offset* 用于确定多月周期的对齐方式：系统会先计算出 *offset* 所在月份的第一天，然后以该日期为基准，每隔 *n* 个月生成一个周期起始边界，并返回 *X* 所属周期对应的结束日期。\n\n#### 参数\n\n**X** 可以是 DATE, DATEHOUR, DATETIME, TIMESTAMP 或 NANOTIMESTAMP 类型的标量、向量或表。\n\n**offset** 是与 *X* 类型相同的标量，并且它必须小于等于 *X* 中的最小值。它是一个可选参数。如果没有指定，*offset* 默认为 *X* 中的最小值。\n\n**n** 是一个正整数。它是一个可选参数，默认值为1。\n\n#### 返回值\n\nDATE 类型标量或向量。\n\n#### 例子\n\n```\nmonthBegin(2016.12.06);\n// output: 2016.12.01\n\ndate=2016.04.12 2016.04.25 2016.05.12 2016.06.28 2016.07.10 2016.07.18 2016.08.02 2016.08.16 2016.09.26 2016.09.30\ntime = [09:34:07,09:36:42,09:36:51,09:36:59,09:32:47,09:35:26,09:34:16,09:34:26,09:38:12,09:38:13]\nsym = take(`MSFT,10)\nprice= 49.6 29.46 29.52 30.02 174.97 175.23 50.76 50.32 51.29 52.38\nqty = 2200 1900 2100 3200 6800 5400 1300 2500 8800 4500\nt1 = table(date, time, sym, qty, price);\n\nselect avg(price),sum(qty) from t1 group by monthBegin(date,2016.01.01,2);\n```\n\n| monthBegin\\_date | avg\\_price | sum\\_qty |\n| ---------------- | ---------- | -------- |\n| 2016.03.01       | 39.53      | 4100     |\n| 2016.05.01       | 29.77      | 5300     |\n| 2016.07.01       | 112.82     | 16000    |\n| 2016.09.01       | 51.835     | 13300    |\n\n相关函数：[monthEnd](https://docs.dolphindb.cn/zh/funcs/m/monthEnd.html), [businessMonthBegin](https://docs.dolphindb.cn/zh/funcs/b/businessMonthBegin.html), [businessMonthEnd](https://docs.dolphindb.cn/zh/funcs/b/businessMonthEnd.html), [semiMonthBegin](https://docs.dolphindb.cn/zh/funcs/s/semiMonthBegin.html), [semiMonthEnd](https://docs.dolphindb.cn/zh/funcs/s/semiMonthEnd.html)\n"
    },
    "monthEnd": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/monthEnd.html",
        "signatures": [
            {
                "full": "monthEnd(X, [offset], [n=1])",
                "name": "monthEnd",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[offset]",
                        "name": "offset",
                        "optional": true
                    },
                    {
                        "full": "[n=1]",
                        "name": "n",
                        "optional": true,
                        "default": "1"
                    }
                ]
            }
        ],
        "markdown": "### [monthEnd](https://docs.dolphindb.cn/zh/funcs/m/monthEnd.html)\n\n\n\n#### 语法\n\nmonthEnd(X, \\[offset], \\[n=1])\n\n#### 详情\n\n用于计算 *X* 所在月份的最后一天。\n\n默认情况下，函数按一个月的周期计算。如果指定了 *offset* 和 *n*，且 *n* > 1，则函数按长度为 *n* 个月的周期计算。此时，*offset* 用于确定多月周期的对齐方式：系统会先计算出 *offset* 所在月份的最后一天，然后以该日期为基准，每隔 *n* 个月生成一个周期结束边界，并返回 *X* 所属周期对应的结束日期。\n\n#### 参数\n\n**X** 可以是 DATE, DATEHOUR, DATETIME, TIMESTAMP 或 NANOTIMESTAMP 类型的标量、向量或表。\n\n**offset** 是与 *X* 类型相同的标量，并且它必须小于等于 *X* 中的最小值。它是一个可选参数。如果没有指定，*offset* 默认为 *X* 中的最小值。\n\n**n** 是一个正整数。它是一个可选参数，默认值为1。当 *n* 大于 1 时，必须同时指定 *offset*。\n\n#### 返回值\n\nDATE 类型标量或向量。\n\n#### 例子\n\n```\nmonthEnd(2016.12.06);\n// output: 2016.12.31\n\ndate=2016.04.12 2016.04.25 2016.05.12 2016.06.28 2016.07.10 2016.07.18 2016.08.02 2016.08.16 2016.09.26 2016.09.30\ntime = [09:34:07,09:36:42,09:36:51,09:36:59,09:32:47,09:35:26,09:34:16,09:34:26,09:38:12,09:38:13]\nsym = take(`MSFT,10)\nprice= 49.6 29.46 29.52 30.02 174.97 175.23 50.76 50.32 51.29 52.38\nqty = 2200 1900 2100 3200 6800 5400 1300 2500 8800 4500\nt1 = table(date, time, sym, qty, price);\n\nselect avg(price),sum(qty) from t1 group by monthEnd(date,2016.01.01,2);\n```\n\n| monthEnd\\_date | avg\\_price | sum\\_qty |\n| -------------- | ---------- | -------- |\n| 2016.05.31     | 36.193333  | 6200     |\n| 2016.07.31     | 126.74     | 15400    |\n| 2016.09.30     | 51.1875    | 17100    |\n\n相关函数：[monthBegin](https://docs.dolphindb.cn/zh/funcs/m/monthBegin.html), [businessMonthBegin](https://docs.dolphindb.cn/zh/funcs/b/businessMonthBegin.html), [businessMonthEnd](https://docs.dolphindb.cn/zh/funcs/b/businessMonthEnd.html), [semiMonthBegin](https://docs.dolphindb.cn/zh/funcs/s/semiMonthBegin.html), [semiMonthEnd](https://docs.dolphindb.cn/zh/funcs/s/semiMonthEnd.html)\n"
    },
    "monthOfYear": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/monthOfYear.html",
        "signatures": [
            {
                "full": "monthOfYear(X)",
                "name": "monthOfYear",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [monthOfYear](https://docs.dolphindb.cn/zh/funcs/m/monthOfYear.html)\n\n\n\n#### 语法\n\nmonthOfYear(X)\n\n#### 详情\n\n返回 *X* 中的月份。\n\n#### 参数\n\n**X** 可以是 DATE, MONTH, DATETIME, TIMESTAMP 或 NANOTIMESTAMP 类型的标量、向量或表。\n\n#### 返回值\n\n整型标量或向量。\n\n#### 例子\n\n```\nmonthOfYear(2012.07.02);\n// output: 7\n\nmonthOfYear([2012.06.12T12:30:00,2012.10.28T12:35:00,2013.01.06T12:36:47,2013.04.06T08:02:14]);\n// output: [6,10,1,4]\n```\n\n相关函数：[dayOfYear](https://docs.dolphindb.cn/zh/funcs/d/dayOfYear.html), [dayOfMonth](https://docs.dolphindb.cn/zh/funcs/d/dayOfMonth.html), [quarterOfYear](https://docs.dolphindb.cn/zh/funcs/q/quarterOfYear.html), [weekOfYear](https://docs.dolphindb.cn/zh/funcs/w/weekOfYear.html), [hourOfDay](https://docs.dolphindb.cn/zh/funcs/h/hourOfDay.html), [minuteOfHour](https://docs.dolphindb.cn/zh/funcs/m/minuteOfHour.html), [secondOfMinute](https://docs.dolphindb.cn/zh/funcs/s/secondOfMinute.html), [millisecond](https://docs.dolphindb.cn/zh/funcs/m/millisecond.html), [microsecond](https://docs.dolphindb.cn/zh/funcs/m/microsecond.html), [nanosecond](https://docs.dolphindb.cn/zh/funcs/n/nanosecond.html)\n"
    },
    "move": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/move.html",
        "signatures": [
            {
                "full": "move(X, steps)",
                "name": "move",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "steps",
                        "name": "steps"
                    }
                ]
            }
        ],
        "markdown": "### [move](https://docs.dolphindb.cn/zh/funcs/m/move.html)\n\n\n\n#### 语法\n\nmove(X, steps)\n\n#### 详情\n\n将 *X* 向左或向右移动一个位置。该函数是 [prev](https://docs.dolphindb.cn/zh/funcs/p/prev.html) 和 [next](https://docs.dolphindb.cn/zh/funcs/n/next.html) 的通用形式。\n\n#### 参数\n\n**X** 可以是向量、矩阵或表；\n\n**steps** 是一个整数或一个 [duration](https://docs.dolphindb.cn/zh/funcs/d/duration.html)，表示移动多少位置或多少时间。\n\n* 如果 *steps* 为正数，*X* 向右移动 *steps* 个位置；\n\n* 如果 *steps* 为负数，*X* 向左移动 *steps* 个位置；\n\n* 如果 *steps* 为 0，不改变 *X* 的位置；\n\n* 如果 *steps* 为 DURATION，对应的 *X* 必须是行索引为时间类型的索引矩阵或者索引序列。对于每个时间点 Ti，设其对应值为 Xi，移动后的结果按如下规则确定：在时间轴上查找时间点 Ti - *steps* 对应的值，并将该值赋给当前位置。\n\n  * 若存在时间点等于Ti - *steps*，则取该时间点对应的值；\n\n  * 若不存在时间等于 Ti - *steps*，取时间上不晚于 Ti - steps 的最大时间点对应的数据；\n\n  * 若不存在满足条件的时间点，则结果为 NULL。\n\n#### 返回值\n\n返回一个与输入 *X* 相同数据类型和形式的对象。\n\n#### 例子\n\n```\nx=3 9 5 1 4 9;\nmove(x,3);\n// output: [,,,3,9,5]\n\nmove(x,-2);\n// output: [5,1,4,9,,]\n\nindex = (second(08:20:00)+1..4) join 08:21:01 join 08:21:02\nx = index.indexedSeries(x)\nmove(x,3s)\n```\n\n| label    | col1 |\n| -------- | ---- |\n| 08:20:01 |      |\n| 08:20:02 |      |\n| 08:20:03 |      |\n| 08:20:04 | 3    |\n| 08:21:01 | 1    |\n| 08:21:02 | 1    |\n\n```\nmove(x,1m)\n```\n\n| label    | col1 |\n| -------- | ---- |\n| 08:20:01 |      |\n| 08:20:02 |      |\n| 08:20:03 |      |\n| 08:20:04 |      |\n| 08:21:01 | 3    |\n| 08:21:02 | 9    |\n"
    },
    "moveChunksAcrossVolume": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/moveChunksAcrossVolume.html",
        "signatures": [
            {
                "full": "moveChunksAcrossVolume(srcPath, destPath, chunkIds, [isDelSrc=true])",
                "name": "moveChunksAcrossVolume",
                "parameters": [
                    {
                        "full": "srcPath",
                        "name": "srcPath"
                    },
                    {
                        "full": "destPath",
                        "name": "destPath"
                    },
                    {
                        "full": "chunkIds",
                        "name": "chunkIds"
                    },
                    {
                        "full": "[isDelSrc=true]",
                        "name": "isDelSrc",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [moveChunksAcrossVolume](https://docs.dolphindb.cn/zh/funcs/m/moveChunksAcrossVolume.html)\n\n**Note:** 此函数将于近期版本中废弃，推荐使用函数 [moveReplicas](https://docs.dolphindb.cn/zh/funcs/m/moveReplicas.html) 实现相关功能。\n\n\n\n#### 语法\n\nmoveChunksAcrossVolume(srcPath, destPath, chunkIds, \\[isDelSrc=true])\n\n#### 详情\n\n将一个磁盘卷 chunks 文件转移至指定的路径。 *isDelSrc* = true 时，源路径下的 chunks 被成功转移后，将被删除；否则，仍被保留。如果转移失败，保留源路径下的所有 chunks，清空目标路径下已经拷贝完成的文件。\n\n注意：\n\n* 只能在同一个节点下进行 chunks 文件的转移。\n\n* 进行该操作前，需要停止写入，保证所有事务都已完成，并将所有缓冲区的数据刷入磁盘。\n\n* 配置项 *volumes* 必须包含 *srcPath* 和 *destPath* 指定路径所在的磁盘卷，且该配置已经生效（修改配置项后重启使其生效）。\n\n* *destPath* 指定的 chunks 目录必须为空目录。\n\n#### 参数\n\n**srcPath** 是一个字符串，格式如：`\"volumeA/CHUNKS\"`。表示源 chunks 的路径。\n\n**destPath** 是一个字符串，格式如：`\"volumeB/CHUNKS\"`。表示要转移到的目的 chunks 的路径。\n\n**chunkIds** 是一个字符串或者字符串向量。表示需要移动的 chunks 的 id 值。\n\n**isDelSrc** 布尔值，默认为 true。表示拷贝后是否删除源 chunks。\n\n**Note:** *srcPath*、 *destPath* 和 *chunkIds* 可以通过 [getChunksMeta](https://docs.dolphindb.cn/zh/funcs/g/getChunksMeta.html) 获取。\n"
    },
    "moveHotDataToColdVolume": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/moveHotDataToColdVolume.html",
        "signatures": [
            {
                "full": "moveHotDataToColdVolume([checkRange=240])",
                "name": "moveHotDataToColdVolume",
                "parameters": [
                    {
                        "full": "[checkRange=240]",
                        "name": "checkRange",
                        "optional": true,
                        "default": "240"
                    }
                ]
            }
        ],
        "markdown": "### [moveHotDataToColdVolume](https://docs.dolphindb.cn/zh/funcs/m/moveHotDataToColdVolume.html)\n\n\n\n#### 语法\n\nmoveHotDataToColdVolume(\\[checkRange=240])\n\n#### 详情\n\n强制触发将用户指定范围的数据转存至 *coldVolumes*。\n\n**Note:**\n\n* 该命令仅对当前节点有效。集群环境中，可通过 `pnodeRun` 调用该函数，使其在其它节点生效。\n\n* 该命令设置的转存策略与 [setRetentionPolicy](https://docs.dolphindb.cn/zh/funcs/s/setRetentionPolicy.html) 设置的转存策略的有区别，详情请参考 [TieredStorage](https://docs.dolphindb.cn/zh/db_distr_comp/db/tiered_storage.html)。\n\n#### 参数\n\n**checkRange** 整数，单位为小时，默认值为 10 天，即 240 小时。用于设置需迁移至 *coldVolumes* 的数据的时间范围。设置后，时间范围在 \\[当前时间 - *hoursToColdVolumes* - *checkRange*, 当前时间 - *hoursToColdVolumes*) 内的数据将会被迁移至 *coldVolumes*。\n"
    },
    "moveReplicas": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/moveReplicas.html",
        "signatures": [
            {
                "full": "moveReplicas(srcNode, destNode, chunkId, [destVolumes])",
                "name": "moveReplicas",
                "parameters": [
                    {
                        "full": "srcNode",
                        "name": "srcNode"
                    },
                    {
                        "full": "destNode",
                        "name": "destNode"
                    },
                    {
                        "full": "chunkId",
                        "name": "chunkId"
                    },
                    {
                        "full": "[destVolumes]",
                        "name": "destVolumes",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [moveReplicas](https://docs.dolphindb.cn/zh/funcs/m/moveReplicas.html)\n\n\n\n#### 语法\n\nmoveReplicas(srcNode, destNode, chunkId, \\[destVolumes])\n\n#### 详情\n\n通过该函数将源节点上的一个或多个 chunk 的副本移动到目标节点。如果目标节点上已经存在该 chunk，那么系统将放弃本次操作。\n\n该命令只能由管理员在控制节点上执行。\n\n通过 [getRecoveryTaskStatus](https://docs.dolphindb.cn/zh/funcs/g/getRecoveryTaskStatus.html) 函数可以查看任务状态。\n\n#### 参数\n\n**srcNode** 字符串，表示源节点的别名。\n\n**destNode** 字符串，表示目标节点的别名。\n\n**chunkId** 字符串/UUID 标量或向量，表示 chunk 的 ID。\n\n**destVolumes** 字符串标量或向量，表示移动到目的节点的具体目录，此目录必须来自配置文件中 volumes 指定的目录。如果为向量，则优先移动到向量中位次靠前的目录下。\n\n#### 例子\n\n把 \"node1\" 上所有 chunk 的副本移动到 \"node2\"的指定目录。\n\n```\nchunkIds=exec chunkId from pnodeRun(getChunksMeta) where node=\"node1\"\nmoveReplicas(\"node1\",\"node2\",chunkIds,\"/ddb/server/clusterDemo/data/node2/storage\");\n```\n"
    },
    "movingTopNIndex": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/movingTopNIndex.html",
        "signatures": [
            {
                "full": "movingTopNIndex(X, window, top, [ascending=true], [fixed=false], [tiesMethod='oldest'])",
                "name": "movingTopNIndex",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "top",
                        "name": "top"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[fixed=false]",
                        "name": "fixed",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[tiesMethod='oldest']",
                        "name": "tiesMethod",
                        "optional": true,
                        "default": "'oldest'"
                    }
                ]
            }
        ],
        "markdown": "### [movingTopNIndex](https://docs.dolphindb.cn/zh/funcs/m/movingTopNIndex.html)\n\n\n\n#### 语法\n\nmovingTopNIndex(X, window, top, \\[ascending=true], \\[fixed=false], \\[tiesMethod='oldest'])\n\n#### 详情\n\n在滑动窗口内对数据进行排序，并返回排序后前 N 个元素的索引位置。\n\n#### 参数\n\n**X** 是一个数值型/时间类型的向量。注意：从 2.00.10 版本开始，*X* 中的空值不参与排序。\n\n**window** 必须是不小于2的正整数，表示窗口长度。\n\n**top** 是一个大于1，小于等于 *window* 的整数。\n\n**ascending** 是一个布尔值，表示窗口内值的排序方式。true 表示升序，false 表示降序。\n\n**fixed** 是一个布尔值。表示输出的数组向量每行的长度是否固定为 *top*。默认值为 false。设置为 true 时所有窗口的长度相同，前( *top* - 1)个窗口内缺少的索引用 NULL 填充。\n\n**tiesMethod** 字符串。在滑动窗口内对 X 进行排序后，如果有多个具有相同值的元素无法全部进入前 *top*，可以通过该参数来指定选择元素的方式。可选值为：\n\n* 'oldest'：从最早进入窗口的元素开始选取，直至达到 *top* 个。\n\n* 'latest'：从最晚进入窗口的元素开始向前选取，直至达到 *top* 个。\n\n#### 返回值\n\n返回一个数组向量，表示 *X* 在每一个滑动窗口内按照指定顺序排序后的前 *top* 个元素所对应的索引。\n\n#### 例子\n\n```\nS = 2 5 6 1 2 4 5 6 9 0\n\nm1 = movingTopNIndex(X=S, window=4, top=2, ascending=true, fixed=true)\nm1;\n// output\n[[,0],[0,1],[0,1],[3,0],[3,4],[3,4],[3,4],[4,5],[5,6],[9,6]]\n\nm2 = movingTopNIndex(X=S, window=4, top=2, ascending=false, fixed=true)\nm2;\n// output\n[[,0],[1,0],[2,1],[2,1],[2,1],[2,5],[6,5],[7,6],[8,7],[8,7]]\n\nm3 = movingTopNIndex(X=S, window=4, top=2, ascending=true, fixed=false)\nprint m3;\n// output\n[[0],[0,1],[0,1],[3,0],[3,4],[3,4],[3,4],[4,5],[5,6],[9,6]]\n\nS[m1[0]]\n// output\n[,2,2,1,1,1,1,2,4,0]\n\nS[m3[0]]\n// output\n[2,2,2,1,1,1,1,2,4,0]\n\nX = [5, 8, 1, 9, 7, 3, 1, NULL, 0, 8, 7, 7]\nmovingTopNIndex(X=X, window=4, top=2, ascending=true, fixed=true)\n// 2.00.10 之前的版本，X 中的空值也参与排序，结果是：\n[[00i,0],[0,1],[2,0],[2,0],[2,4],[2,5],[6,5],[7,6],[7,8],[7,8],[7,8],[8,10]]\n\n// 2.00.10 及之后版本，X 中的空值会被忽略，结果是：\n[[00i,0],[0,1],[2,0],[2,0],[2,4],[2,5],[6,5],[6,5],[8,6],[8,6],[8,10],[8,10]]\n\nX = [2, 1, 4, 3, 4, 3, 4]\n\n// 第6个滑动窗口中，X 排序后是 1 2 3 3 4 4，只取前3个排名，根据 tiesMethod 的设置值来选取哪个3被选取\n\n// tiesMethod 未指定，则取默认值 'oldest'，即选取第一次出现的3，其对应 X 中的索引是3\nmovingTopNIndex(X,6,3)\n\n// output\n[[0],[1,0],[1,0,2],[1,0,3],[1,0,3],[1,0,3],[1,3,5]]]\n\n\n// tiesMethod = 'latest'，即选最后一次出现的3，其对应 X 中的索引是5\nmovingTopNIndex(X,6,3,tiesMethod=\"latest\")\n\n// output\n[[0],[1,0],[1,0,2],[1,0,3],[1,0,3],[1,0,5],[1,3,5]]\n```\n"
    },
    "movingWindowData": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/movingWindowData.html",
        "signatures": [
            {
                "full": "movingWindowData(X, window, [fixed=false])",
                "name": "movingWindowData",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "[fixed=false]",
                        "name": "fixed",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [movingWindowData](https://docs.dolphindb.cn/zh/funcs/m/movingWindowData.html)\n\n\n\n#### 语法\n\nmovingWindowData(X, window, \\[fixed=false])\n\n#### 详情\n\n用于返回向量 *X* 在每个滑动窗口内的所有元素。\n\n#### 参数\n\n**X** 是一个向量（常规向量/元组/数组向量）。\n\n**window** 必须是不小于 2 的正整数，表示以元素个数衡量的窗口的长度。\n\n**fixed** 是一个布尔值，表示输出的数组向量中每行元素的长度是否为 *window*。默认值为 false，直接输出窗口内的元素。设置为 true，前 (*window* - 1)个窗口内缺少的元素用 NULL 填充。\n\n#### 返回值\n\n返回一个数组向量。\n\n#### 例子\n\n```\nS = -1 3 -4 0 5 10 9 7\nm = movingWindowData(X=S,window=3);\nm;\n// output: [[-1],[-1,3],[-1,3,-4],[3,-4,0],[-4,0,5],[0,5,10],[5,10,9],[10,9,7]]\n\nmi = movingWindowData(X=S,window=3,fixed=true);\nmi;\n// output: [[00i,00i,-1],[00i,-1,3],[-1,3,-4],[3,-4,0],[-4,0,5],[0,5,10],[5,10,9],[10,9,7]]\n    \n// 获取每个窗口第一个元素的值\nm[0]\n// output: [-1,-1,-1,3,-4,0,5,10]\n\nmi[0]\n// output: [,,-1,3,-4,0,5,10]\n\n// X 为元组\ns = [[-1,1], [0], [3], [5,6], [7], [8,9], [10,13]]\nm1 = movingWindowData(X=s,window=3);\nm1;\n// output: [[[-1,1]], [[-1,1], [0]], [[-1,1], [0], [3]], [[0], [3], [5,6]], [[3], [5,6], [7]], [[5,6], [7], [8,9]], [[7], [8,9], [10,13]]]\n\n// X 为数组向量\na = array(INT[], 0, 10).append!([1 2 3, 4 5, 6 7 8, 9 10]);\nm2 = movingWindowData(X=a,window=3);\nm2;\n// output: [[[1,2,3]], [[1,2,3], [4,5]], [[1,2,3], [4,5], [6,7,8]], [[4,5], [6,7,8], [9,10]]]\n\n\n// 在响应式引擎中获取长度为 5 的滑动窗口的数据\nn = 100\nDateTime = 2023.01.01T09:00:00 + rand(10000, n).sort!()\nSecurityID = take(`600021`600022`600023`600024`600025, n)\nPrice = 1.0 + rand(1.0, n) \nt = table(1:0, `DateTime`SecurityID`Price, [TIMESTAMP, SYMBOL, DOUBLE])\ntableInsert(t, DateTime, SecurityID, Price)\noutput = table(100:0, `SecurityID`DateTime`PriceNew, [SYMBOL, DATETIME, DOUBLE[]])\n\nengine = createReactiveStateEngine(name=\"rseEngine\", metrics=[<DateTime>, <movingWindowData(Price,5)>], dummyTable=t, outputTable=output, keyColumn=`SecurityID, keepOrder=true)\nengine.append!(t)\ndropStreamEngine(`rseEngine)\n```\n"
    },
    "movingWindowIndex": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/movingWindowIndex.html",
        "signatures": [
            {
                "full": "movingWindowIndex(X, window, [fixed=false])",
                "name": "movingWindowIndex",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "[fixed=false]",
                        "name": "fixed",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [movingWindowIndex](https://docs.dolphindb.cn/zh/funcs/m/movingWindowIndex.html)\n\n\n\n#### 语法\n\nmovingWindowIndex(X, window, \\[fixed=false])\n\n#### 详情\n\n用于返回向量 *X* 在每个滑动窗口内的元素所对应的索引。\n\n#### 参数\n\n**X** 是一个向量（常规向量/元组/数组向量）。\n\n**window** 必须是不小于2的正整数，表示窗口长度。\n\n**fixed** 是一个布尔值。表示输出的数组向量每行的长度是否固定为 *window*。默认值为 false。设置为 true 时 表示所有窗口的长度相同，前 (*window* - 1)个窗口内缺少的索引用 NULL 填充。\n\n#### 返回值\n\n返回一个数组向量，表示 *X* 在每一个窗口内的元素所对应的索引。\n\n#### 例子\n\n```\nS = 1 2 3 4 5 6 7 8 9 0;\nm = movingWindowIndex(X=S,window=3);\nm;\n// output\n[[0],[0,1],[0,1,2],[1,2,3],[2,3,4],[3,4,5],[4,5,6],[5,6,7],[6,7,8],[7,8,9]]\n\nmi = movingWindowIndex(X=S,window=3,fixed=true);\nmi;\n// output\n[[,,0],[,0,1],[0,1,2],[1,2,3],[2,3,4],[3,4,5],[4,5,6],[5,6,7],[6,7,8],[7,8,9]]\n\n// 获取每个窗口第一个元素的值\nS[m[0]]\n// output\n[1,1,1,2,3,4,5,6,7,8]\n\nS[mi[0]]\n// output\n[,,1,2,3,4,5,6,7,8]\n\n\ns = [[-1,1], [0], [3], [5,6], [7], [8,9], [10,13]]\nm = movingWindowIndex(X=s,window=3);\nm;\n// output: [[0], [0,1], [0,1,2], [1,2,3], [2,3,4], [3,4,5], [4,5,6]]\n```\n"
    },
    "mpercentile": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mpercentile.html",
        "signatures": [
            {
                "full": "mpercentile(X, percent, window, [interpolation='linear'], [minPeriods])",
                "name": "mpercentile",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "percent",
                        "name": "percent"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "[interpolation='linear']",
                        "name": "interpolation",
                        "optional": true,
                        "default": "'linear'"
                    },
                    {
                        "full": "[minPeriods]",
                        "name": "minPeriods",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [mpercentile](https://docs.dolphindb.cn/zh/funcs/m/mpercentile.html)\n\n\n\n#### 语法\n\nmpercentile(X, percent, window, \\[interpolation='linear'], \\[minPeriods])\n\n窗口计算规则请参考：[mFunctions](https://docs.dolphindb.cn/zh/funcs/themes/mFunctions.html)\n\n#### 详情\n\n在给定长度（以元素个数或时间长度衡量）的滑动窗口内计算 *X* 元素在其对应窗口内的百分位数。\n\n#### 参数\n\n**X** 是一个向量/矩阵/表/元组（元素为标量或等长向量）/字典。\n\n**percent** 是0到100之间的整数或小数。\n\n**window** 是大于等于 2 的正整型或 DURATION 标量。表示滑动窗口的长度。\n\n**Note:** 在流计算引擎中调用滑动窗口函数时，window 的上限为 102400。\n\n**interpolation** 是一个字符串，表示当选中的分位点位于在 *X* 的第 i 和第 i+1 个元素之间时，采用的插值方法。它具有以下取值：\n\n* 'linear'：![linear](https://docs.dolphindb.cn/zh/images/linear.png)，其中，![fraction](https://docs.dolphindb.cn/zh/images/fraction.png)\n\n* 'lower'：![lower](https://docs.dolphindb.cn/zh/images/lower.png)\n\n* 'higher'：![higher](https://docs.dolphindb.cn/zh/images/higher.png)\n\n* 'nearest'：![lower](https://docs.dolphindb.cn/zh/images/lower.png)和![higher](https://docs.dolphindb.cn/zh/images/higher.png)之中最接近分位点的数据\n\n* 'midpoint'：![midpoint](https://docs.dolphindb.cn/zh/images/midpoint.png)\n\n如果没有指定 *interpolation*，默认采用 'linear'。\n\n**minPeriods** 是一个正整数。表示滑动窗口中最少包含的非 NULL 有效观测值数量。\n\n#### 返回值\n\n* 输入为向量时，返回一个与输入等长的 DOUBLE 类型向量。\n* 输入为矩阵时，返回一个与输入矩阵同维度的矩阵，每列分别计算。\n* 输入为表时，返回一个与输入表结构相同的表。\n* 输入为元组时，返回对应的元组结构。\n\n#### 例子\n\n```\nx=2 1 3 7 6 5 4;\nmpercentile(x, percent=50, window=3);\n// output: [,,2,3,6,6,5]\n\nmpercentile(x, percent=25, window=3, interpolation=\"lower\");\n// output: [,,1,1,3,5,4]\n\nmpercentile(x, percent=75, window=3, interpolation=\"higher\")\n// output: [,,3,7,7,7,6]\n\nmpercentile(x, percent=5, window=3, interpolation=\"nearest\")\n// output: [,,1,1,3,5,4]\n\nmpercentile(x, percent=15, window=3, interpolation=\"midpoint\")\n// output: [,,1.5,2,4.5,5.5,4.5]\n\nmpercentile(x, percent=50, window=3, interpolation=\"linear\", minPeriods=1);\n// output: [2,1.5,2,3,6,6,5]\n\nm=matrix(2 1 3 7 6 5 4, 1..7);\nm;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 2  | 1  |\n| 1  | 2  |\n| 3  | 3  |\n| 7  | 4  |\n| 6  | 5  |\n| 5  | 6  |\n| 4  | 7  |\n\n```\nmpercentile(m, percent=50, window=3, interpolation=\"linear\", minPeriods=1);\n```\n\n| #0  | #1  |\n| --- | --- |\n| 2   | 1   |\n| 1.5 | 1.5 |\n| 2   | 2   |\n| 3   | 3   |\n| 6   | 4   |\n| 6   | 5   |\n| 5   | 6   |\n\n```\nm.rename!(date(2020.09.08)+1..7, `A`B)\nm.setIndexedMatrix!()\nmpercentile(m, percent=50, window=3d, interpolation=\"linear\", minPeriods=1);\n```\n\n| label      | col1 | col2 |\n| ---------- | ---- | ---- |\n| 2020.09.09 | 2    | 1    |\n| 2020.09.10 | 1.5  | 1.5  |\n| 2020.09.11 | 2    | 2    |\n| 2020.09.12 | 3    | 3    |\n| 2020.09.13 | 6    | 4    |\n| 2020.09.14 | 6    | 5    |\n| 2020.09.15 | 5    | 6    |\n\n```\nmpercentile(m, percent=50, window=1w, interpolation=\"linear\", minPeriods=1);\n```\n\n| label      | col1 | col2 |\n| ---------- | ---- | ---- |\n| 2020.09.09 | 2    | 1    |\n| 2020.09.10 | 1.5  | 1.5  |\n| 2020.09.11 | 2    | 2    |\n| 2020.09.12 | 2.5  | 2.5  |\n| 2020.09.13 | 3    | 3    |\n| 2020.09.14 | 4    | 3.5  |\n| 2020.09.15 | 4    | 4    |\n\n相关函数：[percentile](https://docs.dolphindb.cn/zh/funcs/p/percentile.html)\n"
    },
    "mpercentileTopN": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mpercentiletopn.html",
        "signatures": [
            {
                "full": "mpercentileTopN(X, S, percent, window, top, [interpolation], [ascending], [tiesMethod='oldest'])",
                "name": "mpercentileTopN",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "S",
                        "name": "S"
                    },
                    {
                        "full": "percent",
                        "name": "percent"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "top",
                        "name": "top"
                    },
                    {
                        "full": "[interpolation]",
                        "name": "interpolation",
                        "optional": true
                    },
                    {
                        "full": "[ascending]",
                        "name": "ascending",
                        "optional": true
                    },
                    {
                        "full": "[tiesMethod='oldest']",
                        "name": "tiesMethod",
                        "optional": true,
                        "default": "'oldest'"
                    }
                ]
            }
        ],
        "markdown": "### [mpercentileTopN](https://docs.dolphindb.cn/zh/funcs/m/mpercentiletopn.html)\n\n\n\n#### 语法\n\nmpercentileTopN(X, S, percent, window, top, \\[interpolation], \\[ascending], \\[tiesMethod='oldest'])\n\n参数说明和窗口计算规则请参考：[mTopN](https://docs.dolphindb.cn/zh/funcs/themes/TopN.html)\n\n#### 详情\n\n* 若 *X*是向量，在长度为 *window*的滑动窗口内，根据 *ascending*指定的排序方式将 *X* 在窗口内的元素按照*S*进行稳定排序，取其前*top*个元素计算对应的 *percent*百分位数。\n\n* 若 *X*是矩阵或表，在每列内进行上述计算，返回同样数据类型和数据维度的结果。\n\n#### 参数\n\n**percent** 是 0 到 100之间的数，表示计算的百分位数。\n\n**interpolation** 是一个字符串，表示当选中的分位点位于在 *X* 的第 i 和第 i+1 个元素之间时，采用的插值方法。它具有以下取值，默认值为 'linear'：\n\n* ‘linear’：Xi+ ( Xi+1 - Xi ) \\* fraction，其中 fraction 为![](https://docs.dolphindb.cn/zh/images/fraction.png)\n\n* 'lower'：Xi\n\n* 'higher’：Xi+1\n\n* 'nearest'： Xi+1 和 Xi之中最接近分位点的数据\n\n* 'midpoint'：（Xi+1 + Xi)/2\n\n#### 返回值\n\n* 输入为向量时，返回一个与输入等长的 DOUBLE 类型向量。\n* 输入为矩阵时，返回一个与输入矩阵同维度的矩阵，每列分别计算。\n* 输入为表时，返回一个与输入表结构相同的表。\n* 输入为元组时，返回对应的元组结构。\n\n#### 例子\n\n以 IBM 股票为例，构造连续 6 个交易日的成交价格和成交量数据：\n\n```\nsymbol = take(`IBM, 6)\ntradeDate = 2024.01.02 2024.01.03 2024.01.04 2024.01.05 2024.01.08 2024.01.09\ntradePrice = [182.5, 183.8, 181.2, 184.6, 183.1, 185.0]\ntradeVolume = [520, 860, 610, 940, 650, 880]\n\nstockDaily = table(symbol, tradeDate, tradePrice, tradeVolume)\nstockDaily;\n```\n\n输出结果：\n\n| symbol | tradeDate  | tradePrice | tradeVolume |\n| ------ | ---------- | ---------- | ----------- |\n| IBM    | 2024.01.02 | 182.5      | 520         |\n| IBM    | 2024.01.03 | 183.8      | 860         |\n| IBM    | 2024.01.04 | 181.2      | 610         |\n| IBM    | 2024.01.05 | 184.6      | 940         |\n| IBM    | 2024.01.08 | 183.1      | 650         |\n| IBM    | 2024.01.09 | 185        | 880         |\n\n例 1：在最近 4 个交易日中，选取成交量最高的前 2 个交易日，分别计算其成交价格的 50 分位数：\n\n```\nmpercentileTopN(X=tradePrice, S=tradeVolume, percent=50, window=4, top=2, ascending=false)\n// 输出: [182.5, 183.15, 182.5, 184.2, 184.2, 184.8]\n```\n\n* 对 2024.01.09 的数据而言，最近 4 日窗口中：\n\n  * tradePrice=\\[181.2, 184.6, 183.1, 185.0]\n\n  * tradeVolume=\\[610, 940, 650, 880]\n\n* 因为 *ascending*=false，对成交量执行降序，选取成交量最高的前 2 个交易日，其对应的成交价格为 184.6 和 185.0；这两个价格的 50 分位数为 184.8。\n\n例 2：设置 *interpolation* 决定分位点位于两个观测值之间的取值方式。\n\n下面仍使用同一组成交价格和成交量数据，在最近 4 个交易日内，选取成交量最低的前 2 个交易日，分别计算其成交价格的 20 分位数：\n\n```\nmpercentileTopN(X=tradePrice, S=tradeVolume, percent=20, window=4, top=2, interpolation=\"lower\")\n// 输出: [182.5, 182.5, 181.2, 181.2, 181.2, 181.2]\n​\nmpercentileTopN(X=tradePrice, S=tradeVolume, percent=20, window=4, top=2, interpolation=\"higher\")\n// 输出: [182.5, 183.8, 182.5, 182.5, 183.1, 183.1]\n​\nmpercentileTopN(X=tradePrice, S=tradeVolume, percent=20, window=4, top=2, interpolation=\"nearest\")\n// 输出: [182.5, 182.5, 181.2, 181.2, 181.2, 181.2]\n​\nmpercentileTopN(X=tradePrice, S=tradeVolume, percent=20, window=4, top=2, interpolation=\"midpoint\")\n// 输出: [182.5, 183.15, 181.85, 181.85, 182.15, 182.15]\n​\nmpercentileTopN(X=tradePrice, S=tradeVolume, percent=20, window=4, top=2, interpolation=\"linear\")\n// 输出: [182.5, 182.76, 181.46, 181.46, 181.58, 181.58]\n```\n\n以 2024.01.09 的数据为例，按默认升序选择成交量最低的前 2 个交易日，其对应的成交价格是 181.2 和 183.1：\n\n* *interpolation*=\"lower\"：取较低价格 181.2；\n\n* *interpolation*=\"higher\"：取较高价格 183.1；\n\n* *interpolation*=\"nearest\"：取距离分位点最近的价格 181.2；\n\n* *interpolation*=\"midpoint\"：取两者中点 182.15；\n\n* *interpolation*=\"linear\"：按位置做线性插值，将数据代入 Xi+ ( Xi+1 - Xi ) \\* fraction 计算，得到 181.2 + (183.1 - 181.2) \\* 0.2 = 181.58。\n\n例 3：设置 *tiesMethod* 决定边界值并列时如何选样本。\n\n单独构造一组 NVDA 股票的数据：\n\n```\nsymbol = take(`NVDA, 6)\ntradeDate = 2024.02.01 2024.02.02 2024.02.05 2024.02.06 2024.02.07 2024.02.08\ntradePrice = [431.2, 433.5, 432.1, 434.8, 433.0, 435.2]\ntradeVolume = [700, 900, 900, 900, 760, 900]\n\ntieCase = table(symbol, tradeDate, tradePrice, tradeVolume)\ntieCase;\n```\n\n输出结果：\n\n| symbol | tradeDate  | tradePrice | tradeVolume |\n| ------ | ---------- | ---------- | ----------- |\n| NVDA   | 2024.02.01 | 431.2      | 700         |\n| NVDA   | 2024.02.02 | 433.5      | 900         |\n| NVDA   | 2024.02.05 | 432.1      | 900         |\n| NVDA   | 2024.02.06 | 434.8      | 900         |\n| NVDA   | 2024.02.07 | 433.0      | 760         |\n| NVDA   | 2024.02.08 | 435.2      | 900         |\n\n在最近 5 个交易日内，选取成交量最高的前 2 个交易日，分别计算其成交价格的 50 分位数，并指定不同的 *tiesMethod*：\n\n```\nmpercentileTopN(X=tradePrice, S=tradeVolume, percent=50, window=5, top=2, ascending=false, tiesMethod=\"oldest\")\n// 输出: [431.2, 432.35, 432.8, 432.8, 432.8, 432.8]\n\nmpercentileTopN(X=tradePrice, S=tradeVolume, percent=50, window=5, top=2, ascending=false, tiesMethod=\"latest\")\n// 输出: [431.2, 432.35, 432.8, 433.45, 433.45, 435.0]\n\nmpercentileTopN(X=tradePrice, S=tradeVolume, percent=50, window=5, top=2, ascending=false, tiesMethod=\"all\")\n// 输出: [431.2, 432.35, 432.8, 433.5, 433.5, 434.15]\n```\n\n以 2024.02.08 的数据为例，最近 5 日窗口中的 tradeVolume=\\[900, 900, 900, 760, 900]，共有 4 个交易日的成交量都并列为最高值 900，但 *top*=2 只要求保留前 2 个名次：\n\n* *tiesMethod*=\"oldest\"：取最早进入窗口的两个成交量最高的交易日，对应价格为 433.5 和 432.1；\n\n* *tiesMethod*=\"latest\"：取最晚进入窗口的两个成交量最高的交易日，对应价格为 434.8 和 435.2；\n\n* *tiesMethod*=\"all\"：保留全部并列的成交量最高的交易日，对应价格为 433.5、432.1、434.8、435.2。\n"
    },
    "mprod": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mprod.html",
        "signatures": [
            {
                "full": "mprod(X, window, [minPeriods])",
                "name": "mprod",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "[minPeriods]",
                        "name": "minPeriods",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [mprod](https://docs.dolphindb.cn/zh/funcs/m/mprod.html)\n\n\n\n#### 语法\n\nmprod(X, window, \\[minPeriods])\n\n窗口计算规则请参考：[mFunctions](https://docs.dolphindb.cn/zh/funcs/themes/mFunctions.html)\n\n#### 详情\n\n在给定长度（以元素个数或时间长度衡量）的滑动窗口内计算 *X* 元素的乘积。\n\n#### 参数\n\n**X** 是一个向量/矩阵/表/元组（元素为标量或等长向量）/字典。\n\n**window** 是大于等于 2 的正整型或 DURATION 标量。表示滑动窗口的长度。\n\n**Note:** 在流计算引擎中调用滑动窗口函数时，window 的上限为 102400。\n\n**minPeriods** 是一个正整数。表示滑动窗口中最少包含的非 NULL 有效观测值数量。\n\n#### 返回值\n\n* 输入为向量时，返回一个与输入等长的向量。\n* 输入为矩阵时，返回一个与输入矩阵同维度的矩阵，每列分别计算。\n* 输入为表时，返回一个与输入表结构相同的表。\n* 输入为元组时，返回对应的元组结构。\n\n#### 例子\n\n```\nX = 2 1 3 7 6 5 4\nY = 2 1 3 NULL 6 5 4\n\nmprod(X, 3);\n// output: [,,6,21,126,210,120]\n\nmprod(Y, 3);\n// output: [,,6,3,18,30,120]\n\nmprod(Y, 3, minPeriods=1);\n// output: [2,2,6,3,18,30,120]\n```\n\n```\nm=matrix(1 NULL 4 NULL 8 6 , 9 NULL NULL 10 NULL 2)\nm.rename!(date(2020.04.06)+1..6, `col1`col2)\nm.setIndexedMatrix!()\nmprod(m, 3d)\n```\n\n| label      | col1 | col2 |\n| ---------- | ---- | ---- |\n| 2020.04.07 | 1    | 9    |\n| 2020.04.08 | 1    | 9    |\n| 2020.04.09 | 4    | 9    |\n| 2020.04.10 | 4    | 10   |\n| 2020.04.11 | 32   | 10   |\n| 2020.04.12 | 48   | 20   |\n\n```\nmprod(m, 1w)\n```\n\n| label      | col1 | col2 |\n| ---------- | ---- | ---- |\n| 2020.04.07 | 1    | 9    |\n| 2020.04.08 | 1    | 9    |\n| 2020.04.09 | 4    | 9    |\n| 2020.04.10 | 4    | 90   |\n| 2020.04.11 | 32   | 90   |\n| 2020.04.12 | 192  | 180  |\n\n相关函数：[prod](https://docs.dolphindb.cn/zh/funcs/p/prod.html)\n"
    },
    "mr": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mr.html",
        "signatures": [
            {
                "full": "mr(ds, mapFunc, [reduceFunc], [finalFunc], [parallel=true])",
                "name": "mr",
                "parameters": [
                    {
                        "full": "ds",
                        "name": "ds"
                    },
                    {
                        "full": "mapFunc",
                        "name": "mapFunc"
                    },
                    {
                        "full": "[reduceFunc]",
                        "name": "reduceFunc",
                        "optional": true
                    },
                    {
                        "full": "[finalFunc]",
                        "name": "finalFunc",
                        "optional": true
                    },
                    {
                        "full": "[parallel=true]",
                        "name": "parallel",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [mr](https://docs.dolphindb.cn/zh/funcs/m/mr.html)\n\n\n\n#### 语法\n\nmr(ds, mapFunc, \\[reduceFunc], \\[finalFunc], \\[parallel=true])\n\n#### 详情\n\n`mr` 是 DolphinDB 中执行 MapReduce 计算的通用函数。 当数据分布在多个数据源上时，可以先对每个数据源分别计算，再把各部分结果合并，最后按需要做一次统一处理。\n\n##### 什么是 MapReduce\n\n可以把 MapReduce 理解成**两个核心阶段**，更详细的介绍请参考[什么是 MapReduce](https://www.ibm.com/cn-zh/think/topics/mapreduce)：\n\n1. map：对每个数据源分别执行同一段计算逻辑。\n2. reduce：把多个 map 结果逐步合并成一个结果。\n\n**Note:** 除了以上两个核心阶段，`mr` 函数还支持第三阶段（final），即通过 *finalFunc* 参数对合并后的结果做最后加工，得到真正想要的输出。\n\n##### 适用场景\n\n* 数据分散在多个数据源中，如多个分区或多个表；\n* 每份数据都可以先独立计算，再统一汇总；\n* 单个数据源上的计算逻辑相同；\n* 希望利用并行计算提升处理效率。\n\n#### 参数\n\n**ds** 数据源列表，必须是一个元组，元组的每个元素都是[数据源对象](https://docs.dolphindb.cn/zh/tutorials/general_computing.html#ariaid-title6)。 即使只有一个数据源，也需要写成元组形式。\n\n**mapFunc** 针对每个数据源的计算函数（即 map 函数）。 它只接收一个参数，即“从当前数据源列表中提取出来、可供计算的数据对象”。 如果计算函数本身包含多个参数，可以使用[部分应用](https://docs.dolphindb.cn/zh/progr/partial_app.html)将其转换为仅接收一个参数的函数，并将该函数作为 map 函数传给 *mapFunc*。map 函数调用的次数等于数据源的数量，其返回值为一个常规对象（标量，数据对，向量，矩阵，表，集合或字典）或一个元组（包含多个常规对象）。\n\n**reduceFunc** 可选，一个二元函数（即 reduce 函数），用于合并两个返回值。 这里的两个返回值，可能都来自 map 函数，也可能其中一个是前一个 reduce 函数的返回值。 系统会把上一步的合并结果继续与下一个 map 函数的返回值合并，直到所有 map 函数的返回值都被合并完。\n\n**finalFunc** 可选，用于生成最终输出的函数。 它只接收一个参数，即最后一次调用 reduce 函数的输出。 如果没有指定 reduce 函数但指定了 final 函数，系统先将所有 map 函数的结果合并成一个元组，然后将元组作为输入来调用 final 函数。\n\n**parallel** 可选，是否并行执行 map 函数，默认值为 true。 一般情况下，开启并行可以提升计算速度，但在以下情况可以考虑设为 false：\n\n* 单次 map 计算非常占内存；\n* 多个线程并发执行时可能引发线程安全问题； 例如，如果多个线程同时写入同一个文件，则可能会发生错误。\n\n#### 返回值\n\n* 如果指定了 *finalFunc*，返回 *finalFunc* 的结果；\n* 如果没有指定 *finalFunc*，但指定了 *reduceFunc*，返回 *reduceFunc*的最终结果；\n* 如果两者都没有指定，返回所有 *mapFunc* 的汇总结果，形式为一个元组。\n\n#### 例子\n\n例 1：计算多个分区中的全局均值和方差。\n\n```\n// 创建 catalog，并切换到该 catalog\ncreateCatalog\\(\"demo\"\\)\ngo\nuse catalog demo\n// 在当前 catalog 下创建分布式数据库和分区表\ncreate database mr\\_demo partitioned by VALUE\\(2024.01.01 2024.01.02 2024.01.03\\), engine='OLAP'\ngo\ncreate table mr\\_demo.pt \\(\n    date DATE,\n    id INT,\n    value DOUBLE\n\\)\npartitioned by date\n\n// 写入测试数据\ndata = table(\n    2024.01.01 2024.01.01 2024.01.01 2024.01.02 2024.01.02 2024.01.03 2024.01.03 as date,\n    1 2 3 4 5 6 7 as id,\n    10.0 20.0 30.0 40.0 50.0 60.0 70.0 as value\n)\ndemo.mr\\_demo.pt.append!\\(data\\)\n\n\n// 用 sqlDS 把查询转换成数据源列表\nds = sqlDS\\(&lt;select \\* from mr\\_demo.pt&gt;\\)\n\n\n// map：在每个分区中计算局部统计量\ndef statsMap(table){\n    x = table.value // 取表格 value 列的值\n    return [x.size(), sum(x), sum(pow(x, 2.0))] // 计算行数、值的总和、值的平方和\n}\n\n// reduce：把两个局部统计量逐项相加\ndef statsReduce(x, y){\n    return [x[0] + y[0], x[1] + y[1], x[2] + y[2]]\n}\n\n// final：根据汇总统计量计算全局均值和方差\ndef statsFinal(result){\n    count = result[0]\n    totalSum = result[1]\n    totalSquares = result[2]\n    avg = totalSum / count\n    variance = totalSquares / count - avg * avg\n    return table(avg as mean, variance as variance)\n}\n\n// 调用 mr\nresult = mr(ds, statsMap, statsReduce, statsFinal)\n\n// 查看结果\nresult\n```\n\n输出如下：\n\n| mean | variance |\n| ---- | -------- |\n| 40   | 400      |\n\n例 2：在多个数据源上计算最小二乘线性回归的结果。\n\n线性回归用于根据一个或多个自变量预测因变量。 若记因变量为 y，自变量矩阵为 X，则最小二乘法的目标是求出回归系数 beta，计算公式如下：\n\n```\nbeta = (X^T X)^(-1) X^T y\n```\n\n因此，完成回归计算的关键在于先得到整个数据集的 X^T X 和 X^T y。 当数据分布在多个数据源上时，可以先在每个数据源上计算局部的 Xi^T Xi 和 Xi^T yi，再将它们汇总为全局结果。 示例代码：\n\n```\ndef myOLSMap(table, yColName, xColNames, intercept){\n  if(intercept)\n      x = matrix(take(1.0, table.rows()), table[xColNames])\n  else\n      x = matrix(table[xColNames])\n  xt = x.transpose();\n  return xt.dot(x), xt.dot(table[yColName])\n}\n\ndef myOLSFinal(result){\n  xtx = result[0]\n  xty = result[1]\n  return xtx.inv().dot(xty)[0]\n}\n\ndef myOLSEx(ds, yColName, xColNames, intercept){\n  return mr(ds, myOLSMap{, yColName, xColNames, intercept}, +, myOLSFinal)\n}\n```\n\n* **map**：`myOLSMap` 用于对单个数据源执行局部计算。 其输入包括：\n\n  * *table*：当前数据源对应的数据表\n  * *yColName*：因变量列名\n  * *xColNames*：自变量列名\n  * *intercept*：指定是否包含截距项\n    该函数首先构造局部自变量矩阵 Xi，然后返回当前数据源的局部统计量：Xi^T Xi 和 Xi^T yi。\n\n* **reduce**：`+` 作为 reduce 函数，将各单个数据源的计算结果逐项相加。\n  * 例如两个分区分别返回：(X1^T X1, X1^T y1) 和 (X2^T X2, X2^T y2)，那么 reduce 后得到 (X1^T X1 + X2^T X2, X1^T y1 + X2^T y2)；\n  * 继续和下一个分区结果合并后，最终得到全局的 (X^T X, X^T y)。\n\n* **final**：`myOLSFinal` 用于处理 reduce 阶段的汇总结果，即根据最小二乘公式求出回归系数。\n  * *xtx* 表示汇总后的 X^T X；\n  * *xty* 表示汇总后的 X^T y；\n  * `xtx.inv()` 表示对矩阵 *xtx* 求逆；\n  * `xtx.inv().dot(xty)` 表示做矩阵乘法，对应公式 `(X^T X)^(-1) X^T y`。\n\n* `myOLSEx` 用于封装 `mr` 函数，执行 map → reduce → final 的计算逻辑。\n\n**Note:** 作为经常使用的分析工具，分布式最小二乘线性回归已经在内置函数 [olsEx](https://docs.dolphindb.cn/zh/funcs/o/olsEx.html) 中实现。\n"
    },
    "mrank": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mrank.html",
        "signatures": [
            {
                "full": "mrank(X, ascending, window, [ignoreNA=true], [tiesMethod='min'], [percent=false], [minPeriods])",
                "name": "mrank",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "ascending",
                        "name": "ascending"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "[ignoreNA=true]",
                        "name": "ignoreNA",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[tiesMethod='min']",
                        "name": "tiesMethod",
                        "optional": true,
                        "default": "'min'"
                    },
                    {
                        "full": "[percent=false]",
                        "name": "percent",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[minPeriods]",
                        "name": "minPeriods",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [mrank](https://docs.dolphindb.cn/zh/funcs/m/mrank.html)\n\n\n\n#### 语法\n\nmrank(X, ascending, window, \\[ignoreNA=true], \\[tiesMethod='min'], \\[percent=false], \\[minPeriods])\n\n窗口计算规则请参考：[mFunctions](https://docs.dolphindb.cn/zh/funcs/themes/mFunctions.html)\n\n#### 详情\n\n在给定长度（以元素个数或时间长度衡量）的滑动窗口内计算 *X* 元素在其对应窗口内的排名。\n\n#### 参数\n\n**X** 是一个向量/矩阵/表/元组（元素为标量或等长向量）/字典。\n\n**ascending** 是一个布尔值，表示是否按升序排序。默认值是 true。\n\n**window** 是大于等于 2 的正整型或 DURATION 标量。表示滑动窗口的长度。\n\n**Note:** 在流计算引擎中调用滑动窗口函数时，window 的上限为 102400。\n\n**ignoreNA** 是一个布尔值，表示是否忽略 NULL 值。true 表示忽略 NULL 值（默认值），false 表示 NULL 值参与排名，此时 NULL 值为最小值。\n\n**tiesMethod** 是一个字符串，表示窗口内若存在重复值时，排名如何选取。'min' 表示取最小排名，'max' 表示取最大排名，'average' 表示取排名的均值。\n\n**percent** 是一个布尔值，表示是否以百分比形式显示返回的排名，默认值为 false。\n\n**minPeriods** 是一个正整数。表示滑动窗口中最少包含的非 NULL 有效观测值数量。\n\n#### 返回值\n\n返回一个向量、矩阵或表，具体取决于输入参数 *X* 的形式。\n\n* 当 `percent=false`时，返回整数类型，表示元素在窗口内的排名位置(从0开始)。\n* 当 `percent=true` 时，返回浮点数类型的百分比值，范围在0到1之间。\n\n#### 例子\n\n```\nX = 3 2 4 4 4 NULL 1\n\nmrank(X, ascending=false, window=3, ignoreNA=true);\n// output: [,,0,0,0,,1]\n\nmrank(X, ascending=false, window=3, ignoreNA=true, minPeriods=2);\n// output: [,1,0,0,0,,1]\n\nmrank(X, ascending=false, window=3, ignoreNA=false, tiesMethod='max');\n// output: [,,0,1,2,2,1]\n\nmrank(X, ascending=false, window=3, ignoreNA=false, tiesMethod='max', minPeriods=2);\n// output: [,1,0,1,2,2,1]\n\nmrank(X, ascending=false, window=3, ignoreNA=false, tiesMethod='min');\n// output: [,,0,0,0,2,1]\n\nmrank(X, ascending=false, window=3, ignoreNA=false, tiesMethod='min', minPeriods=3);\n// output: [,,0,0,0,,]\n\nmrank(X, ascending=false, window=3, ignoreNA=false, tiesMethod='average');\n// output: [,,0,0.5,1,2,1]\n\nmrank(X, ascending=false, window=3, ignoreNA=false, tiesMethod='average', minPeriods=2);\n// output: [,1,0,0.5,1,2,1]\n```\n\n```\nm=matrix(1 2 5 3 4, 5 4 1 2 3);\nm;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 5  |\n| 2  | 4  |\n| 5  | 1  |\n| 3  | 2  |\n| 4  | 3  |\n\n```\nmrank(m, true, 3);\n```\n\n| #0 | #1 |\n| -- | -- |\n|    |    |\n|    |    |\n| 2  | 0  |\n| 1  | 1  |\n| 1  | 2  |\n\n```\nmrank(m, true, 3, percent=true);\n```\n\n| col1   | col2   |\n| ------ | ------ |\n|        |        |\n|        |        |\n| 1      | 0.3333 |\n| 0.6667 | 0.6667 |\n| 0.6667 | 1      |\n\n```\nm=matrix([1 4 2 4 5 7 4 3 2 5])\nm.rename!(2020.01.01..2020.01.10, [`A])\nm.setIndexedMatrix!()\nmrank(m,window=3d,percent = 1)\n```\n\n| label      | A      |\n| ---------- | ------ |\n| 2020.01.01 | 1      |\n| 2020.01.02 | 1      |\n| 2020.01.03 | 0.6667 |\n| 2020.01.04 | 0.6667 |\n| 2020.01.05 | 1      |\n| 2020.01.06 | 1      |\n| 2020.01.07 | 0.3333 |\n| 2020.01.08 | 0.3333 |\n| 2020.01.09 | 0.3333 |\n| 2020.01.10 | 1      |\n\n```\nmrank(m, window=1w, percent = 1)\n```\n\n| label      | A      |\n| ---------- | ------ |\n| 2020.01.01 | 1      |\n| 2020.01.02 | 1      |\n| 2020.01.03 | 0.6667 |\n| 2020.01.04 | 0.75   |\n| 2020.01.05 | 1      |\n| 2020.01.06 | 1      |\n| 2020.01.07 | 0.4286 |\n| 2020.01.08 | 0.2857 |\n| 2020.01.09 | 0.1429 |\n| 2020.01.10 | 0.7143 |\n\n相关函数：[rank](https://docs.dolphindb.cn/zh/funcs/r/rank.html)\n"
    },
    "mskew": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mskew.html",
        "signatures": [
            {
                "full": "mskew(X, window, [biased=true], [minPeriods])",
                "name": "mskew",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "[biased=true]",
                        "name": "biased",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[minPeriods]",
                        "name": "minPeriods",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [mskew](https://docs.dolphindb.cn/zh/funcs/m/mskew.html)\n\n\n\n#### 语法\n\nmskew(X, window, \\[biased=true], \\[minPeriods])\n\n窗口计算规则请参考：[mFunctions](https://docs.dolphindb.cn/zh/funcs/themes/mFunctions.html)\n\n#### 详情\n\n在给定长度（以元素个数或时间长度衡量）的滑动窗口内计算 *X* 的斜度。\n\n#### 参数\n\n**X** 是一个向量/矩阵/表/元组（元素为标量或等长向量）/字典。\n\n**window** 是大于等于 2 的正整型或 DURATION 标量。表示滑动窗口的长度。\n\n**Note:** 在流计算引擎中调用滑动窗口函数时，window 的上限为 102400。\n\n**biased** 是一个布尔值，表示是否是有偏估计。默认值为 true，表示有偏估计。\n\n**minPeriods** 是一个正整数。表示滑动窗口中最少包含的非 NULL 有效观测值数量。\n\n#### 返回值\n\n* 输入为向量时，返回一个与输入等长的 DOUBLE 类型向量。\n* 输入为矩阵时，返回一个与输入矩阵同维度的矩阵，每列分别计算。\n* 输入为表时，返回一个与输入表结构相同的表。\n* 输入为元组时，返回对应的元组结构。\n\n#### 例子\n\n```\nmskew(1 2 3 10 100 4 3, 3);\n// output\n[,,0,0.665469,0.693810, 0.697217,0.706851]\n```\n\n```\nm=matrix(1 6 2 9 4 5 100, 100 11 12 18 23 21 10);\nm;\n```\n\n| #0  | #1  |\n| --- | --- |\n| 1   | 100 |\n| 6   | 11  |\n| 2   | 12  |\n| 9   | 18  |\n| 4   | 23  |\n| 5   | 21  |\n| 100 | 10  |\n\n```\nmskew(m,3);\n```\n\n| #0                 | #1                 |\n| ------------------ | ------------------ |\n|                    |                    |\n|                    |                    |\n| 0.595170064139498  | 0.706802122668126  |\n| -0.172800544078651 | 0.65201211704403   |\n| 0.470330460336986  | -0.110780117654834 |\n| 0.595170064139498  | -0.239063146929565 |\n| 0.706845142811354  | -0.642723256123865 |\n\n```\nm.rename!(date(2020.04.06)+1..7, `col1`col2)\nm.setIndexedMatrix!()\nmskew(m, 3d)\n```\n\n| label      | col1    | col2    |\n| ---------- | ------- | ------- |\n| 2020.04.07 |         |         |\n| 2020.04.08 | 0       | 0       |\n| 2020.04.09 | 0.5952  | 0.7068  |\n| 2020.04.10 | -0.1728 | 0.652   |\n| 2020.04.11 | 0.4703  | -0.1108 |\n| 2020.04.12 | 0.5952  | -0.2391 |\n| 2020.04.13 | 0.7068  | -0.6427 |\n\n```\nmskew(m, 1w)\n```\n\n| label      | col1   | col2   |\n| ---------- | ------ | ------ |\n| 2020.04.07 |        |        |\n| 2020.04.08 | 0      | 0      |\n| 2020.04.09 | 0.5952 | 0.7068 |\n| 2020.04.10 | 0.2743 | 1.1373 |\n| 2020.04.11 | 0.4079 | 1.4398 |\n| 2020.04.12 | 0.3298 | 1.7107 |\n| 2020.04.13 | 2.0188 | 1.9363 |\n\n相关函数：[skew](https://docs.dolphindb.cn/zh/funcs/s/skew.html)\n"
    },
    "mskewTopN": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mskewTopN.html",
        "signatures": [
            {
                "full": "mskewTopN(X, S, window, top, [biased=true], [ascending=true], [tiesMethod='latest'])",
                "name": "mskewTopN",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "S",
                        "name": "S"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "top",
                        "name": "top"
                    },
                    {
                        "full": "[biased=true]",
                        "name": "biased",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[tiesMethod='latest']",
                        "name": "tiesMethod",
                        "optional": true,
                        "default": "'latest'"
                    }
                ]
            }
        ],
        "markdown": "### [mskewTopN](https://docs.dolphindb.cn/zh/funcs/m/mskewTopN.html)\n\n\n\n#### 语法\n\nmskewTopN(X, S, window, top, \\[biased=true], \\[ascending=true], \\[tiesMethod='latest'])\n\n参数说明和窗口计算规则请参考：[mTopN](https://docs.dolphindb.cn/zh/funcs/themes/TopN.html)\n\n#### 详情\n\n在给定长度（以元素个数衡量）的滑动窗口内，根据 *ascending* 指定的排序方式将 *X* 按照 *S* 进行稳定排序后，取前 *top* 个元素计算斜度。\n\n#### 参数\n\n**biased** 是一个布尔值，表示是否是有偏估计。默认值为 true，表示有偏估计。\n\n#### 返回值\n\n* 输入为向量时，返回一个与输入等长的 DOUBLE 类型向量。\n* 输入为矩阵时，返回一个与输入矩阵同维度的矩阵，每列分别计算。\n* 输入为表时，返回一个与输入表结构相同的表。\n* 输入为元组时，返回对应的元组结构。\n\n#### 例子\n\n```\nX=1 2 3 10 100 4 3\nS = 0.3 0.5 0.1 0.1 0.5 0.2 0.4\nmskewTopN(X, S, 6, 4)\n// output\n[,0,0,1.01,1.13,0.79,1.08]\n\nX = matrix(1..10, 11..20)\nS = matrix(2022.01.01 2022.02.03 2022.01.23 NULL 2021.12.29 2022.01.20 2022.01.23 2022.01.22 2022.01.24 2022.01.24, NULL 2022.02.03 2022.01.23 2022.04.06 NULL 2022.02.03 2022.02.03 2022.02.05 2022.02.08 2022.02.03)\nmskewTopN(X, S, 6, 4)\n```\n\n| col1    | col2    |\n| :------ | :------ |\n|         |         |\n| 0       |         |\n| 0       | 0       |\n| 0       | 0       |\n| 0.4347  | 0       |\n| -0.278  | 0.4347  |\n| -0.4347 | 0       |\n| 0       | -0.6872 |\n| 0       | 0       |\n| 0       | 0.4347  |\n\n```\nsymbol = [\"A\",\"A\",\"A\",\"B\",\"A\",\"A\",\"B\",\"A\",\"A\",\"B\",\"B\",\"B\",\"A\",\"B\",\"A\",\"B\",\"B\",\"A\",\"B\",\"A\"]\ntime = temporalAdd(2023.07.03T09:30:00.000,[10,20,40,60,70,80,90,140,160,170,180,190,200,210,220,230,250,360,390,400],\"ms\")\nprice = [28.11,28.25,28.44,52.31,28.98,28.89,52.22,28.16,28.52,52.62,52.56,52.2,28.01,52.43,28.57,52.42,52.19,28.16,52.84,28.18]\nqty = [1900,3300,100,3000,3500,800,3400,4400,3900,4600,2200,2100,2300,4100,400,300,3100,2500,1000,2700]\nBSFlag = [1,0,1,1,0,0,1,0,0,0,0,1,0,1,0,0,1,1,1,1]\nt = table(time, symbol, price, qty, BSFlag)\nselect time,symbol,BSFlag,mskewTopN(price, qty, 8, 5) as mskewTop5Price from t context by symbol,BSFlag\n```\n\n| time                    | symbol | BSFlag | mskewTop5Price |\n| ----------------------- | ------ | ------ | -------------- |\n| 2023.07.03T09:30:00.020 | A      | 0      |                |\n| 2023.07.03T09:30:00.070 | A      | 0      | 0              |\n| 2023.07.03T09:30:00.080 | A      | 0      | -0.6667        |\n| 2023.07.03T09:30:00.140 | A      | 0      | 0              |\n| 2023.07.03T09:30:00.160 | A      | 0      | 0.0904         |\n| 2023.07.03T09:30:00.200 | A      | 0      | -0.0986        |\n| 2023.07.03T09:30:00.220 | A      | 0      | -0.1794        |\n| 2023.07.03T09:30:00.010 | A      | 1      |                |\n| 2023.07.03T09:30:00.040 | A      | 1      | 0              |\n| 2023.07.03T09:30:00.360 | A      | 1      | 0.6448         |\n| 2023.07.03T09:30:00.400 | A      | 1      | 1.0153         |\n| 2023.07.03T09:30:00.170 | B      | 0      |                |\n| 2023.07.03T09:30:00.180 | B      | 0      | 0              |\n| 2023.07.03T09:30:00.230 | B      | 0      | -0.4451        |\n| 2023.07.03T09:30:00.060 | B      | 1      |                |\n| 2023.07.03T09:30:00.090 | B      | 1      | 0              |\n| 2023.07.03T09:30:00.190 | B      | 1      | 0.6156         |\n| 2023.07.03T09:30:00.210 | B      | 1      | 0.5605         |\n| 2023.07.03T09:30:00.250 | B      | 1      | 0.8565         |\n| 2023.07.03T09:30:00.390 | B      | 1      | 1.3966         |\n\n相关函数：[mskew](https://docs.dolphindb.cn/zh/funcs/m/mskew.html)\n"
    },
    "mslr": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mslr.html",
        "signatures": [
            {
                "full": "mslr(Y, X, window, [minPeriods])",
                "name": "mslr",
                "parameters": [
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "[minPeriods]",
                        "name": "minPeriods",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [mslr](https://docs.dolphindb.cn/zh/funcs/m/mslr.html)\n\n\n\n#### 语法\n\nmslr(Y, X, window, \\[minPeriods])\n\n#### 详情\n\n在长度为 *window* 的滑动窗口中，将因变量 *Y* 与自变量 *X* 进行普通最小二乘回归。返回一个元组，其中第一个元素为截距，第二个元素为斜率。\n\n* 如果没有指定 *minPeriods*，则默认值为 *window*。若窗口中的非 NULL 有效观测值数量小于 *window*，该窗口结果为 NULL；\n* 如果指定了 *minPeriods*，若窗口中的非 NULL 有效观测值数量小于 *minPeriods*，该窗口结果为 NULL。\n\n#### 参数\n\n**Y** 是一个向量，表示因变量。\n\n**X** 是一个向量，表示自变量。\n\n**window** 是一个正整数，表示滑动窗口的长度。\n\n**minPeriods** 是一个正整数。如果一个滑动窗口中的非 NULL 有效观测值数量小于 *minPeriods*，那么该窗口的结果为 NULL。\n\n#### 返回值\n\n返回一个元组，包含两个元素：\n\n* 第一个元素表示截距，类型为 DOUBLE。\n* 第二个元素表示斜率，类型为 DOUBLE。\n\n#### 例子\n\n```\nY=1 4 3 9 5 4\nX=12 31 29 88 67 76\nmslr(Y,X,4);\n\n//output: ([,,,0.177052,0.712557,0.15],[,,,0.101824,0.084418,0.078462])\n```\n"
    },
    "mstd": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mstd.html",
        "signatures": [
            {
                "full": "mstd(X, window, [minPeriods])",
                "name": "mstd",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "[minPeriods]",
                        "name": "minPeriods",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [mstd](https://docs.dolphindb.cn/zh/funcs/m/mstd.html)\n\n\n\n#### 语法\n\nmstd(X, window, \\[minPeriods])\n\n窗口计算规则请参考：[mFunctions](https://docs.dolphindb.cn/zh/funcs/themes/mFunctions.html)\n\n#### 详情\n\n在给定长度（以元素个数或时间长度衡量）的滑动窗口内计算 *X* 的样本标准差。\n\n#### 参数\n\n**X** 是一个向量/矩阵/表/元组（元素为标量或等长向量）/字典。\n\n**window** 是大于等于 2 的正整型或 DURATION 标量。表示滑动窗口的长度。\n\n**Note:** 在流计算引擎中调用滑动窗口函数时，window 的上限为 102400。\n\n**minPeriods** 是一个正整数。表示滑动窗口中最少包含的非 NULL 有效观测值数量。\n\n#### 返回值\n\n* 输入为向量时，返回一个与输入等长的 DOUBLE 类型向量。\n* 输入为矩阵时，返回一个与输入矩阵同维度的矩阵，每列分别计算。\n* 输入为表时，返回一个与输入表结构相同的表。\n* 输入为元组时，返回对应的元组结构。\n\n#### 例子\n\n```\nmstd(1 2 5 4 3, 3);\n// output: [,,2.081666,1.527525,1]\n\nmstd(1 2 5 4 3, 3, 2);\n// output: \n[,0.707107,2.081666,1.527525,1]\n```\n\n```\nm=matrix(1 6 2 9 4 5, 11 12 18 23 21 10);\nm;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 11 |\n| 6  | 12 |\n| 2  | 18 |\n| 9  | 23 |\n| 4  | 21 |\n| 5  | 10 |\n\n```\nmstd(m,3);\n```\n\n<table id=\"table_sng_5hn_ryb\"><thead><tr><th align=\"left\">\n\n\\#0\n\n</th><th align=\"left\">\n\n\\#1\n\n</th></tr></thead><tbody><tr><td align=\"left\">\n\n</td><td align=\"left\">\n\n</td></tr><tr><td align=\"left\">\n\n</td><td align=\"left\">\n\n</td></tr><tr><td align=\"left\">\n\n2.645751311064591\n\n</td><td align=\"left\">\n\n3.78593889720018\n\n</td></tr><tr><td align=\"left\">\n\n3.511884584284247\n\n</td><td align=\"left\">\n\n5.507570547286101\n\n</td></tr><tr><td align=\"left\">\n\n3.605551275463989\n\n</td><td align=\"left\">\n\n2.516611478423591\n\n</td></tr><tr><td align=\"left\">\n\n2.645751311064591\n\n</td><td align=\"left\">\n\n7\n\n</td></tr></tbody>\n</table>```\nm=matrix(1 NULL 4 NULL 8 6 , 9 NULL NULL 10 NULL 2)\nm.rename!(date(2020.04.06)+1..6, `col1`col2)\nm.setIndexedMatrix!()\nmstd(m,4d)\n```\n\n| label      | col1   | col2   |\n| ---------- | ------ | ------ |\n| 2020.04.07 |        |        |\n| 2020.04.08 |        |        |\n| 2020.04.09 | 2.1213 |        |\n| 2020.04.10 | 2.1213 | 0.7071 |\n| 2020.04.11 | 2.8284 |        |\n| 2020.04.12 | 2      | 5.6569 |\n\n```\nmstd(m,1w)\n```\n\n| label      | col1   | col2   |\n| ---------- | ------ | ------ |\n| 2020.04.07 |        |        |\n| 2020.04.08 |        |        |\n| 2020.04.09 | 2.1213 |        |\n| 2020.04.10 | 2.1213 | 0.7071 |\n| 2020.04.11 | 3.5119 | 0.7071 |\n| 2020.04.12 | 2.9861 | 4.3589 |\n\n相关函数：[mmin](https://docs.dolphindb.cn/zh/funcs/m/mmin.html), [mmax](https://docs.dolphindb.cn/zh/funcs/m/mmax.html), [mavg](https://docs.dolphindb.cn/zh/funcs/m/mavg.html), [msum](https://docs.dolphindb.cn/zh/funcs/m/msum.html), [mvar](https://docs.dolphindb.cn/zh/funcs/m/mvar.html)\n"
    },
    "mstdp": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mstdp.html",
        "signatures": [
            {
                "full": "mstdp(X, window, [minPeriods])",
                "name": "mstdp",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "[minPeriods]",
                        "name": "minPeriods",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [mstdp](https://docs.dolphindb.cn/zh/funcs/m/mstdp.html)\n\n\n\n#### 语法\n\nmstdp(X, window, \\[minPeriods])\n\n窗口计算规则请参考：[mFunctions](https://docs.dolphindb.cn/zh/funcs/themes/mFunctions.html)\n\n#### 详情\n\n在给定长度（以元素个数或时间长度衡量）的滑动窗口内计算 *X* 的总体标准差。\n\n#### 参数\n\n**X** 是一个向量/矩阵/表/元组（元素为标量或等长向量）/字典。\n\n**window** 是大于等于 2 的正整型或 DURATION 标量。表示滑动窗口的长度。\n\n**Note:** 在流计算引擎中调用滑动窗口函数时，window 的上限为 102400。\n\n**minPeriods** 是一个正整数。表示滑动窗口中最少包含的非 NULL 有效观测值数量。\n\n#### 返回值\n\n* 输入为向量时，返回一个与输入等长的 DOUBLE 类型向量。\n* 输入为矩阵时，返回一个与输入矩阵同维度的矩阵，每列分别计算。\n* 输入为表时，返回一个与输入表结构相同的表。\n* 输入为元组时，返回对应的元组结构。\n\n#### 例子\n\n```\nmstdp(1 2 5 4 3, 3);\n// output: [,,1.699673171197595,1.247219128924647,0.816496580927726]\n\nmstdp(1 2 5 4 3, 3, 2);\n// output: [,0.5,1.699673171197595,1.247219128924647,0.816496580927726]\n\nm=matrix(1 6 2 9 4 5, 11 12 18 23 21 10);\nm;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 11 |\n| 6  | 12 |\n| 2  | 18 |\n| 9  | 23 |\n| 4  | 21 |\n| 5  | 10 |\n\n```\nmstdp(m,3);\n```\n\n| #0                | #1                |\n| ----------------- | ----------------- |\n|                   |                   |\n|                   |                   |\n| 2.160246899469287 | 3.091206165165233 |\n| 2.867441755680875 | 4.496912521077346 |\n| 2.943920288775949 | 2.054804667656331 |\n| 2.160246899469287 | 5.715476066494082 |\n\n```\nm=matrix(1 NULL 4 NULL 8 6 , 9 NULL NULL 10 NULL 2)\nm.rename!(date(2020.04.06)+1..6, `col1`col2)\nm.setIndexedMatrix!()\nmstdp(m,4d)\n```\n\n| label      | col1  | col2 |\n| ---------- | ----- | ---- |\n| 2020.04.07 | 0     | 0    |\n| 2020.04.08 | 0     | 0    |\n| 2020.04.09 | 1.5   | 0    |\n| 2020.04.10 | 1.5   | 0.5  |\n| 2020.04.11 | 2     | 0    |\n| 2020.04.12 | 1.633 | 4    |\n\n```\nmstdp(m,1w)\n```\n\n| label      | col1   | col2  |\n| ---------- | ------ | ----- |\n| 2020.04.07 | 0      | 0     |\n| 2020.04.08 | 0      | 0     |\n| 2020.04.09 | 1.5    | 0     |\n| 2020.04.10 | 1.5    | 0.5   |\n| 2020.04.11 | 2.8674 | 0.5   |\n| 2020.04.12 | 2.586  | 3.559 |\n\n相关函数：[mstd](https://docs.dolphindb.cn/zh/funcs/m/mstd.html)\n"
    },
    "mstdpTopN": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mstdpTopN.html",
        "signatures": [
            {
                "full": "mstdpTopN(X, S, window, top, [ascending=true], [tiesMethod='oldest'])",
                "name": "mstdpTopN",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "S",
                        "name": "S"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "top",
                        "name": "top"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[tiesMethod='oldest']",
                        "name": "tiesMethod",
                        "optional": true,
                        "default": "'oldest'"
                    }
                ]
            }
        ],
        "markdown": "### [mstdpTopN](https://docs.dolphindb.cn/zh/funcs/m/mstdpTopN.html)\n\n\n\n#### 语法\n\nmstdpTopN(X, S, window, top, \\[ascending=true], \\[tiesMethod='oldest'])\n\n参数说明和窗口计算规则请参考：[mTopN](https://docs.dolphindb.cn/zh/funcs/themes/TopN.html)\n\n#### 详情\n\n在给定长度（以元素个数衡量）的滑动窗口内，根据 *ascending* 指定的排序方式将 *X* 按照 *S* 进行稳定排序后，取前 *top* 个元素计算总体标准差。\n\n#### 返回值\n\n* 输入为向量时，返回一个与输入等长的 DOUBLE 类型向量。\n* 输入为矩阵时，返回一个与输入矩阵同维度的矩阵，每列分别计算。\n* 输入为表时，返回一个与输入表结构相同的表。\n* 输入为元组时，返回对应的元组结构。\n\n#### 例子\n\n```\nX = 1..7\nS = 0.3 0.5 0.1 0.1 0.5 0.2 0.4\nmstdpTopN(X, S, 4, 2)\n// output: [0,0.5,1,0.5,0.5,0.5,1]\n\nX = NULL 1 2 3 4 NULL 5\nS = 3 5 1 1 5 2 4\nmstdpTopN(X, S, 4, 2)\n// output: [,0,0,0.5,0.5,0.5,0]\n\nX = matrix(1..5, 6..10)\nS = 2022.01.01 2022.02.03 2022.01.23 2022.04.06 2021.12.29\nmstdpTopN(X, S, 3, 2)\n```\n\n| #0  | #1  |\n| --- | --- |\n| 0   | 0   |\n| 0.5 | 0.5 |\n| 1   | 1   |\n| 0.5 | 0.5 |\n| 1   | 1   |\n\n```\nX = matrix(1..5, 6..10)\nS = matrix(2022.01.01 2022.02.03 2022.01.23 NULL 2021.12.29,NULL 2022.02.03 2022.01.23 2022.04.06 NULL)\nmstdpTopN(X, S, 3, 2)\n```\n\n| #0  | #1  |\n| --- | --- |\n| 0   |     |\n| 0.5 | 0   |\n| 1   | 0.5 |\n| 0.5 | 0.5 |\n| 1   | 0.5 |\n\n相关函数：[mstdp](https://docs.dolphindb.cn/zh/funcs/m/mstdp.html)\n"
    },
    "mstdTopN": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mstdTopN.html",
        "signatures": [
            {
                "full": "mstdTopN(X, S, window, top, [ascending=true], [tiesMethod='oldest'])",
                "name": "mstdTopN",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "S",
                        "name": "S"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "top",
                        "name": "top"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[tiesMethod='oldest']",
                        "name": "tiesMethod",
                        "optional": true,
                        "default": "'oldest'"
                    }
                ]
            }
        ],
        "markdown": "### [mstdTopN](https://docs.dolphindb.cn/zh/funcs/m/mstdTopN.html)\n\n\n\n#### 语法\n\nmstdTopN(X, S, window, top, \\[ascending=true], \\[tiesMethod='oldest'])\n\n参数说明和窗口计算规则请参考：[mTopN](https://docs.dolphindb.cn/zh/funcs/themes/TopN.html)\n\n#### 详情\n\n在给定长度（以元素个数衡量）的滑动窗口内，根据 *ascending* 指定的排序方式将 *X* 按照 *S* 进行稳定排序后，取前 *top* 个元素计算样本标准差。\n\n#### 返回值\n\n* 输入为向量时，返回一个与输入等长的 DOUBLE 类型向量。\n* 输入为矩阵时，返回一个与输入矩阵同维度的矩阵，每列分别计算。\n* 输入为表时，返回一个与输入表结构相同的表。\n* 输入为元组时，返回对应的元组结构。\n\n#### 例子\n\n```\nX = 1..7\nS = 0.3 0.5 0.1 0.1 0.5 0.2 0.4\nmstdTopN(X, S, 4, 2)\n// output: \n[,0.707106781186548,1.414213562373095,0.707106781186548,0.707106781186548,0.707106781186548,1.414213562373095]\n\nX = NULL 1 2 3 4 NULL 5\nS = 3 5 1 1 5 2 4\nmstdTopN(X, S, 4, 2)\n// output: [,,,0.707106781186548,0.707106781186548,0.707106781186548,]\n\nX = matrix(1..5, 6..10)\nS = 2022.01.01 2022.02.03 2022.01.23 2022.04.06 2021.12.29\nmstdTopN(X, S, 3, 2)\n```\n\n| #0                | #1                |\n| ----------------- | ----------------- |\n|                   |                   |\n| 0.707106781186548 | 0.707106781186548 |\n| 1.414213562373095 | 1.414213562373095 |\n| 0.707106781186548 | 0.707106781186548 |\n| 1.414213562373095 | 1.414213562373095 |\n\n```\nX = matrix(1..5, 6..10)\nS = matrix(2022.01.01 2022.02.03 2022.01.23 NULL 2021.12.29,NULL 2022.02.03 2022.01.23 2022.04.06 NULL)\nmstdTopN(X, S, 3, 2)\n```\n\n| #0     | #1     |\n| ------ | ------ |\n|        |        |\n| 0.7071 |        |\n| 1.4142 | 0.7071 |\n| 0.7071 | 0.7071 |\n| 1.4142 | 0.7071 |\n\n相关函数：[mstd](https://docs.dolphindb.cn/zh/funcs/m/mstd.html)\n"
    },
    "msum": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/msum.html",
        "signatures": [
            {
                "full": "msum(X, window, [minPeriods])",
                "name": "msum",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "[minPeriods]",
                        "name": "minPeriods",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [msum](https://docs.dolphindb.cn/zh/funcs/m/msum.html)\n\n\n\n#### 语法\n\nmsum(X, window, \\[minPeriods])\n\n窗口计算规则请参考：[mFunctions](https://docs.dolphindb.cn/zh/funcs/themes/mFunctions.html)\n\n#### 详情\n\n在给定长度（以元素个数或时间长度衡量）的滑动窗口内计算 *X* 的元素和。\n\n#### 参数\n\n**X** 是一个向量/矩阵/表/元组（元素为标量或等长向量）/字典。\n\n**window** 是大于等于 2 的正整型或 DURATION 标量。表示滑动窗口的长度。\n\n**Note:** 在流计算引擎中调用滑动窗口函数时，window 的上限为 102400。\n\n**minPeriods** 是一个正整数。表示滑动窗口中最少包含的非 NULL 有效观测值数量。\n\n#### 返回值\n\n* 输入为向量时，返回一个与输入等长的向量。\n* 输入为矩阵时，返回一个与输入矩阵同维度的矩阵，每列分别计算。\n* 输入为表时，返回一个与输入表结构相同的表。\n* 输入为元组时，返回对应的元组结构。\n\n#### 例子\n\n```\nX = 2 1 3 7 6 5 4\nY = 2 1 3 NULL 6 5 4\n\nmsum(X, 3);\n// output: [,,6,11,16,18,15]\n\nmsum(Y, 3);\n// output: [,,6,4,9,11,15]\n\nmsum(Y, 3, minPeriods=1);\n// output: [2,3,6,4,9,11,15]\n```\n\n```\nm = matrix(1 NULL 4 NULL 8 6 , 9 NULL NULL 10 NULL 2)\nm.rename!(date(2020.04.06)+1..6, `col1`col2)\nm.setIndexedMatrix!()\nmsum(m, 3d) // 等价于 msum(m, 3)\n```\n\n| label      | col1 | col2 |\n| ---------- | ---- | ---- |\n| 2020.04.07 | 1    | 9    |\n| 2020.04.08 | 1    | 9    |\n| 2020.04.09 | 5    | 9    |\n| 2020.04.10 | 4    | 10   |\n| 2020.04.11 | 12   | 10   |\n| 2020.04.12 | 14   | 12   |\n\n```\nmsum(m, 1w)\n```\n\n| label      | col1 | col2 |\n| ---------- | ---- | ---- |\n| 2020.04.07 | 1    | 9    |\n| 2020.04.08 | 1    | 9    |\n| 2020.04.09 | 5    | 9    |\n| 2020.04.10 | 5    | 19   |\n| 2020.04.11 | 13   | 19   |\n| 2020.04.12 | 19   | 21   |\n\n相关函数：[sum](https://docs.dolphindb.cn/zh/funcs/s/sum.html)\n"
    },
    "msum2": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/msum2.html",
        "signatures": [
            {
                "full": "msum2(X, window, [minPeriods])",
                "name": "msum2",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "[minPeriods]",
                        "name": "minPeriods",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [msum2](https://docs.dolphindb.cn/zh/funcs/m/msum2.html)\n\n\n\n#### 语法\n\nmsum2(X, window, \\[minPeriods])\n\n窗口计算规则请参考：[mFunctions](https://docs.dolphindb.cn/zh/funcs/themes/mFunctions.html)\n\n#### 详情\n\n在给定长度（以元素个数或时间长度衡量）的滑动窗口内计算 *X* 元素的平方和。请注意，该函数的返回值是 DOUBLE 类型。\n\n#### 参数\n\n**X** 是一个向量/矩阵/表/元组（元素为标量或等长向量）/字典。\n\n**window** 是大于等于 2 的正整型或 DURATION 标量。表示滑动窗口的长度。\n\n**Note:** 在流计算引擎中调用滑动窗口函数时，window 的上限为 102400。\n\n**minPeriods** 是一个正整数。表示滑动窗口中最少包含的非 NULL 有效观测值数量。\n\n#### 返回值\n\n* 输入为向量时，返回一个与输入等长的向量。\n* 输入为矩阵时，返回一个与输入矩阵同维度的矩阵，每列分别计算。\n* 输入为表时，返回一个与输入表结构相同的表。\n* 输入为元组时，返回对应的元组结构。\n\n#### 例子\n\n```\nX = 2 1 3 7 6 5 4\nY = 2 1 3 NULL 6 5 4\n\nmsum2(X, 3)\n// output: [,,14,59,94,110,77]\n\nmsum2(Y, 3)\n// output: [,,14,10,45,61,77]\n\nmsum2(Y, 3, minPeriods=1)\n// output: [4,5,14,10,45,61,77]\n\nm = matrix(1 NULL 4 NULL 8 6 , 9 NULL NULL 10 NULL 2)\nm.rename!(date(2021.08.16)+1..6, `col1`col2)\nm.setIndexedMatrix!()\nmsum2(m, 3d)  // 等价于 msum2(m, 3)\n```\n\n| label      | col1 | col2 |\n| ---------- | ---- | ---- |\n| 2021.08.17 | 1    | 81   |\n| 2021.08.18 | 1    | 81   |\n| 2021.08.19 | 17   | 81   |\n| 2021.08.20 | 16   | 100  |\n| 2021.08.21 | 80   | 100  |\n| 2021.08.22 | 100  | 104  |\n\n相关函数：[sum2](https://docs.dolphindb.cn/zh/funcs/s/sum2.html)\n"
    },
    "msumTopN": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/msumTopN.html",
        "signatures": [
            {
                "full": "msumTopN(X, S, window, top, [ascending=true], [tiesMethod='oldest'])",
                "name": "msumTopN",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "S",
                        "name": "S"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "top",
                        "name": "top"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[tiesMethod='oldest']",
                        "name": "tiesMethod",
                        "optional": true,
                        "default": "'oldest'"
                    }
                ]
            }
        ],
        "markdown": "### [msumTopN](https://docs.dolphindb.cn/zh/funcs/m/msumTopN.html)\n\n\n\n#### 语法\n\nmsumTopN(X, S, window, top, \\[ascending=true], \\[tiesMethod='oldest'])\n\n参数说明和窗口计算规则请参考：[mTopN](https://docs.dolphindb.cn/zh/funcs/themes/TopN.html)\n\n#### 详情\n\n在给定长度（以元素个数衡量）的滑动窗口内，根据 *ascending* 指定的排序方式将 *X* 按照 *S* 进行稳定排序后，取前 *top* 个元素进行求和计算。\n\n#### 返回值\n\n* 输入为向量时，返回一个与输入等长的向量。\n* 输入为矩阵时，返回一个与输入矩阵同维度的矩阵，每列分别计算。\n* 输入为表时，返回一个与输入表结构相同的表。\n* 输入为元组时，返回对应的元组结构。\n\n#### 例子\n\n```\nX = 1..7\nS = 0.3 0.5 0.1 0.1 0.5 0.2 0.4\nmsumTopN(X, S, 4, 2)\n// output: [1,3,4,7,7,7,10]\n\nX = NULL 1 2 3 4 NULL 5\nS = 3 5 1 1 5 2 4\nmsumTopN(X, S, 4, 2)\n// output: [,1,2,5,5,5,3]\n\nX = matrix(1..5, 6..10)\nS = 2022.01.01 2022.02.03 2022.01.23 2022.04.06 2021.12.29\nmsumTopN(X, S, 3, 2)\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 6  |\n| 3  | 13 |\n| 4  | 14 |\n| 5  | 15 |\n| 8  | 18 |\n\n```\nX = matrix(1..5, 6..10)\nS = matrix(2022.01.01 2022.02.03 2022.01.23 NULL 2021.12.29,NULL 2022.02.03 2022.01.23 2022.04.06 NULL)\nmsumTopN(X, S, 3, 2)\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  |    |\n| 3  | 7  |\n| 4  | 15 |\n| 5  | 15 |\n| 8  | 17 |\n\n某行情数据的数据表，包含四列：股票代码 code，交易日期 date，收盘价 close 和交易量 volume。\n\n```\nt = table(take(`IBM`APPL, 20) as code, 2020.01.01 + 1..20 as date, rand(100,20) + 20 as volume, rand(10,20) + 100.0 as close)\n```\n\n| code | date       | volume | close |\n| ---- | ---------- | ------ | ----- |\n| IBM  | 2020.01.02 | 50     | 107   |\n| APPL | 2020.01.03 | 55     | 100   |\n| IBM  | 2020.01.04 | 75     | 100   |\n| APPL | 2020.01.05 | 84     | 108   |\n| IBM  | 2020.01.06 | 46     | 103   |\n| APPL | 2020.01.07 | 100    | 101   |\n| IBM  | 2020.01.08 | 96     | 100   |\n| APPL | 2020.01.09 | 84     | 102   |\n| IBM  | 2020.01.10 | 60     | 107   |\n| APPL | 2020.01.11 | 40     | 103   |\n| IBM  | 2020.01.12 | 92     | 105   |\n| APPL | 2020.01.13 | 61     | 106   |\n| IBM  | 2020.01.14 | 86     | 107   |\n| APPL | 2020.01.15 | 41     | 102   |\n| IBM  | 2020.01.16 | 85     | 103   |\n| APPL | 2020.01.17 | 72     | 105   |\n| IBM  | 2020.01.18 | 46     | 108   |\n| APPL | 2020.01.19 | 25     | 100   |\n| IBM  | 2020.01.20 | 114    | 102   |\n| APPL | 2020.01.21 | 50     | 104   |\n\n对每只股票计算窗口期内交易量最大的3条记录的收盘价之和。\n\n```\nselect code, date, msumTopN(close, volume, 5, 3, false) from t context by code\n```\n\n| code | date       | msumTopN\\_close |\n| ---- | ---------- | --------------- |\n| APPL | 2020.01.03 | 100             |\n| APPL | 2020.01.05 | 208             |\n| APPL | 2020.01.07 | 309             |\n| APPL | 2020.01.09 | 311             |\n| APPL | 2020.01.11 | 311             |\n| APPL | 2020.01.13 | 311             |\n| APPL | 2020.01.15 | 309             |\n| APPL | 2020.01.17 | 313             |\n| APPL | 2020.01.19 | 313             |\n| APPL | 2020.01.21 | 315             |\n| IBM  | 2020.01.02 | 107             |\n| IBM  | 2020.01.04 | 207             |\n| IBM  | 2020.01.06 | 310             |\n| IBM  | 2020.01.08 | 307             |\n| IBM  | 2020.01.10 | 307             |\n| IBM  | 2020.01.12 | 305             |\n| IBM  | 2020.01.14 | 312             |\n| IBM  | 2020.01.16 | 312             |\n| IBM  | 2020.01.18 | 315             |\n| IBM  | 2020.01.20 | 314             |\n\n相关函数：[msum](https://docs.dolphindb.cn/zh/funcs/m/msum.html)\n"
    },
    "mTopRange": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mtoprange.html",
        "signatures": [
            {
                "full": "mTopRange(X, window, [minPeriods])",
                "name": "mTopRange",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "[minPeriods]",
                        "name": "minPeriods",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [mTopRange](https://docs.dolphindb.cn/zh/funcs/m/mtoprange.html)\n\n#### 语法\n\nmTopRange(X, window, \\[minPeriods])\n\n窗口计算规则请参考：[mFunctions](https://docs.dolphindb.cn/zh/funcs/themes/mFunctions.html)\n\n#### 详情\n\n在给定长度（以元素个数或时间长度衡量）的滑动窗口内，统计每个元素 Xi 左侧相邻且连续小于它的元素个数。NULL 被视为最小值。\n\n若 *X* 是矩阵，在每列内进行上述计算。\n\n#### 参数\n\n**X** 是一个向量/矩阵/表/元组（元素为标量或等长向量）/字典。\n\n**window** 是大于等于 2 的正整型或 DURATION 标量。表示滑动窗口的长度。\n\n**Note:** 在流计算引擎中调用滑动窗口函数时，window 的上限为 102400。\n\n**minPeriods** 是一个正整数。表示滑动窗口中最少包含的非 NULL 有效观测值数量。\n\n#### 返回值\n\n* 输入为向量时，返回一个与输入等长的向量。\n* 输入为矩阵时，返回一个与输入矩阵同维度的矩阵，每列分别计算。\n* 输入为表时，返回一个与输入表结构相同的表。\n* 输入为元组时，返回对应的元组结构。\n\n#### 例子\n\n```\nx = [NULL, 3.1, NULL, 3.0, 2.9, 2.8, 3.1, NULL, 3.2]\nmTopRange(x, window=3)\n// output: [,,0,1,0,0,2,0,2]\n\nmTopRange(x, window=3, minPeriods=1)\n// output: [,1,0,1,0,0,2,0,2]\n\nx = [NULL, NULL, NULL, NULL, NULL, 2, NULL, NULL, 3.2]\ndate = [0, 1, 2, 3, 7, 8, 9, 10, 11] + 2020.01.01\nX = indexedSeries(date, x) \nmTopRange(X, 3d)\n```\n\n|            | #0 |\n| ---------- | -- |\n| 2020.01.01 |    |\n| 2020.01.02 |    |\n| 2020.01.03 |    |\n| 2020.01.04 |    |\n| 2020.01.08 |    |\n| 2020.01.09 | 1  |\n| 2020.01.10 | 0  |\n| 2020.01.11 | 0  |\n| 2020.01.12 | 2  |\n\n```\nm = matrix(1 2 3 NULL, 1 2 NULL 3, 1 3 NULL NULL, 1 2 3 4)\nmTopRange(m, 2)\n```\n\n| #0 | #1 | #2 | #3 |\n| -- | -- | -- | -- |\n|    |    |    |    |\n| 1  | 1  | 1  | 1  |\n| 1  | 0  | 0  | 1  |\n| 0  | 1  |    | 1  |\n\n"
    },
    "mul": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mul.html",
        "signatures": [
            {
                "full": "mul(X, Y)",
                "name": "mul",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [mul](https://docs.dolphindb.cn/zh/funcs/m/mul.html)\n\n\n\n#### 语法\n\nmul(X, Y) 或 X\\*Y\n\n#### 详情\n\n逐个元素地返回 *X* 和 *Y* 的乘积。\n\n#### 参数\n\n**X** 和 **Y** 可以是标量、数据对、向量或矩阵。如果 *X* 和 *Y* 的其中一个是数据对、向量或矩阵，另一个必须是标量或具有相同长度或维度的数据对、向量或矩阵。\n\n#### 返回值\n\n数据类型和形式取决于输入参数的类型和形式：\n\n* 标量 × 标量：返回一个标量。\n* 向量 × 标量/向量： 返回与输入向量等长的向量。\n* 矩阵 × 标量/向量/矩阵：返回与输入矩阵同维度的矩阵。\n\n#### 例子\n\n```\n1:2*3;\n// output:\n3 : 6\n\n1:2*3:4;\n// output:\n3 : 8\n\nx=1 2 3;\nx * 2;\n// output: [2,4,6]\n\ny=4 5 6;\nx * y;\n// output: [4,10,18]\n```\n\n```\nm1=1..6$2:3;\nm1;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1  | 3  | 5  |\n| 2  | 4  | 6  |\n\n```\nm1*2;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 2  | 6  | 10 |\n| 4  | 8  | 12 |\n\n```\nm2=6..1$2:3;\nm2;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 6  | 4  | 2  |\n| 5  | 3  | 1  |\n\n```\nm1*m2;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 6  | 12 | 10 |\n| 10 | 12 | 6  |\n"
    },
    "multinomialNB": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/multinomialNB.html",
        "signatures": [
            {
                "full": "multinomialNB(Y, X, [varSmoothing=1.0])",
                "name": "multinomialNB",
                "parameters": [
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[varSmoothing=1.0]",
                        "name": "varSmoothing",
                        "optional": true,
                        "default": "1.0"
                    }
                ]
            }
        ],
        "markdown": "### [multinomialNB](https://docs.dolphindb.cn/zh/funcs/m/multinomialNB.html)\n\n\n\n#### 语法\n\nmultinomialNB(Y, X, \\[varSmoothing=1.0])\n\n#### 详情\n\n使用多项式朴素贝叶斯（Multinomial Naive Bayes）算法对数据进行分类训练。\n\n#### 参数\n\n**Y** 是一个长度与 *X* 的行数相等的向量，表示 *X* 中每个样本对应的标签。\n\n**X** 是一个表，表示训练集。表中每一行表示一个样本，每一列表示一个特征。\n\n**varSmoothing** 是0到1之间的浮点数，表示平滑系数。\n\n#### 返回值\n\n返回一个字典，包含以下key：\n\n* modelName：模型名称，为字符串 \"MultinomialNB\"。\n\n* model：multinomialNB 的内部模型。\n\n* varSmoothing：训练时使用的平滑系数。\n\n#### 例子\n\n本例所用数据集 iris.data 可从 <https://archive.ics.uci.edu/ml/datasets/iris> 下载。\n\n```\nDATA_DIR = \"C:/DolphinDB/Data\"\nt = loadText(DATA_DIR+\"/iris.data\")\nt.rename!(`col0`col1`col2`col3`col4, `sepalLength`sepalWidth`petalLength`petalWidth`class)\nt[`classType] = take(0, t.size())\nupdate t set classType = 1 where class = \"Iris-versicolor\"\nupdate t set classType = 2 where class = \"Iris-virginica\"\n\ntraining = select sepalLength, sepalWidth, petalLength, petalWidth from t\nlabels = t.classType\n\nmodel = multinomialNB(labels, training);\n\npredict(model, training);\n```\n"
    },
    "multiTableRepartitionDS": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/multiTableRepartitionDS.html",
        "signatures": [
            {
                "full": "multiTableRepartitionDS(query, [column], [partitionType], [partitionScheme], [local=true])",
                "name": "multiTableRepartitionDS",
                "parameters": [
                    {
                        "full": "query",
                        "name": "query"
                    },
                    {
                        "full": "[column]",
                        "name": "column",
                        "optional": true
                    },
                    {
                        "full": "[partitionType]",
                        "name": "partitionType",
                        "optional": true
                    },
                    {
                        "full": "[partitionScheme]",
                        "name": "partitionScheme",
                        "optional": true
                    },
                    {
                        "full": "[local=true]",
                        "name": "local",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [multiTableRepartitionDS](https://docs.dolphindb.cn/zh/funcs/m/multiTableRepartitionDS.html)\n\n\n\n#### 语法\n\nmultiTableRepartitionDS(query, \\[column], \\[partitionType], \\[partitionScheme], \\[local=true])\n\n#### 详情\n\n使用相同的分区类型和分区方案对多个表重新划分数据源。\n\n如果没有指定 *column*, *partitionType* 和 *partitionScheme*，该函数将根据各表原来的分区类型和分区方案划分数据源。相当于 *query* 中的每个元代码应用到 [sqlDS](https://docs.dolphindb.cn/zh/funcs/s/sqlDS.html) 函数，再将结果合并。\n\n#### 参数\n\n**query** 是一个元组，其中每个元素都是 SQL 查询的元代码，并且每个 SQL 查询表示的数据表结构（包括列名和各列的数据类型）必须完全相同。\n\n**column** 是一个字符串，表示 *query* 中的一个列名。*repartitionDS* 函数会根据该列划分数据源。\n\n**partitionType** 表示分区类型，它的取值可以是 RANGE 或 VALUE。\n\n**partitionScheme** 是一个向量，表示分区方案。\n\n**local** 是一个布尔值，表示是否将数据源获取到当前节点进行计算。默认值为 true。\n\n#### 返回值\n\n返回一个元组，包含一组数据源。\n\n#### 例子\n\n```\nn=100000\ndate=rand(2019.06.01..2019.06.05,n)\nsym=rand(`AAPL`MSFT`GOOG,n)\nprice=rand(1000.0,n)\nt1=table(date,sym,price)\ndb=database(\"dfs://value\",VALUE,2019.06.01..2019.06.05)\ndb.createPartitionedTable(t1,`pt1,`date).append!(t1);\n\nn=100000\ndate=rand(2019.06.01..2019.06.05,n)\nsym=rand(`AAPL`MSFT`GOOG,n)\nprice=rand(1000.0,n)\nqty=rand(500,n)\nt2=table(date,sym,price,qty)\ndb1=database(\"\",VALUE,2019.06.01..2019.06.05)\ndb2=database(\"\",VALUE,`AAPL`MSFT`GOOG)\ndb=database(\"dfs://compo\",COMPO,[db1,db2])\ndb.createPartitionedTable(t2,`pt2,`date`sym).append!(t2);\n\npt1=loadTable(\"dfs://value\",\"pt1\")\npt2=loadTable(\"dfs://compo\",\"pt2\");\n```\n\n例1. 根据原有的分区方案划分数据源，不指定 *column*, *partitionType*和 *partitionScheme*\n\n```\nds=multiTableRepartitionDS(query=[<select * from pt1>,<select date,sym,price from pt2>]);\n// output: (DataSource< select [7] * from pt1 [partition = /value/20190601] >,DataSource< select [7] * from pt1 [partition = /value/20190602] >, ...... ,DataSource< select [7] date,sym,price from pt2 [partition = /compo/20190605/GOOG] >,DataSource< select [7] date,sym,price from pt2 [partition = /compo/20190605/MSFT] >)\n```\n\n例2. 根据股票代码的值划分数据源\n\n```\nds=multiTableRepartitionDS(query=[<select * from pt1>,<select date,sym,price from pt2>],column=`sym, partitionType=VALUE, partitionScheme=symbol(`AAPL`MSFT`GOOG));\n// output: (DataSource< select [4] * from pt1 where sym == \"AAPL\" >,DataSource< select [4] * from pt1 where sym == \"MSFT\" >,DataSource< select [4] * from pt1 where sym == \"GOOG\" >,DataSource< select [4] date,sym,price from pt2 where sym == \"AAPL\" >,DataSource< select [4] date,sym,price from pt2 where sym == \"MSFT\" >,DataSource< select [4] date,sym,price from pt2 where sym == \"GOOG\" >)\n```\n\n例3. 根据日期范围划分数据源\n\n```\nds=multiTableRepartitionDS(query=[<select * from pt1>,<select date,sym,price from pt2>],column=`date,partitionType=RANGE,partitionScheme=2019.06.01 2019.06.03 2019.06.05);\n// output: (DataSource< select [4] * from pt1 where date >= 2019.06.01,date < 2019.06.03 >,DataSource< select [4] * from pt1 where date >= 2019.06.03,date < 2019.06.05 >,DataSource< select [4] date,sym,price from pt2 where date >= 2019.06.01,date < 2019.06.03 >,DataSource< select [4] date,sym,price from pt2 where date >= 2019.06.03,date < 2019.06.05 >)\n```\n\n相关函数：[repartitionDS](https://docs.dolphindb.cn/zh/funcs/r/repartitionDS.html)\n"
    },
    "mutualInfo": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mutualInfo.html",
        "signatures": [
            {
                "full": "mutualInfo(X, Y)",
                "name": "mutualInfo",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [mutualInfo](https://docs.dolphindb.cn/zh/funcs/m/mutualInfo.html)\n\n\n\n#### 语法\n\nmutualInfo(X, Y)\n\n别名：infoGain\n\n#### 详情\n\n计算 *X* 和 *Y* 的互信息。\n\nDolphinDB 使用以下公式计算互信息：\n\n![img](https://docs.dolphindb.cn/zh/images/mutualinfo.png)\n\n若 *X* 或 *Y* 是矩阵，计算每列的互信息，返回一个向量。\n\n**Note:** 该公式计算时使用自然对数，若需要 *base* 为2或者10，直接以结果除以 log 2 或 log 10 即可。\n\n#### 参数\n\n**X** 是一个标量、向量或矩阵。\n\n**Y** 是一个标量、向量或矩阵。\n\n*X* 和 *Y* 支持 Integral 和 symbol 类型。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\na = [NULL,4,NULL,NULL,-82,97,NULL,56,5,-92]\nb = [NULL,53,NULL,18,97,-4,-73,NULL,NULL,24]\nmutualInfo(a, b)\n// output: 2.302585\n\n// 计算表中两列数据的互信息\nt=table(take(1..10,10000000) as id, rand(10,10000000) as x, rand(10,10000000) as y);\nmutualInfo(t.x, t.y)\n// output: 0.000004\n\nm1 = 1..12$3:4\nm2 = 1..3\nmutualInfo(m1, m2)\n// output: [1.0986,1.0986,1.0986,1.0986]\n```\n\n如果 *X* 是矩阵，*Y* 可以是标量、向量或者是与 *X* 行数相同的矩阵。返回结果是与 *X* 列数相同的向量。\n\n```\nm1 = 1..12$3:4\nm2 = 1..3\nmutualInfo(m1, m2)\n// output: [1.0986,1.0986,1.0986,1.0986]\n```\n"
    },
    "mvar": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mvar.html",
        "signatures": [
            {
                "full": "mvar(X, window, [minPeriods])",
                "name": "mvar",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "[minPeriods]",
                        "name": "minPeriods",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [mvar](https://docs.dolphindb.cn/zh/funcs/m/mvar.html)\n\n\n\n#### 语法\n\nmvar(X, window, \\[minPeriods])\n\n窗口计算规则请参考：[mFunctions](https://docs.dolphindb.cn/zh/funcs/themes/mFunctions.html)\n\n#### 详情\n\n在给定长度（以元素个数或时间长度衡量）的滑动窗口内计算 *X* 的样本方差。\n\n#### 参数\n\n**X** 是一个向量/矩阵/表/元组（元素为标量或等长向量）/字典。\n\n**window** 是大于等于 2 的正整型或 DURATION 标量。表示滑动窗口的长度。\n\n**Note:** 在流计算引擎中调用滑动窗口函数时，window 的上限为 102400。\n\n**minPeriods** 是一个正整数。表示滑动窗口中最少包含的非 NULL 有效观测值数量。\n\n#### 返回值\n\n* 输入为向量时，返回一个与输入等长的 DOUBLE 类型向量。\n* 输入为矩阵时，返回一个与输入矩阵同维度的矩阵，每列分别计算。\n* 输入为表时，返回一个与输入表结构相同的表。\n* 输入为元组时，返回对应的元组结构。\n\n#### 例子\n\n```\nmvar(1..6, 5);\n// output: [,,,,2.5,2.5]\n\nmvar(1..6, 5, 2);\n// output: [,0.5,1,1.666667,2.5,2.5]\n```\n\n```\nm=matrix(1 6 2 9 4 5, 11 12 18 23 21 10);\nm;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 11 |\n| 6  | 12 |\n| 2  | 18 |\n| 9  | 23 |\n| 4  | 21 |\n| 5  | 10 |\n\n```\nmvar(m,3);\n```\n\n| #0                 | #1                 |\n| ------------------ | ------------------ |\n|                    |                    |\n|                    |                    |\n| 7                  | 14.333333333333314 |\n| 12.333333333333335 | 30.333333333333314 |\n| 13                 | 6.333333333333372  |\n| 7                  | 49                 |\n\n```\nm=matrix(1 NULL 4 NULL 8 6 , 9 NULL NULL 10 NULL 2)\nm.rename!(date(2020.04.06)+1..6, `col1`col2)\nm.setIndexedMatrix!()\nmvar(m,4d)\n```\n\n| label      | col1 | col2 |\n| ---------- | ---- | ---- |\n| 2020.04.07 |      |      |\n| 2020.04.08 |      |      |\n| 2020.04.09 | 4.5  |      |\n| 2020.04.10 | 4.5  | 0.5  |\n| 2020.04.11 | 8    |      |\n| 2020.04.12 | 4    | 32   |\n\n```\nmvar(m,1w)\n```\n\n| label      | col1    | col2 |\n| ---------- | ------- | ---- |\n| 2020.04.07 |         |      |\n| 2020.04.08 |         |      |\n| 2020.04.09 | 4.5     |      |\n| 2020.04.10 | 4.5     | 0.5  |\n| 2020.04.11 | 12.3333 | 0.5  |\n| 2020.04.12 | 8.9167  | 19   |\n\n**Related information**\n\n[var](https://docs.dolphindb.cn/zh/funcs/v/var.html)\n"
    },
    "mvarp": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mvarp.html",
        "signatures": [
            {
                "full": "mvarp(X, window, [minPeriods])",
                "name": "mvarp",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "[minPeriods]",
                        "name": "minPeriods",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [mvarp](https://docs.dolphindb.cn/zh/funcs/m/mvarp.html)\n\n\n\n#### 语法\n\nmvarp(X, window, \\[minPeriods])\n\n窗口计算规则请参考：[mFunctions](https://docs.dolphindb.cn/zh/funcs/themes/mFunctions.html)\n\n#### 详情\n\n在给定长度（以元素个数或时间长度衡量）的滑动窗口内计算 *X* 的总体方差。\n\n#### 参数\n\n**X** 是一个向量/矩阵/表/元组（元素为标量或等长向量）/字典。\n\n**window** 是大于等于 2 的正整型或 DURATION 标量。表示滑动窗口的长度。\n\n**Note:** 在流计算引擎中调用滑动窗口函数时，window 的上限为 102400。\n\n**minPeriods** 是一个正整数。表示滑动窗口中最少包含的非 NULL 有效观测值数量。\n\n#### 返回值\n\n* 输入为向量时，返回一个与输入等长的 DOUBLE 类型向量。\n* 输入为矩阵时，返回一个与输入矩阵同维度的矩阵，每列分别计算。\n* 输入为表时，返回一个与输入表结构相同的表。\n* 输入为元组时，返回对应的元组结构。\n\n#### 例子\n\n```\nmvarp(1..6, 5);\n// output: [,,,,2,2]\n\nmvarp(1..6, 5, 2);\n// output: [,0.25,0.666666666666667,1.25,2,2]\n\nm=matrix(1 6 2 9 4 5, 11 12 18 23 21 10);\nm;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 11 |\n| 6  | 12 |\n| 2  | 18 |\n| 9  | 23 |\n| 4  | 21 |\n| 5  | 10 |\n\n```\nmvarp(m,3);\n```\n\n| #0                | #1                 |\n| ----------------- | ------------------ |\n|                   |                    |\n|                   |                    |\n| 4.666666666666667 | 9.555555555555542  |\n| 8.222222222222223 | 20.22222222222221  |\n| 8.666666666666666 | 4.222222222222248  |\n| 4.666666666666667 | 32.666666666666664 |\n\n```\nm=matrix(1 NULL 4 NULL 8 6 , 9 NULL NULL 10 NULL 2)\nm.rename!(date(2020.04.06)+1..6, `col1`col2)\nm.setIndexedMatrix!()\nmvarp(m,4d)\n```\n\n| label      | col1   | col2 |\n| ---------- | ------ | ---- |\n| 2020.04.07 | 0      | 0    |\n| 2020.04.08 | 0      | 0    |\n| 2020.04.09 | 2.25   | 0    |\n| 2020.04.10 | 2.25   | 0.25 |\n| 2020.04.11 | 4      | 0    |\n| 2020.04.12 | 2.6667 | 16   |\n\n```\nmvarp(m,1w)\n```\n\n| label      | col1   | col2    |\n| ---------- | ------ | ------- |\n| 2020.04.07 | 0      | 0       |\n| 2020.04.08 | 0      | 0       |\n| 2020.04.09 | 2.25   | 0       |\n| 2020.04.10 | 2.25   | 0.25    |\n| 2020.04.11 | 8.2222 | 0.25    |\n| 2020.04.12 | 6.6875 | 12.6667 |\n\n相关函数：[varp](https://docs.dolphindb.cn/zh/funcs/v/varp.html)\n"
    },
    "mvarpTopN": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mvarpTopN.html",
        "signatures": [
            {
                "full": "mvarpTopN(X, S, window, top, [ascending=true], [tiesMethod='oldest'])",
                "name": "mvarpTopN",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "S",
                        "name": "S"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "top",
                        "name": "top"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[tiesMethod='oldest']",
                        "name": "tiesMethod",
                        "optional": true,
                        "default": "'oldest'"
                    }
                ]
            }
        ],
        "markdown": "### [mvarpTopN](https://docs.dolphindb.cn/zh/funcs/m/mvarpTopN.html)\n\n\n\n#### 语法\n\nmvarpTopN(X, S, window, top, \\[ascending=true], \\[tiesMethod='oldest'])\n\n参数说明和窗口计算规则请参考：[mTopN](https://docs.dolphindb.cn/zh/funcs/themes/TopN.html)\n\n#### 详情\n\n在给定长度（以元素个数衡量）的滑动窗口内，根据 *ascending* 指定的排序方式将 *X* 按照 *S* 进行稳定排序后，取前 *top* 个元素计算总体方差。\n\n#### 返回值\n\n* 输入为向量时，返回一个与输入等长的 DOUBLE 类型向量。\n* 输入为矩阵时，返回一个与输入矩阵同维度的矩阵，每列分别计算。\n* 输入为表时，返回一个与输入表结构相同的表。\n* 输入为元组时，返回对应的元组结构。\n\n#### 例子\n\n```\nX = 1..7\nS = 0.3 0.5 0.1 0.1 0.5 0.2 0.4\nmvarpTopN(X, S, 4, 2)\n// output: [0,0.25,1,0.25,0.25,0.25,1]\n\n\nX = NULL 1 2 3 4 NULL 5\nS = 3 5 1 1 5 2 4\nmvarpTopN(X, S, 4, 2)\n// output: [,0,0,0.25,0.25,0.25,0]\n\nX = matrix(1..5, 6..10)\nS = 2022.01.01 2022.02.03 2022.01.23 2022.04.06 2021.12.29\nmvarpTopN(X, S, 3, 2)\n```\n\n| #0   | #1   |\n| ---- | ---- |\n| 0    | 0    |\n| 0.25 | 0.25 |\n| 1    | 1    |\n| 0.25 | 0.25 |\n| 1    | 1    |\n\n```\nX = matrix(1..5, 6..10)\nS = matrix(2022.01.01 2022.02.03 2022.01.23 NULL 2021.12.29,NULL 2022.02.03 2022.01.23 2022.04.06 NULL)\nmvarpTopN(X, S, 3, 2)\n```\n\n| #0   | #1   |\n| ---- | ---- |\n| 0    |      |\n| 0.25 | 0    |\n| 1    | 0.25 |\n| 0.25 | 0.25 |\n| 1    | 0.25 |\n\n相关函数：[mvarp](https://docs.dolphindb.cn/zh/funcs/m/mvarp.html)\n"
    },
    "mvarTopN": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mvarTopN.html",
        "signatures": [
            {
                "full": "mvarTopN(X, S, window, top, [ascending=true], [tiesMethod='oldest'])",
                "name": "mvarTopN",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "S",
                        "name": "S"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "top",
                        "name": "top"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[tiesMethod='oldest']",
                        "name": "tiesMethod",
                        "optional": true,
                        "default": "'oldest'"
                    }
                ]
            }
        ],
        "markdown": "### [mvarTopN](https://docs.dolphindb.cn/zh/funcs/m/mvarTopN.html)\n\n\n\n#### 语法\n\nmvarTopN(X, S, window, top, \\[ascending=true], \\[tiesMethod='oldest'])\n\n参数说明和窗口计算规则请参考：[mTopN](https://docs.dolphindb.cn/zh/funcs/themes/TopN.html)\n\n#### 详情\n\n在给定长度（以元素个数衡量）的滑动窗口内，根据 *ascending* 指定的排序方式将 *X* 按照 *S* 进行稳定排序后，取前 *top* 个元素计算样本方差。\n\n#### 返回值\n\n* 输入为向量时，返回一个与输入等长的 DOUBLE 类型向量。\n* 输入为矩阵时，返回一个与输入矩阵同维度的矩阵，每列分别计算。\n* 输入为表时，返回一个与输入表结构相同的表。\n* 输入为元组时，返回对应的元组结构。\n\n#### 例子\n\n```\nX = 1..7\nS = 0.3 0.5 0.1 0.1 0.5 0.2 0.4\nmvarTopN(X, S, 4, 2)\n// output: [,0.5,2,0.5,0.5,0.5,2]\n\nX = NULL 1 2 3 4 NULL 5\nS = 3 5 1 1 5 2 4\nmvarTopN(X, S, 4, 2)\n// output: [,,,0.5,0.5,0.5,]\n\nX = matrix(1..5, 6..10)\nS = 2022.01.01 2022.02.03 2022.01.23 2022.04.06 2021.12.29\nmvarTopN(X, S, 3, 2)\n```\n\n| #0  | #1  |\n| --- | --- |\n|     |     |\n| 0.5 | 0.5 |\n| 2   | 2   |\n| 0.5 | 0.5 |\n| 2   | 2   |\n\n```\nX = matrix(1..5, 6..10)\nS = matrix(2022.01.01 2022.02.03 2022.01.23 NULL 2021.12.29,NULL 2022.02.03 2022.01.23 2022.04.06 NULL)\nmvarTopN(X, S, 3, 2)\n```\n\n| #0  | #1  |\n| --- | --- |\n|     |     |\n| 0.5 | 0.5 |\n| 2   | 2   |\n| 0.5 | 0.5 |\n| 2   | 2   |\n\n相关函数：[mvar](https://docs.dolphindb.cn/zh/funcs/m/mvar.html)\n"
    },
    "mvccTable": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mvccTable.html",
        "signatures": [
            {
                "full": "mvccTable(X, [X1], [X2], .....)",
                "name": "mvccTable",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[X1]",
                        "name": "X1",
                        "optional": true
                    },
                    {
                        "full": "[X2]",
                        "name": "X2",
                        "optional": true
                    },
                    {
                        "full": ".....",
                        "name": "....."
                    }
                ]
            },
            {
                "full": "mvccTable(capacity:size, colNames, colTypes, [path], [tableName], [defaultValues], [allowNull])",
                "name": "mvccTable",
                "parameters": [
                    {
                        "full": "capacity:size",
                        "name": "capacity:size"
                    },
                    {
                        "full": "colNames",
                        "name": "colNames"
                    },
                    {
                        "full": "colTypes",
                        "name": "colTypes"
                    },
                    {
                        "full": "[path]",
                        "name": "path",
                        "optional": true
                    },
                    {
                        "full": "[tableName]",
                        "name": "tableName",
                        "optional": true
                    },
                    {
                        "full": "[defaultValues]",
                        "name": "defaultValues",
                        "optional": true
                    },
                    {
                        "full": "[allowNull]",
                        "name": "allowNull",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [mvccTable](https://docs.dolphindb.cn/zh/funcs/m/mvccTable.html)\n\n\n\n#### 语法\n\nmvccTable(X, \\[X1], \\[X2], .....)\n\n或\n\nmvccTable(capacity:size, colNames, colTypes, \\[path], \\[tableName], \\[defaultValues], \\[allowNull])\n\n#### 详情\n\n创建一个多版本并发控制的表（MVCC 表）。我们可以对该表进行并发读写。多版本并发控制的表适用于频繁读写但很少更新和删除记录的场景。\n\n如果指定了 *path* 和 *tableName* 参数，会把表持久化到硬盘上。通过 [loadMvccTable](https://docs.dolphindb.cn/zh/funcs/l/loadMvccTable.html) 函数，可以把磁盘上的表加载到内存中。\n\n**Note:**\n\n* 不支持对 MVCC 表进行以下操作：addColumn、reorderColumns!、upsert!、drop、erase!。\n\n* 当 *size*=0 时，即使对某列设置 *allowNull*=false，也可以成功创建空表，但不能向该列追加空值。\n\n#### 参数\n\n对于第一种用法，**X**, **X1**, **X2** ...是向量。\n\n对于第二种用法：\n\n**capacity** 是正整数，表示表的容量，即建表时系统为该表分配的内存（以记录数为单位）。当记录数超过 *capacity* 时，系统会自动扩充容量。系统首先会分配当前容量1.2\\~2倍的内存，然后复制数据到新的内存空间，最后释放原来的内存。对于规模较大的表，扩容时的内存占用会很高。因此，建议创建内存表时预先分配一个合理的容量。\n\n**size** 是正整数，表示该表新建时的行数。若 *size*=0，创建一个空表；若 *size*>0，则新建表中记录的初始值由 *defaultValues* 决定。\n\n**colNames** 是字符串向量，表示列名。\n\n**colTypes** 是向量，表示列的数据类型。\n\n**path** 是一个字符串，表示保存表的路径。只能指定磁盘路径，不支持指定为分布式数据库路径。\n\n**tableName** 是一个字符串，表示保存到磁盘上的表名。\n\n**defaultValues** 是与 *colNames* 等长的元组，表示建表时各列的默认值。若不指定，则：\n\n* BOOL 类型默认值为 false；\n\n* 数值类型、时间类型、IPADDR、COMPLEX、POINT 的默认值为 0；\n\n* Literal, INT128 类型的默认为 NULL。\n\n**allowNull** 是与 *colNames* 等长的布尔类型向量，表示是否允许各列包含空值。默认值为 true，允许包含空值。\n\n#### 例子\n\n例1：介绍两种创建 MVCC 表的方法\n\n第一种用法：\n\n```\nid=`XOM`GS`AAPL\nx=102.1 33.4 73.6\nmvccTable(id, x);\n```\n\n| id   | x     |\n| ---- | ----- |\n| XOM  | 102.1 |\n| GS   | 33.4  |\n| AAPL | 73.6  |\n\n第二种用法：\n\n```\nmvccTable(200:10, `name`id`value, [STRING,INT,DOUBLE],\"/home/DolphinDB/Data\",\"t1\");\n```\n\n| name | id | value |\n| ---- | -- | ----- |\n|      | 0  | 0     |\n|      | 0  | 0     |\n|      | 0  | 0     |\n|      | 0  | 0     |\n|      | 0  | 0     |\n|      | 0  | 0     |\n|      | 0  | 0     |\n|      | 0  | 0     |\n|      | 0  | 0     |\n|      | 0  | 0     |\n\n`\"/home/DolphinDB/Data\"` 目录下会有一个名为 \"t1\" 文件夹、t1.tbl 文件和 t1.sym 文件。如果需要删除磁盘上的表，需要把这三个文件都删除。\n\n例2：创建分区 MVCC 内存表：\n\n```\nn=200000\ncolNames = `time`sym`qty`price\ncolTypes = [TIME,SYMBOL,INT,DOUBLE]\ntrades_mvcc1 = mvccTable(n:0, colNames, colTypes)\ntrades_mvcc2 = mvccTable(n:0, colNames, colTypes)\ndb=database(, VALUE, `A`D)\ntrades = createPartitionedTable(db,table=[trades_mvcc1, trades_mvcc2], tableName=\"\", partitionColumns=`sym)\n```\n\n在 2.00.10.4 版本之前，只支持对分区 MVCC 内存表的子表进行更新、插入和删除操作：\n\n```\ninsert into trades_mvcc1 values(09:30:00.001,`A,100,56.5)\ninsert into trades_mvcc2 values(09:30:01.001,`D,100,15.5)\n\ninsert into trades values(09:30:00.001,`D,100,26.5)\n// 报错：Can't append data to a segmented table that contains external partitions.\n\nselect * from trades;\n```\n\n| time         | sym | qty | price |\n| :----------- | :-- | :-- | :---- |\n| 09:30:00.001 | A   | 100 | 56.5  |\n| 09:30:01.001 | D   | 100 | 15.5  |\n\n2.00.10.4 版本开始支持直接对分区 MVCC 内存表进行更新、插入和删除操作：\n\n```\ninsert into trades values(09:30:00.001,`D,100,26.5)\nselect * from trades;\n```\n\n| time         | sym | qty | price |\n| :----------- | :-- | :-- | :---- |\n| 09:30:00.001 | A   | 100 | 56.5  |\n| 09:30:01.001 | D   | 100 | 15.5  |\n| 09:30:01.001 | D   | 100 | 26.5  |\n\n```\ndelete from trades where sym=`A\nselect * from trades;\n```\n\n| time         | sym | qty | price |\n| :----------- | :-- | :-- | :---- |\n| 09:30:01.001 | D   | 100 | 15.5  |\n| 09:30:01.001 | D   | 100 | 26.5  |\n\n```\nupdate trades set price=price*10 where sym=`D\nselect * from trades;\n```\n\n| time         | sym | qty | price |\n| :----------- | :-- | :-- | :---- |\n| 09:30:01.001 | D   | 100 | 155   |\n| 09:30:01.001 | D   | 100 | 265   |\n\n需要注意的是，直接向子表插入数据时，系统不会校验向子表插入的数据是否与该表匹配。如果插入了不匹配的数据，会导致分区 MVCC 内存表的数据混乱。 因此，为了确保数据的准确性，建议用户直接对分区 MVCC 内存表进行操作，而不要操作子表。\n"
    },
    "mwavg": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mwavg.html",
        "signatures": [
            {
                "full": "mwavg(X, Y, window, [minPeriods])",
                "name": "mwavg",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "[minPeriods]",
                        "name": "minPeriods",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [mwavg](https://docs.dolphindb.cn/zh/funcs/m/mwavg.html)\n\n\n\n#### 语法\n\nmwavg(X, Y, window, \\[minPeriods])\n\n窗口计算规则请参考：[mFunctions](https://docs.dolphindb.cn/zh/funcs/themes/mFunctions.html)\n\n#### 详情\n\n在给定长度（以元素个数或时间长度衡量）的滑动窗口内，以 *Y* 为权重（权重会自动缩放，使其元素之和为1），计算 *X* 元素的加权平均。\n\n**Note:** 与 `mavg` 以 size(*weight*) 长度的窗口进行滑动窗口计算不同，`mwavg` 的权重 *Y* 必须和 *X* 具有相同的长度。\n\n#### 参数\n\n**X** 是一个向量/矩阵/表/元组（元素为标量或等长向量）/字典。\n\n**Y** 是一个向量/矩阵/表/元组（元素为标量或等长向量）/字典。\n\n**window** 是大于等于 2 的正整型或 DURATION 标量。表示滑动窗口的长度。\n\n**Note:** 在流计算引擎中调用滑动窗口函数时，window 的上限为 102400。\n\n**minPeriods** 是一个正整数。表示滑动窗口中最少包含的非 NULL 有效观测值数量。\n\n#### 返回值\n\n* 输入为向量时，返回一个与输入等长的 DOUBLE 类型向量。\n* 输入为矩阵时，返回一个与输入矩阵同维度的矩阵，每列分别计算。\n* 输入为表时，返回一个与输入表结构相同的表。\n* 输入为元组时，返回对应的元组结构。\n\n#### 例子\n\n```\nprice=2.1 2.2 2.3 2.5 2.6 2.8 2.7 2.5;\nvolume=10 20 10 40 10 40 10 20;\nmwavg(price, volume, 4);\n// output: [,,,2.35,2.4125,2.61,2.65,2.6875]\n\nmwavg(price, volume, 4, 2);\n// output: [,2.166667,2.2,2.35,2.4125,2.61,2.65,2.6875]\n```\n\n```\nprice1 = indexedSeries(date(2020.06.05)+1..8, price)\nvolume1 = indexedSeries(date(2020.06.05)+1..8, volume)\nmwavg(price1,volume1, 4d)\n```\n\n| label      | col1   |\n| ---------- | ------ |\n| 2020.06.06 | 2.1    |\n| 2020.06.07 | 2.1667 |\n| 2020.06.08 | 2.2    |\n| 2020.06.09 | 2.35   |\n| 2020.06.10 | 2.4125 |\n| 2020.06.11 | 2.61   |\n| 2020.06.12 | 2.65   |\n| 2020.06.13 | 2.6875 |\n\n```\nmwavg(price1,volume1, 1w)\n```\n\n| label      | col1   |\n| ---------- | ------ |\n| 2020.06.06 | 2.1    |\n| 2020.06.07 | 2.1667 |\n| 2020.06.08 | 2.2    |\n| 2020.06.09 | 2.35   |\n| 2020.06.10 | 2.3788 |\n| 2020.06.11 | 2.5077 |\n| 2020.06.12 | 2.5214 |\n| 2020.06.13 | 2.5467 |\n\n相关函数：[wavg](https://docs.dolphindb.cn/zh/funcs/w/wavg.html), [mavg](https://docs.dolphindb.cn/zh/funcs/m/mavg.html)\n"
    },
    "mwsum": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mwsum.html",
        "signatures": [
            {
                "full": "mwsum(X, Y, window, [minPeriods])",
                "name": "mwsum",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "[minPeriods]",
                        "name": "minPeriods",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [mwsum](https://docs.dolphindb.cn/zh/funcs/m/mwsum.html)\n\n\n\n#### 语法\n\nmwsum(X, Y, window, \\[minPeriods])\n\n窗口计算规则请参考：[mFunctions](https://docs.dolphindb.cn/zh/funcs/themes/mFunctions.html)\n\n#### 详情\n\n在给定长度（以元素个数或时间长度衡量）的滑动窗口内，计算 *X* 和 *Y* 元素的内积。\n\n#### 参数\n\n**X** 是一个向量/矩阵/表/元组（元素为标量或等长向量）/字典。\n\n**Y** 是一个向量/矩阵/表/元组（元素为标量或等长向量）/字典。\n\n**window** 是大于等于 2 的正整型或 DURATION 标量。表示滑动窗口的长度。\n\n**Note:** 在流计算引擎中调用滑动窗口函数时，window 的上限为 102400。\n\n**minPeriods** 是一个正整数。表示滑动窗口中最少包含的非 NULL 有效观测值数量。\n\n#### 返回值\n\n* 输入为向量时，返回一个与输入等长的 DOUBLE 类型向量。\n* 输入为矩阵时，返回一个与输入矩阵同维度的矩阵，每列分别计算。\n* 输入为表时，返回一个与输入表结构相同的表。\n* 输入为元组时，返回对应的元组结构。\n\n#### 例子\n\n```\nX = 2 1 3 7 6 5 4\nX1 = 2 1 3 NULL 6 5 4\nY = 1 0.5 1 1 2 2.1 2\n\nmwsum(X, Y, 3);\n// output: [,,5.5,10.5,22,29.5,30.5]\n\nmwsum(X1, Y, 3)\n// output: [,,5.5,3.5,15,22.5,30.5]\n\nmwsum(X1, Y, 3, minPeriods=1)\n// output: [2,2.5,5.5,3.5,15,22.5,30.5]\n```\n\n```\nX = 1..10;\nY = 9 5 3 4 5 4 7 1 3 4;\nX1 = indexedSeries(date(2020.06.05)+1..10, X)\nY1 = indexedSeries(date(2020.06.05)+1..10, Y)\nmwsum(X1, Y1, 5d)\n```\n\n| label      | col1 |\n| ---------- | ---- |\n| 2020.06.06 | 9    |\n| 2020.06.07 | 19   |\n| 2020.06.08 | 28   |\n| 2020.06.09 | 44   |\n| 2020.06.10 | 69   |\n| 2020.06.11 | 84   |\n| 2020.06.12 | 123  |\n| 2020.06.13 | 122  |\n| 2020.06.14 | 133  |\n| 2020.06.15 | 148  |\n\n```\nmwsum(X1, Y1, 1w)\n```\n\n| label      | col1 |\n| ---------- | ---- |\n| 2020.06.06 | 9    |\n| 2020.06.07 | 19   |\n| 2020.06.08 | 28   |\n| 2020.06.09 | 44   |\n| 2020.06.10 | 69   |\n| 2020.06.11 | 93   |\n| 2020.06.12 | 142  |\n| 2020.06.13 | 141  |\n| 2020.06.14 | 158  |\n| 2020.06.15 | 189  |\n\n相关函数：[wsum](https://docs.dolphindb.cn/zh/funcs/w/wsum.html), [msum](https://docs.dolphindb.cn/zh/funcs/m/msum.html)\n"
    },
    "mwsumTopN": {
        "url": "https://docs.dolphindb.cn/zh/funcs/m/mwsumTopN.html",
        "signatures": [
            {
                "full": "mwsumTopN(X, Y, S, window, top, [ascending=true], [tiesMethod='oldest'])",
                "name": "mwsumTopN",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "S",
                        "name": "S"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "top",
                        "name": "top"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[tiesMethod='oldest']",
                        "name": "tiesMethod",
                        "optional": true,
                        "default": "'oldest'"
                    }
                ]
            }
        ],
        "markdown": "### [mwsumTopN](https://docs.dolphindb.cn/zh/funcs/m/mwsumTopN.html)\n\n\n\n#### 语法\n\nmwsumTopN(X, Y, S, window, top, \\[ascending=true], \\[tiesMethod='oldest'])\n\n参数说明和窗口计算规则请参考：[mTopN](https://docs.dolphindb.cn/zh/funcs/themes/TopN.html)\n\n#### 详情\n\n在给定长度（以元素个数衡量）的滑动窗口内，根据 *ascending* 指定的排序方式将 *X* 和 *Y* 按照 *S* 进行稳定排序后，取前 *top* 个元素，然后计算 *Y* 和 *X* 的内积。\n\n#### 返回值\n\n* 输入为向量时，返回一个与输入等长的 DOUBLE 类型向量。\n* 输入为矩阵时，返回一个与输入矩阵同维度的矩阵，每列分别计算。\n* 输入为表时，返回一个与输入表结构相同的表。\n* 输入为元组时，返回对应的元组结构。\n\n#### 例子\n\n以 IBM 股票为例，构造连续 6 个交易日的股票成交价格、成交量和换手率数据：\n\n```\nsymbol = take(`IBM, 6)\ntradeDate = 2024.01.02 2024.01.03 2024.01.04 2024.01.05 2024.01.08 2024.01.09\ntradePrice = [182.5, 183.8, 181.2, 184.6, 183.1, 185.0]\ntradeVolume = [520, 860, 610, 940, 650, 880]\nturnoverRate = [1.8, 2.6, 1.9, 3.1, 2.1, 2.8]\n\nstockDaily = table(symbol, tradeDate, tradePrice, tradeVolume, turnoverRate)\nstockDaily;\n```\n\n输出结果：\n\n| symbol | tradeDate  | tradePrice | tradeVolume | turnoverRate |\n| ------ | ---------- | ---------- | ----------- | ------------ |\n| IBM    | 2024.01.02 | 182.5      | 520         | 1.8          |\n| IBM    | 2024.01.03 | 183.8      | 860         | 2.6          |\n| IBM    | 2024.01.04 | 181.2      | 610         | 1.9          |\n| IBM    | 2024.01.05 | 184.6      | 940         | 3.1          |\n| IBM    | 2024.01.08 | 183.1      | 650         | 2.1          |\n| IBM    | 2024.01.09 | 185        | 880         | 2.8          |\n\n在最近 4 个交易日内，选取换手率最高的前 2 个交易日，计算成交价格（tradePrice）与成交量（tradeVolume）的内积：\n\n```\nmwsumTopN(X=tradePrice, Y=tradeVolume, S=turnoverRate, window=4, top=2, ascending=false)\n// 输出: [94,900, 252,968, 268,600, 331,592, 331,592, 336,324]\n```\n\n* turnoverRate 用于筛选换手率最高的交易日；\n\n* 对 2024.01.09 的数据而言，最近 4 日窗口中换手率最高的两个交易日对应样本为(184.6, 940) 和 (185.0, 880)，其内积为 184.6\\*940 + 185.0\\*880 = 336,324。\n\n相关函数：[mwsum](https://docs.dolphindb.cn/zh/funcs/m/mwsum.html)\n"
    },
    "saveAsNpy": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/saveAsNpy.html",
        "signatures": [
            {
                "full": "saveAsNpy(obj, fileName)",
                "name": "saveAsNpy",
                "parameters": [
                    {
                        "full": "obj",
                        "name": "obj"
                    },
                    {
                        "full": "fileName",
                        "name": "fileName"
                    }
                ]
            }
        ],
        "markdown": "### [saveAsNpy](https://docs.dolphindb.cn/zh/funcs/s/saveAsNpy.html)\n\n\n\n#### 语法\n\nsaveAsNpy(obj, fileName)\n\n#### 详情\n\n将一个 DolphinDB 向量或矩阵保存为 Python Numpy 支持的 npy 格式的二进制文件。该函数必须要用户登录后才能执行。\n\n注：*obj* 中的 NULL 值会转换为负无穷（-inf）。\n\n#### 参数\n\n**obj** 是一个数值向量或矩阵。\n\n**fileName** 是服务器端输出文件的绝对路径或相对路径。\n\n#### 例子\n\n```\nv = 1..1000\nv.saveAsNpy(\"/home/DolphinDB/intVec.npy\")\n\nm = (1..1000 + 0.5)$20:50\nm.saveAsNpy(\"/home/DolphinDB/doubleMat.npy\")\n```\n\n在 Python 中加载保存的文件。\n\n```\nimport numpy as np\nv = np.load(\"/home/DolphinDB/intVec.npy\")\nm = np.load(\"/home/DolphinDB/doubleMat.npy\")\n```\n\n**Related information**\n\n[loadNpy](https://docs.dolphindb.cn/zh/funcs/l/loadNpy.html)\n"
    },
    "saveDatabase": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/saveDatabase.html",
        "signatures": [
            {
                "full": "saveDatabase(dbHandle)",
                "name": "saveDatabase",
                "parameters": [
                    {
                        "full": "dbHandle",
                        "name": "dbHandle"
                    }
                ]
            }
        ],
        "markdown": "### [saveDatabase](https://docs.dolphindb.cn/zh/funcs/s/saveDatabase.html)\n\n\n\n#### 语法\n\nsaveDatabase(dbHandle)\n\n#### 详情\n\n保存数据库句柄。该命令必须要用户登录后才能执行。这个命令和 [database](https://docs.dolphindb.cn/zh/funcs/d/database.html) 函数配合使用。\n\n第一次创建数据库之后，我们需要用 `saveDatabase` 命令保存数据库。如果数据库位于一个已经包含了 DolphinDB 表相关文件的目录下，函数 `database` 会重新打开之前创建的数据库，且不需要用 `saveDatabase` 命令保存。\n\n#### 参数\n\n**dbHandle** 是 DolphinDB 数据库句柄。\n\n#### 例子\n\n```\ndb=database(\"C:/DolphinDB/\")\nsaveDatabase(db);\n```\n"
    },
    "saveDualPartition": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/saveDualPartition.html",
        "signatures": [
            {
                "full": "saveDualPartition(dbHandle1, dbHandle2, table, tableName, partitionColumn1, partitionColumn2, [compression=false])",
                "name": "saveDualPartition",
                "parameters": [
                    {
                        "full": "dbHandle1",
                        "name": "dbHandle1"
                    },
                    {
                        "full": "dbHandle2",
                        "name": "dbHandle2"
                    },
                    {
                        "full": "table",
                        "name": "table"
                    },
                    {
                        "full": "tableName",
                        "name": "tableName"
                    },
                    {
                        "full": "partitionColumn1",
                        "name": "partitionColumn1"
                    },
                    {
                        "full": "partitionColumn2",
                        "name": "partitionColumn2"
                    },
                    {
                        "full": "[compression=false]",
                        "name": "compression",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [saveDualPartition](https://docs.dolphindb.cn/zh/funcs/s/saveDualPartition.html)\n\n\n\n#### 语法\n\nsaveDualPartition(dbHandle1, dbHandle2, table, tableName, partitionColumn1, partitionColumn2, \\[compression=false])\n\n#### 详情\n\n在共享表前，将一张表保存为组合分区。该命令必须要用户登录后才能执行。\n\n它通常与 [share](https://docs.dolphindb.cn/zh/progr/statements/share.html) 一起使用。如果分区和表已经存在，该函数会把新数据追加到已有表格。\n\n#### 参数\n\n**dbHandle1** 是第一级分区的数据库句柄。\n\n**dbHandle2** 是第二级分区的数据库句柄。\n\n**table** 是要保存的内存中的表。\n\n**tableName** 是表示保存的分区表的名称的字符串。\n\n**partitionColumn1** 是表示第一级分区的分区列的字符串。\n\n**partitionColumn2** 是表示第二级分区的分区列的字符串。\n\n**compression** 是一个布尔变量。它表示是否压缩表。当它设置为 true 时，表将被压缩保存到磁盘。默认设置为 false（不压缩）。\n\n#### 例子\n\n```\nn=1000000\nID=rand(10, n)\ndates=2017.08.07..2017.08.11\ndate=rand(dates, n)\nx=rand(1.0, n)\nt=table(ID, date, x);\n\nhdb = database(\"C:/DolphinDB/Data/dualDB\", RANGE,  0 5 10)\nvdb = database(, VALUE, dates)\nsaveDualPartition(hdb, vdb, t, `tDualPartition, `ID, `date)\n```\n"
    },
    "saveModel": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/saveModel.html",
        "signatures": [
            {
                "full": "saveModel(model, location)",
                "name": "saveModel",
                "parameters": [
                    {
                        "full": "model",
                        "name": "model"
                    },
                    {
                        "full": "location",
                        "name": "location"
                    }
                ]
            }
        ],
        "markdown": "### [saveModel](https://docs.dolphindb.cn/zh/funcs/s/saveModel.html)\n\n\n\n#### 语法\n\nsaveModel(model, location)\n\n#### 详情\n\n把模型保存到本地文件中。返回表示保存结果的布尔值。\n\n#### 参数\n\n**model** 需要保存的模型，一般是字典，由 [randomForestClassifier](https://docs.dolphindb.cn/zh/funcs/r/randomForestClassifier.html), [randomForestRegressor](https://docs.dolphindb.cn/zh/funcs/r/randomForestRegressor.html) 等机器学习函数生成。\n\n**location** 字符串，表示服务器端输出文件的绝对路径或相对路径。\n\n#### 返回值\n\n返回表示保存结果的布尔值。\n\n#### 例子\n\n```\nx1 = rand(100.0, 100)\nx2 = rand(100.0, 100)\nb0 = 6\nb1 = 1\nb2 = -2\nerr = norm(0, 10, 100)\ny = b0 + b1 * x1 + b2 * x2 + err\nt = table(x1, x2, y)\nmodel = randomForestRegressor(sqlDS(<select * from t>), `y, `x1`x2)\nsaveModel(model, \"/home/DolphinDB/Data/regressionModel.txt\");\n```\n"
    },
    "saveModule": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/saveModule.html",
        "signatures": [
            {
                "full": "saveModule(name, [moduleDir], [overwrite=false])",
                "name": "saveModule",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "[moduleDir]",
                        "name": "moduleDir",
                        "optional": true
                    },
                    {
                        "full": "[overwrite=false]",
                        "name": "overwrite",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [saveModule](https://docs.dolphindb.cn/zh/funcs/s/saveModule.html)\n\n\n\n#### 语法\n\nsaveModule(name, \\[moduleDir], \\[overwrite=false])\n\n#### 详情\n\n将模块序列化成扩展名为 dom 的二进制文件，可以增加代码的保密性和安全性。该函数必须要用户登录后才能执行。\n\n如果没有指定 *moduleDir*，默认是相对目录 modules。系统搜寻相对目录 modules 的顺序如下：先到节点的 home 目录寻找，再到节点的工作目录寻找，最后到 DolphinDB 可执行文件所在目录寻找。请注意，单节点模式下，这三个目录默认为同一目录。\n\n#### 参数\n\n**name** 是一个字符串，表示模块的名称。\n\n**moduleDir** 是一个字符串，表示模块 dos 文件所在的目录。\n\n**overwrite** 是一个布尔值，表示是否覆盖已有的模块 dom 文件。\n\n#### 例子\n\n假设节点 home 目录下的 modules 目录中包含了 ta.dos 以及 system/log/fileLog.dos 模块文件，将它们序列化为二进制文件。\n\n```\nsaveModule(\"ta\");\n\nsaveModule(\"system::log::fileLog\");\n```\n\n相关函数：[loadModule](https://docs.dolphindb.cn/zh/funcs/l/loadModule.html)\n"
    },
    "savePartition": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/savePartition.html",
        "signatures": [
            {
                "full": "savePartition(dbHandle, table, tableName, [compression=true])",
                "name": "savePartition",
                "parameters": [
                    {
                        "full": "dbHandle",
                        "name": "dbHandle"
                    },
                    {
                        "full": "table",
                        "name": "table"
                    },
                    {
                        "full": "tableName",
                        "name": "tableName"
                    },
                    {
                        "full": "[compression=true]",
                        "name": "compression",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [savePartition](https://docs.dolphindb.cn/zh/funcs/s/savePartition.html)\n\n\n\n#### 语法\n\nsavePartition(dbHandle, table, tableName, \\[compression=true])\n\n#### 详情\n\n把一张表保存为分布式数据库中的分区表。该命令必须要用户登录后才能执行。\n\n在用 *savePartition* 保存之前，要用 [createPartitionedTable](https://docs.dolphindb.cn/zh/funcs/c/createPartitionedTable.html) 先创建空的分区表。\n\n#### 参数\n\n**dbHandle** 是一个 DolphinDB 数据库句柄。\n\n**table** 是将要保存的内存中的表。\n\n**tableName** 是表示保存的分区表名称的字符串。\n\n**compression** 是否压缩数据。默认的设置是 true。\n\n#### 例子\n\n```\nn=1000000\nID=rand(10, n)\nvalue=rand(1.0, n)\nt=table(ID, value);\n\ndb=database(\"dfs://rangedb_Trades\", RANGE,  0 5 10)\nTrades = db.createPartitionedTable(t, \"Trades\", \"ID\");\nsavePartition(db, t, `Trades)\n\nTrades=loadTable(db, `Trades)\nselect count(value) from Trades;\n// output\n1,000,000\n```\n\n在上述例子中，数据库 db 有两个分区：\\[0,5)和\\[5,10)。表t被保存为一个分区表 Trades，它包含数据库 db 中的分区列。\n\n我们可以在表 Trades 中追加另一个表：\n\n```\nn=500000\nID=rand(10, n)\nvalue=rand(1.0, n)\nt1=table(ID, value);\nsavePartition(db, t1, `Trades)\nTrades=loadTable(db, `Trades)\nselect count(value) from Trades;\n// output\n1,500,000\n```\n"
    },
    "saveTable": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/saveTable.html",
        "signatures": [
            {
                "full": "saveTable(dbHandle, table, [tableName], [append=false], [compression=false])",
                "name": "saveTable",
                "parameters": [
                    {
                        "full": "dbHandle",
                        "name": "dbHandle"
                    },
                    {
                        "full": "table",
                        "name": "table"
                    },
                    {
                        "full": "[tableName]",
                        "name": "tableName",
                        "optional": true
                    },
                    {
                        "full": "[append=false]",
                        "name": "append",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[compression=false]",
                        "name": "compression",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [saveTable](https://docs.dolphindb.cn/zh/funcs/s/saveTable.html)\n\n\n\n#### 语法\n\nsaveTable(dbHandle, table, \\[tableName], \\[append=false], \\[compression=false])\n\n#### 详情\n\n将一个表保存在未分区的本地磁盘表中。该命令必须要用户登录后才能执行。\n\n如果要把表保存至分区数据库中，需要先使用 `createPartitionedTable` 函数创建分区表，再使用 `append!` 函数或 `tableInsert` 函数把数据保存至分区表中。\n\n**Note:**\n\n磁盘表仅应用于备份数据和本地计算的场景，其相较于分布式表，在使用上具有一定局限，例如不能进行权限控制等。\n\n#### 参数\n\n**dbHandle** 是一个未分区的数据库的句柄。\n\n**table** 是将要被保存的内存中的表。\n\n**tableName** 是要保存的表的名称。如果没有指定，将会与内存中的表的名称相同。它需要用反引号(\\`)或双引号引用。\n\n**append** 设置了追加模式。当它为 true 时，新的表会被追加到旧的表之后。默认的设置是 false。\n\n**compression** 设置压缩模式。当它为 true 时，表会以压缩模式保存到磁盘中。默认的设置是 false。\n\n#### 例子\n\n```\ndb=database(\"C:/DolphinDB/Data/db1\")\nt=table(take(1..10,10000000) as id, rand(10,10000000) as x, rand(10.0,10000000) as y);\n```\n\n把表 t 保存为本地磁盘表：\n\n```\nsaveTable(dbHandle=db, table=t);\n```\n\n指定 *tableName*：\n\n```\nsaveTable(dbHandle=db, table=t, tableName=`t1);\n```\n\n指定 *tableName*，并把 *append* 设置为 true：\n\n```\nsaveTable(dbHandle=db, table=t, tableName=`t2, append=true);\n```\n\n指定 *tableName*，并把 *compression* 设置为 true：\n\n```\nsaveTable(dbHandle=db, table=t, tableName=`t3, append=false, compression=true);\n```\n"
    },
    "saveText": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/saveText.html",
        "signatures": [
            {
                "full": "saveText(obj, filename, [delimiter=','], [append=false], [header=true], [bom=''])",
                "name": "saveText",
                "parameters": [
                    {
                        "full": "obj",
                        "name": "obj"
                    },
                    {
                        "full": "filename",
                        "name": "filename"
                    },
                    {
                        "full": "[delimiter='",
                        "name": "[delimiter='"
                    },
                    {
                        "full": "']",
                        "name": "']"
                    },
                    {
                        "full": "[append=false]",
                        "name": "append",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[header=true]",
                        "name": "header",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[bom='']",
                        "name": "bom",
                        "optional": true,
                        "default": "''"
                    }
                ]
            }
        ],
        "markdown": "### [saveText](https://docs.dolphindb.cn/zh/funcs/s/saveText.html)\n\n\n\n#### 语法\n\nsaveText(obj, filename, \\[delimiter=','], \\[append=false], \\[header=true], \\[bom=''])\n\n#### 详情\n\n将 DolphinDB 变量或 SQL 读取的数据存为磁盘上的文本文件。与 [saveTable](https://docs.dolphindb.cn/zh/funcs/s/saveTable.html) 命令相比，`saveText` 需要更多的磁盘空间且耗时更久。\n\n#### 参数\n\n**obj** 可以是表、矩阵、向量或 SQL 元代码。*obj* 取 SQL 元代码时，系统将分配多个线程并发读取数据，并通过独立的写线程将数据写入文件。否则，数据查询和写入将由当前 worker 处理。\n\n**filename** 是在服务器端输出文件的绝对路径或相对路径。不支持指定保存文件的格式，目前仅支持保存为 CSV 格式的文本。\n\n**delimiter** 是表中的列分隔符。系统的默认分隔符是逗号(,)。\n\n**append** 是一个布尔值，表示输出文件能够被追加。默认值为 false。\n\n**header** 是一个布尔值，表示 *obj* 为数据表时，是否在文件中保留列名。默认值为 true。\n\n**Note:** 向已存在的非空文件中追加数据（即 *append* = true 时），该参数将失效。\n\n**bom** 字符串标量（大小写不敏感），表示是否输出 BOM 头格式。目前仅支持”UTF-8“。默认为空，表示不输出 BOM 头。若用户需要用 Excel 打开导出的 CSV 文件（且数据包含中文），建议传入”UTF-8“，否则可能出现乱码。\n\n#### 例子\n\n例1.\n\n```\nn=20000000\nsyms=`IBM`C`MS`MSFT`JPM`ORCL`GE`EBAY`GOOG`FORD`GS\ntimestamp=09:30:00+rand(18000,n)\nsym=rand(syms,n)\nqty=100*(1+rand(100,n))\nprice=5.0+rand(100.0,n)\nt1=table(timestamp,sym,qty,price);\n\ntimer saveText(t1, \"/home/DolphinDB/trades.txt\");\n// output\nTime elapsed: 191488 ms\n```\n\n例2.\n\n```\nn=100\nt1=table(1..n as id, rand(1000, n) as x)\nsaveText(t1, \"/home/DolphinDB/t.csv\",,1)\nt2=table((n+1)..(2*n) as id, rand(1000, n) as x)\nsaveText(t2, \"/home/DolphinDB/t.csv\",,1)\nt = loadText(\"/home/DolphinDB/t.csv\")\nselect count(*) from t;\n// output\n200\n```\n\n例3. 将分布式表的数据存储为文本文件。\n\n```\nif(existsDatabase(\"dfs://testdb\")){\n  dropDatabase(\"dfs://testdb\")\n}\nn=3000\nticker = rand(`MSFT`GOOG`FB`ORCL`IBM`PPT`AZH`ILM`ANZ,n);\nid = rand(`A`B`C, n)\nx=rand(1.0, n)\nt=table(ticker, id, x)\ndb=database(directory=\"dfs://testdb\", partitionType=HASH, partitionScheme=[STRING, 5])\npt = db.createPartitionedTable(t, `pt, `ticker)\npt.append!(t)\n\nsaveText(<select * from pt>, \"/home/DolphinDB/pt.txt\")\n```\n"
    },
    "saveTextFile": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/saveTextFile.html",
        "signatures": [
            {
                "full": "saveTextFile(content, filename, [append=false], [lastModified])",
                "name": "saveTextFile",
                "parameters": [
                    {
                        "full": "content",
                        "name": "content"
                    },
                    {
                        "full": "filename",
                        "name": "filename"
                    },
                    {
                        "full": "[append=false]",
                        "name": "append",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[lastModified]",
                        "name": "lastModified",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [saveTextFile](https://docs.dolphindb.cn/zh/funcs/s/saveTextFile.html)\n\n\n\n#### 语法\n\nsaveTextFile(content, filename, \\[append=false], \\[lastModified])\n\n#### 详情\n\n通过追加或覆盖将字符串保存到文件中。该函数必须要用户登录后才能执行。\n\n#### 参数\n\n**content** 是要写入文件的内容。\n\n**filename** 是要保存的文件名。仅支持 CSV 格式的文件。若传入其他格式文件，则无法保证数据准确性。\n\n**append** 是一个布尔值。True 表示追加，False表示覆盖。\n\n**lastModified** 是最后修改的时间，显示的是1970年1月1日零时开始的秒数。\n\n#### 例子\n\n```\nsaveTextFile(\"1234567890\\n0987654321\\nabcdefghijk\\n\", \"/home/test/abc.txt\", false, 1495762562671l);\n\n// output\n[content of file \"/home/test/abc.txt\"]\n1234567890\n0987654321\nabcdefghijk\n```\n"
    },
    "scheduleJob": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/scheduleJob.html",
        "signatures": [
            {
                "full": "scheduleJob(jobId, jobDesc, jobFunc, scheduleTime, startDate, endDate, frequency, [days], [onComplete], [priority], [parallelism])",
                "name": "scheduleJob",
                "parameters": [
                    {
                        "full": "jobId",
                        "name": "jobId"
                    },
                    {
                        "full": "jobDesc",
                        "name": "jobDesc"
                    },
                    {
                        "full": "jobFunc",
                        "name": "jobFunc"
                    },
                    {
                        "full": "scheduleTime",
                        "name": "scheduleTime"
                    },
                    {
                        "full": "startDate",
                        "name": "startDate"
                    },
                    {
                        "full": "endDate",
                        "name": "endDate"
                    },
                    {
                        "full": "frequency",
                        "name": "frequency"
                    },
                    {
                        "full": "[days]",
                        "name": "days",
                        "optional": true
                    },
                    {
                        "full": "[onComplete]",
                        "name": "onComplete",
                        "optional": true
                    },
                    {
                        "full": "[priority]",
                        "name": "priority",
                        "optional": true
                    },
                    {
                        "full": "[parallelism]",
                        "name": "parallelism",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [scheduleJob](https://docs.dolphindb.cn/zh/funcs/s/scheduleJob.html)\n\n\n\n#### 语法\n\nscheduleJob(jobId, jobDesc, jobFunc, scheduleTime, startDate, endDate, frequency, \\[days], \\[onComplete], \\[priority], \\[parallelism])\n\n#### 详情\n\n提交定时任务。我们可以使用 [getRecentJobs](https://docs.dolphindb.cn/zh/funcs/g/getRecentJobs.html) 来查看最近完成的定时任务。\n\n执行定时任务生成的信息保存在 jodId.msg 文件中；如果定时任务会返回值，它会保存在 jobId.object 文件中。 jobId.msg 和 jobId.object 保存在 batchJobs 文件夹中。我们可以分别使用 [getJobMessage](https://docs.dolphindb.cn/zh/funcs/g/getJobMessage.html) 和 [getJobReturn](https://docs.dolphindb.cn/zh/funcs/g/getJobReturn.html) 来查看这两个文件。\n\n#### 参数\n\n**jobId** 是一个字符串。\n\n**jobDesc** 是关于任务描述的字符串。\n\n**jobFunc** 是一个没有参数的函数。它通常是一个部分应用。注意：若该函数是一个自定义函数，则它只能接收标量、数据对或常规数组作为默认参数。\n\n**scheduleTime** 是一个 MINUTE 类型的标量/向量。任务之间的时间间隔最小为5分钟。\n\n**startDate** 是一个日期标量。\n\n**endDate** 是一个日期标量。\n\n**frequency** 是一个字符。它可以是下列3个值之一：'D' 表示每日，'W' 表示每周，'M' 表示每月。\n\n**days** 是一个整型标量/向量，表示执行定时任务的日期。如果 *frequency* 为 'W' 或 'M' 时，它是必需的。如果 *frequency* 为W，*days* 可以取以下值：0（周日），1（周一），...，5（周五），6（周六）。\n\n**onComplete** 是一个有4个参数的回调函数，细节请见以下最后一个例子。当定时作业执行完毕（包括有异常的情况）后，会执行该函数。可通过该函数向外部消息系统如邮件系统或微信与钉钉发送消息。\n\n**priority**属于 0 到 8 的整数，表示任务的优先级。默认值为 4。\n\n**parallelism**属于 0 到 8 的整数，表示任务的并行度。默认值为 2。\n\n注：用户设置的优先级和并行度，还分别受到 [setMaxJobPriority](https://docs.dolphindb.cn/zh/funcs/s/setMaxJobPriority.html) 的参数 *maxPriority*和 [setMaxJobParallelism](https://docs.dolphindb.cn/zh/funcs/s/setMaxJobParallelism.html) 的参数 *maxParallelism*限制。最终的优先级和并行度分别为 min(*priority*, *maxPriority*), min(*parallelism*, *maxParallelism*)。\n\n#### 返回值\n\n返回定时任务的任务 ID。如果 *jobId* 与已有的定时任务的 ID 不一致，系统返回 *jobId*。否则在 *jobId* 后面添加当前日期，\"000\", \"001\" 等作为后缀，直到产生唯一的任务 ID。\n\n#### 例子\n\n定时执行一个函数：\n\n```\ndef f():1+2;\nscheduleJob(jobId=`daily, jobDesc=\"Daily Job 1\", jobFunc=f, scheduleTime=17:23m, startDate=2018.01.01, endDate=2018.12.31, frequency='D');\nscheduleJob(jobId=`weekly, jobDesc=\"Weekly Job\", jobFunc=f, scheduleTime=17:30m, startDate=2018.01.01, endDate=2018.12.31, frequency='W', days=2);\n```\n\n定时执行一个脚本：\n\n```\nscheduleJob(jobId=`monthly, jobDesc=\"Monthly Job 1\", jobFunc=run{\"monthlyJob.dos\"}, scheduleTime=17:23m, startDate=2018.01.01, endDate=2018.12.31, frequency='M', days=1);\n```\n\n这里使用部分应用 run{\\<script>}，因为 *jobFunc* 必须是没有参数的函数。\n\n```\ngetJobMessage(`daily);\n// output\n018-02-08 17:23:27.166296 Start the job [daily]: Daily Job 1\n018-02-08 17:23:27.167303 The job is done.\n\ngetJobReturn(`daily);\n// output\n3\n```\n\n可以在一天中多次定时执行相同的任务：\n\n```\nscheduleJob(jobId=`Trading, jobDesc=\"Generate Trading Tickets\", jobFunc=run{\"TradingTickets.dos\"}, scheduleTime=[09:25m, 12:00m, 02:00m, 15:50m], startDate=2018.01.01, endDate=2018.12.31, frequency='D');\n```\n\n在这种情况下，每次执行定时任务时，任务 ID 是不一样的。\n\n可以在每周的工作日中多次执行相同的定时任务：\n\n```\nscheduleJob(jobId=`PnL, jobDesc=\"Calculate Profit & Loss\", jobFunc=run{\"PnL.dos\"}, scheduleTime=[12:00m, 02:00m, 14:50m], startDate=2018.01.01, endDate=2018.12.31, frequency='W', days=[1,2,3,4,5]);\n```\n\n定时任务执行结束后可发送邮件通知。以下脚本运行前需安装 HttpClient 插件。\n\n```\ndef sendEmail(jobId, jobDesc, success, result){\n  desc = \"jobId=\" + jobId + \" jobDesc=\" + jobDesc\n  if(success){\n  desc += \" successful \" + result\n    res = httpClient::sendEmail('patrick.mahomes@dolphindb.com','password','andy.reid@dolphindb.com','This is a subject',desc)\n  }\n  else{\n  desc += \" with error: \" + result\n    res = httpClient::sendEmail('patrick.mahomes@dolphindb.com','password','andy.reid@dolphindb.com','This is a subject',desc)\n  }\n}\nscheduleJob(jobId=`PnL, jobDesc=\"Calculate Profit & Loss\", jobFunc=run{\"PnL.dos\"}, scheduleTime=[12:00m, 02:00m, 14:50m], startDate=2018.01.01, endDate=2018.12.31, frequency='W', days=[1,2,3,4,5], onComplete=sendEmail);\n```\n"
    },
    "schema": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/schema.html",
        "signatures": [
            {
                "full": "schema(table|dbHandle)",
                "name": "schema",
                "parameters": [
                    {
                        "full": "table|dbHandle",
                        "name": "table|dbHandle"
                    }
                ]
            }
        ],
        "markdown": "### [schema](https://docs.dolphindb.cn/zh/funcs/s/schema.html)\n\n\n\n#### 语法\n\nschema(table|dbHandle)\n\n#### 详情\n\n显示指定数据表或数据库的结构信息。\n\n#### 参数\n\n参数可为一个数据表，亦可为一个数据库句柄 （dbHandle）。\n\n#### 返回值\n\n返回一个无序字典，包含以下字段（按首字母排序）：\n\n* atomic：写入事务的原子性层级。\n\n* chunkGranularity：分区粒度。\n\n* clusterReplicationEnabled：集群间异步复制的开启状态。若开启，则该值为 true，否则为 false。\n\n* colDefs：数据表各字段的结构信息。\n\n  * name：列名\n\n  * typeString：列的类型\n\n  * typeInt：列类型对应的ID\n\n  * extra：仅在列类型为 DECIMAL 时，显示 DECIMAL 的 scale\n\n  * comment：列字段的注释信息\n\n  * sensitive：该列是否已设置为敏感列，仅当 DFS 表返回此列。\n\n* compressMethods：分布式表各列的压缩算法类型。\n\n  * name：列名\n\n  * compressMethods：压缩算法类型。lz4，delta （即 delta-of-delta encoding 算法）或 zstd\n\n* databaseDir：数据库的保存目录的路径。\n\n* databaseOwner：数据库创建者名称。\n\n* dbUrl：DFS 表所在分布式数据库的路径。仅当 *table*为 DFS 表时返回。\n\n* encryptMode：建表时指定的表加密方式。仅当 *table*为 DFS 表时返回。\n\n* engineType：存储引擎的类型，OLAP 或者 TSDB。\n\n* keepDuplicates：数据保留策略。\n\n* keyColumn：键值列列名。仅当 *table*包含键值列时返回。\n\n* partitionColumnIndex：分区列在表字段中对应的下标。维度表时，该值为 -1。\n\n* partitionColumnName：分区列的名称。\n\n* partitionColumnType：分区列类型对应的 ID，参照数据类型章节。\n\n* partitionSchema：分区的结构。\n\n* partitionSites：若 `database` 函数配置了 *locations* 参数，则该字段将列出 locations 指定节点的 ip:port 信息。\n\n* partitionTypeName / partitionType：分区的类型名和对应的 ID。VALUE(1), RANGE(2), LIST(3), COMPO(4), HASH(5)。\n\n* sortColumns：数据表的排序列。\n\n* softDelete：创建的表开启了软删除。仅在通过 TSDB 存储引擎创建的库中的表的 schema 返回值中可见。该功能开启时，softDelete 返回字段中显示为 true；否则显示为 false。\n\n* sortKeyMappingFunction：索引列的映射函数。\n\n* tableComment：表的注释。\n\n* tableName：DFS 表的表名。仅当 *table*为 DFS 表时返回。\n\n* tableOwner：表创建者名称。\n\n* partitionFunction：处理分区列数据的函数。是一个字符串向量，每个元素是一个函数签名。若某个元素为 asis，则表示建表时未指定函数对象。例如：`partitionFunction->[myPartitionFunc{, 6, 8},asis]`。\n\n* latestKeyCache：该分区表是否开启最新值缓存功能。\n\n* compressHashSortKey：该分区表是否开启静态表 sortKey 压缩功能。\n\n#### 例子\n\n应用于 OLAP 引擎下的数据库：\n\n```\nn=1000000  // 设置变量n为1000000\nID=rand(10, n)  // 生成一个随机整数数组ID\nx=rand(1.0, n)  // 生成一个随机浮点数数组x\nt=table(ID, x)  // 创建表t，包含ID和x两列\ndb=database(\"dfs://rangedb101\", RANGE, 0 5 10)  // 创建分布式数据库dfs://rangedb101，使用RANGE分布方式\npt = db.createPartitionedTable(t, `pt, `ID)  // 创建分区表pt，使用ID作为分区键\npt.append!(t)  // 将表t的数据追加到分区表pt中\npt=loadTable(db,`pt);  // 从数据库db中加载分区表pt\nschema(db);  // 显示数据库db的模式信息\n```\n\n返回：\n\n```\ndatabaseDir->dfs://rangedb101\npartitionSchema->[0,5,10]\npartitionSites->\natomic->TRANS\nchunkGranularity->TABLE\npartitionType->2\npartitionTypeName->RANGE\npartitionColumnType->4\nclusterReplicationEnabled->1\ndatabaseOwner->admin\n```\n\n应用于 OLAP 引擎下的数据表时：\n\n```\nschema(pt);\n```\n\n返回：\n\n```\nchunkGranularity->TABLE\ntableOwner->admin\ncompressMethods->\nname compressMethods\n---- ---------------\nID   lz4            \nx    lz4            \n\ncolDefs->\nname typeString typeInt comment\n---- ---------- ------- -------\nID   INT        4              \nx    DOUBLE     16             \n\nchunkPath->\npartitionColumnIndex->0\npartitionColumnName->ID\npartitionColumnType->4\npartitionType->2\npartitionTypeName->RANGE\npartitionSchema->[0,5,10]\npartitionSites->\n```\n\n应用于 TSDB 引擎下的数据库：\n\n```\nn = 10000 // 设置变量n为10000\nSecurityID = rand(`st0001`st0002`st0003`st0004`st0005, n) // 从指定的证券ID中随机选择n个值赋给SecurityID\nsym = rand(`A`B, n)  // 从符号A和B中随机选择n个值赋给sym\nTradeDate = 2022.01.01 + rand(100,n) // 从2022年1月1日至100天后的日期中随机选择n个日期赋给TradeDate\nTotalVolumeTrade = rand(1000..3000, n)  // 生成n个介于1000和3000之间的随机整数赋给TotalVolumeTrade\nTotalValueTrade = rand(100.0, n)  // 生成n个小数赋给TotalValueTrade\nschemaTable_snap = table(SecurityID, TradeDate, TotalVolumeTrade, TotalValueTrade).sortBy!(`SecurityID`TradeDate)  \n// 创建表schemaTable_snap，并按SecurityID和TradeDate排序\n\ndbPath = \"dfs://TSDB_STOCK\"  // 设置数据库路径为dfs://TSDB_STOCK\nif (existsDatabase(dbPath)){dropDatabase(dbPath)}  // 如果数据库路径存在，则删除该数据库\ndb_snap = database(dbPath, VALUE, 2022.01.01..2022.01.05, engine='TSDB')  // 创建名为db_snap的数据库，时间范围为2022年1月1日至2022年1月5日，引擎为TSDB\n\nschema(db_snap)  // 显示db_snap的模式信息\n```\n\n返回：\n\n```\ndatabaseDir->dfs://TSDB_STOCK\npartitionSchema->[2022.01.01,2022.01.02,2022.01.03,2022.01.04,2022.01.05]\npartitionSites->\nengineType->TSDB\natomic->TRANS\nchunkGranularity->TABLE\npartitionType->1\npartitionTypeName->VALUE\npartitionColumnType->6\nclusterReplicationEnabled->1\ndatabaseOwner->admin\n```\n\n应用于 TSDB 引擎下的数据表：\n\n```\n// 定义名为myHashFunc的函数，该函数接受一个参数x，并返回x的哈希桶编号，桶数为10\ndef myHashFunc(x){\n  return hashBucket(x, 10)\n}\n\n// 使用db_snap中的schemaTable_snap创建一个分区表snap，表名为\"snap\"\n// 以TradeDate分区，以SecurityID和TradeDate排序\n// 保留重复值，排序键映射函数为myHashFunc\nsnap = createPartitionedTable(dbHandle=db_snap, table=schemaTable_snap, tableName=\"snap\", partitionColumns=`TradeDate, sortColumns=`SecurityID`TradeDate, keepDuplicates=ALL, sortKeyMappingFunction=[myHashFunc])\n\n// 显示snap表的模式信息\nschema(snap)\n```\n\n返回：\n\n```\nengineType->TSDB\nkeepDuplicates->ALL\nchunkGranularity->TABLE\nsortColumns->[\"SecurityID\",\"TradeDate\"]\nsortKeyMappingFunction->[\"def myHashFunc(x){\n  return hashBucket(x, 10)\n}\"]\nsoftDelete->0\ntableOwner->admin\ncompressMethods->\nname             compressMethods\n---------------- ---------------\nSecurityID       lz4            \nTradeDate        lz4            \nTotalVolumeTrade lz4            \nTotalValueTrade  lz4            \n\ncolDefs->\nname             typeString typeInt extra comment\n---------------- ---------- ------- ----- -------\nSecurityID       SYMBOL     17                   \nTradeDate        DATE       6                    \nTotalVolumeTrade INT        4                    \nTotalValueTrade  DOUBLE     16                   \n\nchunkPath->\npartitionColumnIndex->1\npartitionColumnName->TradeDate\npartitionColumnType->6\npartitionType->1\npartitionTypeName->VALUE\npartitionSchema->[2022.01.01,2022.01.02,2022.01.03,2022.01.04,2022.01.05]\npartitionSites->\n```\n\n建立一个点位管理表，复合分区方案按 id 和 ts 分区，创建了一个名为 pt 的点位管理表。该表使用 ticket 和 id2 作为唯一识别一个点位的两列；启用最新值缓存，且 value 为 IOTANY 类型，可存储不同类型的测点数据；启用了 hashSortKey 压缩。\n\n```\ndbName = \"pt\"\nif(existsDatabase(dbName)){\n        dropDatabase(dbName)\n}\ndb1 = database(, partitionType=HASH, partitionScheme=[INT, 10])\ndb2 = database(, partitionType=VALUE, partitionScheme=2017.08.07..2017.08.11)\ndb = database(dbName, COMPO, [db1, db2], engine='IOTDB')\n\ncreate table \"dfs://db\".\"pt\" (\n        id INT,\n        ticket SYMBOL,\n        id2 LONG,\n        ts TIMESTAMP,\n        id3 IOTANY\n)\npartitioned by id, ts,\nsortColumns = [`ticket, `id2, `ts],\nsortKeyMappingFunction = [hashBucket{, 50}, hashBucket{, 50}],\nlatestKeyCache = true,\ncompressHashSortKey = true\nprint schema(loadTable(dbName, `pt))\n```\n\n返回：\n\n```\n/* \nengineType->IOTDB\nkeepDuplicates->ALL\nchunkGranularity->TABLE\nsortColumns->[\"deviceId\",\"location\",\"timestamp\"]\nsortKeyMappingFunction->[\"hashBucket{, 50}\",\"hashBucket{, 50}\"]\nsoftDelete->0\ntableOwner->admin\ncompressMethods->name      compressMethods\n--------- ---------------\ndeviceId  lz4            \nlocation  lz4            \ntimestamp lz4            \nvalue     lz4            \n\ntableComment->\nlatestKeyCache->1\ncompressHashSortKey->0\ncolDefs->name      typeString typeInt extra comment\n--------- ---------- ------- ----- -------\ndeviceId  INT        4                    \nlocation  SYMBOL     17                   \ntimestamp TIMESTAMP  12                   \nvalue     IOTANY     41                   \n\nchunkPath->\npartitionColumnIndex->[0,2]\npartitionColumnName->[\"deviceId\",\"timestamp\"]\npartitionColumnType->[4,6]\npartitionType->[5,1]\npartitionTypeName->[\"HASH\",\"VALUE\"]\npartitionSchema->(20,[2017.08.07,2017.08.08,2017.08.09,2017.08.10,2017.08.11,2024.10.12])\npartitionSites->\n*/\n```\n"
    },
    "schur": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/schur.html",
        "signatures": [
            {
                "full": "schur(obj, [sort])",
                "name": "schur",
                "parameters": [
                    {
                        "full": "obj",
                        "name": "obj"
                    },
                    {
                        "full": "[sort]",
                        "name": "sort",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [schur](https://docs.dolphindb.cn/zh/funcs/s/schur.html)\n\n\n\n#### 语法\n\nschur(obj, \\[sort])\n\n#### 详情\n\n计算矩阵的 Schur（舒尔）分解。\n\n**Note:**\n\nDolphinDB `schur` 与 [scipy.linalg.schur](https://docs.scipy.org/doc/scipy/reference/generated/scipy.linalg.schur.html) 的核心功能相同。区别在于 `scipy.linalg.schur` 额外支持 *output*、自定义排序函数和更多计算控制参数。\n\n#### 参数\n\n**obj** 是一个方阵。\n\n**sort** 是一个字符串，表示根据所选参数对高特征值进行排序。它的可选参数可以是 'lhp'（特征值为小于零的实数），'rhp'（特征值为大于零的实数），'iuc'（特征值的绝对值<=1.0），或 'ouc'（特征值的绝对值>1.0）。\n\n**Note:** 若没有指定该参数，表示不进行排序。\n\n#### 返回值\n\n假设输入方阵为 A：\n\n* 如果不指定 *sort* 参数，返回两个矩阵：T 矩阵（矩阵 A 的 schur 形式，正交矩阵）与酉矩阵 Z（对于实数矩阵而言，Z 的转置矩阵与其逆矩阵相等），使得 A = Z*T*Z-1 。\n\n* 如果指定 *sort* 参数，返回结果还包含一个整数，表示满足排序条件的特征值的数量。\n\n#### 例子\n\n```\nm=matrix([[0,0,1],[2,1,0],[2,2,1]]);\nT,Z=schur(m)\nT;\n```\n\n| #0       | #1        | #2        |\n| -------- | --------- | --------- |\n| 2.658967 | 1.424405  | -1.929334 |\n| 0        | -0.329484 | -0.490637 |\n| 0        | 1.311789  | -0.329484 |\n\n```\nZ\n```\n\n| #0       | #1        | #2        |\n| -------- | --------- | --------- |\n| 0.727116 | -0.601562 | 0.330796  |\n| 0.528394 | 0.798019  | 0.289768  |\n| 0.438294 | 0.035904  | -0.898114 |\n\n```\nT,Z,s=schur(m, 'lhp');\nT;\n```\n\n| #0        | #1        | #2        |\n| --------- | --------- | --------- |\n| -0.329484 | 1.570974  | 2.251318  |\n| -0.40969  | -0.329484 | -0.092398 |\n| 0         | 0         | 2.658967  |\n\n```\nZ\n```\n\n| #0        | #1        | #2       |\n| --------- | --------- | -------- |\n| 0.703818  | -0.632169 | 0.324042 |\n| 0.509043  | 0.766983  | 0.390655 |\n| -0.495495 | -0.109999 | 0.861618 |\n\n```\ns\n// output\n2\nT,Z,s=schur(m, 'rhp');\n\ns;\n// output\n1\n\nm=matrix([[0,0,9],[-2,1,0],[2,2,1]]);\nT,Z,s=schur(m, 'iuc');\ns;\n// output\n0\n\nT,Z,s=schur(m, 'ouc');\ns;\n// output\n1\n```\n"
    },
    "scramClientFinal": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/scramClientFinal.html",
        "signatures": [
            {
                "full": "scramClientFinal(user, combinedNonce, clientProof)",
                "name": "scramClientFinal",
                "parameters": [
                    {
                        "full": "user",
                        "name": "user"
                    },
                    {
                        "full": "combinedNonce",
                        "name": "combinedNonce"
                    },
                    {
                        "full": "clientProof",
                        "name": "clientProof"
                    }
                ]
            }
        ],
        "markdown": "### [scramClientFinal](https://docs.dolphindb.cn/zh/funcs/s/scramClientFinal.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nscramClientFinal(user, combinedNonce, clientProof)\n\n#### 详情\n\n`scramClientFinal` 是 SCRAM 认证过程的第二阶段服务端函数。该函数验证客户端提供的凭证及 combined\\_nonce 有效性。\n\n**Note:**\n\nSCRAM 完整认证流程如下所示：\n\n**1. 客户端发起认证请求**\n\n生成一个客户端 nonce（一次性随机值），然后将其与用户名一起发给服务端。\n\n**2. 服务端响应认证请求**\n\n服务端收到信息后，通过`scramClientFirst`函数生成用于加密的哈希盐值、密码哈希的迭代次数，并生成 nonce 与客户端 nonce 拼接，然后将这些信息返回给客户端。\n\n**3. 客户端生成认证凭证，然后再次提交认证请求**\n\n客户端根据收到的信息将明文密码转化为密钥，最终生成客户端凭证，然后向服务端提交带凭证的认证请求。\n\n**4. 服务端验证认证请求**\n\n服务端收到请求后，通过`scramClientFinal`对拼接后的 nonce 以及客户端凭证进行验证。若验证成功，返回服务端签名发送给客户端。\n\n**5. 客户端验证服务端签名**\n\n客户端对服务端返回的签名进行认证。若签名验证通过，则用户登录成功；若不通过，则断开会话连接。\n\n#### 参数\n\n**user**是表示用户名的字符串。它只能包含字母、下划线或数字，并且它不能以数字开头。长度不能超过30个字符。\n\n**combinedNonce** 客户端 nonce 和服务器端 nonce 的 base64 编码组合，即 [scramClientFirst](https://docs.dolphindb.cn/zh/funcs/s/scramClientFirst.html) 函数在此前返回的 combined\\_nonce 字段。\n\n**clientProof** 客户端生成的凭证，base64 编码。\n\n#### 返回值\n\n返回 Base64 编码的服务端签名。\n\n#### 例子\n\n以下脚本是一个完整的示例，展示了如何在 Python 客户端完成用户（”user01”）SCRAM 模式登录，其中服务端的操作通过 DolphinDB Python API 的相关接口实现（详见 [Python API 手册](https://docs.dolphindb.cn/zh/pydoc/BasicOperations/Session/Constructor.html)）。\n\n```\nimport dolphindb as ddb\n\n# 建立与 DolphinDB 的会话连接\ns = ddb.session(\"183.134.101.133\", 8888)\ns.run(\"print\", 1, 2, 3)\n\n##########################\n\nimport hashlib\nimport hmac\nimport os\nimport base64\nimport hashlib\n\n\n# ------------------ 服务端函数 ------------------\ndef server_handle_client_first(username, client_nonce):\n  \"\"\"处理第一次认证请求，返回 salt、迭代次数和合并后的 nonce\"\"\"\n    salt, iter_count, nonce = s.run(\"scramClientFirst\", username, client_nonce)\n\n    return {\n        \"salt\": salt,\n        \"iteration_count\": iter_count,\n        \"combined_nonce\": nonce\n    }\n\ndef server_handle_client_final(user, combined_nonce, client_proof):    \n\"\"\"处理最终认证请求，验证 client_proof，返回 server_signature\"\"\"\n    return s.run(\"scramClientFinal\", user, combined_nonce, client_proof)\n\n# ------------------ 客户端函数 ------------------\ndef client_initiate_authentication(username):\n    \"\"\"客户端发起认证，生成 client_nonce\"\"\"\n    client_nonce = base64.b64encode(os.urandom(16)).decode()\n    return {\n        \"username\": username,\n        \"client_nonce\": client_nonce\n    }\n\ndef client_generate_proof(user, password, salt, iteration_count, cnonce, combined_nonce):\n    \"\"\"生成 client_proof\"\"\"\n    \n    # 计算SaltedPassword\n    salted_password = hashlib.pbkdf2_hmac(\n        'sha256',\n        password.encode(),\n        base64.b64decode(salt),\n        iteration_count\n    )\n    \n    # 生成密钥\n    client_key = hmac.new(salted_password, b\"Client Key\", hashlib.sha256).digest()\n    stored_key = hashlib.sha256(client_key).digest()\n    server_key = hmac.new(salted_password, b\"Server Key\", hashlib.sha256).digest()\n    \n    # 构造AuthMessage\n    auth_message = (\n        f\"n={user},r={cnonce},\"  # client-first-bare\n        f\"r={combined_nonce},s={salt},i={iteration_count},\"  # server-first\n        f\"c=biws,r={combined_nonce}\"                         # client-final-without-proof\n    )\n    \n    # 计算ClientProof\n    client_signature = hmac.new(stored_key, auth_message.encode(), hashlib.sha256).digest()\n    client_proof = bytes([ck ^ cs for ck, cs in zip(client_key, client_signature)])\n    \n    return {\n        \"client_proof\": base64.b64encode(client_proof).decode(),\n        \"server_key\": server_key,\n        \"auth_message\": auth_message\n    }\n\n# ------------------ SCRAM 模式登录 ------------------\nif __name__ == \"__main__\":\n    \n    # 客户端发起认证\n    client_data = client_initiate_authentication(\"user01\")\n    \n    # 服务端处理首次请求\n    server_response = server_handle_client_first(\n        client_data[\"username\"], \n        client_data[\"client_nonce\"]\n    )\n    \n    password = \"123456\"\n    \n    # 客户端生成证明\n    client_proof_data = client_generate_proof(\n        \"user01\",\n        password,\n        server_response[\"salt\"],\n        server_response[\"iteration_count\"],\n        client_data[\"client_nonce\"],\n        server_response[\"combined_nonce\"]\n    )\n    \n    # 服务端验证并返回签名\n    # auth_sessions[server_response[\"combined_nonce\"]][\"auth_message\"] = client_proof_data[\"auth_message\"]\n    server_signature = server_handle_client_final(\n        \"user01\",\n        server_response[\"combined_nonce\"],\n        client_proof_data[\"client_proof\"]\n    )\n    \n    # 客户端验证服务端签名\n    computed_server_sig = hmac.new(\n        client_proof_data[\"server_key\"],\n        client_proof_data[\"auth_message\"].encode(),\n        hashlib.sha256\n    ).digest()\n    \n    # 若匹配则认证成功\n    assert server_signature == base64.b64encode(computed_server_sig).decode()\n    print(\"SCRAM authentication succeeded!\")\n\n    # 查看当前会话与用户\n    print(s.run(\"getCurrentSessionAndUser()\"))\n```\n"
    },
    "scramClientFirst": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/scramClientFirst.html",
        "signatures": [
            {
                "full": "scramClientFirst(user, cnonce)",
                "name": "scramClientFirst",
                "parameters": [
                    {
                        "full": "user",
                        "name": "user"
                    },
                    {
                        "full": "cnonce",
                        "name": "cnonce"
                    }
                ]
            }
        ],
        "markdown": "### [scramClientFirst](https://docs.dolphindb.cn/zh/funcs/s/scramClientFirst.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nscramClientFirst(user, cnonce)\n\n#### 详情\n\n`scramClientFirst` 用于 SCRAM（Salted Challenge Response Authentication Mechanism）认证过程的第一阶段。通过该函数可获取服务器端的认证信息。\n\n**返回值：**\n\n**Note:**\n\nSCRAM 完整认证流程如下所示：\n\n**1. 客户端发起认证请求**\n\n生成一个客户端 nonce（一次性随机值），然后将其与用户名一起发给服务端。\n\n**2. 服务端响应认证请求**\n\n服务端收到信息后，通过`scramClientFirst`函数生成用于加密的哈希盐值、密码哈希的迭代次数，并生成 nonce 与客户端 nonce 拼接，然后将这些信息返回给客户端。\n\n**3. 客户端生成认证凭证，然后再次提交认证请求**\n\n客户端根据收到的信息将明文密码转化为密钥，最终生成客户端凭证，然后向服务端提交带凭证的认证请求。\n\n**4. 服务端验证认证请求**\n\n服务端收到请求后，通过`scramClientFinal`对拼接后的 nonce 以及客户端凭证进行验证。若验证成功，返回服务端签名发送给客户端。\n\n**5. 客户端验证服务端签名**\n\n客户端对服务端返回的签名进行认证。若签名验证通过，则用户登录成功；若不通过，则断开会话连接。\n\n#### 参数\n\n**user**是表示用户名的字符串。它只能包含字母、下划线或数字，并且它不能以数字开头。长度不能超过30个字符。\n\n**cnonce** 是用户在客户端生成的 [nonce](https://en.wikipedia.org/wiki/Cryptographic_nonce)，必须是 16 字节的一次性随机数，使用 base64 编码。\n\n#### 返回值\n\n一个包含以下三个元素的元组：\n\n* salt：base64 编码的哈希盐值\n* iterCount：密码哈希的迭代次数\n* combined\\_nonce：客户端 nonce 和服务器端 nonce 的 base64 编码组合\n\n#### 例子\n\n以下脚本是一个完整的示例，展示了如何在 Python 客户端完成用户（”user01”）SCRAM 模式登录，其中服务端的操作通过 DolphinDB Python API 的相关接口实现（详见 [Python API 手册](https://docs.dolphindb.cn/zh/pydoc/BasicOperations/Session/Constructor.html)）。\n\n```\nimport dolphindb as ddb\n\n# 建立与 DolphinDB 的会话连接\ns = ddb.session(\"183.134.101.133\", 8888)\ns.run(\"print\", 1, 2, 3)\n\n##########################\n\nimport hashlib\nimport hmac\nimport os\nimport base64\nimport hashlib\n\n\n# ------------------ 服务端函数 ------------------\ndef server_handle_client_first(username, client_nonce):\n  \"\"\"处理第一次认证请求，返回 salt、迭代次数和合并后的 nonce\"\"\"\n    salt, iter_count, nonce = s.run(\"scramClientFirst\", username, client_nonce)\n\n    return {\n        \"salt\": salt,\n        \"iteration_count\": iter_count,\n        \"combined_nonce\": nonce\n    }\n\ndef server_handle_client_final(user, combined_nonce, client_proof):    \n\"\"\"处理最终认证请求，验证 client_proof，返回 server_signature\"\"\"\n    return s.run(\"scramClientFinal\", user, combined_nonce, client_proof)\n\n# ------------------ 客户端函数 ------------------\ndef client_initiate_authentication(username):\n    \"\"\"客户端发起认证，生成 client_nonce\"\"\"\n    client_nonce = base64.b64encode(os.urandom(16)).decode()\n    return {\n        \"username\": username,\n        \"client_nonce\": client_nonce\n    }\n\ndef client_generate_proof(user, password, salt, iteration_count, cnonce, combined_nonce):\n    \"\"\"生成 client_proof\"\"\"\n    \n    # 计算SaltedPassword\n    salted_password = hashlib.pbkdf2_hmac(\n        'sha256',\n        password.encode(),\n        base64.b64decode(salt),\n        iteration_count\n    )\n    \n    # 生成密钥\n    client_key = hmac.new(salted_password, b\"Client Key\", hashlib.sha256).digest()\n    stored_key = hashlib.sha256(client_key).digest()\n    server_key = hmac.new(salted_password, b\"Server Key\", hashlib.sha256).digest()\n    \n    # 构造AuthMessage\n    auth_message = (\n        f\"n={user},r={cnonce},\"  # client-first-bare\n        f\"r={combined_nonce},s={salt},i={iteration_count},\"  # server-first\n        f\"c=biws,r={combined_nonce}\"                         # client-final-without-proof\n    )\n    \n    # 计算ClientProof\n    client_signature = hmac.new(stored_key, auth_message.encode(), hashlib.sha256).digest()\n    client_proof = bytes([ck ^ cs for ck, cs in zip(client_key, client_signature)])\n    \n    return {\n        \"client_proof\": base64.b64encode(client_proof).decode(),\n        \"server_key\": server_key,\n        \"auth_message\": auth_message\n    }\n\n# ------------------ SCRAM 模式登录 ------------------\nif __name__ == \"__main__\":\n    \n    # 客户端发起认证\n    client_data = client_initiate_authentication(\"user01\")\n    \n    # 服务端处理首次请求\n    server_response = server_handle_client_first(\n        client_data[\"username\"], \n        client_data[\"client_nonce\"]\n    )\n    \n    password = \"123456\"\n    \n    # 客户端生成证明\n    client_proof_data = client_generate_proof(\n        \"user01\",\n        password,\n        server_response[\"salt\"],\n        server_response[\"iteration_count\"],\n        client_data[\"client_nonce\"],\n        server_response[\"combined_nonce\"]\n    )\n    \n    # 服务端验证并返回签名\n    # auth_sessions[server_response[\"combined_nonce\"]][\"auth_message\"] = client_proof_data[\"auth_message\"]\n    server_signature = server_handle_client_final(\n        \"user01\",\n        server_response[\"combined_nonce\"],\n        client_proof_data[\"client_proof\"]\n    )\n    \n    # 客户端验证服务端签名\n    computed_server_sig = hmac.new(\n        client_proof_data[\"server_key\"],\n        client_proof_data[\"auth_message\"].encode(),\n        hashlib.sha256\n    ).digest()\n    \n    # 若匹配则认证成功\n    assert server_signature == base64.b64encode(computed_server_sig).decode()\n    print(\"SCRAM authentication succeeded!\")\n\n    # 查看当前会话与用户\n    print(s.run(\"getCurrentSessionAndUser()\"))\n```\n"
    },
    "scs": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/scs.html",
        "signatures": [
            {
                "full": "scs(f, [P], [A], [b], [Aeq], [beq], [lb], [ub], [x0], [c], [eps], [alpha])",
                "name": "scs",
                "parameters": [
                    {
                        "full": "f",
                        "name": "f"
                    },
                    {
                        "full": "[P]",
                        "name": "P",
                        "optional": true
                    },
                    {
                        "full": "[A]",
                        "name": "A",
                        "optional": true
                    },
                    {
                        "full": "[b]",
                        "name": "b",
                        "optional": true
                    },
                    {
                        "full": "[Aeq]",
                        "name": "Aeq",
                        "optional": true
                    },
                    {
                        "full": "[beq]",
                        "name": "beq",
                        "optional": true
                    },
                    {
                        "full": "[lb]",
                        "name": "lb",
                        "optional": true
                    },
                    {
                        "full": "[ub]",
                        "name": "ub",
                        "optional": true
                    },
                    {
                        "full": "[x0]",
                        "name": "x0",
                        "optional": true
                    },
                    {
                        "full": "[c]",
                        "name": "c",
                        "optional": true
                    },
                    {
                        "full": "[eps]",
                        "name": "eps",
                        "optional": true
                    },
                    {
                        "full": "[alpha]",
                        "name": "alpha",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [scs](https://docs.dolphindb.cn/zh/funcs/s/scs.html)\n\n\n\n#### 语法\n\nscs(f, \\[P], \\[A], \\[b], \\[Aeq], \\[beq], \\[lb], \\[ub], \\[x0], \\[c], \\[eps], \\[alpha])\n\n#### 详情\n\n求解目标函数在约束条件下的最优解。具体模型如下：\n\n![image](https://docs.dolphindb.cn/zh/images/scs01.png)\n\n#### 参数\n\n**Note:**\n\n以下参数中，除 *lb*, *ub* 可以为空外，其它参数都不可包含空值。\n\n**f** 二次规划中的一次项系数向量。必须和 x0 长度相同。\n\n**P** 一个矩阵，通过将二次项系数矩阵的对角线元素乘以2得到。例如：所有二次项组成上三角矩阵\n\n![image](https://docs.dolphindb.cn/zh/images/scs02.png)\n\n将对角线上的系数乘以2，其它系数不变，得到的矩阵就是 *P*。\n\n**A** 线性不等式约束的系数矩阵。列数必须和 x 的长度相同。\n\n**b** 线性不等式约束的右端向量。\n\n**Aeq** 线性等式约束的系数矩阵。列数必须和 x 的长度相同。\n\n**beq** 线性等式约束的右端向量。\n\n**lb** 变量的下界。可以是标量或与 x 等长的向量。注意：当 *lb* 为空时，表示 x 无下界约束。\n\n**ub** 变量的上界。可以是标量或与 x 等长的向量。注意：当 *lb* 为空时，表示 x 无上界约束。\n\n若 *lb* 或 *ub* 是标量，则所有变量都受同一个下界或上界约束。若 *lb* 或 *ub* 为NULL，表示 x 无相应的下界或上界约束。\n\n若 *lb* 或 *ub* 是向量，则 x 中的元素受 *lb* 或 *ub* 中相应位置的元素约束。若向量 *lb* 或 *ub* 中某元素为 NULL，表示此位置的 x 元素无相应的下界或上界约束\n\n**x0** 向量绝对值不等式约束的系数向量。必须和 f 长度相同。\n\n**c** 一个非负数字，表示绝对值不等式约束的右侧常量系数。\n\n**eps** 正浮点数，表示求解的精度。默认值为1e-6，范围为 \\[1e-4, 1e-9]。通过减小该参数值以获得更高精度的解。如果该参数设置值超过规定范围，则会自动调整为默认值。\n\n**alpha** 正浮点数，表示松弛参数。默认值为1.5，范围为 (0, 2)。通过增加 *alpha* 的值来加快求解速度。如果该参数设置值超过规定范围，则会自动调整为默认值。\n\n#### 返回值\n\n具有两个元素的元组。第一个元素是目标函数的最小值，第二个元素是目标函数取最小值时，x 的取值。\n\n#### 例子\n\n求 x, y 满足以下约束条件时，目标函数 x2 + y 2 的最小值\n\n![image](https://docs.dolphindb.cn/zh/images/scs03.png)\n\n```\n// 目标函数中没有一次项，所以系数都为0，f取值如下\nf = [0, 0];\n// 仅存在二次项x^2 和 y^2，系数为均为1，则 P 的取值为\nP = [2, 0, 0, 2]$2:2;\n// 绝对值不等式的约束系数和右端向量\nx0 = [0.4, 0.6];\nc = 0.5;\n// 线性等式为 x+y=1，因此 Aeq 和 beq 的取值为\nAeq = [1, 1]$1:2;\nbeq = [1];\n// 由 x,y>0 得到变量的下界\nlb = [0, 0];\nre = scs(f=f,P=P,Aeq=Aeq,beq=beq,lb=lb,x0=x0,c=c);\nre[1]\n// output\n[0.500000043984074,0.499999955746447]\n```\n\n相关函数：[linprog](https://docs.dolphindb.cn/zh/funcs/l/linprog.html), [quadprog](https://docs.dolphindb.cn/zh/funcs/q/quadprog.html)\n"
    },
    "searchK": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/searchK.html",
        "signatures": [
            {
                "full": "searchK(X, k)",
                "name": "searchK",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "k",
                        "name": "k"
                    }
                ]
            }
        ],
        "markdown": "### [searchK](https://docs.dolphindb.cn/zh/funcs/s/searchK.html)\n\n\n\n#### 语法\n\nsearchK(X, k)\n\n#### 详情\n\n返回第 *k* 小的元素，忽略 NULL 值。\n\n#### 参数\n\n**X** 是一个向量。\n\n#### 返回值\n\n数据类型与 *X* 相同的标量。\n\n#### 例子\n\n```\nsearchK(1 7 3 5 3 9 6 1 NULL, 1);\n```\n\n输出返回：1\n\n```\nsearchK(1 7 3 5 3 9 6 1 NULL, 2);\n```\n\n输出返回：1\n\n```\nsearchK(1 7 3 5 3 9 6 1 NULL, 3);\n```\n\n输出返回：3\n"
    },
    "seasonalEsd": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/seasonalEsd.html",
        "signatures": [
            {
                "full": "seasonalEsd(data, period, [hybrid], [maxAnomalies], [alpha])",
                "name": "seasonalEsd",
                "parameters": [
                    {
                        "full": "data",
                        "name": "data"
                    },
                    {
                        "full": "period",
                        "name": "period"
                    },
                    {
                        "full": "[hybrid]",
                        "name": "hybrid",
                        "optional": true
                    },
                    {
                        "full": "[maxAnomalies]",
                        "name": "maxAnomalies",
                        "optional": true
                    },
                    {
                        "full": "[alpha]",
                        "name": "alpha",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [seasonalEsd](https://docs.dolphindb.cn/zh/funcs/s/seasonalEsd.html)\n\n\n\n#### 语法\n\nseasonalEsd(data, period, \\[hybrid], \\[maxAnomalies], \\[alpha])\n\n#### 详情\n\n使用 S-ESD(Seasonal Extreme Studentized Deviate) 算法对周期性的时间序列进行异常检测。\n\n#### 参数\n\n**data** 是一个数值向量，表示时间序列。\n\n**period** 是一个大于1的整数，表示时间序列的周期。\n\n**hybrid** 是一个布尔值，表示是否用中位数和绝对中位差代替 Grubb's test 中 zscore 计算的平均值和标准差。如果 *hybrid* 为 true，算法更具鲁棒性。默认值为 false。\n\n**maxAnomalies** 是一个正整数或(0, 0.5)之间的浮点数。默认值为0.1。\n\n* 如果 *maxAnomalies* 是正整数，且 *maxAnomalies* 必须小于 data 长度的一半，函数最多检测 *maxAnomalies* 个异常点。\n\n* 如果 *maxAnomalies* 是(0, 0.5)之间的浮点数，函数最多检测 int(size(data) \\* *maxAnomalies* ) 个异常点。\n\n**alpha** 是一个正数，表示显著度。*alpha* 越大，数据越有可能被判断为异常点。\n\n#### 返回值\n\n返回结果是包含了异常值的表，该表有两列，index 列记录原始数据中异常值的下标，anoms 列记录异常值。\n\n#### 例子\n\n定时执行一个函数：\n\n```\nn = 100\ntrend = 6 * sin(1..n \\ 200)\nseasonal = sin(pi / 6 * 1..n)\nresidual = rand(1.0, n) - 0.5\ndata = trend + seasonal + residual\ndata[20 50 70] += 20;\n\nseasonalEsd(data, 12);\n```\n\n| index | anoms     |\n| ----- | --------- |\n| 50    | 22.6365   |\n| 70    | 21.141346 |\n| 20    | 19.174165 |\n\n相关函数：[stl](https://docs.dolphindb.cn/zh/funcs/s/stl.html), [esd](https://docs.dolphindb.cn/zh/funcs/e/esd.html)\n"
    },
    "second": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/second.html",
        "signatures": [
            {
                "full": "second(X)",
                "name": "second",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [second](https://docs.dolphindb.cn/zh/funcs/s/second.html)\n\n\n\n#### 语法\n\nsecond(X)\n\n#### 详情\n\n返回对应的秒数，返回值的类型是 SECOND，一个时间值。\n\n#### 参数\n\n**X** 可以是整数/时间类型/字符串类型的标量或向量。\n\n#### 返回值\n\nSECOND 类型的标量或向量。\n\n#### 例子\n\n```\nsecond();\n```\n\n返回：null\n\n```\nsecond(1)\n```\n\n返回：00:00:01\n\n```\nsecond(\"19:36:12\");\n```\n\n返回：19:36:12\n\n```\nsecond(now());\n```\n\n返回：16:01:32\n\n```\nsecond 2012.12.03 01:22:01;\n```\n\n返回：01:22:01\n\n```\nsecond(61);\n```\n\n返回：00:01:01\n\n```\nsecond(\"09:00:01\")\n```\n\n返回：09:00:01\n\n**Related information**\n\n[minute](https://docs.dolphindb.cn/zh/funcs/m/minute.html)\n\n[hour](https://docs.dolphindb.cn/zh/funcs/h/hour.html)\n\n[date](https://docs.dolphindb.cn/zh/funcs/d/date.html)\n\n[month](https://docs.dolphindb.cn/zh/funcs/m/month.html)\n\n[year](https://docs.dolphindb.cn/zh/funcs/y/year.html)\n"
    },
    "secondOfMinute": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/secondOfMinute.html",
        "signatures": [
            {
                "full": "secondOfMinute(X)",
                "name": "secondOfMinute",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [secondOfMinute](https://docs.dolphindb.cn/zh/funcs/s/secondOfMinute.html)\n\n\n\n#### 语法\n\nsecondOfMinute(X)\n\n#### 详情\n\n返回 *X* 中的秒数。\n\n#### 参数\n\n**X** 可以是 TIME、SECOND、DATETIME、TIMESTAMP、NANOTIME 或 NANOTIMESTAMP 类型的标量或向量。\n\n#### 返回值\n\nINT 类型标量或向量。\n\n#### 例子\n\n```\nsecondOfMinute(12:32:00);\n// output\n0\n\nsecondOfMinute([2012.06.12T12:30:00,2012.10.28T12:35:00,2013.01.06T12:36:47,2013.04.06T08:02:14]);\n// output\n[0,0,47,14]\n```\n\n相关函数：[dayOfYear](https://docs.dolphindb.cn/zh/funcs/d/dayOfYear.html), [dayOfMonth](https://docs.dolphindb.cn/zh/funcs/d/dayOfMonth.html), [quarterOfYear](https://docs.dolphindb.cn/zh/funcs/q/quarterOfYear.html), [monthOfYear](https://docs.dolphindb.cn/zh/funcs/m/monthOfYear.html), [weekOfYear](https://docs.dolphindb.cn/zh/funcs/w/weekOfYear.html), [hourOfDay](https://docs.dolphindb.cn/zh/funcs/h/hourOfDay.html), [minuteOfHour](https://docs.dolphindb.cn/zh/funcs/m/minuteOfHour.html), [millisecond](https://docs.dolphindb.cn/zh/funcs/m/millisecond.html), [microsecond](https://docs.dolphindb.cn/zh/funcs/m/microsecond.html), [nanosecond](https://docs.dolphindb.cn/zh/funcs/n/nanosecond.html)\n"
    },
    "seek": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/seek.html",
        "signatures": [
            {
                "full": "seek(handle, offset, [mode])",
                "name": "seek",
                "parameters": [
                    {
                        "full": "handle",
                        "name": "handle"
                    },
                    {
                        "full": "offset",
                        "name": "offset"
                    },
                    {
                        "full": "[mode]",
                        "name": "mode",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [seek](https://docs.dolphindb.cn/zh/funcs/s/seek.html)\n\n\n\n#### 语法\n\nseek(handle, offset, \\[mode])\n\n#### 详情\n\n如果没有抛出异常，`seek` 函数将返回文件内部游标经计算后的位置。\n\n当系统从一个文件中读取数据，或把数据写入一个文件中时，内部的游标将前进。用户可以通过 `seek` 函数手动操纵游标。\n\n#### 参数\n\n**handle** 必须是一个文件句柄。\n\n**offset** 是一个整数。\n\n**mode** 是 HEAD, CURRENT, TAIL 之一。默认的 *mode* 是 CURRENT。\n\n#### 返回值\n\nINT 类型标量。\n\n#### 例子\n\n```\n// 编写一个返回文件长度的函数\ndef fileLength(f): file(f).seek(0, TAIL)\nfileLength(\"test.txt\");\n// output\n14\n\n// 把内部游标移动到文件头部。\nfin=file(\"test.txt\")\nfin.readLine();\n// output\nHello World!\n\nfin.seek(0, HEAD);\n// output\n0\n\nfin.readLine();\n// output\nHello World!\n```\n"
    },
    "segment": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/segment.html",
        "signatures": [
            {
                "full": "segment(X, [segmentOffset=true])",
                "name": "segment",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[segmentOffset=true]",
                        "name": "segmentOffset",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [segment](https://docs.dolphindb.cn/zh/funcs/s/segment.html)\n\n\n\n#### 语法\n\nsegment(X, \\[segmentOffset=true])\n\n#### 详情\n\n将向量分组，连续的相同元素为一组。\n\n如果 *segmentOffset* 为 true，返回的结果是每组第一个元素在 *X* 中的下标。\n\n如果 *segmentOffset* 为 false，返回的结果表示每个元素位于第几组。组号从0开始编号。\n\n#### 参数\n\n**X** 是一个向量。\n\n**segmentOffset** 是一个布尔值。默认值为 true。\n\n#### 返回值\n\nINT 类型，长度与 X 相等的向量。\n\n#### 例子\n\n```\nx = 1 1 2 4 4 5 2 5 NULL NULL\nsegment(x);\n// output\n[0,0,2,3,3,5,6,7,8,8]\n\nsegment(x, false);\n// output\n[0,0,1,2,2,3,4,5,6,6]\n\nx = 1 2 1 2 1 2 1 2 1 2 1 2;\ny = 0 0 1 1 1 2 2 1 1 3 3 2;\nt = table(x,y);\nselect *, cumsum(x) from t context by segment(y);\n```\n\n| y | x | cumsum\\_x |\n| - | - | --------- |\n| 0 | 1 | 1         |\n| 0 | 2 | 3         |\n| 1 | 1 | 1         |\n| 1 | 2 | 3         |\n| 1 | 1 | 4         |\n| 2 | 2 | 2         |\n| 2 | 1 | 3         |\n| 1 | 2 | 2         |\n| 1 | 1 | 3         |\n| 3 | 2 | 2         |\n| 3 | 1 | 3         |\n| 2 | 2 | 2         |\n"
    },
    "sem": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/sem.html",
        "signatures": [
            {
                "full": "sem(X)",
                "name": "sem",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [sem](https://docs.dolphindb.cn/zh/funcs/s/sem.html)\n\n\n\n#### 语法\n\nsem(X)\n\n#### 详情\n\n返回 *X* 的平均值的标准误差。\n\n若 *X* 为矩阵，计算每列的标准误差，返回一个向量。\n\n若 *X* 为表，计算每列的标准误差，返回一个表。\n\n**Note:**\n\nDolphinDB `sem` 与 [scipy.stats.sem](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.sem.html) 的核心功能相同。区别在于：\n\n* DolphinDB `sem` 支持数值型向量、矩阵或表，矩阵和表按列计算，并忽略 NULL。\n* `scipy.stats.sem` 支持数组的轴向计算，默认遇到 NaN 会返回 NaN，可设置*nan\\_policy*=\"omit\" 忽略 NaN。\n* 若输入数据和缺失值处理方式一致，二者的返回结果一致。\n\n#### 参数\n\n**X** 是数值型向量、矩阵或表。\n\n#### 返回值\n\n返回 DOUBLE 类型的标量、向量或表。\n\n#### 例子\n\n```\nsem([85,90,95,NULL]);\n// output\n2.886751\n```\n"
    },
    "semiannualBegin": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/semiannualBegin.html",
        "signatures": [
            {
                "full": "semiannualBegin(X, [startingMonth=1], [offset], [n=1])",
                "name": "semiannualBegin",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[startingMonth=1]",
                        "name": "startingMonth",
                        "optional": true,
                        "default": "1"
                    },
                    {
                        "full": "[offset]",
                        "name": "offset",
                        "optional": true
                    },
                    {
                        "full": "[n=1]",
                        "name": "n",
                        "optional": true,
                        "default": "1"
                    }
                ]
            }
        ],
        "markdown": "### [semiannualBegin](https://docs.dolphindb.cn/zh/funcs/s/semiannualBegin.html)\n\n首发版本：3.00.4，3.00.3.1\n\n\n\n#### 语法\n\nsemiannualBegin(X, \\[startingMonth=1], \\[offset], \\[n=1])\n\n#### 详情\n\n返回 *X* 所在半年期的第一天。每半年包含的月份由参数 *startingMonth* 决定。\n\n默认情况下，一个周期对应一个半年，函数返回 *X* 所在半年期的第一天。半年周期包含的月份由参数 *startingMonth* 决定。\n\n如果指定了 *offset* 和 *n*，且 *n* > 1，则函数按长度为 *n* 个半年期的周期计算。此时，*offset* 用于确定多个半年周期的对齐方式：系统会先根据 *startingMonth* 计算出 *offset* 所在半年期的第一天，然后以该日期为基准，每隔 *n* 个半年期生成一个周期起始边界，并返回 *X* 所属周期对应的起始日期。\n\n#### 参数\n\n**X** 可以是 DATE, DATETIME, DATEHOUR, TIMESTAMP 或 NANOTIMESTAMP 类型的标量或向量。\n\n**startingMonth** （可选参数）是 1 到 12 之间的整数，表示一年的起始月份。默认值是 1。\n\n**offset** 是与 *X* 类型相同的标量，并且它必须小于等于 *X* 中的最小值。它是一个可选参数。如果没有指定，*offset* 默认为 *X* 中的最小值。\n\n**n** 是一个正整数。它是一个可选参数，默认值为 1。\n\n#### 返回值\n\nDATE 类型标量或向量。\n\n#### 例子\n\n```\nsemiannualBegin(2025.08.10);\n// output: 2025.07.01\n\nsemiannualBegin(2025.10.10 10:10:10.008, 3);\n// output: 2025.09.01\n\ndate=[2024.04.20,2024.05.31,2024.07.07,2024.10.24,2024.12.20,2025.01.19,2025.04.24,2025.04.28,2025.10.06,2026.01.06]\nsym = take(`AAA,10)\nprice= 49.6 29.46 29.52 30.02 174.97 175.23 50.76 50.32 51.29 52.38\nqty = 2200 1900 2100 3200 6800 5400 1300 2500 8800 4500\nt1 = table(date, sym, qty, price)\n\nselect avg(price),sum(qty) from t1 group by semiannualBegin(date, 1, 2024.01.01, 2)\n```\n\n| semiannualBegin\\_date | avg\\_price | sum\\_qty |\n| --------------------- | ---------- | -------- |\n| 2024.01.01            | 62.714     | 16,200   |\n| 2025.01.01            | 81.9       | 18,000   |\n| 2026.01.01            | 52.38      | 4,500    |\n"
    },
    "semiannualEnd": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/semiannualEnd.html",
        "signatures": [
            {
                "full": "semiannualEnd(X, [endingMonth=12], [offset], [n=1])",
                "name": "semiannualEnd",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[endingMonth=12]",
                        "name": "endingMonth",
                        "optional": true,
                        "default": "12"
                    },
                    {
                        "full": "[offset]",
                        "name": "offset",
                        "optional": true
                    },
                    {
                        "full": "[n=1]",
                        "name": "n",
                        "optional": true,
                        "default": "1"
                    }
                ]
            }
        ],
        "markdown": "### [semiannualEnd](https://docs.dolphindb.cn/zh/funcs/s/semiannualEnd.html)\n\n首发版本：3.00.4，3.00.3.1\n\n\n\n#### 语法\n\nsemiannualEnd(X, \\[endingMonth=12], \\[offset], \\[n=1])\n\n#### 详情\n\n返回 *X* 所在半年期的最后一天。每半年包含的月份由参数 *endingMonth* 决定。\n\n默认情况下，一个周期对应一个半年，函数返回 *X* 所在半年期的最后一天。半年周期包含的月份由参数 *endingMonth* 决定。\n\n如果指定了 *offset* 和 *n*，且 *n* > 1，则函数按长度为 *n* 个半年期的周期计算。此时，*offset* 用于确定多个半年周期的对齐方式：系统会先根据 *endingMonth* 计算出 *offset* 所在半年期的最后一天，然后以该日期为基准，每隔 *n* 个半年期生成一个周期结束边界，并返回 *X* 所属周期对应的结束日期。\n\n#### 参数\n\n**X** 可以是 DATE, DATETIME, DATEHOUR, TIMESTAMP 或 NANOTIMESTAMP 类型的标量或向量。\n\n**endingMonth** 是 1 到 12 之间的整数，表示一年的结束月份。默认值是 12。\n\n**offset** 是与 *X* 类型相同的标量，并且它必须小于等于 *X* 中的最小值。它是一个可选参数。如果没有指定，*offset* 默认为 *X* 中的最小值。\n\n**n** 是一个正整数。它是一个可选参数，默认值为 1。\n\n#### 返回值\n\nDATE 类型标量。\n\n#### 例子\n\n```\nsemiannualEnd(2025.08.10);\n// output: 2025.12.31\n\nsemiannualEnd(2025.10.10 10:10:10.008, 3);\n// output: 2026.03.31\n\ndate=[2024.04.20,2024.05.31,2024.07.07,2024.10.24,2024.12.20,2025.01.19,2025.04.24,2025.04.28,2025.10.06,2026.01.06]\nsym = take(`AAA,10)\nprice= 49.6 29.46 29.52 30.02 174.97 175.23 50.76 50.32 51.29 52.38\nqty = 2200 1900 2100 3200 6800 5400 1300 2500 8800 4500\nt1 = table(date, sym, qty, price);\n\nselect avg(price),sum(qty) from t1 group by semiannualEnd(date, 12, 2024.01.01, 2)\n```\n\n| semiannualEnd\\_date | avg\\_price        | sum\\_qty |\n| ------------------- | ----------------- | -------- |\n| 2024.06.30          | 39.53             | 4,100    |\n| 2025.06.30          | 85.13666666666667 | 21,300   |\n| 2026.06.30          | 51.835            | 13,300   |\n"
    },
    "semiMonthBegin": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/semiMonthBegin.html",
        "signatures": [
            {
                "full": "semiMonthBegin(X, [dayOfMonth=15], [offset], [n=1])",
                "name": "semiMonthBegin",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[dayOfMonth=15]",
                        "name": "dayOfMonth",
                        "optional": true,
                        "default": "15"
                    },
                    {
                        "full": "[offset]",
                        "name": "offset",
                        "optional": true
                    },
                    {
                        "full": "[n=1]",
                        "name": "n",
                        "optional": true,
                        "default": "1"
                    }
                ]
            }
        ],
        "markdown": "### [semiMonthBegin](https://docs.dolphindb.cn/zh/funcs/s/semiMonthBegin.html)\n\n\n\n#### 语法\n\nsemiMonthBegin(X, \\[dayOfMonth=15], \\[offset], \\[n=1])\n\n#### 详情\n\n返回 *X* 所在半月的第一天。假设 *X* 为当月的第 d 天：\n\n* 如果 d<*dayOfMonth*，那么 *semiMonthBegin* 返回 *X* 所在月份的第一天。\n\n* 如果 d>=*dayOfMonth*，那么 *semiMonthBegin* 返回 *X* 所在月份的第 *dayOfMonth* 天。\n\n如果指定了 *offset* 和 *n*，且 *n* > 1，则函数按长度为 *n* 个半月周期的周期计算。此时，*offset* 用于确定多个半月周期的对齐方式：系统会先根据 *dayOfMonth* 计算出 *offset* 所在半月周期的开始日期，然后以该日期为基准，每隔 *n* 个半月周期生成一个周期起始边界，并返回 *X* 所属周期对应的第一天。\n\n#### 参数\n\n**X** 可以是 DATE, DATEHOUR, DATETIME, TIMESTAMP 或 NANOTIMESTAMP 类型的标量或向量。\n\n**dayOfMonth** 是2到27之间的整数。它是一个可选参数，默认值为15。\n\n**offset** 是与 *X* 类型相同的标量，并且它必须小于等于 *X* 中的最小值。它是一个可选参数。如果没有指定，*offset* 默认为 *X* 中的最小值。\n\n**n** 是一个正整数。它是一个可选参数，默认值为1。\n\n#### 返回值\n\nDATE 类型标量。\n\n#### 例子\n\n```\nsemiMonthBegin(2012.06.12);\n```\n\n输出返回： 2012.06.01\n\n```\nsemiMonthBegin(2012.06.24);\n```\n\n输出返回： 2012.06.15\n\n```\nsemiMonthBegin(2012.06.15);\n```\n\n输出返回： 2012.06.15\n\n```\nsemiMonthBegin(2012.06.16, 16);\n```\n\n输出返回： 2012.06.16\n\n```\ndate=2016.04.07+(1..10)*7\ntime = take(09:30:00, 10);\nsym = take(`MSFT,10)\nprice= 49.6 29.46 29.52 30.02 174.97 175.23 50.76 50.32 51.29 52.38\nqty = 2200 1900 2100 3200 6800 5400 1300 2500 8800 4500\nt1 = table(date, time, sym, qty, price);\nt1;\n```\n\n输出返回：\n\n| date       | time     | sym  | qty  | price  |\n| ---------- | -------- | ---- | ---- | ------ |\n| 2016.04.14 | 09:30:00 | MSFT | 2200 | 49.6   |\n| 2016.04.21 | 09:30:00 | MSFT | 1900 | 29.46  |\n| 2016.04.28 | 09:30:00 | MSFT | 2100 | 29.52  |\n| 2016.05.05 | 09:30:00 | MSFT | 3200 | 30.02  |\n| 2016.05.12 | 09:30:00 | MSFT | 6800 | 174.97 |\n| 2016.05.19 | 09:30:00 | MSFT | 5400 | 175.23 |\n| 2016.05.26 | 09:30:00 | MSFT | 1300 | 50.76  |\n| 2016.06.02 | 09:30:00 | MSFT | 2500 | 50.32  |\n| 2016.06.09 | 09:30:00 | MSFT | 8800 | 51.29  |\n| 2016.06.16 | 09:30:00 | MSFT | 4500 | 52.38  |\n\n```\nselect avg(price),sum(qty) from t1 group by semiMonthBegin(date);\n```\n\n输出返回：\n\n| semiMonthBegin\\_date | avg\\_price | sum\\_qty |\n| -------------------- | ---------- | -------- |\n| 2016.04.01           | 49.6       | 2200     |\n| 2016.04.15           | 29.49      | 4000     |\n| 2016.05.01           | 102.495    | 10000    |\n| 2016.05.15           | 112.995    | 6700     |\n| 2016.06.01           | 50.805     | 11300    |\n| 2016.06.15           | 52.38      | 4500     |\n\n相关函数： [monthBegin](https://docs.dolphindb.cn/zh/funcs/m/monthBegin.html), [monthEnd](https://docs.dolphindb.cn/zh/funcs/m/monthEnd.html), [semiMonthEnd](https://docs.dolphindb.cn/zh/funcs/s/semiMonthEnd.html)\n"
    },
    "semiMonthEnd": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/semiMonthEnd.html",
        "signatures": [
            {
                "full": "semiMonthEnd(X, [dayOfMonth=15], [offset], [n=1])",
                "name": "semiMonthEnd",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[dayOfMonth=15]",
                        "name": "dayOfMonth",
                        "optional": true,
                        "default": "15"
                    },
                    {
                        "full": "[offset]",
                        "name": "offset",
                        "optional": true
                    },
                    {
                        "full": "[n=1]",
                        "name": "n",
                        "optional": true,
                        "default": "1"
                    }
                ]
            }
        ],
        "markdown": "### [semiMonthEnd](https://docs.dolphindb.cn/zh/funcs/s/semiMonthEnd.html)\n\n\n\n#### 语法\n\nsemiMonthEnd(X, \\[dayOfMonth=15], \\[offset], \\[n=1])\n\n#### 详情\n\n返回 *X* 所在半月的最后一天。假设 *X* 为该月的第 d 天：\n\n* 如果 d<*dayOfMonth*，那么 *semiMonthBegin* 返回 *X* 所在月份的上一个月的最后一天。\n\n* 如果 d>=*dayOfMonth*，那么 *semiMonthBegin* 返回 *X* 所在月份的第 *dayOfMonth* 天。\n\n如果指定了 *offset* 和 *n*，且 *n* > 1，则函数按长度为 *n* 个半月周期的周期计算。此时，*offset* 用于确定多个半月周期的对齐方式：系统会先根据 *dayOfMonth* 计算出 *offset* 所在半月周期的结束日期，然后以该日期为基准，每隔 *n* 个半月周期生成一个周期结束边界，并返回 *X* 所属周期对应的最后一天。\n\n#### 参数\n\n**X** 可以是 DATE, DATEHOUR, DATETIME, TIMESTAMP 或 NANOTIMESTAMP 类型的标量或向量。\n\n**dayOfMonth** 是2到27之间的整数。它是一个可选参数，默认值为15。\n\n**offset** 是与 *X* 类型相同的标量，并且它必须小于等于 *X* 中的最小值。它是一个可选参数。如果没有指定，*offset* 默认为 *X* 中的最小值。\n\n**n** 是一个正整数。它是一个可选参数，默认值为1。\n\n#### 返回值\n\nDATE 类型标量。\n\n#### 例子\n\n```\nsemiMonthEnd(2012.06.12);\n// output: 012.05.31\n\n \nsemiMonthEnd(2012.06.24);\n// output: 012.06.15\n\n \nsemiMonthEnd(2012.06.15);\n// output: 012.06.15\n\n \nsemiMonthEnd(2012.06.16, 16);\n// output: 012.06.16\n\n\ndate=2016.04.07+(1..10)*7\ntime = take(09:30:00, 10);\nsym = take(`MSFT,10)\nprice= 49.6 29.46 29.52 30.02 174.97 175.23 50.76 50.32 51.29 52.38\nqty = 2200 1900 2100 3200 6800 5400 1300 2500 8800 4500\nt1 = table(date, time, sym, qty, price);\nt1;\n```\n\n| date       | time     | sym  | qty  | price  |\n| ---------- | -------- | ---- | ---- | ------ |\n| 2016.04.14 | 09:30:00 | MSFT | 2200 | 49.6   |\n| 2016.04.21 | 09:30:00 | MSFT | 1900 | 29.46  |\n| 2016.04.28 | 09:30:00 | MSFT | 2100 | 29.52  |\n| 2016.05.05 | 09:30:00 | MSFT | 3200 | 30.02  |\n| 2016.05.12 | 09:30:00 | MSFT | 6800 | 174.97 |\n| 2016.05.19 | 09:30:00 | MSFT | 5400 | 175.23 |\n| 2016.05.26 | 09:30:00 | MSFT | 1300 | 50.76  |\n| 2016.06.02 | 09:30:00 | MSFT | 2500 | 50.32  |\n| 2016.06.09 | 09:30:00 | MSFT | 8800 | 51.29  |\n| 2016.06.16 | 09:30:00 | MSFT | 4500 | 52.38  |\n\n```\nselect avg(price),sum(qty) from t1 group by semiMonthEnd(date);\n```\n\n| semiMonthEnd\\_date | avg\\_price | sum\\_qty |\n| ------------------ | ---------- | -------- |\n| 2016.03.31         | 49.6       | 2200     |\n| 2016.04.15         | 29.49      | 4000     |\n| 2016.04.30         | 102.495    | 10000    |\n| 2016.05.15         | 112.995    | 6700     |\n| 2016.05.31         | 50.805     | 11300    |\n| 2016.06.15         | 52.38      | 4500     |\n\n相关函数：[monthBegin](https://docs.dolphindb.cn/zh/funcs/m/monthBegin.html), [monthEnd](https://docs.dolphindb.cn/zh/funcs/m/monthEnd.html), [semiMonthBegin](https://docs.dolphindb.cn/zh/funcs/s/semiMonthBegin.html)\n"
    },
    "sendEvent": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/sendEvent.html",
        "signatures": [
            {
                "full": "sendEvent(event)",
                "name": "sendEvent",
                "parameters": [
                    {
                        "full": "event",
                        "name": "event"
                    }
                ]
            }
        ],
        "markdown": "### [sendEvent](https://docs.dolphindb.cn/zh/funcs/s/sendEvent.html)\n\n\n\n#### 语法\n\nsendEvent(event)\n\n#### 详情\n\nsendEvent 是 CEP monitor 内部的事件控制接口，用于将一个事件插入到当前子引擎的事件输入队列的尾部。\n\n#### 参数\n\n**event** 事件实例。\n\n#### 例子\n\n定义事件：\n\n```\nclass UpdateFactor{\n    sym :: STRING\n    factor :: DOUBLE\n    def UpdateFactor(code, val){\n        sym = code\n        factor = val\n    }\n}\n\nclass MarketData{\n    market :: STRING\n    code :: STRING\n    price :: DOUBLE\n    qty :: INT\n    def MarketData(m,c,p,q){\n        market = m\n        code = c\n        price = p\n        qty = q\n    }\n}\n```\n\n定义 monitor：\n\n```\n\nclass MainMonitor : CEPMonitor{\n    maxPrice :: DOUBLE\n\n    def MainMonitor(){ maxPrice = 0.0 }\n    \n    def updateMarketData(event)\n\n    // Monitor 启动时注册事件监听器\n    def onload(){\n        addEventListener(handler=updateMarketData, eventType='MarketData', times='all')\n    }\n\n    // 核心事件处理函数\n    def updateMarketData(event){\n        print(\"处理 MarketData: \"+event.code+\" 价格=\"+string(event.price))\n\n        if(event.price > maxPrice){\n            maxPrice = event.price\n\n            // emitEvent：输出到流表\n            emitEvent(UpdateFactor(\"maxPrice\", maxPrice))\n\n            // routeEvent：队首插入一个警告事件，优先处理\n            routeEvent(UpdateFactor(\"alert\", maxPrice))\n\n            // sendEvent：队尾插入一个信息事件，顺序处理\n            sendEvent(UpdateFactor(\"info\", maxPrice))\n        }\n    }\n}\n```\n\n创建流表接收输出事件：\n\n```\nshare streamTable(array(STRING,0) as eventType, array(BLOB,0) as blobs) as simulateResult\n\nserializer = streamEventSerializer(\n    name=`simulate,\n    eventSchema=[UpdateFactor],\n    outputTable=simulateResult\n)\n\ndummy = table(array(STRING,0) as eventType, array(BLOB,0) as blobs)\n```\n\n创建 CEP 引擎：\n\n```\nengine = createCEPEngine(\n    name='cep1',\n    monitors=<MainMonitor()>,\n    dummyTable=dummy,\n    eventSchema=[MarketData],\n    outputTable=serializer\n)\n```\n\n**相关函数**：[addEventListener](https://docs.dolphindb.cn/zh/funcs/a/addEventListener.html), [createCEPEngine](https://docs.dolphindb.cn/zh/funcs/c/createCEPEngine.html), [appendEvent](https://docs.dolphindb.cn/zh/funcs/a/appendEvent.html), [emitEvent](https://docs.dolphindb.cn/zh/funcs/e/emitEvent.html), [routeEvent](https://docs.dolphindb.cn/zh/funcs/r/routeEvent.html)\n"
    },
    "seq": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/seq.html",
        "signatures": [
            {
                "full": "seq(start, end)",
                "name": "seq",
                "parameters": [
                    {
                        "full": "start",
                        "name": "start"
                    },
                    {
                        "full": "end",
                        "name": "end"
                    }
                ]
            }
        ],
        "markdown": "### [seq](https://docs.dolphindb.cn/zh/funcs/s/seq.html)\n\n\n\n#### 语法\n\nseq(start, end) 或 start..end\n\n#### 详情\n\n返回一个以 *start* 为起点，*end* 为终点的向量，相邻元素之间的差为 1。\n\n注意：若 *start* 和 *end* 都为整型或时间类型的 NULL 值，函数返回一个空向量。\n\n#### 参数\n\n**start** 和 **end** 必须是整型或时间类型。\n\n#### 返回值\n\n返回一个向量。\n\n#### 例子\n\n```\nx=0..3;\nx;\n// output\n[0,1,2,3]\n\n1..3+1;\n// output\n[2,3,4]\n\n11..1;\n// output\n[11,10,9,8,7,6,5,4,3,2,1]\n\nseq(3,1);\n// output\n[3,2,1]\n\n2015.01M..2015.12M;\n// output\n[2015.01M,2015.02M,2015.03M,2015.04M,2015.05M,2015.06M,2015.07M,2015.08M,2015.09M,2015.10M,2015.11M,2015.12M]\n\n2016.01.01..2016.01.07;\n// output\n[2016.01.01,2016.01.02,2016.01.03,2016.01.04,2016.01.05,2016.01.06,2016.01.07]\n```\n"
    },
    "sessionWindow": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/sessionWindow.html",
        "signatures": [
            {
                "full": "sessionWindow(X, sessionGap)",
                "name": "sessionWindow",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "sessionGap",
                        "name": "sessionGap"
                    }
                ]
            }
        ],
        "markdown": "### [sessionWindow](https://docs.dolphindb.cn/zh/funcs/s/sessionWindow.html)\n\n\n\n#### 语法\n\nsessionWindow(X, sessionGap)\n\n#### 详情\n\n从 *X* 的第一个非空元素开始一个会话窗口，依次判断 *X* 中每个元素与前一个相邻元素的差值是否小于 *sessionGap*。若差值小于 *sessionGap*，则会话窗口继续打开；否则，会话窗口关闭，且由当前元素开始一个新的会话窗口。以各个会话窗口的第一个元素值作为它的编号。该函数返回 *X* 中每个元素所属的会话窗口的编号。\n\n**Note:**\n\n* 对于 *X* 中的空值（不参与比较）：若空值位于 *X* 的开头，则返回空；否则，返回其前一个非空元素所属会话窗口的编号。\n\n* 乱序数据不会参与比较，直接返回当前会话窗口的编号。\n\n#### 参数\n\n**X** 整型或时间类型向量。\n\n**sessionGap** 正整数，表示两个会话之间的间隔。其单位同 *X* 一致。\n\n#### 返回值\n\n数据类型与长度均与 *X* 一致的向量。\n\n#### 例子\n\n```\nx = 1 5 6 12 13 13 15\nsessionWindow(x, 5)\n// output\n[1,1,1,12,12,12,12]\n\ny = 2012.06.13 2012.06.15 2012.06.19 2012.06.26 2012.06.28\nsessionWindow(y, 5)\n// output\n[2012.06.13,2012.06.13,2012.06.13,2012.06.26,2012.06.26]\n```\n\n在下例中，第二个会话窗口（编号为12）之后出现的乱序数据3和7不参与判断，直接返回编号12。其后的元素15属于会话窗口12（因为15-12<4）。\n\n```\nx = [, , 1, 12, 3, 7, 15, 19]\nsessionWindow(x, 4) \n// output\n[,,1,12,12,12,12,19]\n\n```\n\n```\ncolTime = 2023.06.01T10:00:00.000 + 1 2 3 4 5 6 7 8 9 21 22 23 28 29 30\ncolSym = take(`A`B`C,15)\ncolVolume = [2,1,5,5,2,3,2,3,2,2,5,5,2,7,2]\nt = table(colTime as time, colSym as sym, colVolume as volume)\nt\n```\n\n| time                    | sym | volume |\n| ----------------------- | --- | ------ |\n| 2023.06.01 10:00:00.001 | A   | 2      |\n| 2023.06.01 10:00:00.002 | B   | 1      |\n| 2023.06.01 10:00:00.003 | C   | 5      |\n| 2023.06.01 10:00:00.004 | A   | 5      |\n| 2023.06.01 10:00:00.005 | B   | 2      |\n| 2023.06.01 10:00:00.006 | C   | 3      |\n| 2023.06.01 10:00:00.007 | A   | 2      |\n| 2023.06.01 10:00:00.008 | B   | 3      |\n| 2023.06.01 10:00:00.009 | C   | 2      |\n| 2023.06.01 10:00:00.021 | A   | 2      |\n| 2023.06.01 10:00:00.022 | B   | 5      |\n| 2023.06.01 10:00:00.023 | C   | 5      |\n| 2023.06.01 10:00:00.028 | A   | 2      |\n| 2023.06.01 10:00:00.029 | B   | 7      |\n| 2023.06.01 10:00:00.030 | C   | 2      |\n\n在下面的代码中，我们使用了高阶函数 `contextby`，根据股票代码 sym 对数据进行分组，并在每个分组内使用 `sessionWindow` 划分会话窗口，然后计算每个窗口中的交易量总和。其中，`sessionWinodow` 使用了部分应用，其第一个参数固定为时间列 time。\n\n```\nselect sum(volume) from t group by contextby(sessionWindow{, 5}, time, sym) as time,sym\n```\n\n| time                    | sym | sum\\_volume |\n| ----------------------- | --- | ----------- |\n| 2023.06.01 10:00:00.001 | A   | 9           |\n| 2023.06.01 10:00:00.002 | B   | 6           |\n| 2023.06.01 10:00:00.003 | C   | 10          |\n| 2023.06.01 10:00:00.021 | A   | 2           |\n| 2023.06.01 10:00:00.022 | B   | 5           |\n| 2023.06.01 10:00:00.023 | C   | 5           |\n| 2023.06.01 10:00:00.028 | A   | 2           |\n| 2023.06.01 10:00:00.029 | B   | 7           |\n| 2023.06.01 10:00:00.030 | C   | 2           |\n"
    },
    "set": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/set.html",
        "signatures": [
            {
                "full": "set(X)",
                "name": "set",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [set](https://docs.dolphindb.cn/zh/funcs/s/set.html)\n\n\n\n#### 语法\n\nset(X)\n\n#### 详情\n\n返回向量 *X* 对应的集合对象。\n\n#### 参数\n\n**X** 是一个向量。\n\n#### 返回值\n\n返回向量 X 对应的集合对象。\n\n#### 例子\n\n`set` 函数返回一个集合。\n\n```\nx=set(4 5 5 2 3 11 6);\nx;\n// output\nset(6,11,3,2,5,4)\n\nx.intersection(set([2,5,9]));\n// output\nset(2,5)\n```\n\n与此不同，[distinct](https://docs.dolphindb.cn/zh/funcs/d/distinct.html) 函数返回一个向量。\n\n```\ndistinct(4 5 5 2 3 11 6);\n// output\n[6,11,3,2,5,4]\n```\n"
    },
    "setAtomicLevel": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/setAtomicLevel.html",
        "signatures": [
            {
                "full": "setAtomicLevel(dbHandle, atomic)",
                "name": "setAtomicLevel",
                "parameters": [
                    {
                        "full": "dbHandle",
                        "name": "dbHandle"
                    },
                    {
                        "full": "atomic",
                        "name": "atomic"
                    }
                ]
            }
        ],
        "markdown": "### [setAtomicLevel](https://docs.dolphindb.cn/zh/funcs/s/setAtomicLevel.html)\n\n\n\n#### 语法\n\nsetAtomicLevel(dbHandle, atomic)\n\n#### 详情\n\n修改分布式数据库的并发写入权限。\n\n#### 参数\n\n**dbHandle** 是 [database](https://docs.dolphindb.cn/zh/funcs/d/database.html) 函数返回的分布式数据库句柄。\n\n**atomic** 表示写入事务的原子性层级，决定了是否允许并发写入同一分区。可选值为 'TRANS' 和 'CHUNK'，默认值为 'TRANS'。\n\n* 设置为'TRANS'，写入事务的原子性层级为事务，即一个事务写入多个分区时，若某个分区被其他写入事务锁定而出现写入冲突，则该事务的写入全部失败。因此，该设置下，不允许并发写入同一个分区。\n\n* 设置为'CHUNK'，写入事务的原子性层级为分区。若一个事务写入多个分区时，某分区被其它写入事务锁定而出现冲突，系统会完成其他分区的写入，同时对之前发生冲突的分区不断尝试写入，尝试数分钟后仍冲突才放弃。此设置下，允许并发写入同一个分区，但由于不能完全保证事务的原子性，可能出现部分分区写入成功而部分分区写入失败的情况。同时由于采用了重试机制，写入速度可能较慢。\n\n#### 例子\n\n```\ndbPath=\"dfs://test\"\nmydb=database(dbPath, VALUE, ['AMZN','NFLX', 'NVDA'])\nmydb.schema()\n\n// output\ndatabaseDir->dfs://test\npartitionSchema->[NVDA,AMZN,NFLX]\npartitionSites->\npartitionTypeName->VALUE\npartitionType->1\natomic->TRANS\n```\n\n```\nsetAtomicLevel(mydb, `CHUNK)\nmydb.schema()\n\n// output\ndatabaseDir->dfs://test\npartitionSchema->[NVDA,AMZN,NFLX]\npartitionSites->\npartitionTypeName->VALUE\npartitionType->1\natomic->CHUNK\n```\n"
    },
    "setCacheEngineMemSize": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/setCacheEngineMemSize.html",
        "signatures": [
            {
                "full": "setCacheEngineMemSize(memSize)",
                "name": "setCacheEngineMemSize",
                "parameters": [
                    {
                        "full": "memSize",
                        "name": "memSize"
                    }
                ]
            }
        ],
        "markdown": "### [setCacheEngineMemSize](https://docs.dolphindb.cn/zh/funcs/s/setCacheEngineMemSize.html)\n\n#### 语法\n\nsetCacheEngineMemSize(memSize)\n\n#### 详情\n\n在线修改 Cache Engine 的容量。集群环境下，该命令只能由管理员在数据节点/计算节点上执行。执行前需要确保开启了 Cache Engine (配置参数 *chunkCacheEngineMemSize*)。仅 OLAP 引擎支持该命令。\n\n**Note:**\n\n此命令修改的配置值在集群重启后将失效。若需要配置值永久生效，请更改配置文件中的 *chunkCacheEngineMemSize* 。\n\n#### 参数\n\n**memSize** 一个数值型标量，且必须大于0且小于 *maxMemSize* \\* 0.5。\n\n#### 场景\n\nCache Engine 开启后，写入数据时，系统会先把数据写入缓存，当缓存中的数据量达到 *chunkCacheEngineMemSize* 的30%时，才会写入磁盘。若该配置项设置过小，大批量数据写入时，Cache Engine 可能很快被占满，从而导致写入卡住。此时，通过该命令在线修改 Cache Engine 的容量，来保证写入继续进行。\n\n#### 相关函数\n\n可以使用 [getCacheEngineMemSize](https://docs.dolphindb.cn/zh/funcs/g/getCacheEngineMemSize.html) 获取 Cache Engine 的实时状态，确认 Cache Engine 是否在线修改成功。\n"
    },
    "setChunkLastUpdateTime": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/setChunkLastUpdateTime.html",
        "signatures": [
            {
                "full": "setChunkLastUpdateTime(chunkId, lastUpdateTime)",
                "name": "setChunkLastUpdateTime",
                "parameters": [
                    {
                        "full": "chunkId",
                        "name": "chunkId"
                    },
                    {
                        "full": "lastUpdateTime",
                        "name": "lastUpdateTime"
                    }
                ]
            }
        ],
        "markdown": "### [setChunkLastUpdateTime](https://docs.dolphindb.cn/zh/funcs/s/setChunkLastUpdateTime.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nsetChunkLastUpdateTime(chunkId, lastUpdateTime)\n\n#### 详情\n\n手动设置指定分区的上次更新时间（可通过函数 `getClusterChunksStatus` 返回的 lastUpdated 字段查看）。\n\n该函数仅支持管理员用户在单节点、或集群模式中的控制节点上调用。\n\n#### 参数\n\n**chunkId** 字符串向量，用于指定分区 ID。\n\n**lastUpdateTime** TIMESTAMP 类型，指定分区的更新时间。\n\n#### 例子\n\n```\nsetChunkLastUpdateTime([\"32953d51-980c-59a1-5f43-c90bfddd5a63\",\"d957b444-be92-9296-ba4a-9d8a41682168\"], timestamp(2016.05.12T19:32:49))\n```\n"
    },
    "setColumnarTuple!": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/setColumnarTuple_.html",
        "signatures": [
            {
                "full": "setColumnarTuple!(X, [on=true])",
                "name": "setColumnarTuple!",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[on=true]",
                        "name": "on",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [setColumnarTuple!](https://docs.dolphindb.cn/zh/funcs/s/setColumnarTuple_.html)\n\n\n\n#### 语法\n\nsetColumnarTuple!(X, \\[on=true])\n\n#### 详情\n\n将 [tuple](https://docs.dolphindb.cn/zh/progr/data_types_forms/TupleANYVector.html) 原地标记为 [columnar tuple](https://docs.dolphindb.cn/zh/progr/data_types_forms/columnarTuple.html)，或取消 columnar tuple 标记。\n\ncolumnar tuple 仍然是由标量或向量组成的 ANY 类型元组，但系统会按照类似数组向量的列式规则解释它：tuple 中的每个元素对应表列中的一行值；当元素为向量时，该行保存一个数组。普通 tuple 则按元组规则解释，作为表列时每一行是一个完整的 ANY 类型元素。\n\n例如，对包含向量元素的表列调用 [ungroup](https://docs.dolphindb.cn/zh/funcs/u/ungroup.html) 时，普通 tuple 列不会被展开；转换为 columnar tuple 后，`ungroup` 会将每行中的向量元素展开。\n\n#### 参数\n\n**X** 由相同数据类型的向量或标量组成的 tuple。\n\n**on** 可选参数，布尔值，表示是否将 *X* 标记为 columnar tuple。默认值为 true。\n\n* 当 *on* = true 时，将普通 tuple 转换为 columnar tuple。\n\n* 当 *on* = false 时，取消 columnar tuple 标记，将其转换为普通 tuple。\n\n#### 返回值\n\n返回修改后的 *X*。\n\n* 当 *on* = true 时，返回 columnar tuple。\n\n* 当 *on* = false 时，返回普通 tuple。\n\n#### 例子\n\n将普通 tuple 转换为 columnar tuple。\n\n```\ntp = [[1,2,3], [4,5,6], [7,8]]\nisColumnarTuple(tp)\n// output: false\n\ntp.setColumnarTuple!()\nisColumnarTuple(tp)\n// output: true\n```\n\n普通 tuple 作为表列时，每一行是一个 ANY 类型元素，`ungroup` 不会展开其中的向量。\n\n```\nt = table([1,2] as id, ([10,11], 12) as v)\nungroup(t)\n```\n\n| id | v        |\n| -- | -------- |\n| 1  | \\[10,11] |\n| 2  | 12       |\n\n将普通 tuple 转换为 columnar tuple 后，`ungroup` 会按照数组向量的规则展开 *v* 列。\n\n```\nt = table([1,2] as id, ([10,11], 12).setColumnarTuple!() as v)\nungroup(t)\n```\n\n| id | v  |\n| -- | -- |\n| 1  | 10 |\n| 1  | 11 |\n| 2  | 12 |\n\n取消 columnar tuple 标记。\n\n```\nv = ([10,11], 12).setColumnarTuple!()\nisColumnarTuple(v)\n// output: true\n\nv.setColumnarTuple!(false)\nisColumnarTuple(v)\n// output: false\n```\n"
    },
    "setColumnComment": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/setColumnComment.html",
        "signatures": [
            {
                "full": "setColumnComment(table, columnComments)",
                "name": "setColumnComment",
                "parameters": [
                    {
                        "full": "table",
                        "name": "table"
                    },
                    {
                        "full": "columnComments",
                        "name": "columnComments"
                    }
                ]
            }
        ],
        "markdown": "### [setColumnComment](https://docs.dolphindb.cn/zh/funcs/s/setColumnComment.html)\n\n\n\n#### 语法\n\nsetColumnComment(table, columnComments)\n\n#### 详情\n\n给分布式表或 mvcc 表的列添加注释。通过 [schema](https://docs.dolphindb.cn/zh/funcs/s/schema.html) 函数可以查看各列的注释。\n\n#### 参数\n\n**table** 是一个分布式表或 mvcc 表。\n\n**columnComments** 是一个字典，其中 key 表示表中的列，value 表示各列的注释。\n\n#### 例子\n\n```\nn=1000000\nsym=rand(`A`B`C`D`E`F,n)\ndate=rand(2019.06.01..2019.06.10,n)\nopen=rand(100.0,n)\nhigh=rand(200.0,n)\nclose=rand(200.0,n)\npre_close=rand(200.0,n)\nchange=rand(100.0,n)\nvol=rand(10000,n)\namount=rand(100000.0,n)\nt=table(sym,date,open,high,close,pre_close,change,vol,amount);\n\ndb1=database(\"\",VALUE,2019.06.01..2019.06.10)\ndb2=database(\"\",VALUE,`A`B`C`D`E`F)\ndb=database(\"dfs://db1\",COMPO,[db1,db2])\npt=db.createPartitionedTable(t,`pt,`date`sym).append!(t);\n\nsetColumnComment(pt,{sym:\"股票代码\",date:\"交易日期\",open:\"开盘价\",high:\"最高价\",close:\"收盘价\",pre_close:\"昨收价\",change:\"涨跌额\",vol:\"成交量（手）\",amount:\"成交额（千元）\"})\nschema(pt).colDefs;\n```\n\n| name       | typeString | typeInt | comment |\n| ---------- | ---------- | ------- | ------- |\n| sym        | SYMBOL     | 17      | 股票代码    |\n| date       | DATE       | 6       | 交易日期    |\n| open       | DOUBLE     | 16      | 开盘价     |\n| high       | DOUBLE     | 16      | 最高价     |\n| close      | DOUBLE     | 16      | 收盘价     |\n| pre\\_close | DOUBLE     | 16      | 昨收价     |\n| change     | DOUBLE     | 16      | 涨跌额     |\n| vol        | INT        | 4       | 成交量（手）  |\n| amount     | DOUBLE     | 16      | 成交额（千元） |\n\n```\nid=`XOM`GS`AAPL\nx=102.1 33.4 73.6\nmt = mvccTable(id, x);\nsetColumnComment(mt, {id:\"标识符\"})\nschema(mt).colDefs\n```\n\n| name | typeString | typeInt | extra | comment |\n| ---- | ---------- | ------- | ----- | ------- |\n| id   | STRING     | 18      |       | 标识符     |\n| x    | DOUBLE     | 16      |       |         |\n"
    },
    "setComputeNodeCachingDelay": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/setcomputenodecachingdelay.html",
        "signatures": [
            {
                "full": "setComputeNodeCachingDelay(delay)",
                "name": "setComputeNodeCachingDelay",
                "parameters": [
                    {
                        "full": "delay",
                        "name": "delay"
                    }
                ]
            }
        ],
        "markdown": "### [setComputeNodeCachingDelay](https://docs.dolphindb.cn/zh/funcs/s/setcomputenodecachingdelay.html)\n\n\n\n#### 语法\n\nsetComputeNodeCachingDelay(delay)\n\n#### 详情\n\n在线设置当前节点下配置项 *computeNodeCachingDelay* 的生效值。只能由管理员在控制节点执行。\n\n#### 参数\n\n**delay** 非负整数，表示时间间隔，单位为秒。\n\n#### 例子\n\n```\nsetComputeNodeCachingDelay(580) \n```\n\n相关函数：[getComputeNodeCachingDelay](https://docs.dolphindb.cn/zh/funcs/g/getcomputenodecachingdelay.html)\n"
    },
    "setDatabaseClusterReplicationExecutionSet": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/setdatabaseclusterreplicationexecutionset.html",
        "signatures": [
            {
                "full": "setDatabaseClusterReplicationExecutionSet(dbHandle, executionSet)",
                "name": "setDatabaseClusterReplicationExecutionSet",
                "parameters": [
                    {
                        "full": "dbHandle",
                        "name": "dbHandle"
                    },
                    {
                        "full": "executionSet",
                        "name": "executionSet"
                    }
                ]
            }
        ],
        "markdown": "### [setDatabaseClusterReplicationExecutionSet](https://docs.dolphindb.cn/zh/funcs/s/setdatabaseclusterreplicationexecutionset.html)\n\n\n\n#### 语法\n\nsetDatabaseClusterReplicationExecutionSet(dbHandle, executionSet)\n\n#### 详情\n\n为一个数据库设置异步复制任务的执行集。不同执行集的任务彼此隔离，互不影响。此函数只能由管理员在主集群的数据节点上对开启了异步复制的数据库执行。\n\n#### 参数\n\n**dbHandle** 数据库句柄，代表要设置执行集的数据库。\n\n**executionSet** 整型标量，只能是 0 或 1，代表执行集。数据库启用异步复制后，默认的执行集为 0。\n\n#### 例子\n\n```\nsetDatabaseClusterReplicationExecutionSet(dbHandle=database(\"dfs://test\"), executionSet=1)\n```\n"
    },
    "setDatabaseForClusterReplication": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/setDatabaseForClusterReplication.html",
        "signatures": [
            {
                "full": "setDatabaseForClusterReplication(dbHandle, option)",
                "name": "setDatabaseForClusterReplication",
                "parameters": [
                    {
                        "full": "dbHandle",
                        "name": "dbHandle"
                    },
                    {
                        "full": "option",
                        "name": "option"
                    }
                ]
            }
        ],
        "markdown": "### [setDatabaseForClusterReplication](https://docs.dolphindb.cn/zh/funcs/s/setDatabaseForClusterReplication.html)\n\n\n\n#### 语法\n\nsetDatabaseForClusterReplication(dbHandle, option)\n\n#### 详情\n\n开启/关闭分布式数据库的集群间的异步复制。该函数只能由管理员在主集群的数据节点调用。\n\n相关函数：[getDatabaseClusterReplicationStatus](https://docs.dolphindb.cn/zh/funcs/g/getDatabaseClusterReplicationStatus.html)\n\n#### 参数\n\n`dbHandle`：一个分布式数据库句柄。\n\n`option`：布尔值，表示开启（true）/关闭（false）指定数据库的异步复制，默认为 false。\n"
    },
    "setDatanodeRestartInterval": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/setDatanodeRestartInterval.html",
        "signatures": [
            {
                "full": "setDatanodeRestartInterval(interval)",
                "name": "setDatanodeRestartInterval",
                "parameters": [
                    {
                        "full": "interval",
                        "name": "interval"
                    }
                ]
            }
        ],
        "markdown": "### [setDatanodeRestartInterval](https://docs.dolphindb.cn/zh/funcs/s/setDatanodeRestartInterval.html)\n\n\n\n#### 语法\n\nsetDatanodeRestartInterval(interval)\n\n#### 详情\n\n在线设置控制节点自动重启计算节点/数据节点的功能。该命令只能由管理员在控制节点上调用。\n\n* 若 *interval*=0，则控制节点不会自动重启数据节点/计算节点。\n\n* 若 *interval*>0，则当节点离线时长超过 interval 时，控制节点会自动启动该节点。\n\n**Note:**\n\n* 该命令并不会改变配置文件中的 datanodeRestartInterval 值。因此，一旦控制节点重启，通过该命令设置的 interval 将失效。\n\n* 高可用环境下，Leader 节点通过该命令设置的 interval 并不会同步到其它 Follower 节点。\n\n相关函数：[getDatanodeRestartInterval](https://docs.dolphindb.cn/zh/funcs/g/getDatanodeRestartInterval.html)\n\n#### 参数\n\n**interval** 非负整数，表示时间，单位为秒。\n"
    },
    "setDefaultCatalog": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/setDefaultCatalog.html",
        "signatures": [
            {
                "full": "setDefaultCatalog(catalog)",
                "name": "setDefaultCatalog",
                "parameters": [
                    {
                        "full": "catalog",
                        "name": "catalog"
                    }
                ]
            }
        ],
        "markdown": "### [setDefaultCatalog](https://docs.dolphindb.cn/zh/funcs/s/setDefaultCatalog.html)\n\n\n\n#### 语法\n\nsetDefaultCatalog(catalog)\n\n#### 详情\n\n为当前 session 设置默认的 catalog。\n\n#### 参数\n\n**catalog** 字符串标量，表示 catalog 的名称。若为空，则表示重置当前 catalog 空间为初始状态，即无默认 catalog。\n\n#### 例子\n\n```\ngetCurrentCatalog()\n// 返回为空\n\ncreateCatalog(\"cat1\")\nsetDefaultCatalog(\"cat1\")\ngetCurrentCatalog()\n// Output: cat1\n\nsetDefaultCatalog(\"\")\ngetCurrentCatalog()\n// 返回为空\n```\n"
    },
    "setDynamicConfig": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/setdynamicconfig.html",
        "signatures": [
            {
                "full": "setDynamicConfig(configName, configValue)",
                "name": "setDynamicConfig",
                "parameters": [
                    {
                        "full": "configName",
                        "name": "configName"
                    },
                    {
                        "full": "configValue",
                        "name": "configValue"
                    }
                ]
            }
        ],
        "markdown": "### [setDynamicConfig](https://docs.dolphindb.cn/zh/funcs/s/setdynamicconfig.html)\n\n\n\n#### 语法\n\nsetDynamicConfig(configName, configValue)\n\n#### 详情\n\n在线修改指定的配置项。无返回值。\n\n**Note:** 此命令修改的配置值在系统重启后将失效。若需永久生效，请更新对应的配置文件。\n\n如下为支持修改的配置项（详情请参考文档 [DolphinDB-功能配置](https://docs.dolphindb.cn/zh/db_distr_comp/cfg/function_configuration.html)）：\n\n*enableMultiThreadMerge*, enableNullSafeJoin, *logLevel*, *maxBlockSizeForReservedMemory*, *maxConnections*, *memLimitOfQueryResult*, *memLimitOfTaskGroupResult*, *maxMemSize*, *maxPartitionNumPerQuery*, *memLimitOfTempResult*, *OLAPCacheEngineSize*, *recoveryWorkers*, *reservedMemSize*,*dfsChunkNodeHeartBeatTimeout*, *TSDBCacheEngineSize*, *TSDBVectorIndexCacheSize*, *memLimitOfAllTempResults*.\n\n#### 参数\n\n**configName** 字符串标量，表示待修改的配置项名。\n\n**configValue** 标量，表示待修改的配置项的值。\n\n#### 例子\n\n```\nsetDynamicConfig(\"maxMemSize\", 8);\nsetDynamicConfig(\"maxConnections\", 4096);\n```\n\n**Related information**\n\n[getDynamicConfig](https://docs.dolphindb.cn/zh/funcs/g/getdynamicconfig.html)\n"
    },
    "setGpFitnessFunc": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/setgpfitnessfunc.html",
        "signatures": [
            {
                "full": "setGpFitnessFunc(engine, func, [funcArgs])",
                "name": "setGpFitnessFunc",
                "parameters": [
                    {
                        "full": "engine",
                        "name": "engine"
                    },
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "[funcArgs]",
                        "name": "funcArgs",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [setGpFitnessFunc](https://docs.dolphindb.cn/zh/funcs/s/setgpfitnessfunc.html)\n\n\n\n#### 语法\n\nsetGpFitnessFunc(engine, func, \\[funcArgs])\n\n**Note:**\n\n社区版 License 暂不支持该函数，如需使用此功能，请联系技术支持。\n\n#### 详情\n\n重置 GPLearn 引擎的适应度函数。\n\n#### 参数\n\n**engine** 通过函数 `createGPLearnEngine` 创建引擎的返回对象。\n\n**func** 替换后的适应度函数，可以是\n\n* 字符串类型标量，必须为 'mse', 'rmse', 'pearson', 'spearmanr', 'mae' 之一。\n* 用户自定义函数，至少包含两个入参，第一个参数代表因子计算结果，第二个参数代表预测值，如有其他参数，则通过 *funcArgs*传递；函数的返回值必须是一个浮点型标量。自定义函数目前不支持复杂赋值、if、for 等语句，只支持 return 语句。return 值为支持的适应度函数和训练函数的组合，其中适应度函数需要手动写公式实现。例如：\n\n  ```\n  def f(x, y){\n    return mean((x+y)*(x+y)-y*y)\n  }\n  ```\n\n自定义的适应度函数，还可与辅助函数进行组合，从而实现在计算适应度前，对数据进行预处理。辅助函数如下所示\n\n<table id=\"table_zzr_lnv_mbc\"><thead><tr><th>\n\n**函数名**\n\n</th><th>\n\n**备注**\n\n</th></tr></thead><tbody><tr><td>\n\nclip(X,Y,Z)\n\n</td><td>\n\n</td></tr><tr><td>\n\nzscore(x)\n\n</td><td>\n\n</td></tr><tr><td>\n\nmad(X, \\[useMedian=false])\n\n</td><td>\n\n</td></tr><tr><td>\n\nmed(x)\n\n</td><td>\n\n</td></tr><tr><td>\n\nmean(x)\n\n</td><td>\n\n</td></tr><tr><td>\n\ncorr(X,Y)\n\n</td><td>\n\n</td></tr><tr><td>\n\ngroupby(func, funcArgs, groupingCol)\n\n</td><td>\n\n</td></tr><tr><td>\n\nstd(X)\n\n</td><td>\n\n</td></tr><tr><td>\n\nstdp(X)\n\n</td><td>\n\n</td></tr><tr><td>\n\nskew(X)\n\n</td><td>\n\n</td></tr><tr><td>\n\nkurtosis(X)\n\n</td><td>\n\n</td></tr><tr><td>\n\ncontextby(func, funcArgs, groupingCol, \\[sortingCol])\n\n</td><td>\n\n仅支持 *func*为辅助函数 `rank` 或 `zscore`。\n\n</td></tr><tr><td>\n\nrank(X, \\[ascending=true], \\[groupNum], \\[ignoreNA=true], \\[tiesMethod='min'], \\[percent=false], \\[precision])\n\n</td><td>\n\n暂不支持设置参数 *groupNum*, *ignoreNA*, *precision*.\n\n</td></tr></tbody>\n</table>**funcArgs**元组，其每个元素依次代表用户自定义的 *func*中除因子计算结果和预测值外的其他参数。\n\n#### 例子\n\n```\ndef myFitness(x, y, groupCOlA, groupColB) {\n  return mean(abs(groupby(mean, y, groupColB) - groupby(mean, x, groupColA)))\n}\nsetGpFitnessFunc(engine=myEngine, func=myFitness, funcArgs=[groupColA, groupColB])\n```\n"
    },
    "setHaMvccColumnDefaultValue": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/setHaMvccColumnDefaultValue.html",
        "signatures": [
            {
                "full": "setHaMvccColumnDefaultValue(table, colName, defaultValue)",
                "name": "setHaMvccColumnDefaultValue",
                "parameters": [
                    {
                        "full": "table",
                        "name": "table"
                    },
                    {
                        "full": "colName",
                        "name": "colName"
                    },
                    {
                        "full": "defaultValue",
                        "name": "defaultValue"
                    }
                ]
            }
        ],
        "markdown": "### [setHaMvccColumnDefaultValue](https://docs.dolphindb.cn/zh/funcs/s/setHaMvccColumnDefaultValue.html)\n\n\n\n#### 语法\n\nsetHaMvccColumnDefaultValue(table, colName, defaultValue)\n\n#### 详情\n\n设置高可用 MVCC 表指定列的默认值。\n\n此函数必须在该表所属 Raft 组的 Leader 节点上执行。\n\n#### 参数\n\n**table** 高可用 MVCC 表对象，表示要修改的表。\n\n**colName** 可以是字符串标量或向量，表示要设置默认值的列名。\n\n**defaultValue** 标量或元组，表示列默认值。若 *colName* 为向量，则 *defaultValue* 必须为与其等长的元组。\n\n#### 例子\n\n```\n//创建高可用 MVCC 表\nschemaTb = table(1:0, `name`id`value, [STRING, INT, DOUBLE])\nhmvcct = haMvccTable(1:0, schemaTb, \"demoHaMvcc\", 5)\n\n//设置 name 列的默认值为 A001\nsetHaMvccColumnDefaultValue(hmvcct, \"name\", \"A001\")\n//设置 id 列的默认值为 1，value 列的默认值为 3.6\nsetHaMvccColumnDefaultValue(hmvcct, [\"id\",\"value\"], (1, 3.6))\n```\n\n**相关函数**：[haMvccTable](https://docs.dolphindb.cn/zh/funcs/h/haMvccTable.html)\n"
    },
    "setHaMvccColumnNullability": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/setHaMvccColumnNullability.html",
        "signatures": [
            {
                "full": "setHaMvccColumnNullability(table, colName, allowNull)",
                "name": "setHaMvccColumnNullability",
                "parameters": [
                    {
                        "full": "table",
                        "name": "table"
                    },
                    {
                        "full": "colName",
                        "name": "colName"
                    },
                    {
                        "full": "allowNull",
                        "name": "allowNull"
                    }
                ]
            }
        ],
        "markdown": "### [setHaMvccColumnNullability](https://docs.dolphindb.cn/zh/funcs/s/setHaMvccColumnNullability.html)\n\n\n\n#### 语法\n\nsetHaMvccColumnNullability(table, colName, allowNull)\n\n#### 详情\n\n设置高可用 MVCC 表的部分列是否允许为 NULL。\n\n此函数必须在该表所属 Raft 组的 Leader 节点上执行。\n\n#### 参数\n\n**table** 高可用 MVCC 表对象，表示要修改的表。\n\n**colName** 字符串标量或向量，表示要设置的列名（单列或多列）。\n\n**allowNull** 布尔标量或向量，表示是否允许为 NULL，true 代表允许为 NULL。若为向量，其长度必须与 *colName* 一致。\n\n#### 例子\n\n```\n//创建高可用 MVCC 表\nschemaTb = table(1:0, `name`id`value, [STRING, INT, DOUBLE])\nhmvcct = haMvccTable(1:0, schemaTb, \"demoHaMvcc\", 5)\n\n//不允许 name 为空值\nsetHaMvccColumnNullability(hmvcct, \"name\", false)\n//设置 id 不允许为 NULL, value 可以为 NULL\nsetHaMvccColumnNullability(hmvcct, [\"id\",\"value\"], [true,false])\n```\n\n**相关函数**：[haMvccTable](https://docs.dolphindb.cn/zh/funcs/h/haMvccTable.html)\n"
    },
    "setIndexedMatrix!": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/setIndexedMatrix_.html",
        "signatures": [
            {
                "full": "setIndexedMatrix!(X, [on=true])",
                "name": "setIndexedMatrix!",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[on=true]",
                        "name": "on",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [setIndexedMatrix!](https://docs.dolphindb.cn/zh/funcs/s/setIndexedMatrix_.html)\n\n\n\n#### 语法\n\nsetIndexedMatrix!(X, \\[on=true])\n\n#### 详情\n\n将矩阵的行与列标签设为索引。\n\n#### 参数\n\n**X** 是一个有行与列标签的矩阵。行与列标签均须严格递增，无重复项。\n\n**on** 布尔值，表示普通矩阵和索引矩阵之间的转换。默认为 true，表示将普通矩阵转换成索引矩阵；若为 false，表示将索引矩阵转换为普通矩阵。\n\n#### 返回值\n\n返回一个矩阵或索引矩阵。\n\n#### 例子\n\n```\nm=matrix(1..5, 11..15)\nm.rename!(2020.01.01..2020.01.05, `A`B)\nm.setIndexedMatrix!();\n```\n\n|            | A | B  |\n| ---------- | - | -- |\n| 2020.01.01 | 1 | 11 |\n| 2020.01.02 | 2 | 12 |\n| 2020.01.03 | 3 | 13 |\n| 2020.01.04 | 4 | 14 |\n| 2020.01.05 | 5 | 15 |\n"
    },
    "setIndexedSeries!": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/setIndexedSeries_.html",
        "signatures": [
            {
                "full": "setIndexedSeries!(X, [on=true])",
                "name": "setIndexedSeries!",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[on=true]",
                        "name": "on",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [setIndexedSeries!](https://docs.dolphindb.cn/zh/funcs/s/setIndexedSeries_.html)\n\n\n\n#### 语法\n\nsetIndexedSeries!(X, \\[on=true])\n\n#### 详情\n\n将一个有行标签的单列矩阵转化为有索引的序列。\n\n#### 参数\n\n**X** 是一个有行标签的单列矩阵。行标签须严格递增，无重复项。\n\n**on** 布尔值，表示普通矩阵和索引序列之间的转换。默认为 true，表示将普通矩阵转换成索引序列；若为 false， 表示将索引序列转换为普通矩阵。\n\n#### 返回值\n\n返回一个向量或索引向量。\n\n#### 例子\n\n```\ns = matrix(1..10).rename!(2012.01.01..2012.01.10, ).setIndexedSeries!();\ns;\n```\n\n|            | #0 |\n| ---------- | -- |\n| 2012.01.01 | 1  |\n| 2012.01.02 | 2  |\n| 2012.01.03 | 3  |\n| 2012.01.04 | 4  |\n| 2012.01.05 | 5  |\n| 2012.01.06 | 6  |\n| 2012.01.07 | 7  |\n| 2012.01.08 | 8  |\n| 2012.01.09 | 9  |\n| 2012.01.10 | 10 |\n"
    },
    "setIPConnectionLimit": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/setIPConnectionLimit.html",
        "signatures": [
            {
                "full": "setIPConnectionLimit(IP, limit)",
                "name": "setIPConnectionLimit",
                "parameters": [
                    {
                        "full": "IP",
                        "name": "IP"
                    },
                    {
                        "full": "limit",
                        "name": "limit"
                    }
                ]
            }
        ],
        "markdown": "### [setIPConnectionLimit](https://docs.dolphindb.cn/zh/funcs/s/setIPConnectionLimit.html)\n\n\n\n#### 语法\n\nsetIPConnectionLimit(IP, limit)\n\n#### 详情\n\n设置每个 IP 对当前节点连接数限制。该限制适用于 API 连接和 `xdb` 连接，不会限制集群内部节点间的连接（如 `rpc` 等）。\n\n仅支持管理员调用，仅支持 Linux 系统部署的 server。\n\n#### 参数\n\n**IP** 字符串，表示要设置连接数限制的 IP 地址。\n\n**limit** 正整数或 -1。正整数表示连接数限制。-1 表示无限制。\n\n#### 例子\n\n设置 IP 地址 \"192.168.1.56\" 的最大连接数为 10：\n\n```\nsetIPConnectionLimit(\"192.168.1.56\", 10);\n```\n\n取消 IP 地址 \"192.168.1.56\" 的连接数限制：\n\n```\nsetIPConnectionLimit(\"192.168.1.56\", -1);\n```\n\n相关函数：[getIPConnectionLimit](https://docs.dolphindb.cn/zh/funcs/g/getIPConnectionLimit.html)\n"
    },
    "setLogLevel": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/setLogLevel.html",
        "signatures": [
            {
                "full": "setLogLevel(logLevel)",
                "name": "setLogLevel",
                "parameters": [
                    {
                        "full": "logLevel",
                        "name": "logLevel"
                    }
                ]
            }
        ],
        "markdown": "### [setLogLevel](https://docs.dolphindb.cn/zh/funcs/s/setLogLevel.html)\n\n\n\n#### 语法\n\nsetLogLevel(logLevel)\n\n#### 详情\n\n在线设置当前节点的日志文件的等级。设置后，系统只打印当前 logLevel 及以上级别的日志。该命令只能由管理员调用。\n\n#### 参数\n\n**logLevel** 日志等级，从低到高可选值为：DEBUG, INFO, WARNING, ERROR。\n"
    },
    "setMaxBlockSizeForReservedMemory": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/setMaxBlockSizeForReservedMemory.html",
        "signatures": [
            {
                "full": "setMaxBlockSizeForReservedMemory(blockSizeKB)",
                "name": "setMaxBlockSizeForReservedMemory",
                "parameters": [
                    {
                        "full": "blockSizeKB",
                        "name": "blockSizeKB"
                    }
                ]
            }
        ],
        "markdown": "### [setMaxBlockSizeForReservedMemory](https://docs.dolphindb.cn/zh/funcs/s/setMaxBlockSizeForReservedMemory.html)\n\n\n\n#### 语法\n\nsetMaxBlockSizeForReservedMemory(blockSizeKB)\n\n#### 详情\n\n在线修改系统预留内存可以分配的最大内存块大小。该命令只能由管理员在数据节点/计算节点上执行。\n\n请注意，此命令修改的配置值只对当前节点有效，且在系统重启后将失效。若需要配置值永久生效，请更改配置文件中的 *maxBlockSizeForReservedMemory*。\n\n#### 参数\n\n**blockSizeKB** 一个数值型标量（单位为KB），必须大于0。\n"
    },
    "setMaxConnections": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/setMaxConnections.html",
        "signatures": [
            {
                "full": "setMaxConnections(newValue)",
                "name": "setMaxConnections",
                "parameters": [
                    {
                        "full": "newValue",
                        "name": "newValue"
                    }
                ]
            }
        ],
        "markdown": "### [setMaxConnections](https://docs.dolphindb.cn/zh/funcs/s/setMaxConnections.html)\n\n\n\n#### 语法\n\nsetMaxConnections(newValue)\n\n#### 详情\n\n在线修改当前节点的最大连接数。该命令只能由管理员执行。\n\n可以在控制节点调用函数 [getClusterPerf](https://docs.dolphindb.cn/zh/funcs/g/getClusterPerf.html) 返回的 maxConnections 字段查看是否成功修改。\n\n**Note:**\n\n* *newValue* 指定的值必须大于当前的最大连接数，否则无法生效。\n\n* 此命令修改的配置值在系统重启后将失效。若需要配置值永久生效，请更改配置文件中的 *maxConnections*。\n\n* `getClusterPerf` 函数获取节点信息存在延迟，获取的可能不是最新的连接数。\n\n#### 参数\n\n**newValue** 一个小于 2^16（65536）的正整数。\n"
    },
    "setMaxJobParallelism": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/setMaxJobParallelism.html",
        "signatures": [
            {
                "full": "setMaxJobParallelism(userId, maxParallelism)",
                "name": "setMaxJobParallelism",
                "parameters": [
                    {
                        "full": "userId",
                        "name": "userId"
                    },
                    {
                        "full": "maxParallelism",
                        "name": "maxParallelism"
                    }
                ]
            }
        ],
        "markdown": "### [setMaxJobParallelism](https://docs.dolphindb.cn/zh/funcs/s/setMaxJobParallelism.html)\n\n\n\n#### 语法\n\nsetMaxJobParallelism(userId, maxParallelism)\n\n#### 详情\n\n为给定用户指定其提交的作业最多可以有多少个子任务同时并行执行。该命令必须要用户登录后才能执行。\n\n若未执行该函数，管理员的作业的默认最大并行度为64；非管理员用户的作业的默认最大并行度为2。\n\n**Note:** 该函数可在控制节点、数据节点和计算节点运行。\n\n#### 参数\n\n**userId** 是一个字符串，表示用户名。\n\n**maxParallelism** 是一个1到64之间的整数，表示该用户的作业的最大并行度，即最多可以有多少个子任务同时并行执行。\n\n#### 例子\n\n```\nlogin(`admin,`123456)\ncreateUser(`ElonMusk, `superman)\nsetMaxJobParallelism(`ElonMusk, 64);\n```\n"
    },
    "setMaxJobPriority": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/setMaxJobPriority.html",
        "signatures": [
            {
                "full": "setMaxJobPriority(userId, maxPriority)",
                "name": "setMaxJobPriority",
                "parameters": [
                    {
                        "full": "userId",
                        "name": "userId"
                    },
                    {
                        "full": "maxPriority",
                        "name": "maxPriority"
                    }
                ]
            }
        ],
        "markdown": "### [setMaxJobPriority](https://docs.dolphindb.cn/zh/funcs/s/setMaxJobPriority.html)\n\n\n\n#### 语法\n\nsetMaxJobPriority(userId, maxPriority)\n\n#### 详情\n\n为给定用户指定其提交作业的最高优先级。该函数必须要用户登录后才能执行。\n\n**Note:** 该函数可在控制节点、数据节点和计算节点运行。\n\n#### 参数\n\n**userId** 是一个字符串，表示用户名。\n\n**maxPriority** 是一个0到8之间的整数，表示给定用户提交作业的最高优先级。\n\n#### 例子\n\n```\nlogin(`admin,`123456)\ncreateUser(`KyleMurray, `Cardinals2020QB)\nsetMaxJobPriority(`KyleMurray, 7);\n```\n"
    },
    "setMaxMemSize": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/setMaxMemSize.html",
        "signatures": [
            {
                "full": "setMaxMemSize(memSizeGB, [emergencyMemSizeGB])",
                "name": "setMaxMemSize",
                "parameters": [
                    {
                        "full": "memSizeGB",
                        "name": "memSizeGB"
                    },
                    {
                        "full": "[emergencyMemSizeGB]",
                        "name": "emergencyMemSizeGB",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [setMaxMemSize](https://docs.dolphindb.cn/zh/funcs/s/setMaxMemSize.html)\n\n\n\n#### 语法\n\nsetMaxMemSize(memSizeGB, \\[emergencyMemSizeGB])\n\n#### 详情\n\n在线修改可以分配给 DolphinDB 的最大内存空间和紧急内存区大小。该命令只能由管理员执行。可通过 getClusterPerf().maxMemSize 查看修改后的设置是否生效。\n\n当动态设置最大内存空间 （即配置项 *maxMemSize*）后，若用户不进行其他修改，系统会自动调整小内存分配区（reservedMemSize）和紧急内存区（emergencyMemSize）大小：\n\n* 小内存分配区将调整为传入的 *memSizeGB*的5%，最小不低于64M、最大不超过 1G。\n* 紧急内存区（如果没有指定）调整为 *memSizeGB*的5%，最小不低于 256M，最大不超过 5G。\n\n关于 DolphinDB 内存管理相关配置参数及策略，参见[功能配置-内存](https://docs.dolphindb.cn/zh/db_distr_comp/cfg/function_configuration.md#)。\n\n**Note:**\n\n此命令修改的配置值在系统重启后将失效。若需要配置值永久生效，请更改配置文件中的 *maxMemSize* 和 *emergencyMemSize*。\n\n#### 参数\n\n**memSizeGB** 一个数值型标量（单位为 GB），必须大于0且不能大于 DolphinDB 的许可证文件配置的 *maxMemoryPerNode* （通过函数 `license` 查看），否则系统会报错。\n\n**emergencyMemSizeGB** 可选参数，一个数值型标量（单位为 GB），用于在线修改紧急内存区的大小，必须大于 0 且小于 *memSizeGB*的 50%。最小不低于 256 M，最大不能超过5G。若不指定，默认保持配置项 *[emergencyMemSize](https://docs.dolphindb.cn/zh/db_distr_comp/cfg/function_configuration.md#)* 的值不变。\n"
    },
    "setMaxTransactionSize": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/setMaxTransactionSize.html",
        "signatures": [
            {
                "full": "setMaxTransactionSize(engine, maxSizeGB)",
                "name": "setMaxTransactionSize",
                "parameters": [
                    {
                        "full": "engine",
                        "name": "engine"
                    },
                    {
                        "full": "maxSizeGB",
                        "name": "maxSizeGB"
                    }
                ]
            }
        ],
        "markdown": "### [setMaxTransactionSize](https://docs.dolphindb.cn/zh/funcs/s/setMaxTransactionSize.html)\n\n\n\n#### 语法\n\nsetMaxTransactionSize(engine, maxSizeGB)\n\n#### 详情\n\n在线修改当前数据/计算节点的单次写入事务上限（以 GB 为单位），注意不可超过对应 cache engine 大小。该命令只能由管理员执行。关于 DolphinDB 内存管理相关配置参数及策略，参见[功能配置-内存](https://docs.dolphindb.cn/zh/db_distr_comp/cfg/function_configuration.md#)。\n\n**注：**\n\n* 若 OLAP 引擎未开启 Cache Engine，该函数对 OLAP 的事务写入无限制。\n* 若当前节点被在线修改了 Cache Engine 容量（[setOLAPCacheEngineSize](https://docs.dolphindb.cn/zh/funcs/s/setOLAPCacheEngineSize.html)/[setTSDBCacheEngineSize](https://docs.dolphindb.cn/zh/funcs/s/setTSDBCacheEngineSize.html)），则该函数不可设置超过当前 Cache Engine 容量。\n* 此命令修改的配置值在系统重启后将失效。若需要永久限制写入事务的上限，请通过配置文件中的 *maxTransactionRatio* 调整事务大小占 Cache Engine 的最大比例。\n\n#### 参数\n\n**engine** 字符串标量，表示对应的存储引擎，可选值为 “TSDB” 或 “OLAP”。\n\n**maxSizeGB** 数值型标量，表示写入事务的大小上限，单位为 GB。\n"
    },
    "setMemLimitOfAllTempResults": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/setmemlimitofalltempresults.html",
        "signatures": [
            {
                "full": "setMemLimitOfAllTempResults()",
                "name": "setMemLimitOfAllTempResults",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [setMemLimitOfAllTempResults](https://docs.dolphindb.cn/zh/funcs/s/setmemlimitofalltempresults.html)\n\n\n\n#### 语法\n\nsetMemLimitOfAllTempResults()\n\n#### 详情\n\n某些分布式查询操作（例如表连接、GROUP BY、CONTEXT BY、PIVOT BY），可能会产生临时表用于存储查询中产生的结果。该函数用于在线设置这些临时表允许占用的内存上限，单位为 GB。可通过 `getMemLimitOfAllTempResults` 查看设置是否生效。\n\n**Note:**\n\n* 该函数只能由管理员在数据节点/计算节点上执行。\n\n* 此函数修改的配置值在系统重启后将失效。若需要配置值永久生效，请更改配置文件中的 *memLimitOfAllTempResults*。\n\n#### 参数\n\n**memLimit** 一个数值型标量，必须大于0且不能大于 *maxMemSize* 的设置值。\n\n#### 例子\n\n```\nsetMemLimitOfAllTempResults(3.0)\n```\n\n相关函数：[getMemLimitOfAllTempResults](https://docs.dolphindb.cn/zh/funcs/g/getmemlimitofalltempresults.html)\n"
    },
    "setMemLimitOfQueryResult": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/setMemLimitOfQueryResult.html",
        "signatures": [
            {
                "full": "setMemLimitOfQueryResult(memLimit)",
                "name": "setMemLimitOfQueryResult",
                "parameters": [
                    {
                        "full": "memLimit",
                        "name": "memLimit"
                    }
                ]
            }
        ],
        "markdown": "### [setMemLimitOfQueryResult](https://docs.dolphindb.cn/zh/funcs/s/setMemLimitOfQueryResult.html)\n\n\n\n#### 语法\n\nsetMemLimitOfQueryResult(memLimit)\n\n#### 详情\n\n在线修改单次查询结果占用的最大内存上限。该命令只能由管理员在数据节点/计算节点执行。\n\n相关函数： [getMemLimitOfQueryResult](https://docs.dolphindb.cn/zh/funcs/g/getMemLimitOfQueryResult.html)\n\n#### 参数\n\n**memLimit** 数值类型标量，表示内存上限，单位为 GB。该值必须小于 80% \\* maxMemSize。\n"
    },
    "setMemLimitOfTaskGroupResult": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/setMemLimitOfTaskGroupResult.html",
        "signatures": [
            {
                "full": "setMemLimitOfTaskGroupResult(memLimit)",
                "name": "setMemLimitOfTaskGroupResult",
                "parameters": [
                    {
                        "full": "memLimit",
                        "name": "memLimit"
                    }
                ]
            }
        ],
        "markdown": "### [setMemLimitOfTaskGroupResult](https://docs.dolphindb.cn/zh/funcs/s/setMemLimitOfTaskGroupResult.html)\n\n\n\n#### 语法\n\nsetMemLimitOfTaskGroupResult(memLimit)\n\n#### 详情\n\n在线修改当前节点发送的批量子查询占用的内存上限。该命令只能由管理员在数据节点/计算节点执行。\n\n相关函数： [getMemLimitOfTaskGroupResult](https://docs.dolphindb.cn/zh/funcs/g/getMemLimitOfTaskGroupResult.html)\n\n#### 参数\n\n**memLimit** 数值类型标量，表示内存上限。单位为 GB。\n"
    },
    "setMemLimitOfTempResult": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/setMemLimitOfTempResult.html",
        "signatures": [
            {
                "full": "setMemLimitOfTempResult(X)",
                "name": "setMemLimitOfTempResult",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [setMemLimitOfTempResult](https://docs.dolphindb.cn/zh/funcs/s/setMemLimitOfTempResult.html)\n\n\n\n#### 语法\n\nsetMemLimitOfTempResult(X)\n\n#### 详情\n\n在线修改表连接过程中产生的临时数据表（单个）的大小，单位为 GB。该命令只能由管理员在数据节点/计算节点上执行。\n\n**Note:** 此命令修改的配置值在系统重启后将失效。若需要配置值永久生效，请更改配置文件中的 *memLimitOfTempResult*。\n\n#### 参数\n\n**X** 一个数值型标量，必须大于0且不能大于 *maxMemSize* 的设置值。\n"
    },
    "setOLAPCacheEngineSize": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/setOLAPCacheEngineSize.html",
        "signatures": [
            {
                "full": "setOLAPCacheEngineSize(memSize)",
                "name": "setOLAPCacheEngineSize",
                "parameters": [
                    {
                        "full": "memSize",
                        "name": "memSize"
                    }
                ]
            }
        ],
        "markdown": "### [setOLAPCacheEngineSize](https://docs.dolphindb.cn/zh/funcs/s/setOLAPCacheEngineSize.html)\n\n\n\n#### 语法\n\nsetOLAPCacheEngineSize(memSize)\n\n别名：setCacheEngineMemSize\n\n#### 详情\n\n在线修改 Cache Engine 的容量。集群环境下，该命令只能由管理员在数据节点上执行。执行前需要确保开启了 Cache Engine (配置参数 *OLAPCacheEngineSize*)。仅 OLAP 引擎支持该命令。\n\n**Note:**\n\n此命令修改的配置值在集群重启后将失效。若需要配置值永久生效，请更改配置文件中的 *OLAPCacheEngineSize* 。\n\n#### 参数\n\n**memSize** 一个数值型标量，且必须大于0且小于 *maxMemSize* \\* 0.5。单位：GB。\n\n#### 场景\n\nCache Engine 开启后，写入数据时，系统会先把数据写入缓存，当缓存中的数据量达到 *OLAPCacheEngineSize* 的30%时，才会写入磁盘。若该配置项设置过小，大批量数据写入时，Cache Engine 可能很快被占满，从而导致写入卡住。此时，通过该命令在线修改 Cache Engine 的容量，来保证写入继续进行。\n\n#### 相关函数：\n\n可以使用 [getOLAPCacheEngineSize](https://docs.dolphindb.cn/zh/funcs/g/getOLAPCacheEngineSize.html) 获取 Cache Engine 的实时状态，确认 Cache Engine 是否在线修改成功。\n"
    },
    "setOrcaCheckpointConfig": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/setOrcaCheckpointConfig.html",
        "signatures": [
            {
                "full": "setOrcaCheckpointConfig(name, configMap)",
                "name": "setOrcaCheckpointConfig",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "configMap",
                        "name": "configMap"
                    }
                ]
            }
        ],
        "markdown": "### [setOrcaCheckpointConfig](https://docs.dolphindb.cn/zh/funcs/s/setOrcaCheckpointConfig.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nsetOrcaCheckpointConfig(name, configMap)\n\n#### 详情\n\n动态修改 checkpoint 的配置。\n\n#### 参数\n\n**name** 字符串标量，表示流图的名字。可以传入完整的流图全限定名（如 \"catalog\\_name.orca\\_graph.graph\\_name\"），也可以仅提供流图名（如 \"factors\"）；系统会根据当前的 catalog 设置自动补全为对应的全限定名。\n\n**configMap** 一个字典，表示具体配置。键值设置如下表所示。\n\n| **key**                  | **解释**                                                         | **value 取值** | **默认值** |\n| ------------------------ | -------------------------------------------------------------- | ------------ | ------- |\n| enable                   | 是否开启 Checkpoint                                                | true/false   | false   |\n| interval                 | 触发 Checkpoint 的时间间隔，单位为毫秒                                      | \\[10秒, 1年]   | 1小时     |\n| timeout                  | Checkpoint 的超时时间，即在指定时间内无法完成的 Checkpoint 将判定为失败，单位毫秒           | \\[1秒，1小时]    | 10分钟    |\n| alignedTimeout           | Barrier 对齐的超时时间，即在指定时间内无法完成 Barrier 对齐的Checkpoint 将被判定为失败，单位毫秒 | \\[100毫秒，1小时] | 10分钟    |\n| minIntervalBetweenCkpt   | 从上一个 Checkpoint 完成到下一个 Checkpoint 发起之间的最小时间间隔                  | \\[0，1年]      | 0       |\n| consecutiveFailures      | Checkpoint 最大连续失败次数。超过该次数后会导致整个流图的状态转换为 ERROR。                 | \\[0, 102400] | 3       |\n| maxConcurrentCheckpoints | 允许 Checkpoint 并发个数。请注意，允许并发Checkpoint可能会对运行中的流计算任务产生影响。        | \\[1, 102400] | 1       |\n| maxRetainedCheckpoints   | 系统会定期清理历史 Checkpoint 的数据，该配置项用于设置最多保留多少个最新的 Checkpoint 数据。     | \\[1， 1024]   | 3       |\n\n#### 例子\n\n```\nckptConfig = {\n    \"enable\":true,\n    \"interval\": 10000,\n    \"timeout\": 36000,\n    \"maxConcurrentCheckpoints\": 1\n};\nsetOrcaCheckpointConfig(\"streamGraph1\", ckptConfig)\n```\n"
    },
    "setPrefetchComputeNodeData": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/setprefetchcomputenodedata.html",
        "signatures": [
            {
                "full": "setPrefetchComputeNodeData(flag)",
                "name": "setPrefetchComputeNodeData",
                "parameters": [
                    {
                        "full": "flag",
                        "name": "flag"
                    }
                ]
            }
        ],
        "markdown": "### [setPrefetchComputeNodeData](https://docs.dolphindb.cn/zh/funcs/s/setprefetchcomputenodedata.html)\n\n\n\n#### 语法\n\nsetPrefetchComputeNodeData(flag)\n\n#### 详情\n\n在线设置当前节点下配置项 *enableComputeNodePrefetchData* 的生效值。只能由管理员在控制节点执行。\n\n#### 参数\n\n**flag** 布尔值，表示配置项 *enableComputeNodePrefetchData* 的内存生效值。\n\n#### 例子\n\n```\nsetPrefetchComputeNodeData(false) \n```\n\n相关函数：[getPrefetchComputeNodeData](https://docs.dolphindb.cn/zh/funcs/g/getprefetchcomputenodedata.html)\n"
    },
    "setRaftElectionTick": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/setRaftElectionTick.html",
        "signatures": [
            {
                "full": "setRaftElectionTick(groupId, tickCount)",
                "name": "setRaftElectionTick",
                "parameters": [
                    {
                        "full": "groupId",
                        "name": "groupId"
                    },
                    {
                        "full": "tickCount",
                        "name": "tickCount"
                    }
                ]
            }
        ],
        "markdown": "### [setRaftElectionTick](https://docs.dolphindb.cn/zh/funcs/s/setRaftElectionTick.html)\n\n\n\n#### 语法\n\nsetRaftElectionTick(groupId, tickCount)\n\n#### 详情\n\n通过该命令可以动态实现配置项 *raftElectionTick* 的功能。 由 *tickCount* 确定一个时间区间：\\[*tickCount*, 2 \\* *tickCount*]。在指定的 raft 组内， follower 在该区间内的一个随机时刻之后仍然没有收到 leader 的心跳，则会发出竞选 leader 的请求。\n\n**Note:**\n\n1. 必须由管理员在 raft 组内的所有控制节点上执行该命令，保证它们的 *raftElectionTick* 设置值相同。\n\n2. 该命令不会修改配置文件，重启后会恢复成默认配置或 *raftElectionTick* 指定的配置。\n\n相关函数： [getRaftElectionTick](https://docs.dolphindb.cn/zh/funcs/g/getRaftElectionTick.html), [getControllerElectionTick](https://docs.dolphindb.cn/zh/funcs/g/getControllerElectionTick.html)\n\n#### 参数\n\n**groupId** 是一个正整数，表示 raft 组的 ID，目前只能是1，表示控制节点组成的 raft 组 ID。\n\n**tickCount** 是一个不小于800的整数，单位为10ms。\n"
    },
    "setRandomSeed": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/setRandomSeed.html",
        "signatures": [
            {
                "full": "setRandomSeed(seed)",
                "name": "setRandomSeed",
                "parameters": [
                    {
                        "full": "seed",
                        "name": "seed"
                    }
                ]
            }
        ],
        "markdown": "### [setRandomSeed](https://docs.dolphindb.cn/zh/funcs/s/setRandomSeed.html)\n\n\n\n#### 语法\n\nsetRandomSeed(seed)\n\n#### 详情\n\n设置随机数种子。\n\n#### 参数\n\n**seed** 是一个整数，表示随机数种子。\n\n#### 例子\n\n```\nsetRandomSeed(5);\nrand(10, 10);\n```\n\n输出返回：\\[2,0,8,8,2,3,9,9,4,0]\n"
    },
    "setReservedMemSize": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/setReservedMemSize.html",
        "signatures": [
            {
                "full": "setReservedMemSize(memSizeGB)",
                "name": "setReservedMemSize",
                "parameters": [
                    {
                        "full": "memSizeGB",
                        "name": "memSizeGB"
                    }
                ]
            }
        ],
        "markdown": "### [setReservedMemSize](https://docs.dolphindb.cn/zh/funcs/s/setReservedMemSize.html)\n\n\n\n#### 语法\n\nsetReservedMemSize(memSizeGB)\n\n#### 详情\n\n在线修改系统预留内存空间的大小。该命令只能由管理员执行。\n\n请注意：\n\n* 此命令修改的配置值在系统重启后将失效。若需要配置值永久生效，请更改配置文件中的 *reservedMemSize*。\n* 此函数所设置的预留内存空间大小（对应配置项 *reservedMemSize*）与紧急内存区空间大小（对应配置项 *emergencyMemSize* 或通过`setMaxMemSize`在线修改），其值相加不可超过当前最大内存空间（对应配置项 *maxMemSize* 或通过`setMaxMemSize`在线修改）的 50%。\n\n#### 参数\n\n**memSizeGB** 一个数值型标量（单位为GB），必须大于0，且不能超过 *maxMemSize* \\* 0.5。\n"
    },
    "setRetentionPolicy": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/setRetentionPolicy.html",
        "signatures": [
            {
                "full": "setRetentionPolicy(dbHandle, retentionHours, [retentionDimension], [hoursToColdVolume])",
                "name": "setRetentionPolicy",
                "parameters": [
                    {
                        "full": "dbHandle",
                        "name": "dbHandle"
                    },
                    {
                        "full": "retentionHours",
                        "name": "retentionHours"
                    },
                    {
                        "full": "[retentionDimension]",
                        "name": "retentionDimension",
                        "optional": true
                    },
                    {
                        "full": "[hoursToColdVolume]",
                        "name": "hoursToColdVolume",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [setRetentionPolicy](https://docs.dolphindb.cn/zh/funcs/s/setRetentionPolicy.html)\n\n\n\n#### 语法\n\nsetRetentionPolicy(dbHandle, retentionHours, \\[retentionDimension], \\[hoursToColdVolume])\n\n#### 详情\n\n设置数据保留策略以及 [TieredStorage](https://docs.dolphindb.cn/zh/db_distr_comp/db/tiered_storage.html) 策略。若用户只通过该函数配置分级存储策略，建议将参数 *retentionHours* 指定为一个尽可能大的值。\n\n分级存储和数据保留策略都以分区为单位进行，因此 *retentionHours* 和 *hoursToColdVolume* 配置的时间必须是分区精度的倍数，如按天分区，则需要为 24 的整数倍。\n\n数据库会根据当前系统的机器时间，保留分区字段中存储的时间戳为最近 *retentionHours* 小时的数据。其中最新 *hoursToColdVolume* 小时的数据将继续存储在 volumes 中。在 \\[当前时间 - *hoursToColdVolume* - 10天，当前时间 - *hoursToColdVolume*) 范围内的数据将被迁移到 *coldVolumes*。若 *coldVolumes* 配置了多个路径，则数据将随机分布在各个存储路径下 。\n\n对于保留时间外的数据，只会删除 \\[当前时间 - *retentionHours* - 10 天, 当前时间 - *retentionHours*) 范围的数据。若需要删除之前的数据，可以调用 [dropPartition](https://docs.dolphindb.cn/zh/funcs/d/dropPartition.html) 函数实现。\n\n**Note:** 该函数只能对分布式数据库使用。\n\n可以通过 [schema](https://docs.dolphindb.cn/zh/funcs/s/schema.html) 函数查看数据库的数据保留时间。\n\n#### 参数\n\n**dbHandle** 分布式数据库的句柄。数据库的分区方案必须包含 DATE 类型或 DATEHOUR 类型。\n\n**retentionHours** 正整数，表示数据保留时间，单位是小时。\n\n**retentionDimension** 整数，表示时间分区所在的层次。默认值是0，表示第一层分区是按时间分区。\n\n**hoursToColdVolume** 正整数，表示 volumes 数据的保留时间，单位是小时。存储在 volumes 中的数据，经过 *hoursToColdVolume* 指定的时间后，将会自动迁移至 coldVolumes（该配置项需在配置文件中预先指定）。若不指定该参数，则 volumes 数据不会自动迁移。\n\n**Note:**\n\n必须满足 *retentionHours* - *hoursToColdVolume* > 7 \\* 24（即 7 天）\n\n#### 例子\n\n```\ndb=database(\"dfs://db1\",VALUE,2019.06.01..date(now()))\nretentionHour=9*24\nhoursToColdVolume=1*24\nsetRetentionPolicy(db,retentionHour,0, hoursToColdVolume);\n\nschema(db);\n// output\npartitionSchema->[2022.05.05,2022.05.04,2022.05.03,2022.05.02,2022.05.01,2022.04.30,2022.04.29,2022.04.28,2022.04.27,2022.04.26,...]\npartitionSites->\npartitionTypeName->VALUE\nhoursToColdVolume->24\natomic->TRANS\ndatabaseDir->dfs://db1\nengineType->OLAP\nchunkGranularity->TABLE\nretentionDimension->0\npartitionType->1\nretentionHours->216\n```\n"
    },
    "setSessionExpiredTime": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/setsessionexpiredtime.html",
        "signatures": [
            {
                "full": "setSessionExpiredTime(expire)",
                "name": "setSessionExpiredTime",
                "parameters": [
                    {
                        "full": "expire",
                        "name": "expire"
                    }
                ]
            }
        ],
        "markdown": "### [setSessionExpiredTime](https://docs.dolphindb.cn/zh/funcs/s/setsessionexpiredtime.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nsetSessionExpiredTime(expire)\n\n#### 详情\n\n在启用严格安全策略（参见配置项 *strictSecurityPolicy*）时，管理员可通过此函数设置会话过期时间。\n\n#### 参数\n\n**expire** 是一个 DURATION 类型的标量，表示会话的有效期限。\n\n#### 例子\n\n```\nsetSessionExpiredTime(3600s)  // 设置会话过期时间为1小时\ngetSessionExpiredTime() // output: 1H\n```\n"
    },
    "setStreamTableFilterColumn": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/setStreamTableFilterColumn.html",
        "signatures": [
            {
                "full": "setStreamTableFilterColumn(streamTable, columnName)",
                "name": "setStreamTableFilterColumn",
                "parameters": [
                    {
                        "full": "streamTable",
                        "name": "streamTable"
                    },
                    {
                        "full": "columnName",
                        "name": "columnName"
                    }
                ]
            }
        ],
        "markdown": "### [setStreamTableFilterColumn](https://docs.dolphindb.cn/zh/funcs/s/setStreamTableFilterColumn.html)\n\n\n\n#### 语法\n\nsetStreamTableFilterColumn(streamTable, columnName)\n\n#### 详情\n\n指定流数据表的过滤列。该函数需要配合 [subscribeTable](https://docs.dolphindb.cn/zh/funcs/s/subscribeTable.html) 函数的 *filter* 参数一起使用。*filter* 是一个向量，*streamTable* 的 *columnName* 列在 *filter* 中的数据才会发布到订阅端，不在 *filter* 中的数据不会发布。一个流数据表只能指定一个过滤列。\n\n#### 参数\n\n**streamTable** 是流数据表。\n\n**columnName** 是一个字符串。\n\n#### 例子\n\n下例中，指定了流数据表 trades 的 symbol 列为过滤列，同一节点上的表 trades\\_slave 订阅流数据表 trades 时把 filter 设置为 \\[\"IBM\", \"GOOG\"]，即流数据表 trades 的 symbol 为 \"IBM\" 或 \"GOOG\" 时才会发布到订阅端。\n\n```\nshare streamTable(10000:0,`time`symbol`price, [TIMESTAMP,SYMBOL,INT]) as trades\nsetStreamTableFilterColumn(trades, `symbol)\ntrades_1=table(10000:0,`time`symbol`price, [TIMESTAMP,SYMBOL,INT])\n\nfilter=symbol(`IBM`GOOG)\n\nsubscribeTable(tableName=`trades, actionName=`trades_1, handler=append!{trades_1}, msgAsTable=true, filter=filter);\n```\n"
    },
    "setStreamTableTimestamp": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/setstreamtabletimestamp.html",
        "signatures": [
            {
                "full": "setStreamTableTimestamp(streamTable, columnName)",
                "name": "setStreamTableTimestamp",
                "parameters": [
                    {
                        "full": "streamTable",
                        "name": "streamTable"
                    },
                    {
                        "full": "columnName",
                        "name": "columnName"
                    }
                ]
            }
        ],
        "markdown": "### [setStreamTableTimestamp](https://docs.dolphindb.cn/zh/funcs/s/setstreamtabletimestamp.html)\n\n\n\n#### 语法\n\nsetStreamTableTimestamp(streamTable, columnName)\n\n#### 详情\n\n为指定的流数据表设置一个时间戳列（支持所有时间类型）。设置后，每次向流表写入数据时，系统会记录写入时的系统时间到该时间戳列。这有助于用户统计实时数据写入流表时的延迟。\n\n**注意**：\n\n* 设置后不可更改和撤销时间戳列。\n* 设置后的表不支持作为流引擎的输出表。\n\n#### 参数\n\n**streamTable** 流数据表。可以是普通流表、共享流表、持久化流表和高可用流表。\n\n**columnName** 一个字符串，是流数据表最后一列的列名。该列用于记录数据写入流表的系统时间。\n\n#### 例子\n\n```\nshare streamTable(10000:0,`time`symbol`price`timestamp, [TIMESTAMP,SYMBOL,DOUBLE,TIMESTAMP]) as trades\n//指定 timestamp 列为时间戳列\nsetStreamTableTimestamp(trades, `timestamp)\n\n//插入的数据中不能包含 timestamp 列，系统会自动为其添加时间戳。\ninsert into trades values(2023.03.19T03:17:49, `A, 10.2)\n\nselect * from trades\n```\n\n| time                    | symbol | price | timestamp               |\n| ----------------------- | ------ | ----- | ----------------------- |\n| 2023.03.19 03:17:49.000 | A      | 10.2  | 2024.03.31 08:01:31.324 |\n\n```\n//高可用流表\ncolNames = `timestamp`sym`qty`price\ncolTypes = [TIMESTAMP,SYMBOL,INT,DOUBLE]\nt=table(1:0,colNames,colTypes)\nhaStreamTable(2,t,`trades,100000);\nsetStreamTableTimestamp(trades, `timestamp)\n```\n"
    },
    "setSystem": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/setSystem.html",
        "signatures": [
            {
                "full": "setSystem(paramName, paramValue)",
                "name": "setSystem",
                "parameters": [
                    {
                        "full": "paramName",
                        "name": "paramName"
                    },
                    {
                        "full": "paramValue",
                        "name": "paramValue"
                    }
                ]
            }
        ],
        "markdown": "### [setSystem](https://docs.dolphindb.cn/zh/funcs/s/setSystem.html)\n\n\n\n#### 语法\n\nsetSystem(paramName, paramValue)\n\n#### 详情\n\n`setSystem` 用于设置以下的系统级参数：\n\n* 在命令行窗口显示的对象的最大行数\n\n* 在命令行窗口显示的对象的最大行宽\n\n只有管理员有权限执行 `setSystem` 命令。\n\n#### 参数\n\n**paramName** 是参数名，**paramValue** 是对应的参数值。\n\n#### 例子\n\n```\nsetSystem(\"rows\", 30);\nsetSystem(\"width\", 200);\n```\n"
    },
    "setTableComment": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/settablecomment.html",
        "signatures": [
            {
                "full": "setTableComment(table, comment)",
                "name": "setTableComment",
                "parameters": [
                    {
                        "full": "table",
                        "name": "table"
                    },
                    {
                        "full": "comment",
                        "name": "comment"
                    }
                ]
            }
        ],
        "markdown": "### [setTableComment](https://docs.dolphindb.cn/zh/funcs/s/settablecomment.html)\n\n\n\n#### 语法\n\nsetTableComment(table, comment)\n\n#### 详情\n\n给分布式表添加注释，表注释可通过函数 [schema](https://docs.dolphindb.cn/zh/funcs/s/schema.html) 查看。\n\n#### 参数\n\n**table** 是一个分布式表。\n\n**comment** 字符串标量，表示表注释。长度不可超过 4096 字节。\n\n#### 例子\n\n```\n// 创建分布式表\ndb = database(directory=\"dfs://testDB\", partitionType=VALUE, partitionScheme=1..5)\nschemaTB = table(1..5 as id, take(`A`B`C,5) as sym, rand(10.0,5) as price)\npt = db.createPartitionedTable(table=schemaTB, tableName=\"pt\", partitionColumns=\"id\")\n\n// 设置表的注释\nsetTableComment(table=pt, comment=\"my first pt\")\n\n// 通过 schema 查看\nschema(pt)[\"tableComment\"]\n// output：'my first pt'\n```\n"
    },
    "setTableSensitiveColumn": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/setTableSensitiveColumn.html",
        "signatures": [
            {
                "full": "setTableSensitiveColumn(table, colName, option, [func])",
                "name": "setTableSensitiveColumn",
                "parameters": [
                    {
                        "full": "table",
                        "name": "table"
                    },
                    {
                        "full": "colName",
                        "name": "colName"
                    },
                    {
                        "full": "option",
                        "name": "option"
                    },
                    {
                        "full": "[func]",
                        "name": "func",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [setTableSensitiveColumn](https://docs.dolphindb.cn/zh/funcs/s/setTableSensitiveColumn.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nsetTableSensitiveColumn(table, colName, option, \\[func])\n\n#### 详情\n\n将表 *table* 的 *colName* 列设置或取消设置为敏感列。\n\n设置为敏感列后，仅该表的创建者、管理员和具有 DB\\_SENSITIVE\\_VIEW 或 TABLE\\_SENSITIVE\\_VIEW 权限的用户可以访问该列的明文数据，其他用户仅可访问经 *func* 脱敏处理后的数据。\n\n#### 参数\n\n**table**一个 DFS 表对象。\n\n**colName** STRING 类型标量，表示列名。\n\n**option** BOOL 类型标量，true 表示将 *colName*设置为敏感列，false 表示取消设置该列为敏感列。\n\n**func** 可选参数，是一个一元函数，表示脱敏算法。仅当 \\*option =\\*true 时支持设置此参数。默认算法为将目标列数据处理为空值。当该算法需要作用于不同类型时，UDF 内部应定义对不同类型的处理逻辑。\n\n#### 例子\n\n```\n// 建库建表\nlogin(`admin,`123456)\ndb = database(directory=\"dfs://sensitive\", partitionType=VALUE, partitionScheme=1..5)\nt = table(1..5 as tag, [\"John\",\"Emily\",\"Michael\",\"James\",\"Tommy\"] as userId, format(rand(100000,5),\"000000\") as password)\npt = createPartitionedTable(dbHandle=db, table=t, tableName=\"pt\", partitionColumns=\"tag\")\npt.tableInsert(t)\n\n// 设置敏感列\ndef encryptId(str){\n    return str[0]+\"******\"\n}\nsetTableSensitiveColumn(table=loadTable(\"dfs://sensitive\",\"pt\"), colName=\"userId\", option=true, func=encryptId)\n\ndef encryptPw(str) {\n    return regexReplace(str, \"[0-9]+\", \"#\")\n}\nsetTableSensitiveColumn(table=loadTable(\"dfs://sensitive\",\"pt\"), colName=\"password\", option=true, func=encryptPw)\n\n// 创建用户 user1\ncreateUser(`user1,`123456)\ngrant(userId=\"user1\", accessType=TABLE_READ, objs=\"dfs://sensitive/pt\")\n\n// user1 读取脱敏数据\nlogin(`user1,`123456)\nselect * from loadTable(\"dfs://sensitive\",\"pt\")\n\n// 为 user1 赋权\nlogin(`admin,`123456)\ngrant(userId=user1, accessType=TABLE_SENSITIVE_VIEW, objs=\"dfs://sensitive/pt\")\n\n// user1 读取敏感数据\nlogin(`user1,`123456)\nselect * from loadTable(\"dfs://sensitive\",\"pt\")\n```\n"
    },
    "setTimeoutTick": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/setTimeoutTick.html",
        "signatures": [
            {
                "full": "setTimeoutTick(tick)",
                "name": "setTimeoutTick",
                "parameters": [
                    {
                        "full": "tick",
                        "name": "tick"
                    }
                ]
            }
        ],
        "markdown": "### [setTimeoutTick](https://docs.dolphindb.cn/zh/funcs/s/setTimeoutTick.html)\n\n\n\n#### 语法\n\nsetTimeoutTick(tick)\n\n别名： setDfsChunkNodeHeartBeatTimeoutTick\n\n#### 详情\n\n动态设置控制节点判断数据节点是否在线的超时时间。该命令只能由管理员在控制节点上执行。若为高可用集群，则需要在 raft 组的每个控制节点上执行该命令。\n\n**Note:** 此命令修改的配置值在集群重启后将失效。若需要配置值永久生效，请更改配置文件中的 *dfsChunkNodeHeartBeatTimeout* 。\n\n#### 参数\n\n**tick** 一个正整数，表示超时时间，单位为秒。\n"
    },
    "setTSDBCacheEngineSize": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/setTSDBCacheEngineSize.html",
        "signatures": [
            {
                "full": "setTSDBCacheEngineSize(memSize)",
                "name": "setTSDBCacheEngineSize",
                "parameters": [
                    {
                        "full": "memSize",
                        "name": "memSize"
                    }
                ]
            }
        ],
        "markdown": "### [setTSDBCacheEngineSize](https://docs.dolphindb.cn/zh/funcs/s/setTSDBCacheEngineSize.html)\n\n\n\n#### 语法\n\nsetTSDBCacheEngineSize(memSize)\n\n#### 详情\n\n用于在线修改 TSDB 引擎的 Cache Engine 容量。集群环境下，该命令只能由管理员在数据节点/计算节点上执行。执行前需要确保开启了 Cache Enigne (配置参数 *TSDBCacheEngineSize* )。可以通过 `getTSDBCacheEngineSize` 查看设置是否生效。\n\n**Note:**\n\n此命令修改的配置值在集群重启后将失效。若需要配置值永久生效，请更改配置文件中的 *TSDBCacheEngineSize*。\n\n自 2.00.16/3.00.3 起，当 Cache Engine 内存占用达到 *TSDBCacheEngineSize*设定值时，系统将阻塞写入线程。此前版本中，内存占用允许升至设定值的两倍后才会触发阻塞。详情请见[配置项 *TSDBCacheEngineSize*说明](https://docs.dolphindb.cn/zh/db_distr_comp/cfg/function_configuration.md#)。\n\n相关函数： [getTSDBCacheEngineSize](https://docs.dolphindb.cn/zh/funcs/g/getTSDBCacheEngineSize.html)\n\n#### 参数\n\n**memSize** 一个数值型标量（单位为GB），必须大于0且小于 *maxMemSize* \\* 0.5。\n"
    },
    "seuclidean": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/seuclidean.html",
        "signatures": [
            {
                "full": "seuclidean(X, Y, Z)",
                "name": "seuclidean",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "Z",
                        "name": "Z"
                    }
                ]
            }
        ],
        "markdown": "### [seuclidean](https://docs.dolphindb.cn/zh/funcs/s/seuclidean.html)\n\n首发版本：3.00.5，3.00.4.3\n\n\n\n#### 语法\n\n```\nseuclidean(X, Y, Z)\n```\n\n#### 详情\n\n计算两个数值向量（X 和 Y）之间的标准化欧式距离，先将 X 和 Y 分别标准化处理后，再调用 [euclidean](https://docs.dolphindb.cn/zh/funcs/e/euclidean.html)。公式定义如下：\n\n![](https://docs.dolphindb.cn/zh/images/seuclidean.png)\n\n#### 参数\n\n**X** 数值向量。\n\n**Y** 数值向量。\n\n**Z** 数值向量，表示各维度的方差，用于标准化。\n\n**Note:** *X* 、*Y*、*Z* 三者的长度必须相等。\n\n#### 返回值\n\nDOUBLE 类型标量。\n\n#### 例子\n\n```\nX = [2, 5]\nY = [3, 7]\nZ = [1, 2]\n\nseuclidean(X, Y, Z)\n// 输出：1.7320508075688772\n```\n\n**相关函数**\n\n[euclidean](https://docs.dolphindb.cn/zh/funcs/e/euclidean.html)、[minkowski](https://docs.dolphindb.cn/zh/funcs/m/minkowski.html)、[mahalanobis](https://docs.dolphindb.cn/zh/funcs/m/mahalanobis.html)\n"
    },
    "shape": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/shape.html",
        "signatures": [
            {
                "full": "shape(X)",
                "name": "shape",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [shape](https://docs.dolphindb.cn/zh/funcs/s/shape.html)\n\n\n\n#### 语法\n\nshape(X)\n\n#### 详情\n\n以数据对的形式返回标量、向量或矩阵的维度。\n\n**Note:**\n\nDolphinDB `shape` 与 [numpy.shape](https://numpy.org/doc/stable/reference/generated/numpy.shape.html) 的核心功能相同。区别在于：\n\n* DolphinDB `shape` 返回数据对，以`行数:列数`的形式描述对象，标量返回1:1，向量返回`长度:1`，矩阵和表返回`行数:列数`。\n* `numpy.shape` 返回元组，表示数组各维度的长度，标量返回`()`，一维数组返回`(n,)`，二维数组返回`(m, n)`。\n\n#### 参数\n\n**X** 可以是标量、向量、矩阵或表。\n\n#### 返回值\n\nINT PAIR 类型标量。\n\n#### 例子\n\n标量的维度总是 1:1\n\n```\nshape 1;\n// output\n1:1\n\ns;\n```\n\n向量的维度总是向量长度:1\n\n```\nshape 1 5 3 7 8;\n// output\n5:1\n```\n\n矩阵的维度\n\n```\nm=(5 3 1 4 9 10)$3:2;\nm;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 5  | 4  |\n| 3  | 9  |\n| 1  | 10 |\n\n```\nshape m;\n\n// output\n3 :2\n```\n\n表的维度\n\n```\nt=table(1 2 3 as x, 4 5 6 as y);\nt;\n```\n\n| x | y |\n| - | - |\n| 1 | 4 |\n| 2 | 5 |\n| 3 | 6 |\n\n```\nshape t;\n// output\n3 :2\n```\n"
    },
    "shapiroTest": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/shapiroTest.html",
        "signatures": [
            {
                "full": "shapiroTest(X)",
                "name": "shapiroTest",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [shapiroTest](https://docs.dolphindb.cn/zh/funcs/s/shapiroTest.html)\n\n\n\n#### 语法\n\nshapiroTest(X)\n\n#### 详情\n\n对样本数据进行 Shapiro-Wilk 检验。\n\n#### 参数\n\n**X** 是一个数值向量，表示样本。\n\n#### 返回值\n\n一个字典，包含以下 key：\n\n* method ：字符串 \"Shapiro-Wilk normality test\"\n\n* pValue ：p 值\n\n* W ：W 统计量\n\n#### 例子\n\n```\nx = norm(0.0, 1.0, 50)\nshapiroTest(x);\n\n// output\nmethod->Shapiro-Wilk normality test\npValue->0.621668\nW->0.981612\n```\n"
    },
    "share": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/share.html",
        "signatures": [
            {
                "full": "share(table, sharedName, [database], [dbName], [partitionColumn], [readonly=false])",
                "name": "share",
                "parameters": [
                    {
                        "full": "table",
                        "name": "table"
                    },
                    {
                        "full": "sharedName",
                        "name": "sharedName"
                    },
                    {
                        "full": "[database]",
                        "name": "database",
                        "optional": true
                    },
                    {
                        "full": "[dbName]",
                        "name": "dbName",
                        "optional": true
                    },
                    {
                        "full": "[partitionColumn]",
                        "name": "partitionColumn",
                        "optional": true
                    },
                    {
                        "full": "[readonly=false]",
                        "name": "readonly",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [share](https://docs.dolphindb.cn/zh/funcs/s/share.html)\n\n\n\n#### 语法\n\nshare(table, sharedName, \\[database], \\[dbName], \\[partitionColumn], \\[readonly=false])\n\n#### 详情\n\n如果只有 *table* 和 *sharedName* 两个参数:\n\n* *table* 是表时，以指定名称在会话中共享表。包括表在内的本地对象在其他会话中不可见的。只有通过共享，它们才能在其他会话中可见。共享表的名称必须与会话中的普通表的名称不同。一般来说，共享的流数据表不支持删除和更新记录，但是 [table](https://docs.dolphindb.cn/zh/funcs/t/table.html) 和 [mvccTable](https://docs.dolphindb.cn/zh/funcs/m/mvccTable.html) 函数创建的表共享后支持删除和更新记录。所有的共享表都支持插入记录。\n\n* *table* 是引擎时，会对引擎增加写入锁，以实现对引擎的并发写入。\n\n如果使用了5个参数，填充分布式表的碎片，然后以指定名称在会话中共享。分区碎片是以给定列为基础。我们可以使用多个 `share` 语句在多个节点之间保存分区表。\n\n请注意，不可以将同一个流数据表通过修改共享变量名称的方式共享2次及以上。\n\n#### 参数\n\n**table** 是要在会话中共享的表或引擎。\n\n**sharedName** 是在会话中共享表的名称，或共享的分布式表的名称。\n\n**database** 是数据库句柄。当该参数是用 [database](https://docs.dolphindb.cn/zh/funcs/d/database.html) 函数定义时，它需要指定每个分区的名称。\n\n**dbName** 是分布式数据库的名称。\n\n**partitionColumn** 是分布式表的分区列。\n\n**readonly** 是一个布尔值，表示是否将普通/键值/索引内存表共享为一个只读的内存表，以提升读取和查询时的性能。默认值为 false。\n\n#### 例子\n\n例 1. 使用 `share` 函数将内存表共享为全局可见的共享表，使得当前节点的所有会话都可以访问该表。这是 DolphinDB 中实现跨会话数据共享的基础方法。\n\n```\nshare(t, `sharedT);\nshare(t, `quotes, tickDB, `tickDB, `date)\n```\n\n例 2. 创建 TSDB 引擎的分布式数据库和表，按日期分区并按时间排序，然后使用 `share` 共享表句柄。\n\n```\n// 共享通过 loadTable 加载的分布式表\nCREATE DATABASE \"dfs://valuedb\" PARTITIONED BY VALUE(2023.01.01..2023.12.31),engine=\"TSDB\"\nCREATE TABLE \"dfs://valuedb\".\"pt\"(\n    date DATE,\n    time TIME,\n    sym SYMBOL,\n    price DOUBLE\n)\nPARTITIONED BY date,\nsortColumns=`time\nshare(loadTable(\"dfs://valuedb\", \"pt\"), `pt)\n```\n\n例 3. 创建流数据表作为输入，创建输出表并共享，然后创建响应式状态引擎进行实时计算。使用 `go` 语句确保动态注册的变量能够被后续代码正确引用。\n\n```\ntrades = streamTable(1:0, `time`sym`price, [TIMESTAMP, SYMBOL, DOUBLE])\nshare(table(100:0, `sym`time`factor1, [SYMBOL, TIMESTAMP, DOUBLE]), `outputTable)\ngo\nengine = createReactiveStateEngine(name=\"test\", metrics=[<time>, <mavg(price, 3)>], dummyTable=trades, outputTable=outputTable, keyColumn=`sym)\n```\n\n例 4. 通过 `share` 函数共享响应式状态引擎，为引擎添加写入锁，允许当前节点的所有会话并发地向引擎写入数据。\n\n```\n// 将引擎 engine 共享\nshare(engine, \"test\")\n\n// 第一个自定义函数，向 engine 写入数据\ndef write1(mutable engine) {\n\tN = 10\n\tfor (i in 1..500) {\n\t\tdata = table(take(now(), N) as time, take(`A`B, N) as sym, rand(10.0, N) as price)\n\t\tengine.append!(data)\n\t}\n}\n// 第二个自定义函数，向 engine 写入数据\ndef write2(mutable engine) {\n\tN = 10\n\tfor (i in 1..500) {\n\t\tdata = table(take(now(), N) as time, take(`C`D, N) as sym, rand(10.0, N) as price)\n\t\tengine.append!(data)\n\t}\n}\n// 提交作业，使 write1 和 write2 同时向引擎写入数据\nsubmitJob(\"j1\", \"j1\", write1, engine)\nsubmitJob(\"j2\", \"j2\", write2, engine)\n// 查看输出表中数据行数为 10000，正好是 write1 和 write2 写入的数据量之和。\nselect count(*) from outputTable \n// output: 10,000\n```\n\n相关文档：[undef](https://docs.dolphindb.cn/zh/funcs/u/undef.html), [取消变量](https://docs.dolphindb.cn/zh/progr/objs/undef_var.html)\n"
    },
    "shell": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/shell.html",
        "signatures": [
            {
                "full": "shell(cmd)",
                "name": "shell",
                "parameters": [
                    {
                        "full": "cmd",
                        "name": "cmd"
                    }
                ]
            }
        ],
        "markdown": "### [shell](https://docs.dolphindb.cn/zh/funcs/s/shell.html)\n\n\n\n#### 语法\n\nshell(cmd)\n\n#### 详情\n\n执行操作系统命令。该函数只能在配置参数 enableShellFunction 设置为 true 时，由 DolphinDB 系统管理员执行。\n\n#### 参数\n\n**cmd** 是字符串，表示操作系统命令。\n\n#### 返回值\n\n若 *cmd* 成功被执行，系统会返回 0。其它返回值请参阅相应操作系统的 `system()` 函数返回值。\n\n#### 例子\n\n```\ncmd=\"rm -rf /home/user1/test.txt\"\nshell(cmd);\n```\n"
    },
    "short": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/short.html",
        "signatures": [
            {
                "full": "short(X)",
                "name": "short",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [short](https://docs.dolphindb.cn/zh/funcs/s/short.html)\n\n\n\n#### 语法\n\nshort(X)\n\n#### 详情\n\n将输入的数据类型转换为 SHORT。\n\n#### 参数\n\n**x** 可以是任意数据类型。\n\n#### 返回值\n\nSHORT 类型对象。\n\n#### 例子\n\n```\nx=short();\nx;\n```\n\n返回：null\n\n```\ntypestr x;\n```\n\n返回：SHORT\n\n```\nshort(`12.3);\n```\n\n返回：12\n\n```\nshort(`120.9c);\n```\n\n返回：120\n\n```\nshort(32767);\n```\n\n返回：32,767\n\n**Note:** SHORT 数据类型的范围是\\[ -215+1, 215 -1] = \\[-32767, 32767]。如果 *X* 超出了该范围，将会发生[溢出](https://docs.dolphindb.cn/zh/progr/data_types.md#section_oxj_hty_jxb)。\n\n```\nshort(32768);\n//Output\nnull\n\nshort(65578);\n//Output\n42\n\nshort(32789)\n//Output\n-32747\n```\n"
    },
    "shuffle": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/shuffle.html",
        "signatures": [
            {
                "full": "shuffle(X)",
                "name": "shuffle",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [shuffle](https://docs.dolphindb.cn/zh/funcs/s/shuffle.html)\n\n\n\n#### 语法\n\nshuffle(X)\n\nshuffle! 是 shuffle 的原地计算的版本。\n\n#### 详情\n\n对数据重组后，返回一个新的向量或矩阵。\n\n#### 参数\n\n**x** 可以是向量或矩阵。\n\n#### 返回值\n\n数据重组后，返回一个新的向量或矩阵。\n\n#### 例子\n\n```\nx=(1..6).shuffle();\nx;\n// output\n[1,6,3,5,4,2]\n\nx.shuffle!();\n// output\n[5,4,1,3,2,6]\n\n\nx=(1..6).reshape(3:2);\nx;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 4  |\n| 2  | 5  |\n| 3  | 6  |\n\n```\nx.shuffle();\n```\n\n| #0 | #1 |\n| -- | -- |\n| 5  | 3  |\n| 2  | 1  |\n| 4  | 6  |\n"
    },
    "shuffle!": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/shuffle_.html",
        "signatures": [
            {
                "full": "shuffle!(X)",
                "name": "shuffle!",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [shuffle!](https://docs.dolphindb.cn/zh/funcs/s/shuffle_.html)\n\n\n\n#### 语法\n\nshuffle!(X)\n\n#### 详情\n\n`shuffle!` 是 `shuffle` 的原地计算的版本。它们的唯一区别在于：`shuffle!` 会将结果赋值给 `X`，因此在执行后会改变 `X` 的值。\n"
    },
    "signbit": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/signbit.html",
        "signatures": [
            {
                "full": "signbit(X)",
                "name": "signbit",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [signbit](https://docs.dolphindb.cn/zh/funcs/s/signbit.html)\n\n\n\n#### 语法\n\nsignbit(X)\n\n#### 详情\n\n获取输入数据的符号位。\n\n**Note:**\n\nDolphinDB `signbit` 与 [numpy.signbit](https://numpy.org/doc/stable/reference/generated/numpy.signbit.html) 的核心功能相同。区别在于：\n\n* DolphinDB `signbit` 主要面向浮点数或整数标量，复数可通过 `lowDouble` 和 `highDouble` 分别检测实部和虚部。\n* `numpy.signbit` 支持标量和数组逐元素计算，并支持更多参数，如 *out*、*where*。\n\n#### 参数\n\n**X**：一个整型或者浮点型的标量。\n\n#### 返回值\n\n负号返回 true；正号返回 false。\n\n#### 例子\n\n```\nsignbit('a')\nfalse\n\nsignbit(-21)\ntrue\n\nsignbit(-2.1)\ntrue\n\nb=complex(10,-5)//创建一个复数\nb\n10.0-5.0i\nsignbit(highDouble(b)) //判断虚部符号\ntrue\n\nsignbit(lowDouble(b))  //判断实部符号\nfalse\n```\n"
    },
    "signum": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/signum.html",
        "signatures": [
            {
                "full": "signum(X)",
                "name": "signum",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [signum](https://docs.dolphindb.cn/zh/funcs/s/signum.html)\n\n\n\n#### 语法\n\nsignum(X)\n\n别名：sign\n\n#### 详情\n\n返回 *X* 的符号标志。\n\n#### 参数\n\n**X** 是布尔值或数值类型的标量、向量或矩阵。\n\n#### 返回值\n\n如果 *X* 为正数，返回1； 如果 *X* 为0，返回0；如果 *X* 为负数，返回-1；如果 *X* 中元素为 NULL，则返回 NULL。\n\n#### 例子\n\n```\nsignum(8.2 0 -6 NULL);\n// output\n[1,0,-1, ]\n```\n"
    },
    "sin": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/sin.html",
        "signatures": [
            {
                "full": "sin(X)",
                "name": "sin",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [sin](https://docs.dolphindb.cn/zh/funcs/s/sin.html)\n\n\n\n#### 语法\n\nsin(X)\n\n#### 详情\n\n返回 *X* 的正弦。\n\n**Note:**\n\nDolphinDB 的 `sin` 函数仅单一参数，支持标量、向量及矩阵计算；而 NumPy 的 `sin` 函数作为通用 ufunc，支持任意维度的 N 维数组，并可通过 *out*、*where*等参数实现指定输出与条件计算。\n\n#### 参数\n\n**X** 可以是标量、向量或矩阵。\n\n#### 返回值\n\nDOUBLE 类型的标量、向量或矩阵。\n\n#### 例子\n\n```\nsin(1 2 3);\n// output\n[0.841471,0.909297,0.141120]\n```\n\n相关函数：[asin](https://docs.dolphindb.cn/zh/funcs/a/asin.html), [acos](https://docs.dolphindb.cn/zh/funcs/a/acos.html), [atan](https://docs.dolphindb.cn/zh/funcs/a/atan.html), [cos](https://docs.dolphindb.cn/zh/funcs/c/cos.html), [tan](https://docs.dolphindb.cn/zh/funcs/t/tan.html), [asinh](https://docs.dolphindb.cn/zh/funcs/a/asinh.html), [acosh](https://docs.dolphindb.cn/zh/funcs/a/acosh.html), [atanh](https://docs.dolphindb.cn/zh/funcs/a/atanh.html), [sinh](https://docs.dolphindb.cn/zh/funcs/s/sinh.html), [cosh](https://docs.dolphindb.cn/zh/funcs/c/cosh.html), [tanh](https://docs.dolphindb.cn/zh/funcs/t/tanh.html)\n"
    },
    "sinh": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/sinh.html",
        "signatures": [
            {
                "full": "sinh(X)",
                "name": "sinh",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [sinh](https://docs.dolphindb.cn/zh/funcs/s/sinh.html)\n\n\n\n#### 语法\n\nsinh(X)\n\n#### 详情\n\n返回 *X* 的双曲正弦。\n\n**Note:**\n\nDolphinDB 的 `sinh` 函数仅接收单一参数，支持标量、向量及矩阵的计算；而 NumPy 的 `sinh` 函数作为通用 ufunc，支持任意维度的 N 维数组，并可通过 `out`、`where` 等参数实现指定输出与条件计算。\n\n#### 参数\n\n**X** 可以是标量、向量或矩阵。\n\n#### 返回值\n\nDOUBLE 类型的标量、向量或矩阵。\n\n#### 例子\n\n```\nsinh 1 2 3;\n// output\n[1.175201,3.62686,10.017875]\n```\n\n相关函数：[asin](https://docs.dolphindb.cn/zh/funcs/a/asin.html), [acos](https://docs.dolphindb.cn/zh/funcs/a/acos.html), [atan](https://docs.dolphindb.cn/zh/funcs/a/atan.html), [sin](https://docs.dolphindb.cn/zh/funcs/s/sin.html), [cos](https://docs.dolphindb.cn/zh/funcs/c/cos.html), [tan](https://docs.dolphindb.cn/zh/funcs/t/tan.html), [asinh](https://docs.dolphindb.cn/zh/funcs/a/asinh.html), [acosh](https://docs.dolphindb.cn/zh/funcs/a/acosh.html), [atanh](https://docs.dolphindb.cn/zh/funcs/a/atanh.html), [cosh](https://docs.dolphindb.cn/zh/funcs/c/cosh.html), [tanh](https://docs.dolphindb.cn/zh/funcs/t/tanh.html)\n"
    },
    "snippet": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/sinppet.html",
        "signatures": [
            {
                "full": "snippet(X)",
                "name": "snippet",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [snippet](https://docs.dolphindb.cn/zh/funcs/s/sinppet.html)\n\n\n\n#### 语法\n\nsnippet(X)\n\n#### 详情\n\n获取打印结果。\n\n#### 参数\n\n**X** 任意数据。\n\n#### 返回值\n\n返回一个字符串标量。\n\n#### 例子\n\n```\na = [[\"a\",\"b\"],\"c\"]\nsnippet(a)\n//output\n\"([\"a\",\"b\"],\"c\")\"\n\nsnippet(date(2023.01.01))\n//output\n\"2023.01.01\"\n```\n"
    },
    "size": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/size.html",
        "signatures": [
            {
                "full": "size(X)",
                "name": "size",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [size](https://docs.dolphindb.cn/zh/funcs/s/size.html)\n\n\n\n#### 语法\n\nsize(X)\n\n#### 详情\n\n对于向量或矩阵，`size` 返回元素的个数，而 [count](https://docs.dolphindb.cn/zh/funcs/c/count.html) 返回的是非 NULL 元素个数。\n\n对于内存表，`size` 返回行数。\n\n**Note:**\n\nDolphinDB 的 `size` 函数用于返回输入对象的元素总量：针对向量或矩阵，返回其包含的元素总个数；针对内存表，返回其行数。NumPy 的 `size` 函数用于返回数组沿指定轴方向的元素数量：在未指定 `axis` 参数时，返回数组所有维度上的元素总数；在指定 `axis` 参数时，返回该特定维度上的元素个数。\n\n#### 参数\n\n**X** 可以是标量、向量、矩阵或表。\n\n#### 返回值\n\nINT 类型标量。\n\n#### 例子\n\n```\nsize(3 NULL 5 6);\n// output\n4\ncount(3 NULL 5 6);\n// output\n3\n\nm=1 2 3 NULL 4 5$2:3;\nm;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1  | 3  | 4  |\n| 2  |    | 5  |\n\n```\nsize(m);\n// output\n6\n\ncount(m);\n// output\n5\n\nt = table(1 NULL 3 as id, 3 NULL 9 as qty);\nt;\n```\n\n| id | qty |\n| -- | --- |\n| 1  | 3   |\n|    |     |\n| 3  | 9   |\n\n```\nsize(t);\n// output\n3\n\ncount(t);\n// output\n3\n```\n"
    },
    "skew": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/skew.html",
        "signatures": [
            {
                "full": "skew(X, [biased=true])",
                "name": "skew",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[biased=true]",
                        "name": "biased",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [skew](https://docs.dolphindb.cn/zh/funcs/s/skew.html)\n\n\n\n#### 语法\n\nskew(X, \\[biased=true])\n\n#### 详情\n\n计算 *X* 的倾斜度。`skew` 函数在计算时会忽略 NULL 值。\n\nDolphinDB 使用以下公式计算倾斜度：\n\n* 当 *biased*=true 时，\n\n  ![](https://docs.dolphindb.cn/zh/images/rowskewx.png)\n\n* 当 *biased*= false 时\n\n  ![](https://docs.dolphindb.cn/zh/images/skew.png)\n\n若 *X* 为矩阵，计算每列的倾斜度，返回一个向量。\n\n若 *X* 为表，计算每列的倾斜度，返回一个表。\n\n`skew` 函数也支持校正偏差查询分区表和分布式表。\n\n**Note:** DolphinDB 与 SciPy 的 `skew` 函数均采用 Fisher-Pearson 系数计算倾斜度，但存在以下差异：DolphinDB 在计算时会忽略 NULL 值，而 SciPy 通过 *nan\\_policy* 参数提供显式控制；SciPy 提供 *keepdims* 参数，允许在计算后保留原数组的维度结构。\n\n#### 参数\n\n**X** 是一个向量、矩阵或表。\n\n**biased** 是一个布尔值，表示是否为有偏估计。默认值为 true，表示为有偏估计。**biased**\n\n值为 false ，表示无偏估计。\n\n#### 返回值\n\nDOUBLE 类型的标量、向量或表。\n\n#### 例子\n\n下面的例子使用了 [norm](https://docs.dolphindb.cn/zh/funcs/n/norm.html) 函数生成数据，每次生成的数据都会有细微差别，因此每次计算的结果会有所偏差。\n\n```\nx=norm(0, 1, 1000000);\nskew(x);\n```\n\n返回：-0.00124\n\n```\nx[0]=100;\nskew(x);\n```\n\n返回：0.983656\n\n```\nm=matrix(1..10, 1 2 3 4 5 6 7 8 9 100);\nm;\n```\n\n返回：\n\n| #0 | #1  |\n| -- | --- |\n| 1  | 1   |\n| 2  | 2   |\n| 3  | 3   |\n| 4  | 4   |\n| 5  | 5   |\n| 6  | 6   |\n| 7  | 7   |\n| 8  | 8   |\n| 9  | 9   |\n| 10 | 100 |\n\n```\nskew(m);\n```\n\n返回：\\[0,2.630083823883674]\n"
    },
    "skipClusterReplicationTask": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/skipClusterReplicationTask.html",
        "signatures": [
            {
                "full": "skipClusterReplicationTask(taskIds)",
                "name": "skipClusterReplicationTask",
                "parameters": [
                    {
                        "full": "taskIds",
                        "name": "taskIds"
                    }
                ]
            }
        ],
        "markdown": "### [skipClusterReplicationTask](https://docs.dolphindb.cn/zh/funcs/s/skipClusterReplicationTask.html)\n\n\n\n#### 语法\n\nskipClusterReplicationTask(taskIds)\n\n#### 详情\n\n用于跳过异步复制任务（通常是由于执行异常导致异步复制停止的任务）。该命令只能由管理员在从集群的控制节点调用。\n\n调用该命令前，需先将集群的异步复制流程暂停（调用 [stopClusterReplication](https://docs.dolphindb.cn/zh/funcs/s/stopClusterReplication.html) 函数）。执行完该命令后，再重启异步复制（调用 [startClusterReplication](https://docs.dolphindb.cn/zh/funcs/s/startClusterReplication.html) 命令）。跳过的任务会被标记为完成状态。\n\n#### 参数\n\n`taskIds` 标量或向量，表示待跳过的异步复制任务的 id（通过函数 [getMasterReplicationStatus](https://docs.dolphindb.cn/zh/funcs/g/getMasterReplicationStatus.html) 获取）。\n\n#### 例子\n\n```\nskipClusterReplicationTask(1);\n```\n\n相关函数： [startClusterReplication](https://docs.dolphindb.cn/zh/funcs/s/startClusterReplication.html), [stopClusterReplication](https://docs.dolphindb.cn/zh/funcs/s/stopClusterReplication.html)\n"
    },
    "sleep": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/sleep.html",
        "signatures": [
            {
                "full": "sleep(X)",
                "name": "sleep",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [sleep](https://docs.dolphindb.cn/zh/funcs/s/sleep.html)\n\n\n\n#### 语法\n\nsleep(X)\n\n#### 详情\n\n暂停程序 *X* 毫秒。\n\n#### 参数\n\n**X** 是一个非负数。\n\n#### 例子\n\n```\nfor(s in 1:10){\n   sleep(1000)\n   print(s+\" seconds passed.\")\n};\n\n// output\n1 seconds passed.\n2 seconds passed.\n3 seconds passed.\n4 seconds passed.\n5 seconds passed.\n6 seconds passed.\n7 seconds passed.\n8 seconds passed.\n9 seconds passed.\n```\n"
    },
    "slice": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/slice.html",
        "signatures": [
            {
                "full": "slice(obj, index)",
                "name": "slice",
                "parameters": [
                    {
                        "full": "obj",
                        "name": "obj"
                    },
                    {
                        "full": "index",
                        "name": "index"
                    }
                ]
            },
            {
                "full": "slice(obj, rowIndex, [colIndex])",
                "name": "slice",
                "parameters": [
                    {
                        "full": "obj",
                        "name": "obj"
                    },
                    {
                        "full": "rowIndex",
                        "name": "rowIndex"
                    },
                    {
                        "full": "[colIndex]",
                        "name": "colIndex",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [slice](https://docs.dolphindb.cn/zh/funcs/s/slice.html)\n\n\n\n#### 语法\n\nslice(obj, index)\n\n或\n\nslice(obj, rowIndex, \\[colIndex])\n\n相当于obj\\[index]或obj\\[rowIndex, colIndex]\n\n#### 详情\n\n对于第一种用法：\n\n* 如果 *obj* 是一个数组向量，\n\n  * *index* 是标量，返回指定的列，用向量表示。\n\n  * *index* 是向量，返回指定行组成的数组向量。\n\n  * *index* 是数据对，返回指定列组成的数组向量。\n\n* 如果 *obj* 是一个矩阵，\n\n  * *index* 是标量，返回指定的列，用向量表示。\n\n  * *index* 是向量或数据对，返回指定列组成的子矩阵。\n\n* 如果 *obj* 是一个表，\n\n  * *index* 是标量，返回指定的行，用字典表示。\n\n  * *index* 是向量或数据对，返回指定行组成的子表。\n\n对于第二种用法：\n\n* 如果 *obj* 是一个数组向量，\n\n  * *rowIndex* 和 *colIndex* 都是标量，返回指向行列的值，用向量表示。\n\n  * *rowIndex* 是标量，*colIndex* 是数据对，返回由指定行列组成的数组向量。\n\n  * *rowIndex* 是数据对，*colIndex* 是标量，返回由指定行列组成的向量。\n\n  * *rowIndex* 和 *colIndex* 都是数据对，返回由指定行列组成的数组向量。\n\n* 如果 *obj* 是一个矩阵，\n\n  * *rowIndex* 和 *colIndex* 都是标量，返回指定行列的值，用标量表示。\n\n  * *rowIndex* 和 *colIndex* 中一个是标量，另一个是数据对，返回由指定行列组成的子矩阵。\n\n  * *rowIndex* 和 *colIndex* 都是向量或数据对，返回指定行列组成的子矩阵。\n\n* 如果 *obj* 是一个表，\n\n  * *rowIndex* 和 *colIndex* 都是标量，返回指定行列的值，用标量表示。\n\n  * *rowIndex* 和 *colIndex* 中一个是标量，另一个是数据对，返回指定行列组成的子表。\n\n  * *rowIndex* 和 *colIndex* 都是向量或数据对，返回指定行列组成的子表。\n\n**Note:**\n\n*index*, *rowIndex*，*collIndex* 作为数组向量或矩阵的索引值或索引范围时，若其值不在 \\[0, size(X)-1] 内，则超出 \\[0, size(X)-1] 的值所对应的位置返回空值。\n\n#### 参数\n\n**obj** 可以是数组向量、矩阵或表。\n\n**index**, **rowIndex** 和 **colIndex** 可以是标量、向量或数据对，表示行或列的下标。如果 *index*, *rowIndex* 或 *colIndex* 为数据对，那么它表示下标的范围，上边界不包含在内。\n\n#### 返回值\n\n返回向量、数组向量、矩阵或表。\n\n#### 例子\n\n例1. 矩阵\n\n```\nm=1..9$3:3\nm.slice(0);\n[1,2,3]\n\nm.slice([0]);\n```\n\n| #0 |\n| -- |\n| 1  |\n| 2  |\n| 3  |\n\n```\nm.slice(0:2);\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 4  |\n| 2  | 5  |\n| 3  | 6  |\n\n```\nm.slice(0 2);\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 7  |\n| 2  | 8  |\n| 3  | 9  |\n\n```\nm.slice(0,1);\n// output\n4\n\nm.slice(0 1,0 1);\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 4  |\n| 2  | 5  |\n\n```\nm.slice(1:2,1:2);\n```\n\n| #0 |\n| -- |\n| 5  |\n\n例2. 表\n\n```\nt=table(`A`B`C as sym,2018.01.01..2018.01.03 as date,10 48 5 as val)\nt.slice(0);\n\n// output\nval->10\ndate->2018.01.01\nsym->A\nt.slice([0]);\n```\n\n| sym | date       | val |\n| --- | ---------- | --- |\n| A   | 2018.01.01 | 10  |\n\n```\nt.slice(0 1);\n```\n\n| sym | date       | val |\n| --- | ---------- | --- |\n| A   | 2018.01.01 | 10  |\n| B   | 2018.01.02 | 48  |\n\n```\nt.slice(0:1);\n```\n\n| sym | date       | val |\n| --- | ---------- | --- |\n| A   | 2018.01.01 | 10  |\n\n```\nt.slice(0,1);\n// output\n2018.01.01\n\nt.slice(0 1,0 1);\n```\n\n| sym | date       |\n| --- | ---------- |\n| A   | 2018.01.01 |\n| B   | 2018.01.02 |\n\n```\nt.slice(1:2,1:2);\n```\n\n| date       |\n| ---------- |\n| 2018.01.02 |\n\n例3. 数组向量\n\n```\nav =array(DOUBLE[], 0, 10).append!([1.0, 2.1 4.1 6.8, 0.5 2.2 2]);\nav[1]\n// output\n[,4.1,2.2]\nav[1,1]\n// output\n[4.1]\nav[1:3,1:3]\n// output\n[[4.1,6.8],[2.2,2]]\n```\n"
    },
    "sliceByKey": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/sliceByKey.html",
        "signatures": [
            {
                "full": "sliceByKey(table, rowKeys, [colNames], [preserveOrder=false])",
                "name": "sliceByKey",
                "parameters": [
                    {
                        "full": "table",
                        "name": "table"
                    },
                    {
                        "full": "rowKeys",
                        "name": "rowKeys"
                    },
                    {
                        "full": "[colNames]",
                        "name": "colNames",
                        "optional": true
                    },
                    {
                        "full": "[preserveOrder=false]",
                        "name": "preserveOrder",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [sliceByKey](https://docs.dolphindb.cn/zh/funcs/s/sliceByKey.html)\n\n\n\n#### 语法\n\nsliceByKey(table, rowKeys, \\[colNames], \\[preserveOrder=false])\n\n#### 详情\n\n从键值表或索引内存表中获取含有索引列指定值（由参数 *rowKeys* 指定）的行以及指定列（由 *colNames* 参数指定）的数据。耗时约为相应的 SQL 语句的50%。\n\n如果是键值表，*rowKeys* 参数必须含有所有 *keyColumns* 的值。\n\n如果是索引内存表，可指定前 n 个 *keyColumns* 的值，若其中有一列指定值为向量，所有指定列的指定值均需为同等长度的向量。\n\n若不指定 *colNames* 参数，则会输出所有列。\n\n结果的数据结构取决于 *colNames*。若 *colNames* 为标量，返回一个向量；若 *colNames* 为向量，返回一个内存表。\n\n#### 参数\n\n**table** 是键值表或索引内存表。\n\n**rowKeys** 是标量或向量，表示索引列的指定值。\n\n**colNames** 可选参数，是字符串标量或向量，表示要选择的列的列名。\n\n**preserveOrder** 可选参数，布尔标量，表示是否按照 *rowKeys*中值的顺序返回结果。默认为 false，此时输出顺序可能不同于 *rowKeys* 的顺序。\n\n#### 返回值\n\n返回结果的数据结构取决于 colNames。若 colNames 为标量，返回一个向量；若 colNames 为向量，返回一个内存表。\n\n#### 例子\n\n```\nt = indexedTable(`sym`side, 10000:0, `sym`side`price`qty, [SYMBOL,CHAR,DOUBLE,INT])\ninsert into t values(`IBM`MSFT`IBM, ['B','S','S'], 125.27 208.9 125.29, 1000 800 200)\na=sliceByKey(t,\"IBM\", 'price');\n\na;\n// output\n[125.27,125.29]\n\ntypestr(a);\n// output\nFAST DOUBLE VECTOR\n\na=sliceByKey(t,(\"IBM\",'S'));\na;\n```\n\n| sym | side | price  | qty |\n| --- | ---- | ------ | --- |\n| IBM | S    | 125.29 | 200 |\n\n```\ntypestr(a);\n// output\nIN-MEMORY TABLE\n\nt1 = keyedTable(`sym`side, 10000:0, `sym`side`price`qty, [SYMBOL,CHAR,DOUBLE,INT])\ninsert into t1 values(`IBM`MSFT`IBM, ['B','S','S'], 125.27 208.9 125.29, 1000 800 200)\nsliceByKey(t1, [[\"IBM\", \"MSFT\"], ['B', 'S']]);\n```\n\n| sym  | side | price  | qty  |\n| ---- | ---- | ------ | ---- |\n| IBM  | B    | 125.27 | 1000 |\n| MSFT | S    | 208.9  | 800  |\n\n指定 *preserveOrder*=true，可按索引列的输入顺序返回结果。\n\n```\nsliceByKey(table=t1, rowKeys=[[\"MSFT\", \"IBM\"], ['S', 'B']], preserveOrder=true); \n```\n\n| sym  | side | price  | qty  |\n| ---- | ---- | ------ | ---- |\n| MSFT | S    | 208.9  | 800  |\n| IBM  | B    | 125.27 | 1000 |\n"
    },
    "sma": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/sma.html",
        "signatures": [
            {
                "full": "sma(X, window)",
                "name": "sma",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    }
                ]
            }
        ],
        "markdown": "### [sma](https://docs.dolphindb.cn/zh/funcs/s/sma.html)\n\n\n\n#### 语法\n\nsma(X, window)\n\nTA-lib 系列函数参数说明和窗口计算规则请参考：[TAlib](https://docs.dolphindb.cn/zh/funcs/themes/TAlib.html)\n\n#### 详情\n\n在给定长度（以元素个数衡量）的滑动窗口内，计算 *X* 的简单移动平均（Simple Moving Average）。\n\n其计算公式为：\n\n![](https://docs.dolphindb.cn/zh/images/sma.png)\n\n#### 返回值\n\nDOUBLE 类型向量。\n\n#### 例子\n\n```\nx=12.1 12.2 12.6 12.8 11.9 11.6 11.2\nsma(x,3);\n// output\n[,,12.299999999999998,12.533333333333331,12.433333333333331,12.099999999999999,11.566666666666664]\n\nx=matrix(12.1 12.2 12.6 12.8 11.9 11.6 11.2, 14 15 18 19 21 12 10)\nsma(x,3);\n```\n\n| col1    | col2    |\n| ------- | ------- |\n|         |         |\n|         |         |\n| 12.3    | 15.6667 |\n| 12.5333 | 17.3333 |\n| 12.4333 | 19.3333 |\n| 12.1    | 17.3333 |\n| 11.5667 | 14.3333 |\n\n相关函数：[wma](https://docs.dolphindb.cn/zh/funcs/w/wma.html), [trima](https://docs.dolphindb.cn/zh/funcs/t/trima.html)\n"
    },
    "socp": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/socp.html",
        "signatures": [
            {
                "full": "socp(f, [G], [h], [l], [q], [A], [b])",
                "name": "socp",
                "parameters": [
                    {
                        "full": "f",
                        "name": "f"
                    },
                    {
                        "full": "[G]",
                        "name": "G",
                        "optional": true
                    },
                    {
                        "full": "[h]",
                        "name": "h",
                        "optional": true
                    },
                    {
                        "full": "[l]",
                        "name": "l",
                        "optional": true
                    },
                    {
                        "full": "[q]",
                        "name": "q",
                        "optional": true
                    },
                    {
                        "full": "[A]",
                        "name": "A",
                        "optional": true
                    },
                    {
                        "full": "[b]",
                        "name": "b",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [socp](https://docs.dolphindb.cn/zh/funcs/s/socp.html)\n\n\n\n#### 语法\n\nsocp(f, \\[G], \\[h], \\[l], \\[q], \\[A], \\[b])\n\n#### 详情\n\n该函数用于求解二阶锥规划问题，计算目标函数在限定条件下的最小值。若其约束条件以标准形式给出，其形式如下：\n\n![](https://docs.dolphindb.cn/zh/images/socp_standard_format.png)\n\n则矩阵 G 为：\n\n![](https://docs.dolphindb.cn/zh/images/socp_matrix_g.png)\n\n向量 h 为：\n\n![](https://docs.dolphindb.cn/zh/images/socp_h.png)\n\n#### 参数\n\n二阶锥规划（Second-Order Cone Programming，SOCP）问题的约束条件形式如下：\n\n![](https://docs.dolphindb.cn/zh/images/socp.png)\n\n其中 K 为锥，s 为松弛变量，其值在优化过程中会被确定。\n\n**f** 是数值型向量，表示目标函数的系数向量。\n\n**G** 是数值型矩阵，表示锥约束的系数矩阵。\n\n**h** 是数值型向量，表示锥约束的右端向量。\n\n**l** 是整数标量，表示非负象限约束的维度。\n\n**q** 是正数向量，表示各个二阶锥约束的维度大小，形式为 \\[r0,r1,…,rN-1]。\n\n**A** 是数值型矩阵，表示等式约束的系数矩阵。\n\n**b** 是数值型向量，表示等式约束的右端向量。\n\n#### 返回值\n\n返回一个长度为 4 的元组：\n\n* 第一个元素表示求解状态。\n* 第二个元素是目标函数取最小值时 x 的取值。\n* 第三个元素是目标函数的最小值。\n* 第四个元素是整型标量，表示 Exitcode。\n\nExitcode 与状态描述的对应关系如下表：\n\n| Exitcode | 状态描述                                                                    |\n| -------- | ----------------------------------------------------------------------- |\n| 0        | Optimal solution found                                                  |\n| 1        | Certificate of primal infeasibility found                               |\n| 2        | Certificate of dual infeasibility found                                 |\n| 10       | Optimal solution found subject to reduced tolerances                    |\n| 11       | Certificate of primal infeasibility found subject to reduced tolerances |\n| 12       | Certificate of dual infeasibility found subject to reduced tolerances   |\n| -1       | Maximum number of iterations reached                                    |\n| -2       | Numerical problems (unreliable search direction)                        |\n| -3       | Numerical problems (slacks or multipliers outside cone)                 |\n| -7       | Unknown problem in solver                                               |\n\n#### 例子\n\n求解以下二阶锥规划问题：\n\n![](https://docs.dolphindb.cn/zh/images/socp_exp.png)\n\n```\nf = [-6, -4, -5]\nG = matrix([[16, 7, 24, -8, 8, -1, 0, -1, 0], \n[-14, 2, 7, -13, -18, 3, 0, 0, -1], \n[5, 0, -15, 12, -6, 17, 0, 0, 0]])\nh = [-3, 5, 12, -2, -14, -13, 10, 0, 0]\n\nl = 2\nq = [4,3]\n\nre = socp(f,G,h,l,q, ,)\nprint(re)\n```\n\n返回：(\"Optimal solution found\",\\[-9.902804882871327,-1.39084684264198,26.211851780740154],-66.079042235904907)\n"
    },
    "solve": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/solve.html",
        "signatures": [
            {
                "full": "solve(X, Y)",
                "name": "solve",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [solve](https://docs.dolphindb.cn/zh/funcs/s/solve.html)\n\n\n\n#### 语法\n\nsolve(X, Y)\n\n#### 详情\n\n返回线性方程 X\\*b=Y 的解 b。\n\n#### 参数\n\n**X** 是矩阵；\n\n**Y** 是向量。\n\n#### 返回值\n\n一个向量。\n\n#### 例子\n\n```\nm=1..4$2:2;\nm;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 3  |\n| 2  | 4  |\n\n```\nm.solve(7 10);\n// output\n[1, 2]\n```\n"
    },
    "sort": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/sort.html",
        "signatures": [
            {
                "full": "sort(X, [ascending=true])",
                "name": "sort",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [sort](https://docs.dolphindb.cn/zh/funcs/s/sort.html)\n\n\n\n#### 语法\n\nsort(X, \\[ascending=true])\n\n 是 sort 的原地版本。\n\n#### 详情\n\n返回一个排序后的向量或矩阵。\n\nDolphinDB `sort` 和 `numpy.sort` 的区别在于：\n\n* 排序方向：DolphinDB `sort` 可通过 *ascending* 参数指定排序方式（升序或降序）；而 `numpy.sort` 默认仅支持升序排序，不支持通过参数指定降序，降序通常通过对结果反转实现。\n* 空值处理：DolphinDB `sort` 将 NULL 值当作最小值，其排序位置与 *ascending* 参数有关；而 `numpy.sort` 中 NaN 排序固定（通常放在末尾） 。\n\n#### 参数\n\n**X** 可以是向量或矩阵。\n\n**ascending** 是一个布尔值，表示按升序排序还是按降序排序。默认值为 true（按升序排序）。\n\n#### 返回值\n\n返回一个排序后的向量或矩阵。\n\n#### 例子\n\n```\nx=9 1 5;\nx;\n// output: [9,1,5]\n\ny=sort(x);\ny;\n// output: [1,5,9]\n\nsort(x, false);  // 逆序排序\n// output: [9,5,1]\n\nx=1 4 2 5 6 3$2:3;\nx;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1  | 2  | 6  |\n| 4  | 5  | 3  |\n\n```\nsort x;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1  | 3  | 5  |\n| 2  | 4  | 6  |\n\nsort! 函数排序并修改输入。\n\n```\nx=9 1 5;\nsort!(x);\nx;\n\n// output: [1 5 9];\n```\n\n相关函数：[isort](https://docs.dolphindb.cn/zh/funcs/i/isort.html)\n"
    },
    "sortBy!": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/sortBy_.html",
        "signatures": [
            {
                "full": "sortBy!(table, sortColumns, [sortDirections])",
                "name": "sortBy!",
                "parameters": [
                    {
                        "full": "table",
                        "name": "table"
                    },
                    {
                        "full": "sortColumns",
                        "name": "sortColumns"
                    },
                    {
                        "full": "[sortDirections]",
                        "name": "sortDirections",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [sortBy!](https://docs.dolphindb.cn/zh/funcs/s/sortBy_.html)\n\n\n\n#### 语法\n\nsortBy!(table, sortColumns, \\[sortDirections])\n\n#### 详情\n\n根据指定列和指定的排序方向对一个表进行就地排序。如果是分区表，将对每个分区进行排序，而不是对整个表进行排序。\n\n如果 table 是分区表并且启用了并行处理功能（即配置参数 localExcutors > 0），那么该操作是并行操作。\n\n#### 参数\n\n**table** 是 DolphinDB 中 Table 类型的表。它可以是分区或未分区的内存表。\n\n**sortColumns** 是一个字符串标量或向量，表示某列，该表按照该列进行排序。它也可以是表达式的元代码。\n\n**sortDirections** 是一个布尔值，表示排序方向。1表示按照升序排序，0表示按照降序排序。如果 *sortColumns* 是向量而 *sortDirections* 是标量，那么所有的排序列都根据 *sortDirections* 表示的排序方向排序。\n\n#### 返回值\n\n返回一个表。\n\n#### 例子\n\n对未分区表进行排序：\n\n```\nn=20000000\ntrades=table(rand(`IBM`MSFT`GM`C`YHOO`GOOG,n) as sym, 2000.01.01+rand(365,n) as date, 10.0+rand(2.0,n) as price, rand(1000,n) as qty);\ntrades.sortBy!(`sym`date, [0,1]);\n```\n\n对分区表进行排序：\n\n```\nworkDir = \"C:/DolphinDB/Data\"\nif(!exists(workDir)) mkdir(workDir)\ntrades.saveText(workDir + \"/trades.txt\")\ndb = database(workDir + \"/trade\",VALUE,`IBM`MSFT`GM`C`YHOO`GOOG)\ndb.loadTextEx(\"trades\",\"sym\", workDir + \"/trades.txt\")\ntrades = db.loadTable(\"trades\",`IBM`GM`YHOO,1)\ntrades.sortBy!(`date)\ntrades.sortBy!(`date, false)\ntrades.sortBy!(`date`qty, false)\ntrades.sortBy!(`date`qty, false true)\ntrades.sortBy!(<qty*price>)\ntrades.sortBy!(<[date, sym]>)\ntrades.sortBy!(<[sym, qty*price]>, true false)\n```\n"
    },
    "sort!": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/sort_.html",
        "signatures": [
            {
                "full": "sort!(X, [ascending=true])",
                "name": "sort!",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [sort!](https://docs.dolphindb.cn/zh/funcs/s/sort_.html)\n\n\n\n#### 语法\n\nsort!(X, \\[ascending=true])\n\n#### 详情\n\n对向量/矩阵进行排序。该函数会改变 *X* 的值。\n\n#### 参数\n\n**X** 是一个向量/向量。\n\n**ascending** 是一个布尔值，表示按升序排序还是按降序排序。默认值为 true（按升序排序）。\n\n#### 返回值\n\n返回排序后的向量/矩阵。\n\n#### 例子\n\n```\nx=9 1 5;\nsort!(x);\nx;\n// output\n[1 5 9]\n\nx.sort!(0);\nx;\n// output\n[9,5,1]\n```\n"
    },
    "spawnMonitor": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/spawnMonitor.html",
        "signatures": [
            {
                "full": "spawnMonitor(name, handler, arguments...)",
                "name": "spawnMonitor",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "handler",
                        "name": "handler"
                    },
                    {
                        "full": "arguments...",
                        "name": "arguments..."
                    }
                ]
            }
        ],
        "markdown": "### [spawnMonitor](https://docs.dolphindb.cn/zh/funcs/s/spawnMonitor.html)\n\n\n\n#### 语法\n\nspawnMonitor(name, handler, arguments...)\n\n#### 详情\n\n在 Monitor 中，通过 `spawnMonitor` 接口深拷贝构造一个 subMonitor。`spawnMonitor` 的功能如下:\n\n1. 构造一个深拷贝的 Monitor 新实例。\n\n2. 深拷贝原 Monitor 中所有支持深拷贝的属性和方法。\n\n3. 在生成的 Monitor 实例中可以通过参数，指定需要执行的操作。\n\n#### 参数\n\n**name** 生成 monitor 实例的名称。不可与已存在的实例重名。\n\n**handler** 生成的 Monitor 实例的方法。在生成新的实例后，将调用这个方法。\n\n**arguments** *handler* 的参数。\n\n#### 返回值\n\n一个 Monitor 实例\n\n#### 例子\n\n```\nclass NewStock {\n    code :: STRING\n    price :: DOUBLE\n    def NewStock(c, p){\n        code = c\n        price = p\n    }\n}\nclass SimpleShareSearch : CEPMonitor { \n    numberTicks :: INT\n    price :: DOUBLE\n    stockName :: STRING\n    def SimpleShareSearch(){\n        stockName = \"\"\n\t\tnumberTicks = 0\n\t\tprice = 0.0\n\t}\n    def matchTicks(newStock)\n    def spawnTicks(newStock){\n        numberTicks = numberTicks+1\n        spawnMonitor(\"MonitorOf\"+newStock.code, matchTicks, newStock)\n    }\n    // 监听所有 NewStock 事件。当发现 NewStock 事件时, \n    // 调用从当前监视器深拷贝构造一个监视器实例，并执行 matchTicks() 方法。\n    // 这个操作深拷贝了当前监视器的状态。\n    def onload() { \n        addEventListener(handler=spawnTicks, eventType=\"NewStock\", times=\"all\")\n    } \n    def processTick(ticks)\n    def matchTicks(newStock) { \n        stockName=newStock.code\n        price = newStock.price\n        addEventListener(handler=processTick, eventType=\"StockTick\", condition=<StockTick.code==stockName>,times=\"all\")\n    } \n   def processTick(ticks) { \n\t\tstr = \"StockTick event received\" + \n\t\t\t\" name = \" + ticks.code + \n\t\t\t\" Price = \" + ticks.price.string()\n\t\twriteLog(str)\n   } \n}\n```\n"
    },
    "spearmanr": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/spearmanr.html",
        "signatures": [
            {
                "full": "spearmanr(X, Y)",
                "name": "spearmanr",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [spearmanr](https://docs.dolphindb.cn/zh/funcs/s/spearmanr.html)\n\n\n\n#### 语法\n\nspearmanr(X, Y)\n\n#### 详情\n\n计算 *X* 和 *Y* 的 Spearman 等级相关系数。`spearman` 函数在计算时会忽略 NULL 值。Spearman 相关性是两个数据集之间关系的单调性的非参数度量，该系数在-1和+1之间变化，其中0表示无相关。-1或+1意味着确切的单调关系。正相关表明，随着 *X* 的增加，*Y* 也随之增加。负相关性表示随着 *X* 增加，*Y* 减少。\n\n若 *X* 或 *Y* 是矩阵，计算每列的 Spearman 等级相关系数，返回一个向量。\n\nDolphinDB `spearmanr` 函数和 `scipy.stats.spearmanr` 的区别在于：\n\n* 返回值形式：DolphinDB `spearmanr` 函数只返回相关系数，不返回 p 值；而 `scipy.stats.spearmanr` 会返回相关系数及其对应的 p 值。\n* 控制处理：DolphinDB `spearmanr`在计算时会忽略 NULL 值；`scipy.stats.spearmanr` 使用 nan\\_policy 参数控制 NaN 值处理方式。\n\n#### 参数\n\n**X** 是一个向量或矩阵。\n\n**Y** 是一个向量或矩阵。\n\n#### 返回值\n\n若 X 或 Y 是向量，返回一个标量。\n\n若 X 或 Y 是矩阵，返回一个向量。\n\n#### 例子\n\n```\nx=[2013.06.13, 2013.06.14, 2013.06.15]\ny=1 5 3\nspearmanr(x, y)\n// output: 0.5\n\nx = [33,21,46,-11,78,47,18,20,-5,66]\ny = [1,NULL,10,6,10,3,NULL,NULL,5,3]\nspearmanr(x, y)\n// output: 0.109109\n```\n\n如果 *X* 是矩阵，*Y* 可以是标量、向量或者是与 *X* 行数相同的矩阵。返回结果是与 *X* 列数相同的向量。\n\n```\nm1 = [34,77,35,-40,-39,-86,49,-55,15,72,NULL,-24,16,20,26,-82,80,-93,-65,99,45,90,44,46]$4:6\nm2 = [0, 25, 7, 3]\nspearmanr(m1, m2)\n// output: [0.8, -0.4, 0.5, 0.6, -0.8, 0.4]\n```\n"
    },
    "splev": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/splev.html",
        "signatures": [
            {
                "full": "splev(x, tck)",
                "name": "splev",
                "parameters": [
                    {
                        "full": "x",
                        "name": "x"
                    },
                    {
                        "full": "tck",
                        "name": "tck"
                    }
                ]
            }
        ],
        "markdown": "### [splev](https://docs.dolphindb.cn/zh/funcs/s/splev.html)\n\n\n\n#### 语法\n\nsplev(x, tck)\n\n#### 详情\n\n`splev` 全称 Spline Evaluation，即评估 B 样条曲线或其导数。给定 B 样条表示的节点和系数，使用该函数可求解平滑多项式及其导数的值。若 x, tck 传入参数中包含 None 将直接填充为 0。\n\n**Note:**\n\n不建议自定义 *tck*，如果 *tck* 不是由 splrep 生成，则返回的 y 可能是随机值，也可能全为0。\n\n#### 参数\n\n**x** Integral/Temporal/Floating 类型向量。一组点，用来获得样条上的对应的值。\n\n**tck** 三元组或 B 样条曲线对象。若传入元组，则应为长度为3的序列；若传入 B 样条曲线对象，则应包含节点 t、B 样条系数 c 和样条次数 k，可使用函数 [splrep](https://docs.dolphindb.cn/zh/funcs/s/splrep.html) 生成。注意，须遵守 1<=k<=5。\n\n#### 返回值\n\nDOUBLE 类型的向量，表示在 x 点处求解的样条函数值的数组。\n\n#### 例子\n\n```\nx = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\ny = [0, 3, 5, 6, 5, 3, 1, 2, 4, 5]\nnewx = [0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5, 9.5]\nt=[1,3,5,8]\ntck= splrep(x, y, t=t)\nprint(tck)\n// output\n([0,0,0,0,1,3,5,8,9,9,9,9],\n[0,2.234794827972243,2.999908797063527,8.195517483732592,0.982766102937427,0.416533320193195,6.868465914739519,5,0,0,0,0],\n3)\n\nnewy = splev(newx, tck)\nprint(newy)\n// output\n[2.147514374187927,3.928180605155257,5.780093403045226,5.788551610920491,3.842319632145274,1.928386784305488,1.343262026468735,2.600266282317609,5.680148059970901,-0.902321655035049] \n```\n\n相关函数：[splrep](https://docs.dolphindb.cn/zh/funcs/s/splrep.html)\n"
    },
    "spline": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/spline.html",
        "signatures": [
            {
                "full": "spline(X, Y, resampleRule, [closed='left'], [origin='start_day'], [outputX=false])",
                "name": "spline",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "resampleRule",
                        "name": "resampleRule"
                    },
                    {
                        "full": "[closed='left']",
                        "name": "closed",
                        "optional": true,
                        "default": "'left'"
                    },
                    {
                        "full": "[origin='start_day']",
                        "name": "origin",
                        "optional": true,
                        "default": "'start_day'"
                    },
                    {
                        "full": "[outputX=false]",
                        "name": "outputX",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [spline](https://docs.dolphindb.cn/zh/funcs/s/spline.html)\n\n\n\n#### 语法\n\nspline(X, Y, resampleRule, \\[closed='left'], \\[origin='start\\_day'], \\[outputX=false])\n\n#### 详情\n\n该函数根据 *resampleRule*, *closed*, *origin* 确定的采样规则，对 *X* 进行重采样操作。并根据重采样后的 *X*，对 *Y* 进行三次样条插值（Cubic Spline Interpolation）。\n\n#### 参数\n\n**X** 严格递增的时间类型向量。\n\n**Y** 同 *X* 等长的数值型向量。\n\n**resampleRule** 一个字符串，可选值请参考 [resample](https://docs.dolphindb.cn/zh/funcs/r/resample.html) 的 *rule* 参数。\n\n**closed** 和 **origin** 同 [resample](https://docs.dolphindb.cn/zh/funcs/r/resample.html) 的 *closed* 和 *origin* 参数。\n\n**outputX** 布尔类型，表示是否输出 *X* 按照 *resampleRule*, *closed*, *origin* 重采样后的向量。默认值为 false。\n\n#### 返回值\n\n若不指定 *outputX*，仅返回一个对 *Y* 插值后的向量。若指定 *outputX* = true，则返回一个 tuple，其第一个元素为 *X* 重采样后的向量，第二个元素为对 *Y* 插值后的向量。\n\n#### 例子\n\n**例 1**\n\n```\nspline([2016.02.14 00:00:00, 2016.02.15 00:00:00, 2016.02.16 00:00:00], [1.0, 2.0, 4.0], resampleRule=`60min);\n\n// output\n[1,1.0313,1.0626,1.0942,1.1262,1.1585,1.1914,1.225,1.2593,1.2944,1.3306,1.3678,1.4062,1.446,1.4871,1.5298,1.5741,1.6201,1.668,1.7178\n,1.7697,1.8237,1.8801,1.9388,2,2.0638,2.1301,2.1987,2.2697,2.3428,2.418,2.4951,2.5741,2.6548,2.7371,2.821,2.9062,2.9928,3.0806,3.1694\n,3.2593,3.35,3.4414,3.5335,3.6262,3.7192,3.8126,3.9063,4]\n```\n\n**例 2** 不同 *closed* 取值的影响。\n\n```\nX = 2022.01.01T00:00:00 + [0, 3, 6, 9] * 60\nY = [1.0, 3.0, 7.0, 13.0]\n\n// closed='left'（默认）：00:03 归入 [00:03, 00:06) 的起点\nspline(X, Y, `3min, closed=`left, outputX=true)\n\n// closed='right'：00:03 归入 (00:00, 00:03] 的终点\n// 重采样 X 的起始点不同，样条曲线形状不同\nspline(X, Y, `3min, closed=`right, outputX=true)\n```\n\n**例 3** 不同 *origin* 取值的影响。\n\n```\nX = 2022.01.01T00:00:30 + (0..4) * 60\nY = [2.0, 4.0, 7.0, 11.0, 16.0]\n\n// origin='start_day'（默认）：从当天零点对齐\nspline(X, Y, `1min, origin=`start_day, outputX=true)\n\n// origin='start'：从第一个数据点 00:00:30 对齐\nspline(X, Y, `1min, origin=`start, outputX=true)\n\n// origin=自定义时间戳：从 00:00:10 对齐\nspline(X, Y, `1min, origin=2022.01.01T00:00:10, outputX=true)\n```\n\n**例 4** 不同 *outputX* 取值的影响。\n\n```\nX = [2016.02.14T00:00:00, 2016.02.15T00:00:00, 2016.02.16T00:00:00]\nY = [1.0, 2.0, 4.0]\n\n// outputX=false（默认）：只返回三次样条插值后的 Y 向量\nspline(X, Y, `60min)\n\n// outputX=true：返回 tuple，[0] 为重采样后的时间戳，[1] 为插值 Y\nresult = spline(X, Y, `60min, outputX=true)\nresult[0]\nresult[1]\n```\n"
    },
    "split": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/split.html",
        "signatures": [
            {
                "full": "split(str, [delimiter])",
                "name": "split",
                "parameters": [
                    {
                        "full": "str",
                        "name": "str"
                    },
                    {
                        "full": "[delimiter]",
                        "name": "delimiter",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [split](https://docs.dolphindb.cn/zh/funcs/s/split.html)\n\n\n\n#### 语法\n\nsplit(str, \\[delimiter])\n\n#### 详情\n\n若 *str* 为标量：\n\n* 如果没有指定 *delimiter*，把 *str* 分割为 CHAR 类型向量。\n\n* 如果指定了 *delimiter*，把它作为分隔符，把 *str* 分成 CHAR 类型或 STRING 类型的向量。\n\n若 *str* 为向量，则对 *str* 的每一个元素进行分割，返回一个列式元组（columnar tuple）。\n\nDolphinDB 的 `split` 函数与 numpy 的 `split` 函数是完全不同用途的函数，前者用于字符串分割，后者用于数组分割。\n\n#### 参数\n\n**str** 是STRING类型标量或向量；\n\n**delimiter** 是 CHAR 类型或 STRING 类型标量，表示分隔符。分隔符可以是一个或多个字符，默认是逗号（\",\"）。\n\n#### 返回值\n\n返回向量或列式元组。\n\n#### 例子\n\n```\nsplit(\"xyz 1\");\n// output\n['x','y','z',' ','1']\n\nsplit(\"xyz 1\",\" \");\n// output\n[\"xyz\",\"1\"]\n\nsplit(`xyz1,`xyz);\n// output\n[,\"1\"]\n\nsplit(`xyz1,`xyz)[1];\n// output\n1\n\na = split\\(\"20220101 09:00:00\" \"20220101 09:12:20\" \"20220101 10:00:00\", \" \"\\)\n// output\n\\(\\[\"20220101\",\"09:00:00\"\\],\\[\"20220101\",\"09:12:20\"\\],\\[\"20220101\",\"10:00:00\"\\]\\)\n\n// 按列取数\na\\[0\\];\n// output\n\\[\"20220101\",\"20220101\",\"20220101\"\\]\n\na\\[1\\];\n// output\n\\[\"09:00:00\",\"09:12:20\",\"10:00:00\"\\]\n\n// 按行取数\na.row\\(0\\)\n// output\n\\[\"20220101\",\"09:00:00\"\\]\n```\n"
    },
    "splrep": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/splrep.html",
        "signatures": [
            {
                "full": "splrep(x, y, t)",
                "name": "splrep",
                "parameters": [
                    {
                        "full": "x",
                        "name": "x"
                    },
                    {
                        "full": "y",
                        "name": "y"
                    },
                    {
                        "full": "t",
                        "name": "t"
                    }
                ]
            }
        ],
        "markdown": "### [splrep](https://docs.dolphindb.cn/zh/funcs/s/splrep.html)\n\n\n\n#### 语法\n\nsplrep(x, y, t)\n\n#### 详情\n\n`splrep` 全称 Spline Representation，即样条插值函数，要求找到一维曲线的 B 样条表示。在给定数据点集 (x\\[i], y\\[i]) 后，使用该函数可确定在区间 x\\[0] <= x <= x\\[size(x)-1] 上的度数为 3 的平滑样条逼近。注意，若 *x*, *y*, *t* 传入参数中包含 NULL 将直接填充为 0。\n\n#### 参数\n\n**x**/**y** Integral/Temporal/Floating 类型向量，定义三次样条曲线 y = f(x) 的数据点。\n\n**Note:** *x* 与 *y* 的输入值须保证相同长度，且 *y* 的输入值须为递增向量。\n\n**t** 向量，可选，表示结点。样条在结点两边可以是不同的多项式。*t* 须满足 Schoenberg-Whitney 条件，如必须存在一个数据点的子集 x\\[j] 对于所有的 j=0, 1,...,n-5，满足 t\\[j] < x\\[j] < t\\[j+4]。\n\n#### 返回值\n\n返回值为一个长度为3的元组，其各个元素的含义如下：\n\n* 第一个元素：向量，表示样条曲线的结点。\n\n* 第二个元素：向量，表示 B 样条系数。\n\n* 第三个元素：标量，表示样条的次数。\n\n#### 例子\n\n```\nx = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\ny = [0, 3, 5, 6, 5, 3, 1, 2, 4, 5]\nt=[1,3,5,8]\ntck= splrep(x, y, t=t)\nprint(tck)\n//output\n([0,0,0,0,1,3,5,8,9,9,9,9],[0,2.234794827972243,2.999908797063527,8.195517483732592,0.982766102937427,0.416533320193195,6.868465914739519,5,0,0,0,0],3)\n```\n\n相关函数：[splev](https://docs.dolphindb.cn/zh/funcs/s/splev.html)\n"
    },
    "sql": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/sql.html",
        "signatures": [
            {
                "full": "sql(select, from, [where], [groupBy], [groupFlag=1], [csort], [ascSort=1], [having], [orderBy], [ascOrder=1], [limit], [hint], [exec=false], [map=false], [cgroupBy])",
                "name": "sql",
                "parameters": [
                    {
                        "full": "select",
                        "name": "select"
                    },
                    {
                        "full": "from",
                        "name": "from"
                    },
                    {
                        "full": "[where]",
                        "name": "where",
                        "optional": true
                    },
                    {
                        "full": "[groupBy]",
                        "name": "groupBy",
                        "optional": true
                    },
                    {
                        "full": "[groupFlag=1]",
                        "name": "groupFlag",
                        "optional": true,
                        "default": "1"
                    },
                    {
                        "full": "[csort]",
                        "name": "csort",
                        "optional": true
                    },
                    {
                        "full": "[ascSort=1]",
                        "name": "ascSort",
                        "optional": true,
                        "default": "1"
                    },
                    {
                        "full": "[having]",
                        "name": "having",
                        "optional": true
                    },
                    {
                        "full": "[orderBy]",
                        "name": "orderBy",
                        "optional": true
                    },
                    {
                        "full": "[ascOrder=1]",
                        "name": "ascOrder",
                        "optional": true,
                        "default": "1"
                    },
                    {
                        "full": "[limit]",
                        "name": "limit",
                        "optional": true
                    },
                    {
                        "full": "[hint]",
                        "name": "hint",
                        "optional": true
                    },
                    {
                        "full": "[exec=false]",
                        "name": "exec",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[map=false]",
                        "name": "map",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[cgroupBy]",
                        "name": "cgroupBy",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [sql](https://docs.dolphindb.cn/zh/funcs/s/sql.html)\n\n\n\n#### 语法\n\nsql(select, from, \\[where], \\[groupBy], \\[groupFlag=1], \\[csort], \\[ascSort=1], \\[having], \\[orderBy], \\[ascOrder=1], \\[limit], \\[hint], \\[exec=false], \\[map=false], \\[cgroupBy])\n\n#### 详情\n\n动态生成 SQL 语句。使用函数 [eval](https://docs.dolphindb.cn/zh/funcs/e/eval.html) 执行生成的 SQL 语句。\n\n#### 参数\n\n**select** 是表示选取的列的元代码。每列由函数 [sqlCol](https://docs.dolphindb.cn/zh/funcs/s/sqlCol.html) 或 [sqlColAlias](https://docs.dolphindb.cn/zh/funcs/s/sqlColAlias.html) 生成。若选择多列，使用元组表示。\n\n**from** 选取数据的表对象或表名称。\n\n**where** where 条件。如果有多个 where 条件，使用 ANY 向量来表示，每个元素对应一个条件的元代码。\n\n**groupBy** group by 后面的关键字（列名）。如果有多个 group by 关键字，使用 ANY 向量来表示，每个元素对应一个列名的元代码。\n\n**groupFlag** 1表示 group by，0表示 context by，2表示 pivot by。默认值为1。\n\n**csort** csort 后面的关键字（列名）。只有当 *groupFlag*=0，即使用 context by 时，才能指定该参数。如果有多个 csort 关键字，使用元组来表示，每个元素对应一个列名的元代码。\n\n**ascSort** 表示 csort 关键字按升序或降序排列的整型标量或向量。1表示升序，0表示降序。默认值为1。\n\n**having** having 条件。如果有多个 having 条件，使用 ANY 向量来表示，每个元素对应一个条件的元代码。\n\n**orderBy** order by 后面的关键字（列名）。如果有多个 order by 关键字，使用 ANY 向量来表示，每个元素对应一个列名的元代码。\n\n**ascOrder** 表示 order by 后面的关键字按升序或降序排列的整型标量或向量。1表示升序，0表示降序。默认值为1。\n\n**limit** 整数或整型数据对，用于指定返回记录的行范围，语义对应 SQL 中的 top 语句。\n\n* *limit* 为整数（例如 n）时，表示返回前 n 行。\n* limit 为数据对（start:end）时，表示返回从 start 行开始（含）到第 end 行（不含）的记录。\n\n如果指定了 *groupBy* 且 *groupFlag*=0，则 *limit* 在每个分组内单独应用。\n\n**hint** 常量。目前该参数可以是 HINT\\_HASH、HINT\\_SNAPSHOT 或 HINT\\_KEEPORDER。HINT\\_HASH 表示执行 group by 查询时采用哈希算法，HINT\\_SNAPSHOT 表示从快照引擎中查询数据，HINT\\_KEEPORDER 表示执行context by 后的结果仍然按输入数据中的顺序排列。\n\n**exec** 表示是否使用 exec 子句。默认值为 false。若设置为 true，可以生成一个标量或者一个向量，与 pivot by 共同使用，可以生成一个矩阵。\n\n**map** 布尔类型的标量，表示是否使用 map 关键字，默认值为 false。\n\n**cgroupBy** 可选参数，CODE 类型标量/向量，或整型标量，用于指定 cgroup by 的关键字。\n\n* 当为 CODE 标量或向量时，表示 cgroup by 关键字的元代码；CODE 向量可包含多个元素，每个元素对应一个列名的元代码。\n* 当为整型标量时，表示将 *groupBy* 参数中最后 n 个元素作为 cgroup by 关键字，其余元素仍作为 group by 关键字。例如，*groupBy* = \\[\"col1\", \"col2\", \"col3\"]，*cgroupBy* = 1，则：\n  * group by 关键字为：col1, col2\n  * cgroup by 关键字为：col3\n\n**Note:**\n\n* 如果 *groupFlag* 为 0（context by）或 2（pivot by），不能再指定 *cgroupBy* 参数。\n* 如果指定了 *cgroupBy* 参数，也必须指定 *orderBy* 参数。\n\n#### 返回值\n\nCODE 类型标量。\n\n#### 例子\n\n```\nsymbol = take(`GE,6) join take(`MSFT,6) join take(`F,6)\ndate=take(take(2017.01.03,2) join take(2017.01.04,4), 18)\nprice=31.82 31.69 31.92 31.8  31.75 31.76 63.12 62.58 63.12 62.77 61.86 62.3 12.46 12.59 13.24 13.41 13.36 13.17\nvolume=2300 3500 3700 2100 1200 4600 1800 3800 6400 4200 2300 6800 4200 5600 8900 2300 6300 9600\nt1 = table(symbol, date, price, volume);\n\nt1;\n```\n\n| symbol | date       | price volume |\n| ------ | ---------- | ------------ |\n| GE     | 2017.01.03 | 31.82 2300   |\n| GE     | 2017.01.03 | 31.69 3500   |\n| GE     | 2017.01.04 | 31.92 3700   |\n| GE     | 2017.01.04 | 31.8 2100    |\n| GE     | 2017.01.04 | 31.75 1200   |\n| GE     | 2017.01.04 | 31.76 4600   |\n| MSFT   | 2017.01.03 | 63.12 1800   |\n| MSFT   | 2017.01.03 | 62.58 3800   |\n| MSFT   | 2017.01.04 | 63.12 6400   |\n| MSFT   | 2017.01.04 | 62.77 4200   |\n| MSFT   | 2017.01.04 | 61.86 2300   |\n| MSFT   | 2017.01.04 | 62.3 6800    |\n| F      | 2017.01.03 | 12.46 4200   |\n| F      | 2017.01.03 | 12.59 5600   |\n| F      | 2017.01.04 | 13.24 8900   |\n| F      | 2017.01.04 | 13.41 2300   |\n| F      | 2017.01.04 | 13.36 6300   |\n| F      | 2017.01.04 | 13.17 9600   |\n\n```\nx=5000\nwhereConditions = [<symbol=`MSFT>,<volume>x>]\nhavingCondition = <sum(volume)>200>;\n\nsql(sqlCol(\"*\"), t1);\n//output:< select * from t1 >\n\nsql(sqlCol(\"*\"), t1, whereConditions);\n//output:< select * from t1 where symbol == \"MSFT\",volume > x >\n\nsql(select=sqlColAlias(<avg(price)>), from=t1, where=whereConditions, groupBy=sqlCol(`date));\n//output:< select avg(price) as avg_price from t1 where symbol == \"MSFT\",volume > x group by date >\n\nsql(select=sqlColAlias(<avg(price)>), from=t1, groupBy=[sqlCol(`date),sqlCol(`symbol)]);\n//output:< select avg(price) as avg_price from t1 group by date,symbol >\n\nsql(select=(sqlCol(`symbol),sqlCol(`date),sqlColAlias(<cumsum(volume)>, `cumVol)), from=t1, groupBy=sqlCol(`date`symbol), groupFlag=0);\n//output:< select symbol,date,cumsum(volume) as cumVol from t1 context by date,symbol >\n\nsql(select=(sqlCol(`symbol),sqlCol(`date),sqlColAlias(<cumsum(volume)>, `cumVol)), from=t1, where=whereConditions, groupBy=sqlCol(`date), groupFlag=0);\n//output:< select symbol,date,cumsum(volume) as cumVol from t1 where symbol == \"MSFT\",volume > x context by date >\n\nsql(select=(sqlCol(`symbol),sqlCol(`date),sqlColAlias(<cumsum(volume)>, `cumVol)), from=t1, where=whereConditions, groupBy=sqlCol(`date), groupFlag=0, csort=sqlCol(`volume), ascSort=0);\n//output:< select symbol,date,cumsum(volume) as cumVol from t1 where symbol == \"MSFT\",volume > x context by date csort volume desc >\n\nsql(select=(sqlCol(`symbol),sqlCol(`date),sqlColAlias(<cumsum(volume)>, `cumVol)), from=t1, where=whereConditions, groupBy=sqlCol(`date), groupFlag=0, having=havingCondition);\n//output:< select symbol,date,cumsum(volume) as cumVol from t1 where symbol == \"MSFT\",volume > x context by date having sum(volume) > 200 >\n\nsql(select=sqlCol(\"*\"), from=t1, where=whereConditions, orderBy=sqlCol(`date), ascOrder=0);\n//output:< select * from t1 where symbol == \"MSFT\",volume > x order by date desc >\n\nsql(select=sqlCol(\"*\"), from=t1, limit=1);\n//output:< select top 1 * from t1 >\n\nsql(select=sqlCol(\"*\"), from=t1, groupBy=sqlCol(`symbol), groupFlag=0, limit=1);\n//output:< select top 1 * from t1 context by symbol >\n\nsql(select=(sqlCol(`symbol),sqlCol(`date),sqlColAlias(<cumsum(volume)>, `cumVol)), from=t1, groupBy=sqlCol(`date`symbol), groupFlag=0, hint=HINT_KEEPORDER);\n//output:< select [128] symbol,date,cumsum(volume) as cumVol from t1 context by date,symbol >\n\nwhereConditions1 = <symbol=`MSFT or volume>x>\nsql(select=sqlCol(\"*\"), from=t1, where=whereConditions1, orderBy=sqlCol(`date), ascOrder=0);\n//output:< select * from t14059d76a00000000 where symbol == \"MSFT\" or volume > x order by date desc >\nsql(select=sqlCol(\"*\"), from=t1, where=whereConditions, orderBy=sqlCol(`date), ascOrder=0, map=true);\n//output:< select [256] * from t17092a30500000000 where symbol == \"MSFT\",volume > x order by date desc map >\n\nsql(select=sqlColAlias(<avg(price)>), from=t1, groupBy=sqlCol(`date), groupFlag=1, cgroupBy=1, having=havingCondition, orderBy=sqlCol(`date), ascOrder=0);\n// Output: < select avg(price) as avg_price from t14094040000610000 cgroup by date having sum(volume) > 200 order by date desc >\n\nsql(select=sqlColAlias(<avg(price)>), from=t1, groupBy=[sqlCol(`date), sqlCol(`volume)], groupFlag=1, cgroupBy=1, having=havingCondition, orderBy=sqlCol(`date), ascOrder=0);\n// Output: < select avg(price) as avg_price from t14094040000610000 group by date cgroup by volume having sum(volume) > 200 order by date desc >\n\nsql(select=sqlColAlias(<avg(price)>), from=t1, groupBy=sqlCol(`date), groupFlag=1, cgroupBy=[sqlCol(`volume)], having=havingCondition, orderBy=sqlCol(`date), ascOrder=0);\n// Output: < select avg(price) as avg_price from t14094040000610000 group by date cgroup by volume having sum(volume) > 200 order by date desc >\n\nsql(select=sqlColAlias(<avg(price)>), from=t1, cgroupBy=[sqlCol(`date)], having=havingCondition, orderBy=sqlCol(`date), ascOrder=0);\n// Output: < select avg(price) as avg_price from t14094040000610000 cgroup by date having sum(volume) > 200 order by date desc >\n```\n\n可以定义一个函数使用 `sql` 函数来动态生成 SQL 语句。\n\n```\ndef f1(t, sym, x){\nwhereConditions=[<symbol=sym>,<volume>x>]\nreturn sql(sqlCol(\"*\"),t,whereConditions).eval()\n};\n\nf1(t1, `MSFT, 5000);\n```\n\n| symbol | date       | price volume |\n| ------ | ---------- | ------------ |\n| MSFT   | 2017.01.04 | 63.12 6400   |\n| MSFT   | 2017.01.04 | 62.3 6800    |\n\n```\nf1(t1, `F, 9000);\n```\n\n| symbol | date       | price volume |\n| ------ | ---------- | ------------ |\n| F      | 2017.01.04 | 13.17 9600   |\n\n```\ndef f2(t, sym, colNames, filterColumn, filterValue){\n whereConditions=[<symbol=sym>,expr(sqlCol(filterColumn),>,filterValue)]\n    return sql(sqlCol(colNames),t,whereConditions).eval()\n};\n```\n\n```\nf2(t1,`GE, `symbol`date`volume, `volume, 3000);\n```\n\n| symbol | date       | volume |\n| ------ | ---------- | ------ |\n| GE     | 2017.01.03 | 3500   |\n| GE     | 2017.01.04 | 3700   |\n| GE     | 2017.01.04 | 4600   |\n\n```\nf2(t1,`F, `symbol`date`volume,`price,13.2);\n```\n\n| symbol | date       | volume |\n| ------ | ---------- | ------ |\n| F      | 2017.01.04 | 8900   |\n| F      | 2017.01.04 | 2300   |\n| F      | 2017.01.04 | 6300   |\n\n设置参数 *exec*=true，配合 pivot by 语句，生成一个矩阵：\n\n```\ndate = 2020.09.21 + 0 0 0 0 1 1 1 1\nsym = `MS`MS`GS`GS`MS`MS`GS`GS$SYMBOL\nfactorNum = 1 2 1 2 1 2 1 2\nfactorValue = 1.2 -3.4 -2.5 6.3 1.1 -3.2 -2.1 5.6\nt = table(date, sym, factorNum, factorValue);\nsql(select=sqlCol(`factorValue), from=t, groupBy=[sqlCol(`date), sqlCol(`sym)], groupFlag=2, exec=true)\n\n//output:< exec factorValue from t pivot by date,sym >\n```\n"
    },
    "sqlCol": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/sqlCol.html",
        "signatures": [
            {
                "full": "sqlCol(colName, [func], [alias], [qualifier])",
                "name": "sqlCol",
                "parameters": [
                    {
                        "full": "colName",
                        "name": "colName"
                    },
                    {
                        "full": "[func]",
                        "name": "func",
                        "optional": true
                    },
                    {
                        "full": "[alias]",
                        "name": "alias",
                        "optional": true
                    },
                    {
                        "full": "[qualifier]",
                        "name": "qualifier",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [sqlCol](https://docs.dolphindb.cn/zh/funcs/s/sqlCol.html)\n\n\n\n#### 语法\n\nsqlCol(colName, \\[func], \\[alias], \\[qualifier])\n\n#### 详情\n\n生成表示选择某些列或对某些列进行计算的元代码。一般与函数 [sql](https://docs.dolphindb.cn/zh/funcs/s/sql.html) 和 [eval](https://docs.dolphindb.cn/zh/funcs/e/eval.html) 共同使用，用于动态生成 SQL 语句。\n\n#### 参数\n\n**colName** 是一个字符串标量或向量，表示列名。\n\n**func** 是一个一元函数。\n\n**alias** 是一个字符串标量或向量，表示选择列或计算结果列的别名。\n\n**qualifier** 是一个字符串标量，表示表名。多表连接时，可以通过该参数指定含有相同名字的非连接列属于哪个表。\n\n#### 返回值\n\nCODE 类型标量。\n\n#### 例子\n\n```\nt = table(`GME`AMC`KOSS as symbol, 325 13.26 64 as price);\ncolName=\"symbol\";\nsql(select=sqlCol(colName), from=t).eval();\n```\n\n| symbol |\n| ------ |\n| GME    |\n| AMC    |\n| KOSS   |\n\n```\ncolName=\"price\";\nsql(select=sqlCol(colName, max, `maxPrice), from=t).eval();\n```\n\n| maxPrice |\n| -------- |\n| 325      |\n\n```\nt1 = table(1 2 3 3 as id, 7.8 4.6 5.1 0.1 as value, 4 3 2 1 as x);\nt2 = table(5 3 1 as id,  300 500 800 as qty, 44 66 88 as x) ;\nsql(select=(sqlCol(`id),sqlCol(colName=`x, alias=\"t1_x\", qualifier=\"t1\"),sqlCol(colName=`x, alias=\"t2_x\", qualifier=`t2)), from=<ej(t1,t2,`id)>).eval()\n```\n\n| id | t1\\_x | t2\\_x |\n| -- | ----- | ----- |\n| 1  | 4     | 88    |\n| 3  | 2     | 66    |\n| 3  | 1     | 66    |\n"
    },
    "sqlColAlias": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/sqlColAlias.html",
        "signatures": [
            {
                "full": "sqlColAlias(colDefs, [colNames])",
                "name": "sqlColAlias",
                "parameters": [
                    {
                        "full": "colDefs",
                        "name": "colDefs"
                    },
                    {
                        "full": "[colNames]",
                        "name": "colNames",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [sqlColAlias](https://docs.dolphindb.cn/zh/funcs/s/sqlColAlias.html)\n\n\n\n#### 语法\n\nsqlColAlias(colDefs, \\[colNames])\n\n#### 详情\n\n使用元代码和可选择的别名来定义一个列。它通常用于计算列。\n\n#### 参数\n\n**colDefs** 是给定的元代码；\n\n**colNames** 是表示别名的字符串。\n\n#### 返回值\n\nCODE 类型标量。\n\n#### 例子\n\n```\nsqlColAlias(<x>, `y);\n// output\n< x as y >\n\nsqlColAlias(<avg(PRC)>, `avgPRC);\n// output\n< avg(PRC) as avgPRC >\n\nsqlColAlias(<avg(PRC)>);\n// output\n< avg(PRC) as avg_PRC >\n```\n"
    },
    "sqlDelete": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/sqlDelete.html",
        "signatures": [
            {
                "full": "sqlDelete(table, [where], [from])",
                "name": "sqlDelete",
                "parameters": [
                    {
                        "full": "table",
                        "name": "table"
                    },
                    {
                        "full": "[where]",
                        "name": "where",
                        "optional": true
                    },
                    {
                        "full": "[from]",
                        "name": "from",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [sqlDelete](https://docs.dolphindb.cn/zh/funcs/s/sqlDelete.html)\n\n\n\n#### 语法\n\nsqlDelete(table, \\[where], \\[from])\n\n#### 详情\n\n动态生成 SQL delete 语句的元代码。若需执行生成的元代码，请配合使用 [eval](https://docs.dolphindb.cn/zh/funcs/e/eval.html) 函数。\n\n#### 参数\n\n**table** 可以是内存表，亦可为分布式表。\n\n**where** 是元代码，表示 where 条件。\n\n**from** 是元代码，表示 from 子句。\n\n#### 返回值\n\nCODE 类型标量。\n\n#### 例子\n\n例1. 删除内存表记录\n\n```\nt1=table(`A`B`C as symbol, 10 20 30 as x)\nsqlDelete(t1, <symbol=`C>).eval()\nt1;\n```\n\n| symbol | x  |\n| ------ | -- |\n| A      | 10 |\n| B      | 20 |\n\n例2. 删除分区表记录\n\n```\nif(existsDatabase(\"dfs://db1\")){\n    dropDatabase(\"dfs://db1\")\n}\n\nn=1000000\nt=table(take(`A`B`C`D,n) as symbol, rand(10.0, n) as value)\ndb = database(\"dfs://db1\", VALUE, `A`B`C`D)\nTrades = db.createPartitionedTable(t, \"Trades\", \"symbol\")\nTrades.append!(t)\nselect count(*) from Trades;\n\n// output: 1000000\n\nTrades=loadTable(\"dfs://db1\", \"Trades\")\nsqlDelete(Trades, <symbol=`A>).eval()\nselect count(*) from Trades;\n\n// output: 750000\n```\n\n例3. 结合表连接删除记录\n\n```\nt1 = table(1..5 as id, [1,2,2,1,1] as flag)\nt2 = table(3..7 as id, [100,200,100,150,100] as profit)\nsqlDelete(table=t2, where=<flag=1>, from=<ej(t2,t1,`id)>).eval()\nt2\n```\n\n<table id=\"table_drc_cmf_xbc\"><thead><tr><th>\n\nid\n\n</th><th>\n\nprofit\n\n</th></tr></thead><tbody><tr><td>\n\n3\n\n</td><td>\n\n100\n\n</td></tr><tr><td>\n\n6\n\n</td><td>\n\n150\n\n</td></tr><tr><td>\n\n7\n\n</td><td>\n\n100\n\n</td></tr></tbody>\n</table>\n"
    },
    "sqlDS": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/sqlDS.html",
        "signatures": [
            {
                "full": "sqlDS(sqlObj, [forcePartition=false])",
                "name": "sqlDS",
                "parameters": [
                    {
                        "full": "sqlObj",
                        "name": "sqlObj"
                    },
                    {
                        "full": "[forcePartition=false]",
                        "name": "forcePartition",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [sqlDS](https://docs.dolphindb.cn/zh/funcs/s/sqlDS.html)\n\n\n\n#### 语法\n\nsqlDS(sqlObj, \\[forcePartition=false])\n\n#### 详情\n\n根据输入的 SQL 元代码创建数据源列表。如果 SQL 查询中的数据表有 n 个分区，`sqlDS` 生成 n 个数据源。如果 SQL 查询没有包含任何分区表，`sqlDS` 返回包含一个数据源的元组。\n\n#### 参数\n\n**sqlObj** 是 SQL 元代码。元代码的详情请参考 [Metaprogramming](https://docs.dolphindb.cn/zh/progr/objs/meta_progr.html)。\n\n**forcePartition** 是一个布尔值。默认值为 false。如果 *forcePartition*=false，系统会检查该查询能够拆分为多个子查询。如果不能拆分为多个子查询，系统不会在分区上拆分查询，并且会抛出异常。如果 *forcePartition*=true，系统会在分区上拆分查询，并且在选中的分区中执行查询。下面两种情况的查询不能拆分为多个子查询：(1) group by 关键字不是分区列；(2) 指定了 order by 子句。\n\n#### 返回值\n\n一个元组。\n\n#### 例子\n\n```\nn=1000000\ndate=take(2019.01.01..2019.01.03,n)\nsym = take(`C`MS`MS`MS`IBM`IBM`IBM`C`C$SYMBOL,n)\nprice= take(49.6 29.46 29.52 30.02 174.97 175.23 50.76 50.32 51.29,n)\nqty = take(2200 1900 2100 3200 6800 5400 1300 2500 8800,n)\nt=table(date, sym, price, qty)\n\ndb1=database(\"\",VALUE,2019.01.01..2019.01.03)\ndb2=database(\"\",VALUE,`C`MS`IBM)\ndb=database(\"dfs://stock\",COMPO,[db1,db2])\ntrades=db.createPartitionedTable(t,`trades,`date`sym).append!(t)\n\nds=sqlDS(<select * from trades where date=2019.01.02>);\n\ntypestr ds;\n// output\nANY VECTOR\n\nsize ds;\n// output\n3\n\nds[0];\n// output\nDataSource< select [7] * from trades [partition = /stock/20190102/C] >\n\nds[1];\n// output\nDataSource< select [7] * from trades [partition = /stock/20190102/IBM] >\n\nds[2];\n// output\nDataSource< select [7] * from trades [partition = /stock/20190102/MS] >\n```\n"
    },
    "sqlTuple": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/sqlTuple.html",
        "signatures": [
            {
                "full": "sqlTuple(colNames)",
                "name": "sqlTuple",
                "parameters": [
                    {
                        "full": "colNames",
                        "name": "colNames"
                    }
                ]
            }
        ],
        "markdown": "### [sqlTuple](https://docs.dolphindb.cn/zh/funcs/s/sqlTuple.html)\n\n\n\n#### 语法\n\nsqlTuple(colNames)\n\n#### 详情\n\n生成一个元代码，其内容是一个元组表达式，元组的元素为 colNames 指定的列。常与函数 sql，makeUnifiedCall 共同使用，用于动态生成 SQL 语句。\n\n#### 参数\n\n**colNames** 字符串标量或向量，表示列名。\n\n#### 返回值\n\nCODE 类型标量。\n\n#### 例子\n\n下例中，函数 makeUnifiedCall 以 sqlTuple 生成的元组表达式的元代码为参数，调用自定义函数 f，其结果作为函数 sql 的参数 select ，从而生成元代码 c 。\n\n```\n// 自定义函数\nf = def (x,y)->(x-y)/(x+y)\n\n// 定义待查询的表\nt = table(1.0 2.0 3.0 as qty1, 1.0 3.0 7.0 as qty2)\n\n// 生成查询的元代码\nc = sql(select=makeUnifiedCall(f, sqlTuple(`qty1`qty2)), from=t)\n\n// 执行对应元代码\nc.eval()\n```\n\n| \\_qty1 |\n| ------ |\n| 0      |\n| -0.2   |\n| -0.4   |\n\n**Related information**\n\n[makeUnifiedCall](https://docs.dolphindb.cn/zh/funcs/m/makeUnifiedCall.html)\n"
    },
    "sqlUpdate": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/sqlUpdate.html",
        "signatures": [
            {
                "full": "sqlUpdate(table, updates, [from], [where], [contextBy], [csort], [ascSort], [having])",
                "name": "sqlUpdate",
                "parameters": [
                    {
                        "full": "table",
                        "name": "table"
                    },
                    {
                        "full": "updates",
                        "name": "updates"
                    },
                    {
                        "full": "[from]",
                        "name": "from",
                        "optional": true
                    },
                    {
                        "full": "[where]",
                        "name": "where",
                        "optional": true
                    },
                    {
                        "full": "[contextBy]",
                        "name": "contextBy",
                        "optional": true
                    },
                    {
                        "full": "[csort]",
                        "name": "csort",
                        "optional": true
                    },
                    {
                        "full": "[ascSort]",
                        "name": "ascSort",
                        "optional": true
                    },
                    {
                        "full": "[having]",
                        "name": "having",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [sqlUpdate](https://docs.dolphindb.cn/zh/funcs/s/sqlUpdate.html)\n\n\n\n#### 语法\n\nsqlUpdate(table, updates, \\[from], \\[where], \\[contextBy], \\[csort], \\[ascSort], \\[having])\n\n#### 详情\n\n动态生成 SQL update 语句的元代码。若需执行生成的元代码，请配合使用 [eval](https://docs.dolphindb.cn/zh/funcs/e/eval.html) 函数。\n\n#### 参数\n\n各参数对应 SQL update 语句中相应部分：\n\n```\nupdate\n    table_name\n    set col1=X1, [col2=X2,…]\n    [from table_joiner(table_names)]\n    [where condition(s)]\n    [context by col_name(s)]\n```\n\n**table** 可以是内存表，亦可为分布式表。\n\n**updates** 是元代码或元代码组成的元组，表示更新的操作。\n\n**from** 是元代码，表示表连接操作。\n\n**where** 是元代码，表示 where 条件。\n\n**contextBy** 是元代码，表示 context by 子句。\n\n**csort** 是 csort 后面的关键字（列名）。仅在使用 context by 子句时，才能指定该参数。如果有多个 csort 关键字，使用元组来表示，每个元素对应一个列名的元代码。\n\n**ascSort** 是 csort 关键字按升序或降序排列的整型标量或向量。仅在使用 context by 子句时，才能指定该参数。1 表示升序，0 表示降序。默认值为 1。\n\n**having** 是 having 条件。仅在使用 context by 子句时，才能指定该参数。如果有多个 having 条件，使用 ANY 向量来表示，每个元素对应一个条件的元代码。\n\n#### 返回值\n\nCODE 类型标量。\n\n#### 例子\n\n例1：更新内存表记录。\n\n```\nt1=table(`A`A`B`B as symbol, 2021.04.15 2021.04.16 2021.04.15 2021.04.16 as date, 12 13 21 22 as price)\nt2=table(`A`A`B`B as symbol, 2021.04.15 2021.04.16 2021.04.15 2021.04.16 as date, 10 20 30 40 as volume);\n\nsqlUpdate(t1, <price*2 as updatedPrice>).eval()\nt1;\n```\n\n| symbol | date       | price | updatedPrice |\n| ------ | ---------- | ----- | ------------ |\n| A      | 2021.04.15 | 12    | 24           |\n| A      | 2021.04.16 | 13    | 26           |\n| B      | 2021.04.15 | 21    | 42           |\n| B      | 2021.04.16 | 22    | 44           |\n\n```\nsqlUpdate(table=t1, updates=[<price*10 as updatedPrice>,<price*20 as updatedPrice2>]).eval()\nt1;\n```\n\n| symbol | date       | price | updatedPrice | updatedPrice2 |\n| ------ | ---------- | ----- | ------------ | ------------- |\n| A      | 2021.04.15 | 12    | 120          | 240           |\n| A      | 2021.04.16 | 13    | 130          | 260           |\n| B      | 2021.04.15 | 21    | 210          | 420           |\n| B      | 2021.04.16 | 22    | 220          | 440           |\n\n```\nsqlUpdate(table=t2, updates=<cumsum(volume) as cumVolume>, contextby=<symbol>).eval()\n\nt2;\n```\n\n| symbol | date       | volume | cumVolume |\n| ------ | ---------- | ------ | --------- |\n| A      | 2021.04.15 | 10     | 10        |\n| A      | 2021.04.16 | 20     | 30        |\n| B      | 2021.04.15 | 30     | 30        |\n| B      | 2021.04.16 | 40     | 70        |\n\n```\nsqlUpdate(table=t1, updates=<updatedPrice*volume as dollarVolume>, from=<lj(t1, t2, `symbol`date)>).eval()\n\nt1;\n```\n\n| symbol | date       | price | updatedPrice | dollarVolume |\n| ------ | ---------- | ----- | ------------ | ------------ |\n| A      | 2021.04.15 | 12    | 120          | 1200         |\n| A      | 2021.04.16 | 13    | 130          | 2600         |\n| B      | 2021.04.15 | 21    | 42           | 1260         |\n| B      | 2021.04.16 | 22    | 44           | 1760         |\n\n```\nsqlUpdate(table=t2,updates=<cumsum(volume) as cumVolume>,contextBy=<symbol>,csort=<volume>,ascSort=0).eval() \n\nt2;\n```\n\n| symbol | date       | volume | cumVolume |\n| ------ | ---------- | ------ | --------- |\n| A      | 2021.04.15 | 10     | 30        |\n| A      | 2021.04.16 | 20     | 20        |\n| B      | 2021.04.15 | 30     | 70        |\n| B      | 2021.04.16 | 40     | 40        |\n\n例2：更新分区表记录。\n\n```\nif(existsDatabase(\"dfs://db1\")){\n    dropDatabase(\"dfs://db1\")\n}\nn=1000000\nt=table(take(`A`B`C`D,n) as symbol, rand(10.0, n) as value)\ndb = database(\"dfs://db1\", VALUE, `A`B`C`D)\nTrades = db.createPartitionedTable(t, \"Trades\", \"symbol\")\nTrades.append!(t)\nx=exec sum(value) from Trades;\n\nTrades=loadTable(\"dfs://db1\", \"Trades\")\nsqlUpdate(table=Trades, updates=<value+1 as value>, where=<symbol=`A>).eval()\ny=exec sum(value) from Trades;\n\ny-x;\n\n// output\n250000\n```\n\n例3：按门店分组、按日期排序，计算门店累计销售额，但只更新月累计销售额达到 50,000 的门店记录。\n\n```\nsales = table(\n    `store101`store101`store101`store205`store205`store205 as storeId,\n    2024.06.01 2024.06.02 2024.06.03 2024.06.01 2024.06.02 2024.06.03 as bizDate,\n    18000.0 22000.0 15000.0 16000.0 12000.0 9000.0 as salesAmt,\n    take(double(NULL), 6) as cumSalesAmt\n)\n​\nsqlUpdate(\n    table=sales,\n    updates=<cumsum(salesAmt) as cumSalesAmt>,\n    contextBy=<storeId>,\n    csort=<bizDate>,\n    having=<sum(salesAmt) >= 50000>\n).eval()\n​\nsales\n```\n\n输出如下：\n\n| storeId  | bizDate    | salesAmt | cumSalesAmt |\n| -------- | ---------- | -------- | ----------- |\n| store101 | 2024.06.01 | 18,000   | 18,000      |\n| store101 | 2024.06.02 | 22,000   | 40,000      |\n| store101 | 2024.06.03 | 15,000   | 55,000      |\n| store205 | 2024.06.01 | 16,000   |             |\n| store205 | 2024.06.02 | 12,000   |             |\n| store205 | 2024.06.03 | 9,000    |             |\n\n* *having* 只能和 *contextBy* 一起使用。\n\n* store101 的组内销售额合计为 55000，满足 `sum(salesAmt) >= 50000`，所以该组的 cumSalesAmt 被更新为按 bizDate 排序后的累计值。\n\n* store205 的组内销售额合计为 37000，不满足 `sum(salesAmt) >= 50000`，因此该组记录不会被本次更新命中，cumSalesAmt 保持空值。\n"
    },
    "sqrt": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/sqrt.html",
        "signatures": [
            {
                "full": "sqrt(X)",
                "name": "sqrt",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [sqrt](https://docs.dolphindb.cn/zh/funcs/s/sqrt.html)\n\n\n\n#### 语法\n\nsqrt(X)\n\n#### 详情\n\n计算 *X* 中每个元素的平方根。\n\n与 Python 中 `numpy.sqrt` 的区别：二者都用于计算平方根；DolphinDB 的 `sqrt` 返回 DOUBLE，负数结果为空值，`numpy.sqrt`对负实数输入通常返回 `nan`，复数输入可返回复数结果。\n\n#### 参数\n\n**X** 可以是标量、向量或矩阵。\n\n#### 返回值\n\nDOUBLE 类型的标量、向量或矩阵。\n\n#### 例子\n\n```\nsqrt(4 16 -4 NULL);\n// output\n[2,4, , ]\n\ntypestr(sqrt(4));\n// output\nDOUBLE\n```\n"
    },
    "square": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/square.html",
        "signatures": [
            {
                "full": "square(X)",
                "name": "square",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [square](https://docs.dolphindb.cn/zh/funcs/s/square.html)\n\n\n\n#### 语法\n\nsquare(X)\n\n#### 详情\n\n返回 *X* 的平方。返回结果的数据类型为 DOUBLE 类型。\n\n与 Python 中 `numpy.square` 和 `scipy.signal.square` 的区别：`numpy.square` 用于计算平方，是 ufunc，按 NumPy 类型规则决定返回 *dtype*，并支持复数、广播、*out*、*where* 等参数；`scipy.signal.square` 用于生成周期方波信号，输入是时间 *t* 和占空比 *duty*；DolphinDB 的 `square` 用于返回 *X* 的平方，返回 DOUBLE 类型结果。\n\n#### 参数\n\n**X** 可以是标量、数据对、向量或矩阵。\n\n#### 返回值\n\nDOUBLE 类型的标量、数据对、向量或矩阵。\n\n#### 例子\n\n```\nsquare(3);\n// output\n9\n\nsquare(2 4 NULL 6);\n// output\n[4,16,,36]\n\nsquare(1..4$2:2);\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 9  |\n| 4  | 16 |\n"
    },
    "startClusterReplication": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/startClusterReplication.html",
        "signatures": [
            {
                "full": "startClusterReplication()",
                "name": "startClusterReplication",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [startClusterReplication](https://docs.dolphindb.cn/zh/funcs/s/startClusterReplication.html)\n\n\n\n#### 语法\n\nstartClusterReplication()\n\n#### 详情\n\n重启由多次任务失败而停止或调用 [stopClusterReplication](https://docs.dolphindb.cn/zh/funcs/s/stopClusterReplication.html) 主动停止的异步复制。该命令只能由管理员在主/从集群的控制节点调用。调用该命令前，必须先配置 *replicationMode* 参数。\n\n#### 参数\n\n无\n\n#### 例子\n\n```\nstartClusterReplication();\n```\n\n相关函数： [stopClusterReplication](https://docs.dolphindb.cn/zh/funcs/s/stopClusterReplication.html), [skipClusterReplicationTask](https://docs.dolphindb.cn/zh/funcs/s/skipClusterReplicationTask.html)\n"
    },
    "startDataNode": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/startDataNode.html",
        "signatures": [
            {
                "full": "startDataNode(X)",
                "name": "startDataNode",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [startDataNode](https://docs.dolphindb.cn/zh/funcs/s/startDataNode.html)\n\n\n\n#### 语法\n\nstartDataNode(X)\n\n#### 详情\n\n用于在集群控制器上启动数据节点/计算节点。\n\n#### 参数\n\n**X** 是一个向量。包含了要启动的数据节点/计算节点的信息。\n\n#### 例子\n\n```\nx = [\"192.168.1.27:8506\",\"192.168.1.27:8502\",\"192.168.1.27:8527\"]\nstartDataNode(x);\n```\n"
    },
    "startHeapSample": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/startheapsample.html",
        "signatures": [
            {
                "full": "startHeapSample(sampleParameter)",
                "name": "startHeapSample",
                "parameters": [
                    {
                        "full": "sampleParameter",
                        "name": "sampleParameter"
                    }
                ]
            }
        ],
        "markdown": "### [startHeapSample](https://docs.dolphindb.cn/zh/funcs/s/startheapsample.html)\n\n\n\n#### 语法\n\nstartHeapSample(sampleParameter)\n\n#### 详情\n\n用于动态启用堆内存采样。调用后将动态设置环境变量 TCMALLOC\\_SAMPLE\\_PARAMETER 的值，从而使开发者能够监控和分析程序的内存使用情况。仅管理员可执行该函数。\n\n#### 参数\n\n**sampleParameter** 长整型标量，表示采样阈值，单位为字节。在分配到指定字节的内存后会，将进行一次内存采样。取值范围是 \\[1, 524288]，建议设置为 524288。\n\n#### 例子\n\n对内存使用情况进行分析的流程如下：\n\n1. 启用堆内存采样。\n\n2. 在可能发生内存泄漏的操作前、后分别执行 `dumpHeapSample`，保存两个不同的文件。通过对比两个文件，确认操作涉及到的内存分配和使用情况。\n\n3. 关闭堆内存采样。\n\n```\nstartHeapSample(524288)\n\ndumpHeapSample(\"/DolphinDB/Data/heap1\")\ndumpHeapSample(\"/DolphinDB/Data/heap2\")\n\nstopHeapSample()\n```\n\n相关函数：[dumpHeapSample](https://docs.dolphindb.cn/zh/funcs/d/dumpheapsample.html), [stopHeapSample](https://docs.dolphindb.cn/zh/funcs/s/stopheapsample.html)\n"
    },
    "startStreamGraph": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/startStreamGraph.html",
        "signatures": [
            {
                "full": "startStreamGraph(name)",
                "name": "startStreamGraph",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    }
                ]
            }
        ],
        "markdown": "### [startStreamGraph](https://docs.dolphindb.cn/zh/funcs/s/startStreamGraph.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\nstartStreamGraph(name)\n\n#### 详情\n\n重启指定流图。该函数成功执行后将使指定流图状态变为 running。可通过 getStreamGraphMeta 查看流图状态。\n\n在使用该功能时，建议通过 setConfigMap 明确设置数据源消费策略（subscription.sourceOffset\\*\\*）\\*\\*，以控制暂停期间的数据处理方式。\n\n* sourceOffset = -1（推荐）：流图重启时从源表当前最新一条数据开始消费。暂停期间收到的数据将被忽略，适用于只关心实时数据、不需处理历史数据的场景。\n\n* sourceOffset = -3（默认，谨慎使用）：流图重启时会从源表第一行开始回放所有历史数据，可能消耗大量资源并产生重复计算，适用于需保证绝对数据完整性且源表数据量可控的场景。\n\n\\*\\*返回值：\\*\\*无\n\n#### 参数\n\n**name** 字符串标量，表示需要重启的流图名称。可以传入完整的流图全限定名（如 catalog\\_name.orca\\_graph.graph\\_name），也可以仅提供流图名（如 factors）；系统会根据当前的 catalog 设置自动补全为对应的全限定名。\n\n#### 例子\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\n\nuse catalog orca\n\ndef callTimes(mutable call, mutable tempTable, msg) {\n    call += 1\n    price = [call]\n    volume = [call]\n    t = table(price, volume)\n    tempTable.append!(t)\n    return t\n}\nname = \"UDF\"\ng = createStreamGraph(name)\nckptConfig = {\n    \"enable\":true,\n    \"interval\": 10000,\n    \"timeout\": 36000,\n    \"maxConcurrentCheckpoints\": 1\n};\n\ng.source(\"trade\", `price`volume, [INT,INT])\n .udfEngine(callTimes,[\"price\", \"volume\"], [`cnt, `tmpTable], [433, table(128:0, [\"price\",\"volume\"], [INT, INT])])\n .setEngineName(\"udf\")\n .sink(\"output\")\ng.submit(ckptConfig)\ngo\ngetStreamGraphMeta()\nstopStreamGraph(\"UDF\") // 暂停流图，流图状态变为 stopped\nstartStreamGraph(\"UDF\") // 开始流图，流图状态变为 running\n```\n\n**相关函数：**[createStreamGraph](https://docs.dolphindb.cn/zh/funcs/c/createStreamGraph.html), [stopStreamGraph](https://docs.dolphindb.cn/zh/funcs/s/stopStreamGraph.html)\n"
    },
    "startsWith": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/startsWith.html",
        "signatures": [
            {
                "full": "startsWith(X, str)",
                "name": "startsWith",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "str",
                        "name": "str"
                    }
                ]
            }
        ],
        "markdown": "### [startsWith](https://docs.dolphindb.cn/zh/funcs/s/startsWith.html)\n\n\n\n#### 语法\n\nstartsWith(X, str)\n\n#### 详情\n\n检查 *X* 是否以 *str* 开头。如果是，返回 true； 否则返回 false。\n\n#### 参数\n\n**X** 是在该字符串中搜索。它可以是标量或向量。\n\n**str** 是被搜索的目标字符串。它必须是标量。\n\n#### 返回值\n\n一个布尔值。\n\n#### 例子\n\n```\nstr1=\"US product\"\nstr2=\"UK product\"\nif (startsWith(str1, \"US\")) print \"str1 is a US product.\"\nelse print \"str1 is not a US product.\"\nif (startsWith(str2, \"US\")) print \"str2 is a US product.\"\nelse print \"str2 is not a US product.\";\n\n// output\nstr1 is a US product.\nstr2 is not a US product.\n```\n"
    },
    "stat": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/stat.html",
        "signatures": [
            {
                "full": "stat(X)",
                "name": "stat",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [stat](https://docs.dolphindb.cn/zh/funcs/s/stat.html)\n\n\n\n#### 语法\n\nstat(X)\n\n#### 详情\n\n获取 *X* 的统计信息。\n\n#### 参数\n\n**X** 可以是向量或矩阵。\n\n#### 返回值\n\n返回一个字典，它包含了 X 的统计信息，有平均值、最大值、最小值、计数、中位数和标准差。\n\n#### 例子\n\n```\nx=5 7 4 3 2 1 7 8 9 NULL;\n\nstat(x);\n// output\nMedian->5\nAvg->5.111111\nMin->1\nStdev->2.803767\nCount->9\nSize->10\nName->x\nMax->9\n\nstats = stat(x);\nstats[`Avg];\n// output\n5.111111\n```\n"
    },
    "stateIterate": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/stateIterate.html",
        "signatures": [
            {
                "full": "stateIterate(X, initial, initialWindow, iterateFunc, combineCoeff)",
                "name": "stateIterate",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "initial",
                        "name": "initial"
                    },
                    {
                        "full": "initialWindow",
                        "name": "initialWindow"
                    },
                    {
                        "full": "iterateFunc",
                        "name": "iterateFunc"
                    },
                    {
                        "full": "combineCoeff",
                        "name": "combineCoeff"
                    }
                ]
            }
        ],
        "markdown": "### [stateIterate](https://docs.dolphindb.cn/zh/funcs/s/stateIterate.html)\n\n\n\n#### 语法\n\nstateIterate(X, initial, initialWindow, iterateFunc, combineCoeff)\n\n该函数只能用作响应式状态引擎 *metrics* 中的函数。\n\n#### 详情\n\n通过线性迭代实现线性递归。\n\n假设该函数计算结果对应输出表的列为 factor，且迭代仅基于前一个值，对于第 k 条记录(k = 0, 1, 2 …)，其计算逻辑为：\n\n* k < *initialWindow*：factor\\[k] = initial\\[k]\n\n* k >= *initialWindow*：factor\\[k] = combineCoeff\\[0] \\* X\\[k] + combineCoeff\\[1] \\* iterateFunc(factor)\\[k-1]。\n\n注意：若 `iterateFunc` 为窗口函数，则会基于前多个 factor 值进行计算。\n\n#### 参数\n\n**X** 输入表中的字段或其应用向量函数的计算结果。\n\n**initial** 数据形式同 *X*，作为 *initialWindow* 内数据的输出结果。\n\n**initialWindow** 正整数，表示初始化窗口的长度。其确定的窗口范围为\\[0, initialWindow)。\n\n**iterateFunc** 用于迭代计算的函数。必须是一个单目函数，其唯一参数是 `stateIterate` 对应输出表中的字段。目前只支持以下函数（非单目函数以部分应用形式给出其他参数）：\n\n* 滑动窗口函数：`tmove`, `tmavg`, `tmmax`, `tmmin`, `tmsum`, `mavg`, `mmax`, `mmin`, `mcount`, `msum`\n\n* 累计窗口函数：`cumlastNot`, `cumfirstNot`\n\n* 序列相关函数：`ffill`, `move`\n\n**Note:**\n\n* 由于迭代是基于历史数据进行的，因此当前记录的输出是基于输出表中的历史结果和 *X* 计算得到的。\n\n* tm 系列函数计算时，时间窗口由当前记录的时间戳确定。且计算窗口范围为 (T - window, T)。\n\n**combineCoeff** 长度为 2 的向量，作为 *iterateFunc* 迭代结果和 *X* 的关联系数。\n\n#### 例子\n\n```\ntrade = table(take(\"A\", 6) join take(\"B\", 6) as sym,  1..12 as val0,  take(10, 12) as val1)\ntrade;\n```\n\n| sym | val0 | val1 |\n| --- | ---- | ---- |\n| A   | 1    | 10   |\n| A   | 2    | 10   |\n| A   | 3    | 10   |\n| A   | 4    | 10   |\n| A   | 5    | 10   |\n| A   | 6    | 10   |\n| B   | 7    | 10   |\n| B   | 8    | 10   |\n| B   | 9    | 10   |\n| B   | 10   | 10   |\n| B   | 11   | 10   |\n| B   | 12   | 10   |\n\n定义一个响应式状态引擎，并按 sym 列分组进行计算。组内的计算逻辑如下：\n\n* 前 *initialWindow* 行记录，计算公式为 factor\\[k]=initial\\[k]，因此 factor\\[0], factor\\[1], factor\\[2] 均将 val1 列的值直接作为 factor 列的输出。\n\n* 之后的记录，对应计算公式为 factor\\[k]=0.5\\*val0\\[k]+0.5\\*msum(factor, 3)\\[k-1]。以计算 sym=\\`A，val0=4 这条记录为例，此时 factor 列仅有前 3 条数据的输出，即 factor=\\[10, 10, 10]，k=3，带入计算公式即 0.5\\*4+0.5\\*msum(\\[10, 10, 10], 3)\\[2]=17。同理 sym=\\`A，val0=5 这条记录带入计算公式即 0.5\\*5+0.5\\*msum(\\[10, 10, 10, 17], 3)\\[3]=21，以此类推。\n\n```\ninputTable = streamTable(1:0, `sym`val0`val1, [SYMBOL, INT, INT])\noutputTable = table(100:0, `sym`factor, [STRING, DOUBLE])\nengine = createReactiveStateEngine(name=\"rsTest\", metrics=<[stateIterate(val0, val1, 3, msum{, 3}, [0.5, 0.5])]>, dummyTable=inputTable, outputTable=outputTable, keyColumn=[\"sym\"], keepOrder=true)\n\nengine.append!(trade)\nselect * from outputTable\n```\n\n| sym | factor |\n| --- | ------ |\n| A   | 10     |\n| A   | 10     |\n| A   | 10     |\n| A   | 17     |\n| A   | 21     |\n| A   | 27     |\n| B   | 10     |\n| B   | 10     |\n| B   | 10     |\n| B   | 20     |\n| B   | 25.5   |\n| B   | 33.75  |\n\n相关函数：[conditionalIterate](https://docs.dolphindb.cn/zh/funcs/c/conditionalIterate.html)\n"
    },
    "stateMavg": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/stateMavg.html",
        "signatures": [
            {
                "full": "stateMavg(X, window)",
                "name": "stateMavg",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    }
                ]
            }
        ],
        "markdown": "### [stateMavg](https://docs.dolphindb.cn/zh/funcs/s/stateMavg.html)\n\n\n\n#### 语法\n\nstateMavg(X, window)\n\n该函数只能用作响应式状态引擎 *metrics* 中的函数。\n\n#### 详情\n\n计算基于历史结果的移动平均。\n\n计算逻辑为：若窗口中 *X* 的元素个数小于 *window*，则直接输出 *X*；否则取输出字段前 *window* - 1 个值与当前 *X* 值求平均。\n\n#### 参数\n\n**X** 输入表的字段，仅支持数值类型。\n\n**window** 正整数，表示窗口长度。\n\n#### 例子\n\n定义一个响应式状态引擎，按照 sym 分组。\n\n对于 A 组数据，窗口大小为 3，当 09:00:02 和 09:00:06 这两条数据到来时，窗口未满，因此直接输出 val 的值 2 和 6 到 total 列。下一条到来的 A 组数据的时间戳为 09:00:08，val=8，此时 A 组的第一个窗口触发计算，计算结果为 (2+6+8)\\3=5.333333；接下来一条 A 组数据的时间戳为 09:00:10，val=10，计算结果为 (6+5.333333...+10)\\3=7.11111，以此类推。\n\n```\nn=10\ntrade = table(09:00:00 + 1..n as time, rand(`A`B, n) as sym, 1..n as val)\n\noutputTable = table(100:0, `sym`time`total, [STRING, SECOND, DOUBLE])\n\nengine = createReactiveStateEngine(name=\"test\", metrics=[<time>, <stateMavg(val, 3)>], dummyTable=trade, outputTable=outputTable, keyColumn=`sym, keepOrder=true)\n\nengine.append!(trade)\nselect * from outputTable\n```\n\n| sym | time     | total  |\n| --- | -------- | ------ |\n| B   | 09:00:01 | 1      |\n| A   | 09:00:02 | 2      |\n| B   | 09:00:03 | 3      |\n| B   | 09:00:04 | 2.6667 |\n| B   | 09:00:05 | 3.5556 |\n| A   | 09:00:06 | 6      |\n| B   | 09:00:07 | 4.4074 |\n| A   | 09:00:08 | 5.3333 |\n| B   | 09:00:09 | 5.6543 |\n| A   | 09:00:10 | 7.1111 |\n\n相关函数：[conditionalIterate](https://docs.dolphindb.cn/zh/funcs/c/conditionalIterate.html), [stateIterate](https://docs.dolphindb.cn/zh/funcs/s/stateIterate.html)\n"
    },
    "std": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/std.html",
        "signatures": [
            {
                "full": "std(X)",
                "name": "std",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [std](https://docs.dolphindb.cn/zh/funcs/s/std.html)\n\n\n\n#### 语法\n\nstd(X)\n\n#### 详情\n\n若 *X* 为向量，返回 *X* 的标准差。\n\n若 *X* 为矩阵，计算每列的标准差，返回一个向量。\n\n若 *X* 为表，计算每列的标准差，返回一个表。\n\n与所有其它聚合函数一致，计算时忽略 NULL 值。\n\n**Note:** 该函数返回无偏差样本标准差（unbiased sample standard deviation），而不是总体标准差。\n\n与 Python 中 `numpy.std` 的区别：`numpy.std` 默认计算总体标准差（*ddof*=0），DolphinDB 的 `std` 返回无偏样本标准差，相当于 *ddof*=1；此外，DolphinDB 计算时忽略 NULL 值，矩阵和表按列计算。\n\n#### 参数\n\n**X** 可以是标量、向量、矩阵或表。\n\n#### 返回值\n\n一个标量、向量或表。\n\n#### 例子\n\n```\nstd(1 2 3);\n// output\n1\n\nm=matrix(1 3 5 7 9, 1 4 7 10 13);\nm;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 1  |\n| 3  | 4  |\n| 5  | 7  |\n| 7  | 10 |\n| 9  | 13 |\n\n```\nstd(m);\n// output\n[3.162277660168379,4.743416490252569]\n```\n\n相关函数：[std](https://docs.dolphindb.cn/zh/funcs/s/std.html), [cumstd](https://docs.dolphindb.cn/zh/funcs/c/cumstd.html)\n"
    },
    "stdp": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/stdp.html",
        "signatures": [
            {
                "full": "stdp(X)",
                "name": "stdp",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [stdp](https://docs.dolphindb.cn/zh/funcs/s/stdp.html)\n\n\n\n#### 语法\n\nstdp(X)\n\n#### 详情\n\n若 *X* 为向量，返回 *X* 的总体标准差。\n\n若 *X* 为矩阵，计算每列的总体标准差，返回一个向量。\n\n若 *X* 为表，计算每列的总体标准差，返回一个表。\n\n与所有其它聚合函数一致，计算时忽略 NULL 值。\n\n#### 参数\n\n**X** 可以是向量、矩阵或表。\n\n#### 返回值\n\n一个标量、向量或表。\n\n#### 例子\n\n```\nstdp(1 2 3);\n// output\n0.816497\n\nm=matrix(1 3 5 7 9, 1 4 7 10 13);\nm;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 1  |\n| 3  | 4  |\n| 5  | 7  |\n| 7  | 10 |\n| 9  | 13 |\n\n```\nstdp(m);\n// output\n[2.8284,4.2426]\n```\n\n相关函数：[std](https://docs.dolphindb.cn/zh/funcs/s/std.html), [cumstdp](https://docs.dolphindb.cn/zh/funcs/c/cumstdp.html)\n"
    },
    "stl": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/stl.html",
        "signatures": [
            {
                "full": "stl(data, period, sWindow, [sDegree], [sJump], [tWindow], [tDegree], [tJump], [lWindow], [lDegree], [lJump], [robust], [inner], [outer])",
                "name": "stl",
                "parameters": [
                    {
                        "full": "data",
                        "name": "data"
                    },
                    {
                        "full": "period",
                        "name": "period"
                    },
                    {
                        "full": "sWindow",
                        "name": "sWindow"
                    },
                    {
                        "full": "[sDegree]",
                        "name": "sDegree",
                        "optional": true
                    },
                    {
                        "full": "[sJump]",
                        "name": "sJump",
                        "optional": true
                    },
                    {
                        "full": "[tWindow]",
                        "name": "tWindow",
                        "optional": true
                    },
                    {
                        "full": "[tDegree]",
                        "name": "tDegree",
                        "optional": true
                    },
                    {
                        "full": "[tJump]",
                        "name": "tJump",
                        "optional": true
                    },
                    {
                        "full": "[lWindow]",
                        "name": "lWindow",
                        "optional": true
                    },
                    {
                        "full": "[lDegree]",
                        "name": "lDegree",
                        "optional": true
                    },
                    {
                        "full": "[lJump]",
                        "name": "lJump",
                        "optional": true
                    },
                    {
                        "full": "[robust]",
                        "name": "robust",
                        "optional": true
                    },
                    {
                        "full": "[inner]",
                        "name": "inner",
                        "optional": true
                    },
                    {
                        "full": "[outer]",
                        "name": "outer",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [stl](https://docs.dolphindb.cn/zh/funcs/s/stl.html)\n\n\n\n#### 语法\n\nstl(data, period, sWindow, \\[sDegree], \\[sJump], \\[tWindow], \\[tDegree], \\[tJump], \\[lWindow], \\[lDegree], \\[lJump], \\[robust], \\[inner], \\[outer])\n\n#### 详情\n\n使用 Loess 方法将一个时间序列分解为趋势性、季节性和随机性。\n\n#### 参数\n\n**data** 是一个数值型向量，表示时间序列。\n\n**period** 是一个大于1的整数，表示时间序列的周期。\n\n**sWindow** 可以是一个字符串，它的取值只能是 \"periodic\"，表示在提取时间序列中的周期性时，不采取平滑算法，直接用平均值代替；*sWindow* 也可以是一个大于7的奇数，表示提取时间序列中的周期性时 Loess 窗口的长度。\n\n**sDegree** 可以是0,1或2，表示提取时间序列中的周期性时，局部拟合的多项式次数。默认值为1。\n\n**sJump** 是一个大于1的整数，表示提取时间序列的周期性时，每隔 *sJump* 个元素执行一次平滑计算。默认值为 ceil(*sWindow*/10)。\n\n**tWindow** 是一个正奇数，表示提取时间序列中的趋势性时 Loess 窗口的长度。默认值为 1.5 \\* *period* / (1 - (1.5 / *sWindow*)) 的下一个奇数。\n\n**tDegree** 可以是0,1或2，表示提取时间序列中的趋势性时，局部拟合的多项式次数。默认值为1。\n\n**tJump** 是一个大于1的整数，表示提取时间序列的趋势性时，每隔 *tJump* 个元素执行一次平滑计算。默认值为ceil(tWindow/10)。\n\n**lWindow** 是一个正奇数，表示提取时间序列的周期性时，每一个子序列的低通滤波器的 Loess 窗口长度。默认值为 *period* 的下一个奇数。\n\n**lDegree** 可以是0,1或2，表示子序列的低通滤波器中，局部拟合的多项式次数。默认值为1。\n\n**lJump** 是一个大于1的整数，表示子序列的低通滤波器中，每隔 *lJump* 个元素执行一次平滑计算。默认值为 ceil(*lWindow*/10)。\n\n**robust** 是一个布尔值，表示在 Loess 过程中是否采用稳健拟合。默认值为 false。\n\n**inner** 是一个大于等于1的整数，表示内部迭代次数，一般较小的取值即可满足需求。如果 *robust* 为 true，*inner* 的默认值为1，如果 *robust* 为 false，*inner* 的默认值为2。\n\n**outer** 是一个大于等于1的整数，表示外部迭代次数，用于增加稳健性。如果 *robust* 为 true，*outer* 的默认值为15，如果 *robust* 为 false，*outer* 的默认值为0。\n\n#### 返回值\n\n一个包含以下 key 的字典：trend, seasonal 和 residuals，每个 key 对应一个与 data 长度相同的向量。\n\n#### 例子\n\n```\nn = 100\ntrend = 6 * sin(1..n \\ 200)\nseasonal = sin(pi / 6 * 1..n)\nresiduals = rand(1.0, n) - 0.5\ndata = trend + seasonal + residuals\nres = stl(data, 12, \"periodic\");\n```\n\n我们可以在 DolphinDB GUI 中画图检验分解结果。\n\n```\nplot([trend, res.trend]);\n```\n\n![stl1](https://docs.dolphindb.cn/zh/images/stl01.png)\n\n```\nplot([seasonal, res.seasonal]);\n```\n\n![stl2](https://docs.dolphindb.cn/zh/images/stl02.png)\n"
    },
    "stopClusterReplication": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/stopClusterReplication.html",
        "signatures": [
            {
                "full": "stopClusterReplication()",
                "name": "stopClusterReplication",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [stopClusterReplication](https://docs.dolphindb.cn/zh/funcs/s/stopClusterReplication.html)\n\n\n\n#### 语法\n\nstopClusterReplication()\n\n#### 详情\n\n停止集群间的异步复制。该命令只能由管理员在主/从集群的控制节点调用。\n\n* 主集群：调用后，停止将任务放入发送队列。\n\n* 从集群：调用后，停止从主集群读取新任务，但执行中的任务不会停止。\n\n调用该命令前，必须先配置 *replicationMode* 参数。\n\n#### 参数\n\n无\n\n#### 例子\n\n```\nstopClusterReplication();\n```\n\n相关函数： [startClusterReplication](https://docs.dolphindb.cn/zh/funcs/s/startClusterReplication.html), [skipClusterReplicationTask](https://docs.dolphindb.cn/zh/funcs/s/skipClusterReplicationTask.html)\n"
    },
    "stopDataNode": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/stopDataNode.html",
        "signatures": [
            {
                "full": "stopDataNode(X)",
                "name": "stopDataNode",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [stopDataNode](https://docs.dolphindb.cn/zh/funcs/s/stopDataNode.html)\n\n\n\n#### 语法\n\nstopDataNode(X)\n\n#### 详情\n\n用于在集群控制器上停止数据节点/计算节点。\n\n#### 参数\n\n**X** 是一个向量。包含了要停止的数据节点/计算节点的信息。\n\n#### 例子\n\n```\nx = [\"192.168.1.27:8506\",\"192.168.1.27:8502\",\"192.168.1.27:8527\"]\nstopDataNode(x);\n```\n"
    },
    "stopHeapSample": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/stopheapsample.html",
        "signatures": [
            {
                "full": "stopHeapSample()",
                "name": "stopHeapSample",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [stopHeapSample](https://docs.dolphindb.cn/zh/funcs/s/stopheapsample.html)\n\n\n\n#### 语法\n\nstopHeapSample()\n\n#### 详情\n\n动态关闭堆内存采样。仅管理员可执行该函数。\n\n#### 参数\n\n无\n\n#### 例子\n\n对内存使用情况进行分析的流程如下：\n\n1. 启用堆内存采样：可在启动 DolphinDB 前，设置环境变量 TCMALLOC\\_SAMPLE\\_PARAMETER 为1-524288之间的值（建议值 524288）；或通过函数 `startHeapSample` 动态开启。\n\n2. 在可能发生内存泄漏的操作前、后分别执行 `dumpHeapSample`，保存两个不同的文件。通过对比两个文件，确认操作涉及到的内存分配和使用情况。\n\n3. 关闭堆内存采样。\n\n```\nstartHeapSample(524288)\n\ndumpHeapSample(\"/DolphinDB/Data/heap1\")\ndumpHeapSample(\"/DolphinDB/Data/heap2\")\n\nstopHeapSample()\n```\n\n相关函数：[dumpHeapSample](https://docs.dolphindb.cn/zh/funcs/d/dumpheapsample.html), [startHeapSample](https://docs.dolphindb.cn/zh/funcs/s/startheapsample.html)\n"
    },
    "stopStreamGraph": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/stopStreamGraph.html",
        "signatures": [
            {
                "full": "stopStreamGraph(name)",
                "name": "stopStreamGraph",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    }
                ]
            }
        ],
        "markdown": "### [stopStreamGraph](https://docs.dolphindb.cn/zh/funcs/s/stopStreamGraph.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\nstopStreamGraph(name)\n\n##### 详情\n\n暂停指定流图。该函数成功执行后将是指定流图状态变为 stopped。\n\n可通过 `getStreamGraphMeta` 查看流图状态。\n\n\\*\\*返回值：\\*\\*无\n\n##### 参数\n\n**name** 字符串标量，表示需要暂停的流图名称。可以传入完整的流图全限定名（如 catalog\\_name.orca\\_graph.graph\\_name），也可以仅提供流图名（如 factors）；系统会根据当前的 catalog 设置自动补全为对应的全限定名。\n\n##### 例子\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\n\nuse catalog orca\n\ndef callTimes(mutable call, mutable tempTable, msg) {\n    call += 1\n    price = [call]\n    volume = [call]\n    t = table(price, volume)\n    tempTable.append!(t)\n    return t\n}\nname = \"UDF\"\ng = createStreamGraph(name)\nckptConfig = {\n    \"enable\":true,\n    \"interval\": 10000,\n    \"timeout\": 36000,\n    \"maxConcurrentCheckpoints\": 1\n};\n\ng.source(\"trade\", `price`volume, [INT,INT])\n .udfEngine(callTimes,[\"price\", \"volume\"], [`cnt, `tmpTable], [433, table(128:0, [\"price\",\"volume\"], [INT, INT])])\n .setEngineName(\"udf\")\n .sink(\"output\")\ng.submit(ckptConfig)\ngo\ngetStreamGraphMeta()\nstopStreamGraph(\"UDF\") // 暂停流图，流图状态变为 stopped\nstartStreamGraph(\"UDF\") // 开始流图，流图状态变为 running\n```\n\n**相关函数：**[createStreamGraph](https://docs.dolphindb.cn/zh/funcs/c/createStreamGraph.html), [startStreamGraph](https://docs.dolphindb.cn/zh/funcs/s/startStreamGraph.html)\n"
    },
    "stopSubEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/stopSubEngine.html",
        "signatures": [
            {
                "full": "stopSubEngine()",
                "name": "stopSubEngine",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [stopSubEngine](https://docs.dolphindb.cn/zh/funcs/s/stopSubEngine.html)\n\n\n\n#### 语法\n\nstopSubEngine()\n\n#### 详情\n\n要停止特定子引擎内的事件处理操作，可以在其任何 monitor 实例中调用 `stopSubEngine()`。\n\n在关闭子引擎前：\n\n1. 如果存在通过 spawn 产生的 monitor 实例，将首先调用这些由 spawn 产生的 monitor 实例中已声明的 `onDestroy` 方法。\n2. 调用其内部所有 monitor 实例中已声明的 `onunload` 方法。\n"
    },
    "stopTimerEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/stopTimerEngine.html",
        "signatures": [
            {
                "full": "stopTimerEngine(engine)",
                "name": "stopTimerEngine",
                "parameters": [
                    {
                        "full": "engine",
                        "name": "engine"
                    }
                ]
            }
        ],
        "markdown": "### [stopTimerEngine](https://docs.dolphindb.cn/zh/funcs/s/stopTimerEngine.html)\n\n\n\n#### 语法\n\nstopTimerEngine(engine)\n\n#### 详情\n\n该函数只能通过 `useOrcaStreamEngine` 调用，暂停由 `DStream::timerEngine` 提交的任务。\n\n#### 参数\n\n**engine**表示引擎名称。字符串标量，可以传入完整的全限定名（如 \"catalog\\_name.orca\\_engine.engine\\_name\"）；或引擎名（如 \"engine\\_name\"），系统会根据当前的 catalog 设置自动补全为对应的全限定名。\n\n#### 例子\n\n提交任务\n\n```\nif (!existsCatalog(\"test\")) {\n\tcreateCatalog(\"test\")\t\n}\ngo\nuse catalog test\n\n// 定义任务\ndef myFunc(x,y,z){\n    writeLog(x,y,z)\n}\n\n// 定义参数\na = \"aaa\"\nb = \"bbb\"\nc = \"ccc\"\n\n// 提交流图\ng = createStreamGraph(\"timerEngineDemo\")\ng.source(\"trade\", `id`price, [INT, DOUBLE])\n .timerEngine(3, myFunc, a, b, c)\n .setEngineName(\"myJob\")\n .sink(\"result\")\ng.submit()\n```\n\n暂停任务执行\n\n```\nuseOrcaStreamEngine(\"myJob\", stopTimerEngine)\n```\n\n继续执行任务\n\n```\nuseOrcaStreamEngine(\"myJob\", resumeTimerEngine)\n```\n\n**相关函数：**[DStream::timerEngine](https://docs.dolphindb.cn/zh/funcs/d/DStream_timerEngine.html), [resumeTimerEngine](https://docs.dolphindb.cn/zh/funcs/r/resumeTimerEngine.html)\n"
    },
    "streamEngineParser": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/streamEngineParser.html",
        "signatures": [
            {
                "full": "streamEngineParser(name, metrics, dummyTable, outputTable, keyColumn, [timeColumn], [useSystemTime=false], [snapshotDir], [snapshotIntervalInMsgCount], [raftGroup], [filter], [keepOrder], [keyPurgeFilter], [keyPurgeFreqInSecond], [triggeringPattern='perBatch'], [triggeringInterval=1000], [lastBatchOnly=false], [contextByColumn], [updateTime], [useWindowStartTime=false], [roundTime=true], [forceTriggerTime], [sessionBegin], [sessionEnd], [mergeSessionEnd=false], [closed='left'], [fill='none'], [garbageSize], [forceTriggerSessionEndTime], [keyPurgeFreqInSec=-1])",
                "name": "streamEngineParser",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "metrics",
                        "name": "metrics"
                    },
                    {
                        "full": "dummyTable",
                        "name": "dummyTable"
                    },
                    {
                        "full": "outputTable",
                        "name": "outputTable"
                    },
                    {
                        "full": "keyColumn",
                        "name": "keyColumn"
                    },
                    {
                        "full": "[timeColumn]",
                        "name": "timeColumn",
                        "optional": true
                    },
                    {
                        "full": "[useSystemTime=false]",
                        "name": "useSystemTime",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[snapshotDir]",
                        "name": "snapshotDir",
                        "optional": true
                    },
                    {
                        "full": "[snapshotIntervalInMsgCount]",
                        "name": "snapshotIntervalInMsgCount",
                        "optional": true
                    },
                    {
                        "full": "[raftGroup]",
                        "name": "raftGroup",
                        "optional": true
                    },
                    {
                        "full": "[filter]",
                        "name": "filter",
                        "optional": true
                    },
                    {
                        "full": "[keepOrder]",
                        "name": "keepOrder",
                        "optional": true
                    },
                    {
                        "full": "[keyPurgeFilter]",
                        "name": "keyPurgeFilter",
                        "optional": true
                    },
                    {
                        "full": "[keyPurgeFreqInSecond]",
                        "name": "keyPurgeFreqInSecond",
                        "optional": true
                    },
                    {
                        "full": "[triggeringPattern='perBatch']",
                        "name": "triggeringPattern",
                        "optional": true,
                        "default": "'perBatch'"
                    },
                    {
                        "full": "[triggeringInterval=1000]",
                        "name": "triggeringInterval",
                        "optional": true,
                        "default": "1000"
                    },
                    {
                        "full": "[lastBatchOnly=false]",
                        "name": "lastBatchOnly",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[contextByColumn]",
                        "name": "contextByColumn",
                        "optional": true
                    },
                    {
                        "full": "[updateTime]",
                        "name": "updateTime",
                        "optional": true
                    },
                    {
                        "full": "[useWindowStartTime=false]",
                        "name": "useWindowStartTime",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[roundTime=true]",
                        "name": "roundTime",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[forceTriggerTime]",
                        "name": "forceTriggerTime",
                        "optional": true
                    },
                    {
                        "full": "[sessionBegin]",
                        "name": "sessionBegin",
                        "optional": true
                    },
                    {
                        "full": "[sessionEnd]",
                        "name": "sessionEnd",
                        "optional": true
                    },
                    {
                        "full": "[mergeSessionEnd=false]",
                        "name": "mergeSessionEnd",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[closed='left']",
                        "name": "closed",
                        "optional": true,
                        "default": "'left'"
                    },
                    {
                        "full": "[fill='none']",
                        "name": "fill",
                        "optional": true,
                        "default": "'none'"
                    },
                    {
                        "full": "[garbageSize]",
                        "name": "garbageSize",
                        "optional": true
                    },
                    {
                        "full": "[forceTriggerSessionEndTime]",
                        "name": "forceTriggerSessionEndTime",
                        "optional": true
                    },
                    {
                        "full": "[keyPurgeFreqInSec=-1]",
                        "name": "keyPurgeFreqInSec",
                        "optional": true,
                        "default": "-1"
                    }
                ]
            }
        ],
        "markdown": "### [streamEngineParser](https://docs.dolphindb.cn/zh/funcs/s/streamEngineParser.html)\n\n\n\n#### 语法\n\nstreamEngineParser(name, metrics, dummyTable, outputTable, keyColumn, \\[timeColumn], \\[useSystemTime=false], \\[snapshotDir], \\[snapshotIntervalInMsgCount], \\[raftGroup], \\[filter], \\[keepOrder], \\[keyPurgeFilter], \\[keyPurgeFreqInSecond], \\[triggeringPattern='perBatch'], \\[triggeringInterval=1000], \\[lastBatchOnly=false], \\[contextByColumn], \\[updateTime], \\[useWindowStartTime=false], \\[roundTime=true], \\[forceTriggerTime], \\[sessionBegin], \\[sessionEnd], \\[mergeSessionEnd=false], \\[closed='left'], \\[fill='none'], \\[garbageSize], \\[forceTriggerSessionEndTime], \\[keyPurgeFreqInSec=-1])\n\n#### 详情\n\n在实际场景下，用户的因子可能嵌套横截面、历史状态、时序窗口、表连接等多种复杂逻辑，需要多个计算引擎的级联才能实现。`streamEngineParser` 为只涉及横截面、历史状态、时序窗口三种逻辑嵌套的复杂因子，提供了一个统一的计算入口。用户无需编写复杂的级联代码，只需将嵌套因子按规则改写后传入`streamEngineParser` ，系统将自动解析各层嵌套涉及的计算逻辑，形成流计算引擎流水线，自动分发给对应的引擎进行计算。\n\n为满足各逻辑对应引擎的功能，该函数集合了（日级）时序引擎、响应式状态引擎和横截面引擎的参数。需要注意的是，由于部分为公共参数（如 *keyColumn*），若公共参数在不同计算逻辑下需要指定的值不同（如时序窗口按天分组，状态逻辑要求按股票代码分组，则需要配置不同的 *keyColumn*），不能使用该函数，只能通过级联实现。\n\n根据上文，若要使用 `streamEngineParser` ，必须根据业务场景提供的指标，分析业务中涉及的流计算引擎，将指标改写成 `streamEngineParser` 能够识别分解的 *metrics*。若 *metrics* 中包含了用户自定义函数，引擎对函数体内部的嵌套逻辑进一步进行解析。\n\n改写规则如下：\n\n1. **引擎分解标识**\n   * 若指标中的某一层嵌套逻辑要求计算截面数据，需将对应的计算函数改成以 “row开头” 的函数作为标识，若不添加 row 则该操作默认在响应式状态引擎处理。如：需要在截面计算排名，则需要将该层嵌套改写为 `rowRank`。\n\n     目前支持的标识函数如下：\n\n     ```\n     \"byRow\", \"rowAvg\", \"rowCount\", \"count\", \"rowDenseRank\", \"rowMax\", \"rowMin\", \"rowProd\", \"rowRank\",\n     \"rowSize\", \"rowSkew\", \"rowStd\", \"rowStdp\", \"rowSum\", \"rowSum2\", \"rowVar\", \"rowVarp\",\n     \"rowAnd\", \"rowOr\", \"rowXor\", \"rowKurtosis\", \"rowCorr\", \"rowCovar\", \"rowBeta\", \"rowWsum\", \"rowWavg\"\n     ```\n\n     用户自定义函数或者 row 系列函数不支持的逻辑可以通过 `byRow` 高阶函数实现。\n\n   * 若指标中的某一层嵌套逻辑涉及到时序聚合窗口的计算，必须在指标中以 [rolling](https://docs.dolphindb.cn/zh/funcs/ho_funcs/rolling.html) 作为标识进行改写。如：窗口为 3， 步长为 3，窗口内进行求和计算，计算列为 price，空值以前值填充，则可以写为 rolling(sum, price, 3, 3, 'ffill')。形式如下：\n\n     ```\n     rolling(func, funcArgs, window, [step=1], [fill='none'])\n     ```\n\n   * 分解时，不包含上述标识的内置函数均在响应式状态引擎中处理。\n\n2. **中间引擎输入表结构**\n\n   在 `streamEngineParser` 中，用户只能通过参数 *dummyTable* 指定第一个引擎输入表的 schema ，中间引擎的 *dummyTable* 对用户而言是透明的， 为了能在 *metrics* 和部分参数中指定中间表的列名，`streamEngineParser` 提供了一套中间引擎 *dummyTable* 的命名规范：\n\n   * 第一列为时间列。\n\n   * 之后几列对应指定的 *keyColumn*。\n\n   * 后续列为 *metrics* 对应的计算结果列，列名为：“col\\_0\\_, col\\_1\\_, col\\_2\\_...”。\n\n   **Note:**\n\n   * 由于响应式状态引擎的输出表没有时间列，而时间序列聚合引擎以及横截面引擎的输出表需包含时间列，因此当流水线中涉及到响应式状态引擎相关操作时，其 *metrics* 会自动增加时间列作为下一个引擎的 *dummyTable* 的一列。若此时 *useSystemTime* = true，则其中间表的时间列的列名为 \"datatime\"。\n   * 以下引擎的部分参数需要指定列名，如：\n\n     * 横截面引擎：*contextByColumn*\n     * 响应式状态引擎：*filter*, *keyPurgeFilter*\n       若这些参数需要指定中间引擎的 *dummyTable* 的列名，则可以根据如上的命名规则给出的列名进行指定，如 \"*contextByColumn* = col\\_0\\_\"。若指定的列为 *timeColumn* 和 *keyColumn*，则也可以指定参数对应的列名。\n\n#### 必选参数\n\n**name** 是一个字符串，表示指定流水线内引擎名称的前缀，可包含字母，数字和下划线，但必须以字母开头。比如指定 *name* = \"test\"，则流水线内部对应的引擎名称为 \"test0\", \"test1\", \"test2\"... 其中，数字代表 *metrics* 分解出的流数据引擎的级联顺序。\n\n**metrics** 以元代码的形式表示计算指标，支持输入元组。有关元代码的更多信息可参考 [Metaprogramming](https://docs.dolphindb.cn/zh/progr/objs/meta_progr.html)。\n\n* metrics 可以是系统内置或用户自定义的函数，如 <\\[sum(qty), avg(price)]>；可以对计算结果使用表达式，如 <\\[avg(price1)-avg(price2)]>；也可以对多列进行运算，如 <\\[std(price1-price2)]>。\n\n* metrics 内支持具有多个返回值的函数，例如 \\<func(price) as `col1`col2>（可不指定列名）。\n\n在 `streamEngineParser` 中，计算指标通常是一个嵌套的因子，每层嵌套逻辑都被解析后放入特定的引擎进行计算。更多说明见详情。\n\n**dummyTable** 一个表对象，和输入的流数据表的 schema 一致，可以含有数据，亦可为空表。\n\n**outputTable** 计算结果的输出表，可以是内存表或者分布式表。调用 `streamEngineParser` 之前，需要将输出表预先设立为一个空表，并指定各列列名以及数据类型。各引擎会将计算结果插入该表。 若 *metrics* 分解的流水线上的最后一个操作对应：\n\n* **时序聚合引擎**\n\n  输出表的各列的顺序为：时间列，分组列，计算结果列。\n\n  其中：\n\n  * 第一列必须是时间类型。\n    * 若 *useSystemTime* = true，为 TIMESTAMP 类型。\n    * 若 *useSystemTime* = false，数据类型与 *timeColumn* 列一致。\n    * 若 *useWindowStartTime* = true，显示时间为数据窗口起始时间。\n    * 若 *useWindowStartTime* = false，显示时间为数据窗口终止时间。\n  * 如果 *keyColumn* 不为空，则其后几列和 *keyColumn* 设置的列及其顺序保持一致。\n  * 最后为计算结果列，可为多列。\n    最终的 schema 为“时间列，分组列(可选)，计算结果列1，计算结果列2...”这样的格式。\n\n* **响应式状态引擎**\n\n  输出表的各列的顺序为：分组列，计算结果列。\n\n  其中：\n\n  * 根据 *keyColumn* 的设置，输出表的前几列必须和 *keyColumn* 设置的列及其顺序保持一致。\n  * 其后为计算结果列，可为多列。\n\n* **横截面引擎**\n\n  输出表的 schema 需要遵循以下规范:\n\n  * 如果没有指定 *contextByColumn*， 输出表的列数为 *metrics* 数量+1，第一列为 TIMESTAMP 类型，用于存放发生计算的时间戳（如果指定了 *timeColumn* 则是对应记录的时间戳），其他列为 *metrics* 计算结果对应的列，其数据类型必须与 *metrics* 返回结果的数据类型一致。\n  * 如果指定 *contextByColumn*， 输出表的列数为 *metrics* 数量+2。第一列为 TIMESTAMP 类型，用于存放发生计算的时间戳（如果指定了 *timeColumn* 则是对应记录的时间戳）；第二列为 *contextByColumn* 指定的列；最后几列为 *metrics* 计算结果对应的列，其数据类型必须与 *metrics* 返回结果的数据类型一致。\n\n**keyColumn** 是一个字符串标量或向量。\n\n* 时序聚合引擎/响应式状态引擎：表示分组列名。若设置，计算按分组进行，例如以每支股票为一组进行聚合计算。\n\n* 横截面引擎：表示将某列值作为横截面引擎的 key，横截面引擎的每次计算，只使用每个 key 对应的最新一条记录。\n\n#### 可选参数\n\n**timeColumn** 指定输入的流数据表中时间列的名称。当 *useSystemTime* = false 时，必须指定该参数。\n\n* 时序聚合引擎/响应式状态引擎：是一个字符串标量或向量。请注意，若为字符串向量，必须是 date 和 time 组成的向量，date 类型为 DATE，time 类型为 TIME, SECOND 或 NANOTIME。此时，输出表第一列的时间类型必须与 [concatDateTime(date, time)](https://docs.dolphindb.cn/zh/funcs/c/concatDateTime.html) 的类型一致。\n\n* 横截面引擎：是一个字符串，仅支持 TIMESTAMP 类型。\n\n**useSystemTime** 表示是否使用系统时间作为时间戳。\n\n* 横截面引擎：可选参数。表示 *outputTable* 中第一列（时间列）为系统当前时间( *useSystemTime* = true)或数据中时间列( *useSystemTime* = false)。\n\n* 时间序列聚合引擎：可选参数，表示时间序列引擎计算的触发方式。若指定该参数为 true，不能指定 *timeColumn*。\n\n  a. 当 *useSystemTime* = true 时，时间序列引擎会按照数据进入时间序列引擎的时刻（毫秒精度的本地系统时间，与数据中的时间列无关），每隔固定时间截取固定长度窗口的流数据进行计算。只要一个数据窗口中含有数据，数据窗口结束后就会自动进行计算。结果中的第一列为计算发生的时间戳，与数据中的时间无关。 b. 当 *useSystemTime* = false（缺省值）时，时间序列引擎根据流数据中的 timeColumn 列来截取数据窗口。一个数据窗口结束后的第一条新数据才会触发该数据窗口的计算。请注意，触发计算的数据并不会参与该次计算。\n\n若要开启快照机制 （snapshot），必须指定 *snapshotDir* 与 *snapshotIntervalInMsgCount*。启用快照机制之后，系统若出现异常，可及时将流数据引擎恢复到最新的快照状态。\n\n**snapshotDir** 可选参数，字符串，表示保存引擎快照的文件目录。\n\n* 指定的目录必须存在，否则系统会提示异常。\n\n* 创建流数据引擎时，如果指定了 *snapshotDir*，会检查该目录下是否存在快照。如果存在，会加载该快照，恢复引擎的状态。\n\n* 多个引擎可以指定同一个目录存储快照，用引擎的名称来区分快照文件。\n\n* 一个引擎的快照可能会使用三个文件名：\n\n* 临时存储快照信息：文件名为 \\<engineName>.tmp；\n\n* 快照生成并刷到磁盘：文件保存为 \\<engineName>.snapshot；\n\n* 存在同名快照：旧快照自动重命名为 \\<engineName>.old。\n\n**snapshotIntervalInMsgCount** 可选参数，为整数类型，表示每隔多少条数据保存一次流数据引擎快照。\n\n**raftGroup** 是流数据高可用订阅端 raft 组的 ID (大于1的整数，由流数据高可用相关的配置项 *streamingRaftGroups* 指定)。设置该参数表示开启计算引擎高可用。在 leader 节点创建流数据引擎后，会同步在 follower 节点创建该引擎。每次保存的 snapshot 也会同步到 follower。当 raft 组的 leader 节点宕机时，会自动切换新 leader 节点重新订阅流数据表。请注意，若要指定 *raftGroup*，必须同时指定 *snapshotDir*。\n\n该流水线引擎只能在 raft 组的 leader 节点创建。\n\n各引擎特有的参数如下：\n\n* 响应式状态引擎 [createReactiveStateEngine](https://docs.dolphindb.cn/zh/funcs/c/createReactiveStateEngine.html): *filter*, *keepOrder*, *keyPurgeFilter*, *keyPurgeFreqInSecond*\n\n* 横截面引擎参数 [createCrossSectionalEngine](https://docs.dolphindb.cn/zh/funcs/c/createCrossSectionalEngine.html): *triggeringPattern*, *triggeringInterval*, *lastBatchOnly*, *contextByColumn*\n\n* 时间序列聚合引擎 [createTimeSeriesEngine](https://docs.dolphindb.cn/zh/funcs/c/createTimeSeriesEngine.html): *updateTime*, *useWindowStartTime*, *roundTime*, *forceTriggerTime*, closed, fill, garbageSize, keyPurgeFreqInSec\n\n* 日级时间序列聚合引擎 [createDailyTimeSeriesEngine](https://docs.dolphindb.cn/zh/funcs/c/createDailyTimeSeriesEngine.html): *sessionBegin*, *sessionEnd*, *mergeSessionEnd*, closed, fill, garbageSize, forceTriggerSessionEndTime, keyPurgeFreqInSec\n\n**Note:** 如果 *triggeringPattern*='keyCount'，则 *keepOrder* 的默认值为 true，且不可设置为 false。\n\n#### 返回值\n\n返回一个表对象，为解析后流水线上第一个流计算引擎返回的表，向该表写入数据意味着这些数据进入流水线进行计算。删除时，需要根据 streamEngineParser 解析出的引擎对应的名称（详见 name）单独进行删除。暂不支持通过一个函数删除全部引擎。\n\n#### 例子\n\n下面的例子是 World Quant 101 个 Alpha 因子中的1号因子公式的流数据实现。`rank` 函数是一个横截面操作。`rank` 的参数部分用响应式状态引擎实现。`rank` 函数本身用横截面引擎实现。横截面引擎作为状态引擎的输出。\n\n```\nn = 100\nsym = rand(`aaa`bbb`ccc, n)\ntime = 2021.01.01T13:30:10.008 + 1..n\nmaxIndex=rand(100.0, n)\ndata = table(sym as sym, time as time, maxIndex as maxIndex)\n```\n\n```\nrank(Ts_ArgMax(SignedPower((returns<0?stddev(returns,20):close), 2), 5))-0.5\n\n// 创建横截面引擎，计算每个股票的rank\ndummy = table(1:0, `sym`time`maxIndex, [SYMBOL, TIMESTAMP, DOUBLE])\nresultTable = streamTable(10000:0, `time`sym`factor1, [TIMESTAMP, SYMBOL, DOUBLE])\nccsRank = createCrossSectionalAggregator(name=\"alpha1CCS\", metrics=<[sym, rank(maxIndex, percent=true) - 0.5]>,  dummyTable=dummy, outputTable=resultTable,  keyColumn=`sym, triggeringPattern='keyCount', triggeringInterval=3000, timeColumn=`time, useSystemTime=false)\n\n@state\ndef wqAlpha1TS(close){\n    ret = ratios(close) - 1\n    v = iif(ret < 0, mstd(ret, 20), close)\n    return mimax(signum(v)*v*v, 5)\n}\n\n// 创建响应式状态引擎，输出到前面的横截面引擎ccsRank\ninput = table(1:0, `sym`time`close, [SYMBOL, TIMESTAMP, DOUBLE])\nrse = createReactiveStateEngine(name=\"alpha1\", metrics=<[time, wqAlpha1TS(close)]>, dummyTable=input, outputTable=ccsRank, keyColumn=\"sym\")\nrse.append!(data)\n\ndropStreamEngine(\"alpha1CCS\")\ndropStreamEngine(\"alpha1\")\n```\n\n上述操作可以通过直接构建流水线引擎进行替代：\n\n```\ninput = table(1:0, `sym`time`close, [SYMBOL, TIMESTAMP, DOUBLE])\nresultTable = streamTable(10000:0, `time`sym`factor1, [TIMESTAMP, SYMBOL, DOUBLE])\n\n// 构建计算因子\nmetrics=<[sym, rowRank(wqAlpha1TS(close), percent=true)- 0.5]>\n\nstreamEngine=streamEngineParser(name=`alpha1_parser, metrics=metrics, dummyTable=input, outputTable=resultTable, keyColumn=`sym, timeColumn=`time, triggeringPattern='keyCount', triggeringInterval=3000)\nstreamEngine.append!(data)\n\ndropStreamEngine(\"alpha1_parser0\")\ndropStreamEngine(\"alpha1_parser1\")\n```\n"
    },
    "streamEventSerializer": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/streamEventSerializer.html",
        "signatures": [
            {
                "full": "streamEventSerializer(name, eventSchema, outputTable, [eventTimeField], [commonField])",
                "name": "streamEventSerializer",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "eventSchema",
                        "name": "eventSchema"
                    },
                    {
                        "full": "outputTable",
                        "name": "outputTable"
                    },
                    {
                        "full": "[eventTimeField]",
                        "name": "eventTimeField",
                        "optional": true
                    },
                    {
                        "full": "[commonField]",
                        "name": "commonField",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [streamEventSerializer](https://docs.dolphindb.cn/zh/funcs/s/streamEventSerializer.html)\n\n\n\n#### 语法\n\nstreamEventSerializer(name, eventSchema, outputTable, \\[eventTimeField], \\[commonField])\n\n#### 详情\n\n将事件序列化为 BLOB 格式，并写入到异构流表。\n\n#### 参数\n\n**name** 字符串，表示序列化引擎的名称，可包含字母，数字和下划线，但必须以字母开头。\n\n**eventSchema** 可以是事件定义或一个表。用于指定进行序列化的事件及其声明的成员变量。\n\n* 如果指定为事件类型定义，则可以指定为一个或多个事件类型定义。例如：定义了两个事件类型类，event1 和 event2，则可指定为 *eventSchema*=\\[event1, event2]\n* 如果指定为表，则必须具有如下表结构（可通过 `getCEPEngineStat(engine).eventSchemas` 获得 CEP 引擎中所有事件的结构）：\n\n<table id=\"topic_bzv_h21_ybc_table_serializer_1\"><thead><tr><th id=\"topic_bzv_h21_ybc_table_serializer_1_entry_1\">\n\n列名\n\n</th><th id=\"topic_bzv_h21_ybc_table_serializer_1_entry_2\">\n\n含义\n\n</th></tr></thead><tbody><tr><td>\n\neventType\n\n</td><td>\n\n字符串，表示事件类型\n\n</td></tr><tr><td>\n\neventField\n\n</td><td>\n\n字符串，表示事件类型中所声明的字段名。多个字段名之间以逗号（,）分隔\n\n</td></tr><tr><td>\n\nfieldType（可选）\n\n</td><td>\n\n字符串，表示 eventField 中各字段对应的数据类型的名称，多个名称之间以逗号（,）分隔\n\n</td></tr><tr><td>\n\nfieldTypeId\n\n</td><td>\n\n整型数组向量，表示 eventField 中各字段对应的数据类型的 ID。\n\n</td></tr><tr><td>\n\nfieldFormId\n\n</td><td>\n\n整型数组向量，表示 eventField 中各字段对应的数据形式的 ID。整型数组向量，0：标量; 1：向量; 2：数据对; 3：矩阵; 4：集合; 5：字典; 6：表\n\n注意：目前只能指定标量和向量。\n\n</td></tr></tbody>\n</table>\n**outputTable**：事件流序列化之后输出的表，是一个异构流表（未分区的内存表/流数据表），至少包含三列：其中：\n\n* 如果指定 *eventTimeField*，第一列为时间戳；\n\n* 第二列为 STRING 类型，表示事件；\n\n* 第三列为 BLOB 类型，用于存储事件流序列化后的结果。\n\n* 此外，若如果指定了 *commonField*，则输出由它指定的列。\n\n**eventTimeField** 可选，字符串标量或向量，用于指定事件时间的字段名字。如果所有事件的时间字段名都相同，则 *eventTimeField* 是一个标量，否则 *eventTimeField* 是一个向量，其长度和 *eventSchemes* 的长度一相同，每个元素分别代表每个事件的时间字段。\n\n**commonField** 可选，字符串标量或向量，用于指定所有事件中具有相同名字的字段名称。在订阅时可以通过指定的字段对数据进行过滤。\n\n#### 返回值\n\n返回一个表对象。\n\n#### 例子\n\n```\nclass MarketData{\n    market :: STRING\n    code :: STRING\n    price :: DOUBLE\n    qty :: INT\n    def MarketData(m,c,p,q){\n        market = m\n        code = c\n        price = p\n        qty = q\n    }\n}\nclass Orders{\n    trader :: STRING\n    market :: STRING\n    code :: STRING\n    price :: DOUBLE\n    qty :: INT\n    def Orders(t, m,c,p,q){\n        trader = t\n        market = m\n        code = c\n        price = p\n        qty = q\n    }\n}\nclass Trades{\n    trader :: STRING\n    market :: STRING\n    code :: STRING\n    price :: DOUBLE\n    qty :: INT\n    def Trades(t, m,c,p,q){\n        trader = t\n        market = m\n        code = c\n        price = p\n        qty = q\n    }\n}\nshare streamTable(array(STRING, 0) as eventType, array(BLOB, 0) as blobs) as events\nserializer = streamEventSerializer(name=`serOutput, eventSchema=[MarketData, Orders, Trades], outputTable=events)\n```\n\n可通过参数 *eventTimeField* 指定事件中的时间字段名称，从而指示序列化器使用该字段作为事件时间。此时，输出表的第一列必须为时间戳。若需要基于部分字段对数据进行过滤，可通过参数 *commonField* 指定相关字段名称。\n\n```\n// 定义事件类  \nclass MarketData{  \n    market :: STRING  \n    code :: STRING  \n    price :: DOUBLE  \n    qty :: INT  \n    timestamp :: TIMESTAMP  \n    def MarketData(m,c,p,q){  \n        market = m  \n        code = c  \n        price = p  \n        qty = q  \n        timestamp = now()  \n    }  \n}  \n  \n// 定义监视器类  \nclass TestMonitor: CEPMonitor {  \n    def TestMonitor(){  \n    } \n    \n    def processMarketData(event){  \n        // 将事件发送到输出表（序列化器）  \n        emitEvent(event)  \n    }\n          \n    def onload(){  \n        // 监听 MarketData 事件并发送到序列化器  \n        addEventListener(handler=processMarketData, eventType=\"MarketData\", times=\"all\")  \n    }       \n  \n}  \n  \n//  创建输出表  \nshare(streamTable(array(TIMESTAMP, 0) as eventTime, array(STRING, 0) as eventType, array(BLOB, 0) as blobs, array(STRING, 0) as market, array(STRING, 0) as code), `events) \n  \n// 创建序列化器  \nserializer = streamEventSerializer(name=`serOutput,   \n                                 eventSchema=[MarketData],   \n                                 outputTable=events,  \n                                 eventTimeField=\"timestamp\",  \n                                 commonField=[\"market\", \"code\"])  \n  \n// 创建 CEP 引擎  \ndummy = table(array(STRING, 0) as eventType, array(BLOB, 0) as blobs)  \nengine = createCEPEngine(name=\"testEngine\",   \n                       monitors=<TestMonitor()>,   \n                       dummyTable=dummy,   \n                       eventSchema=[MarketData],  \n                       outputTable=serializer)  \n  \n// 创建并注入事件  \nmd1 = MarketData(\"SHSE\", \"000001\", 10.50, 1000)  \nmd2 = MarketData(\"SZSE\", \"000002\", 15.80, 500)  \n  \n// 通过 CEP 引擎注入事件  \nappendEvent(engine, md1)  \nappendEvent(engine, md2)  \n  \n// 查看结果  \nselect * from events\n```\n\n| eventTime               | eventType  | blobs                                | market | code   |\n| ----------------------- | ---------- | ------------------------------------ | ------ | ------ |\n| 2026.04.10 19:43:13.585 | MarketData | SHSE000001%@�\\u0003���x�\\u0001       | SHSE   | 000001 |\n| 2026.04.10 19:43:13.585 | MarketData | SZSE000002������/@�\\u0001���x�\\u0001 | SZSE   | 000002 |\n"
    },
    "streamFilter": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/streamFilter.html",
        "signatures": [
            {
                "full": "streamFilter(name, dummyTable, filter, [msgSchema], [timeColumn], [conditionColumn])",
                "name": "streamFilter",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "dummyTable",
                        "name": "dummyTable"
                    },
                    {
                        "full": "filter",
                        "name": "filter"
                    },
                    {
                        "full": "[msgSchema]",
                        "name": "msgSchema",
                        "optional": true
                    },
                    {
                        "full": "[timeColumn]",
                        "name": "timeColumn",
                        "optional": true
                    },
                    {
                        "full": "[conditionColumn]",
                        "name": "conditionColumn",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [streamFilter](https://docs.dolphindb.cn/zh/funcs/s/streamFilter.html)\n\n\n\n#### 语法\n\nstreamFilter(name, dummyTable, filter, \\[msgSchema], \\[timeColumn], \\[conditionColumn])\n\n#### 详情\n\n创建流数据过滤引擎，对输入引擎的数据进行过滤和分发处理，返回一个表对象。\n\n该引擎的处理流程包含以下步骤：\n\n1. 输入数据为异构流数据表（由 [replay](https://docs.dolphindb.cn/zh/funcs/r/replay.html) 函数回放得到）时，解析（反序列化）数据。输入数据为普通流数据表时无此步骤。注意：1.30.18 版本开始，streamFilter 函数支持过滤普通流数据表数据，并进行分发处理。\n\n2. 根据 *filter* 指定的规则对流数据表进行过滤。\n\n3. 过滤后的数据按照时间顺序分发到不同的 *handler* 处理。\n\n**Note:**\n\n2.00.5 版本开始，DolphinDB 支持通过 [replay](https://docs.dolphindb.cn/zh/funcs/r/replay.html) 函数将多个结构不同的流数据表，回放（序列化）到一个流数据表里，这个流数据表被称为异构流数据表。`streamFilter` 函数用于解析（反序列化）和过滤异构流数据表的数据并进行分发处理。\n\n#### 参数\n\n**name** 字符串标量，表示流数据过滤引擎的名称，可包含字母，数字和下划线，但必须以字母开头。\n\n**dummyTable** 表对象，和输入的流数据表的 schema 一致，可以含有数据，亦可为空表。\n\n**filter** 单个字典或包含多个字典的 tuple。对注入引擎的数据进行过滤和处理。\n\n字典可选的 key-value 说明如下：\n\n* 'timeRange'：可选字段，一个数据对或包含多个数据对的 tuple。以指定的 *timeRange* 对 *timeColumn* 进行过滤。注意：若分发普通流数据表，则 *timeRange* 必须和 *timeColumn* 的数据类型一致；异构流数据表无该限制。\n\n* 'condition'：表示过滤条件。\n\n  * 若分发异构流数据表，则 'condition' 是一个字符串，且必须是 replay 参数 *inputTables* 的键值（表的标识）。用于过滤出异构表中具有 *condition* 标识的数据。\n\n  * 若分发普通流数据表，则 'condition' 可以是一个字符串标量/向量，或者是包含一个或多个布尔表达式的元代码。其中表达式中可以使用内置函数，但不支持部分应用。请注意，若 'condition' 指定为字符串标量/向量，必须为 *conditionColumn* 指定列的元素。\n\n* 'handler'：一元函数或表对象（包括流数据引擎返回的表对象）。\n\n  * 如果它是一元函数，它唯一的参数是经过解析和过滤后的数据表。\n\n  * 如果它是表对象，经过解析和过滤后的数据会直接插入到该表中。\n\n**msgSchema** 可选字段，字典。\n\n* 若分发异构流数据表，其结构与 replay 回放到异构流数据表的数据表结构保持一致。引擎将根据 *msgSchema* 指定的结构对注入的数据解析;\n\n* 若分发普通流数据表，该参数必须设置为空。\n\n以下参数仅在分发普通流数据表时指定：\n\n**timeColumn** 字符串，指定为 *dummyTable* 中时间列的名称。若不指定，则取 *dummyTable* 第一列的列名。\n\n**conditionColumn** 字符串，指定为 *dummyTable* 中的列名。注意 *conditionColumn* 只能指定 STRING 或 SYMBOL 类型的列。若不指定该参数，则 *filter* 的 *condition* 字段将失效。\n\n#### 返回值\n\n返回一个表对象。\n\n#### 例子\n\n(1) 异构流数据表分发：\n\n一个典型场景：对分布式数据库中的订单表和交易表进行回放，模拟两者实时 asof join 的场景。如使用 replay 进行 N 对 N 回放，则无法保证数据严格按照时间戳 顺序注入 asof join 引擎的左表和右表（原因详见 `replay` 说明）。但通过 `replay` 将两表回放到一个异构流数据表则可以保证表内所有数据按照时间戳顺序排序， 之后通过 `streamFilter` 将表中数据分发至 asof join 引擎的左、右表时，可保证数据按时间戳顺序注入引擎左、右两表。\n\n```\n// 创建 order 表\nn=1000\nsym = take(take(\"IBM\",n).join(take(\"GS\",n)), n*2*3)\ndate=take(2022.01.04..2022.01.06, n*2*3).sort!()\ntimestamp1=take(2022.01.04 09:30:00.000+rand(1000,n),n) join take(2022.01.04 09:31:00.000+rand(1000,n),n)\ntimestamp2=take(2022.01.05 09:30:00.000+rand(1000,n),n) join take(2022.01.05 09:31:00.000+rand(1000,n),n)\ntimestamp3=take(2022.01.06 09:30:00.000+rand(1000,n),n) join take(2022.01.06 09:31:00.000+rand(1000,n),n)\ntimestamp=timestamp1 join timestamp2 join timestamp3\nvolume = rand(100, n*2*3)\nt=table(sym,date,timestamp,volume)\n\nif(existsDatabase(\"dfs://test_order\")){\ndropDatabase(\"dfs://test_order\")\n}\ndb1_or=database(\"\",RANGE, 2022.01.04..2022.01.07)\ndb2_or=database(\"\",VALUE,`IBM`GS)\ndb_or=database(\"dfs://test_order\",COMPO,[db1_or, db2_or])\norders=db_or.createPartitionedTable(t,`orders,`date`sym)\norders.append!(t);\nselect count(*) from orders\n// output\n6000\n\n// 创建trades表\nn=2000\nsym = take(take(\"IBM\",n).join(take(\"GS\",n)), n*2*3)\ndate=take(2022.01.04..2022.01.06, n*2*3).sort!()\ntimestamp1=take(2022.01.04 09:30:00.000+rand(1000,n),n) join take(2022.01.04 09:31:00.000+rand(1000,n),n)\ntimestamp2=take(2022.01.05 09:30:00.000+rand(1000,n),n) join take(2022.01.05 09:31:00.000+rand(1000,n),n)\ntimestamp3=take(2022.01.06 09:30:00.000+rand(1000,n),n) join take(2022.01.06 09:31:00.000+rand(1000,n),n)\ntimestamp=timestamp1 join timestamp2 join timestamp3\nvolume = rand(100, n*2*3)\nprice = rand(50.0, n*3) join  rand(20.0, n*3)\n\nt=table(sym,date,timestamp,volume,price)\n\nif(existsDatabase(\"dfs://test_trades\")){\ndropDatabase(\"dfs://test_trades\")\n}\ndb1=database(\"\",RANGE, 2022.01.04..2022.01.07)\ndb2=database(\"\",VALUE,`IBM`GS)\ndb=database(\"dfs://test_trades\",COMPO,[db1, db2])\ntrades=db.createPartitionedTable(t,`trades,`date`sym)\ntrades.append!(t);\nselect count(*) from trades\n// output\n12000\n\n// 准备回放的数据源和输出表\nds_or = replayDS(sqlObj=<select * from loadTable(db_or, `orders)>, dateColumn=`date, timeColumn=`timestamp)\nds = replayDS(sqlObj=<select * from loadTable(db, `trades)>, dateColumn=`date, timeColumn=`timestamp)\ninput_dict=dict([\"orders\",\"trades\"], [ds_or, ds])\nshare streamTable(100:0,`timestamp`sym`blob`volume, [TIMESTAMP,SYMBOL, BLOB, INT]) as opt\n\n\n// 订阅异构流数据表回放数据到分配引擎\nshare streamTable(100:0,`timestamp`sym`blob`volume, [TIMESTAMP,SYMBOL, BLOB, INT]) as streamFilterOpt\nshare streamTable(100:0, `sym`date`timestamp`volume, [SYMBOL, DATE, TIMESTAMP, INT] ) as streamOrders\nshare streamTable(100:0, `sym`date`timestamp`volume`price, [SYMBOL, DATE, TIMESTAMP, INT, DOUBLE] ) as streamTrades\nstreamOpt=table(100:0, `timestamp`sym`volume`price`result, [TIMESTAMP, SYMBOL, INT, DOUBLE, DOUBLE])\n\nfilter1=dict(STRING,ANY)\nfilter1['condition']=`orders\nfilter1['timeRange']=09:30:00.000:09:30:00.005\n\nfilter2=dict(STRING,ANY)\nfilter2['condition']=`trades\nfilter2['timeRange']=09:30:00.000:09:30:00.005\n\najEngine=createAsofJoinEngine(name=\"ajEngine\", leftTable=streamOrders, rightTable=streamTrades, outputTable=streamOpt, metrics=<[volume,price,price*volume]>, matchingColumn=`sym, useSystemTime=true)\nfilter1['handler']=getLeftStream(ajEngine)\nfilter2['handler']=getRightStream(ajEngine)\nschema=dict([\"orders\",\"trades\"], [streamOrders, streamTrades])\n\nengine=streamFilter(name=`streamFilter,dummyTable=streamFilterOpt, filter=[filter1,filter2],msgSchema=schema)\nsubscribeTable(tableName=\"opt\", actionName=\"sub1\", offset=0, handler=engine, msgAsTable=true)\n\n// 结构不同的两个表数据回放到opt\nreplay(inputTables=input_dict,outputTables=opt, timeColumn=`timestamp)\n\nselect count(*) from streamOpt\n// output\n20\n\n// 取消订阅\nunsubscribeTable(tableName=\"opt\", actionName=\"sub1\")\ndropStreamEngine(`streamFilter)\ndropStreamEngine(`ajEngine)\n```\n\n(2) 普通流数据表分发：\n\n下例，将普通流数据表（trades）数据注入分发引擎中，根据过滤条件进行分发处理。\n\n```\nn=20\nsym = symbol(take(`A`B`C,n))\nname = string(rand(1..10,n))\ndate = temporalAdd(2012.12.06,0..(n-1),'d')\ntime = temporalAdd(09:30:00.000,0..(n-1),'ms')\nvol = 100+take(1..8,20)\nt = table(date,time,sym,name,vol)\n\n// 定义两个流数据引擎，作为分发引擎 handler\nshare streamTable(100:0,`date`time`sym`name`vol,[DATE,TIME,SYMBOL,STRING,INT]) as st1\nshare streamTable(100:0,`date`time`sym`name`vol,[DATE,TIME,SYMBOL,STRING,INT]) as st2\nshare streamTable(100:0,`date`time`sym`name`vol,[DATE,TIME,SYMBOL,STRING,INT]) as st3\n\n// handler为引擎时的输入流数据表\nshare streamTable(100:0,`time`sym`sum_vol,[TIME,SYMBOL,INT]) as output1\nshare streamTable(100:0,`time`avg_vol,[TIME,INT]) as output2\nengine1=createTimeSeriesEngine(name=\"timeEngine\", windowSize=3, step=3, metrics=<[sum(vol)]>, dummyTable=st3, outputTable=output1, timeColumn=`time, useSystemTime=false, keyColumn=`sym, garbageSize=50)\nengine2=createReactiveStateEngine(name=\"reactiveEngine\", metrics=<[mavg(vol, 3)]>, dummyTable=st1, outputTable=output2, keyColumn=`sym)\n\n// 需要注入分发引擎的流数据表\nshare streamTable(100:0,`date`time`sym`name`vol,[DATE,TIME,SYMBOL,STRING,INT]) as trades\n\n// 设置第一个过滤条件，将 trades 表中 sym 列对应元素为 A 且时间在09:30:00.001:09:30:00.010和09:29:00.000:09:30:00.000的数据输入状态引擎进行处理\nfilter1 = dict(STRING,ANY)\nfilter1['condition']=`A\nfilter1['handler']=engine2\nfilter1['timeRange']=(09:30:00.001:09:30:00.010,09:29:00.000:09:30:00.000)\n\n// 设置第二个过滤条件，将 trades 表时间范围在09:30:00.002:09:30:00.005里的数据全部输出到st2表里\nfilter2 = dict(STRING,ANY)\nfilter2['handler']=st2\nfilter2['timeRange']=09:30:00.002:09:30:00.005\n\n// 设置第三个过滤条件，将 trades 表中 sym 列对应元素为 A 和 C 的数据输入时序引擎进行处理\nfilter3 = dict(STRING,ANY)\nfilter3['condition']=`C`A\nfilter3['handler']=engine1\n\n// 订阅分发引擎，根据以上三个过滤条件，对 trades 表中的数据进行分发处理\nstreamFilter2=streamFilter(name=\"streamFilterDemo\",dummyTable=trades,filter=[filter1,filter2,filter3], timeColumn=`time, conditionColumn=`sym)\nsubscribeTable(tableName=\"trades\", actionName=\"sub1\", offset=0, handler=streamFilter2, msgAsTable=true)\ntrades.append!(t)\nselect * from output1\n```\n\n| time         | sym | sum\\_vol |\n| ------------ | --- | -------- |\n| 09:30:00.003 | A   | 101      |\n| 09:30:00.003 | C   | 103      |\n| 09:30:00.006 | A   | 104      |\n| 09:30:00.006 | C   | 106      |\n| 09:30:00.009 | A   | 107      |\n| 09:30:00.009 | C   | 101      |\n| 09:30:00.012 | A   | 102      |\n| 09:30:00.012 | C   | 104      |\n| 09:30:00.015 | A   | 105      |\n| 09:30:00.015 | C   | 107      |\n| 09:30:00.018 | A   | 108      |\n\n```\nselect * from output2\n```\n\n| time         | avg\\_vol |\n| ------------ | -------- |\n| 00:00:00.001 |          |\n| 00:00:00.001 |          |\n| 00:00:00.001 | 104      |\n| 00:00:00.001 | 104      |\n\n```\nselect * from st2\n```\n\n| date       | time         | sym | name | vol |\n| ---------- | ------------ | --- | ---- | --- |\n| 2012.12.08 | 09:30:00.002 | C   | 6    | 103 |\n| 2012.12.09 | 09:30:00.003 | A   | 8    | 104 |\n| 2012.12.10 | 09:30:00.004 | B   | 10   | 105 |\n| 2012.12.11 | 09:30:00.005 | C   | 10   | 106 |\n| 2012.12.12 | 09:30:00.006 | A   | 10   | 107 |\n| 2012.12.13 | 09:30:00.007 | B   | 1    | 108 |\n| 2012.12.14 | 09:30:00.008 | C   | 3    | 101 |\n| 2012.12.15 | 09:30:00.009 | A   | 4    | 102 |\n| 2012.12.16 | 09:30:00.010 | B   | 9    | 103 |\n\n可以为 condition 指定表达式，以支持更复杂的过滤逻辑，将上例中 filter2 的 *condition* 指定为条件表达式，同时对 vol 和 date 列进行过滤。\n\n```\nfilter2 = dict(STRING,ANY)\nfilter2['condition'] = <sym==`A and 101<vol<105 and date<2012.12.15>\nfilter2['handler'] = st2\nfilter2['timeRange'] = 09:30:00.002:09:30:00.010\n\nselect * from st2\n```\n\n| date       | time         | sym | name | vol |\n| ---------- | ------------ | --- | ---- | --- |\n| 2012.12.09 | 09:30:00.003 | A   | 7    | 104 |\n"
    },
    "StreamGraph::changelogSource": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/StreamGraph_changelogSource.html",
        "signatures": [
            {
                "full": "StreamGraph::changelogSource(name, keyColumn, colNames, colTypes, [asyncWrite=true], [compress=true], [cacheSize], [retentionMinutes=1440], [flushMode=0], [preCache], [cachePurgeTimeColumn], [cachePurgeInterval], [cacheRetentionTime])",
                "name": "StreamGraph::changelogSource",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "keyColumn",
                        "name": "keyColumn"
                    },
                    {
                        "full": "colNames",
                        "name": "colNames"
                    },
                    {
                        "full": "colTypes",
                        "name": "colTypes"
                    },
                    {
                        "full": "[asyncWrite=true]",
                        "name": "asyncWrite",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[compress=true]",
                        "name": "compress",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[cacheSize]",
                        "name": "cacheSize",
                        "optional": true
                    },
                    {
                        "full": "[retentionMinutes=1440]",
                        "name": "retentionMinutes",
                        "optional": true,
                        "default": "1440"
                    },
                    {
                        "full": "[flushMode=0]",
                        "name": "flushMode",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[preCache]",
                        "name": "preCache",
                        "optional": true
                    },
                    {
                        "full": "[cachePurgeTimeColumn]",
                        "name": "cachePurgeTimeColumn",
                        "optional": true
                    },
                    {
                        "full": "[cachePurgeInterval]",
                        "name": "cachePurgeInterval",
                        "optional": true
                    },
                    {
                        "full": "[cacheRetentionTime]",
                        "name": "cacheRetentionTime",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [StreamGraph::changelogSource](https://docs.dolphindb.cn/zh/funcs/s/StreamGraph_changelogSource.html)\n\n首发版本：3.00.5\n\n\n\n#### 语法\n\nStreamGraph::changelogSource(name, keyColumn, colNames, colTypes, \\[asyncWrite=true], \\[compress=true], \\[cacheSize], \\[retentionMinutes=1440], \\[flushMode=0], \\[preCache], \\[cachePurgeTimeColumn], \\[cachePurgeInterval], \\[cacheRetentionTime])\n\n#### 详情\n\n创建一个包含状态列的持久化键值流数据表。参考 [changelogStreamTable](https://docs.dolphindb.cn/zh/funcs/c/changelogStreamTable.html) 和 [enableTableShareAndPersistence](https://docs.dolphindb.cn/zh/funcs/e/enableTableShareAndPersistence.html)。\n\n#### 参数\n\n**name** 表示流表的名称。字符串标量，可以传入完整的流表全限定名（如 \"trading.orca\\_table.trades\"）；也可以仅提供流表名（如 \"trades\"），系统会根据当前的 catalog 设置自动补全为对应的全限定名。\n\n**keyColumn** 是一个字符串或向量，表示主键。主键的数据类型必须属于以下类别：INTEGRAL, TEMPORAL, LITERAL 或 FLOATING。\n\n**colNames** 是一个向量，表示列名。\n\n**colTypes** 是一个向量，表示每列的数据类型，支持数组向量类型和元组（ANY）类型。可使用表示数据类型的系统保留字或相应的字符串。\n\n**asyncWrite** 可选参数，是一个布尔值，表示是否异步持久化数据到磁盘。默认值为 true，流数据写入内存即为写入成功，持久化到磁盘的操作将会由另一个线程执行。\n\n**Note:**\n\n持久化数据到磁盘包含两个步骤：\n\n* 写内存数据到操作系统缓存\n\n* 写缓存数据到磁盘（是否开启同步刷盘由参数 *flushMode* 决定）\n\n**compress** 可选参数，是一个布尔值，表示是否以压缩模式模式保存至磁盘。默认值为 true。\n\n**cacheSize** 可选参数，整数，表示流数据表在内存中最多保留多少行。如果未指定该参数，则所有记录行都会保存在内存中。如果 *cacheSize* 小于 1000，它会被自动调整为 1000。\n\n**retentionMinutes** 可选参数，是一个整数，表示文件大小超过 1GB的 log 文件的保留时间(从文件的最后修改时间开始计算)，单位是分钟。默认值是 1440，即一天。如果 log 文件未达 1GB，则会一直保留至大小达到 1GB。\n\n**flushMode** 可选参数，是一个整数，表示是否开启同步刷盘，取值只能为 0 或 1。默认值是 0，表示异步刷盘，内存中的流数据写入操作系统缓存即为写入成功，并进行下一批数据的写入。 若为 1，则表示同步刷盘，当前批次的流数据必须落盘完成，才会进行下一批数据的写入。\n\n**preCache** 可选参数，是一个整数，表示从磁盘加载到内存的记录条数。如果没有指定该参数，重启后实际加载到内存的数据量受 *cacheSize* 限制。\n\n**cachePurgeTimeColumn** 可选参数，字符串标量，需要指定为持久化流表中的时间列名称。\n\n**cachePurgeInterval** 可选参数，DURATION 类型标量，表示触发清理内存中数据的时间间隔。\n\n**cacheRetentionTime** 可选参数，DURATION 类型标量，表示内存中数据的最长保留期限。\n\n#### 返回值\n\n一个 DStream 对象。\n\n#### 例子\n\n```\ng = createStreamGraph(\"streamGraph\")\ng1 = g.changelogSource(`st, `sym`time, `sym`time`qty, [SYMBOL, DATETIME, INT])\n    .timeSeriesEngine(windowSize=60, step=60, metrics=[<sum(qty) as sum_qty>], timeColumn=`time,keyColumn=`sym, updateTime=0)\n    .setEngineName(\"tse\")\n    .reactiveStateEngine([<time>, <mavg(sum_qty, 3)>], `sym)\n    .setEngineName(\"rse\")\n    .changelogSink(\"output\", `sym`time)\ng.submit() \ngo\n```\n\n**相关函数**：[changelogStreamTable](https://docs.dolphindb.cn/zh/funcs/c/changelogStreamTable.html)、[enableTableShareAndPersistence](https://docs.dolphindb.cn/zh/funcs/e/enableTableShareAndPersistence.html)、DStream::changelogSink\n"
    },
    "StreamGraph::deleteRule": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/StreamGraph_deleteRule.html",
        "signatures": [
            {
                "full": "StreamGraph::deleteRule(engineName, key)",
                "name": "StreamGraph::deleteRule",
                "parameters": [
                    {
                        "full": "engineName",
                        "name": "engineName"
                    },
                    {
                        "full": "key",
                        "name": "key"
                    }
                ]
            }
        ],
        "markdown": "### [StreamGraph::deleteRule](https://docs.dolphindb.cn/zh/funcs/s/StreamGraph_deleteRule.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\nStreamGraph::deleteRule(engineName, key)\n\n#### 详情\n\n删除流图中规则引擎的指定规则。\n\n与接口 `deleteRule` 的核心区别在于：\n\n* 通过 `StreamGraph::deleteRule` 执行的规则变更会被系统自动持久化，确保服务重启后所有已提交的规则修改能被加载并继续生效。\n\n* 通过 `deleteRule` 对规则的变更仅限于内存，修改将在服务重启后失效。\n\n#### 参数\n\n**engineName** STRING 类型标量，引擎的全限定名（如 \"catalog\\_name.orca\\_engine.engine\\_name\"）。\n\n**key** 是 STRING 或 INT 类型的标量，表示要删除的规则对应的 key 。\n\n#### 例子\n\n```\ncreateCatalog(\"demo\")\ngo\nuse catalog demo\n\ng = createStreamGraph(\"updateRuleDemo\")\n\n// 设置规则集\nx = [1, 2, NULL]\ny = [ [ < value > 1 > ], [ < price < 2 >, < price > 6 > ], [ < value*price > 10 > ] ]\nruleSets = dict(x, y)\n\ng.source(\"trades\", `sym`value`price`quantity, [INT, DOUBLE, DOUBLE, DOUBLE])\n    .ruleEngine(ruleSets=ruleSets, outputColumns=[\"sym\",\"value\",\"price\"], policy=\"all\", ruleSetColumn=\"sym\")\n    .setEngineName(\"myRuleEngine\")\n    .sink(\"output\")\ng.submit()\n\n// 删除规则\ng.deleteRule(\"demo.orca_engine.myRuleEngine\",1)\n```\n\n相关函数：[StreamGraph::updateRule](https://docs.dolphindb.cn/zh/funcs/s/StreamGraph_updateRule.html), [updateRule](https://docs.dolphindb.cn/zh/funcs/u/updateRule.html)\n"
    },
    "StreamGraph::dropGraph": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/StreamGraph_dropGraph.html",
        "signatures": [
            {
                "full": "StreamGraph::dropGraph([includeTables])",
                "name": "StreamGraph::dropGraph",
                "parameters": [
                    {
                        "full": "[includeTables]",
                        "name": "includeTables",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [StreamGraph::dropGraph](https://docs.dolphindb.cn/zh/funcs/s/StreamGraph_dropGraph.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\nStreamGraph::dropGraph(\\[includeTables])\n\n#### 详情\n\n销毁流图。销毁成功后，流图状态转为 destroyed，但流图记录不会被删除。\n\n* 如果 *includesTables*=true，则在删除流图的同时，也会删除该流图中用户显式创建的流表（如 source、sink 等）。必须保证该流图中的流表未被其它流图引用。可通过 getStreamTableMeta 查看流流表的引用情况。\n* 否则，仅删除流图本身，不会影响这些流表。\n\n在集群部署模式下，执行该操作的用户必须是管理员用户，或拥有流图创建时所用计算组的 COMPUTE\\_GROUP\\_EXEC 权限。若在单节点部署环境中使用，则无需进行权限校验。\n\n#### 参数\n\n**includesTables** 可选参数，布尔值，表示在删除流图时是否同时删除该流图中用户显式创建的流表（如 source、sink 等），默认为 false。\n\n#### 例子\n\n```\n// 提交流图\ncreateCatalog(\"test\")\nuse catalog test\n\nt = table(1..100 as id, 1..100 as value, take(09:29:00.000..13:00:00.000, 100) as timestamp)\ng = createStreamGraph(\"factor\")\nbaseStream = g.source(\"snapshot\",  schema(t).colDefs.name, schema(t).colDefs.typeString)\n  .reactiveStateEngine([<cumsum(value)>, <timestamp>])\n  .setEngineName(\"rse\")\n  .buffer(\"end\")\n  \ng.submit()\n\n// 删除流图\ng.dropGraph()\n```\n\n相关函数：[dropStreamGraph](https://docs.dolphindb.cn/zh/funcs/d/dropStreamGraph.html), [createStreamGraph](https://docs.dolphindb.cn/zh/funcs/c/createStreamGraph.html)\n"
    },
    "StreamGraph::haKeyedSource": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/StreamGraph_haKeyedSource.html",
        "signatures": [
            {
                "full": "StreamGraph::haKeyedSource(name, keyColumn, colNames, colTypes, raftGroup, cacheLimit, [retentionMinutes=1440])",
                "name": "StreamGraph::haKeyedSource",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "keyColumn",
                        "name": "keyColumn"
                    },
                    {
                        "full": "colNames",
                        "name": "colNames"
                    },
                    {
                        "full": "colTypes",
                        "name": "colTypes"
                    },
                    {
                        "full": "raftGroup",
                        "name": "raftGroup"
                    },
                    {
                        "full": "cacheLimit",
                        "name": "cacheLimit"
                    },
                    {
                        "full": "[retentionMinutes=1440]",
                        "name": "retentionMinutes",
                        "optional": true,
                        "default": "1440"
                    }
                ]
            }
        ],
        "markdown": "### [StreamGraph::haKeyedSource](https://docs.dolphindb.cn/zh/funcs/s/StreamGraph_haKeyedSource.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nStreamGraph::haKeyedSource(name, keyColumn, colNames, colTypes, raftGroup, cacheLimit, \\[retentionMinutes=1440])\n\n#### 详情\n\n创建一个高可用键值流数据表。\n\n#### 参数\n\n**name** 表示流表的名称。字符串标量，可以传入完整的流表全限定名（如 \"trading.orca\\_table.trades\"）；也可以仅提供流表名（如 \"trades\"），系统会根据当前的 catalog 设置自动补全为对应的全限定名。\n\n**keyColumn** 是一个字符串或向量，表示主键。主键的数据类型必须属于以下类别：INTEGRAL, TEMPORAL, LITERAL 或 FLOATING。\n\n**capacity** 是正整数，表示建表时系统为该表分配的内存（以记录数为单位）。当记录数超过 *capacity* 时，系统首先会分配 *capacity* 1.2\\~2倍的新的内存空间，然后复制数据到新的内存空间，最后释放原来的内存。对于规模较大的表，此类操作的内存占用会很高。因此，建议建表时预先分配一个合理的 *capacity*。\n\n**colNames** 是一个向量，表示列名。\n\n**colTypes** 是一个向量，表示每列的数据类型，支持数组向量类型和元组（ANY）类型。可使用表示数据类型的系统保留字或相应的字符串。\n\n**raftGroup** 是一个大于1的整数，或者字符串。\n\n* 当为整数时，表示 Raft 组的 ID。\n* 当为字符串时，表示 Raft 组的别名（需事先通过 *streamingRaftGroupAliases* 配置 ）。\n\n**cacheSize** 是一个正整数，用于指定高可用流数据表在内存中最多保留多少行。如果 *cacheSize* 是小于1000的正整数，它会被自动调整为1000。\n\n**retentionMinutes** 可选参数，整数，用于指定保留大小超过 1GB 的 log 文件的时间（从文件的最后修改时间开始计算），单位是分钟。默认值是1440，即一天。\n\n#### 返回值\n\n一个 DStream 对象。\n\n#### 例子\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\ng = createStreamGraph(\"indicators\")\ng.haKeyedSource(\"ha_keyedTable\",`symbol, `time`symbol`price`volume, [DATETIME,SYMBOL,DOUBLE,LONG], 3, 50000)\n```\n"
    },
    "StreamGraph::haSource": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/StreamGraph_haSource.html",
        "signatures": [
            {
                "full": "StreamGraph::haSource(name, colNames, colTypes, raftGroup, cacheLimit, [retentionMinutes=1440])",
                "name": "StreamGraph::haSource",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "colNames",
                        "name": "colNames"
                    },
                    {
                        "full": "colTypes",
                        "name": "colTypes"
                    },
                    {
                        "full": "raftGroup",
                        "name": "raftGroup"
                    },
                    {
                        "full": "cacheLimit",
                        "name": "cacheLimit"
                    },
                    {
                        "full": "[retentionMinutes=1440]",
                        "name": "retentionMinutes",
                        "optional": true,
                        "default": "1440"
                    }
                ]
            }
        ],
        "markdown": "### [StreamGraph::haSource](https://docs.dolphindb.cn/zh/funcs/s/StreamGraph_haSource.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nStreamGraph::haSource(name, colNames, colTypes, raftGroup, cacheLimit, \\[retentionMinutes=1440])\n\n#### 详情\n\n创建一个高可用流数据表。参考 [haStreamTable](https://docs.dolphindb.cn/zh/funcs/h/haStreamTable.html)。\n\n#### 参数\n\n**name** 表示流表的名称。字符串标量，可以传入完整的流表全限定名（如 \"trading.orca\\_table.trades\"）；也可以仅提供流表名（如 \"trades\"），系统会根据当前的 catalog 设置自动补全为对应的全限定名。\n\n**colNames** 是一个向量，表示列名。\n\n**colTypes** 是一个向量，表示每列的数据类型，支持数组向量类型和元组（ANY）类型。可使用表示数据类型的系统保留字或相应的字符串。\n\n**raftGroup** 是一个大于1的整数，或者字符串。\n\n* 当为整数时，表示 Raft 组的 ID。\n* 当为字符串时，表示 Raft 组的别名（需事先通过 *streamingRaftGroupAliases* 配置 ）。\n\n**cacheLimit** 是一个正整数，用于指定高可用流数据表在内存中最多保留多少行。如果 *cacheLimit* 是小于1000的正整数，它会被自动调整为1000。\n\n**retentionMinutes** 可选参数，整数，用于指定保留大小超过 1GB 的 log 文件的时间（从文件的最后修改时间开始计算），单位是分钟。默认值是1440，即一天。\n\n#### 返回值\n\n一个 DStream 对象。\n\n#### 例子\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\ng = createStreamGraph(\"indicators\")\ng.haSource(\"ha_table\", `time`symbol`price`volume, [DATETIME,SYMBOL,DOUBLE,LONG], 3, 50000)\n```\n"
    },
    "StreamGraph::keyedSource": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/StreamGraph_keyedSource.html",
        "signatures": [
            {
                "full": "StreamGraph::keyedSource(name, keyColumn, colNames, colTypes, [asyncWrite=true], [compress=true], [cacheSize], [retentionMinutes=1440], [flushMode=0], [preCache], [cachePurgeTimeColumn], [cachePurgeInterval], [cacheRetentionTime])",
                "name": "StreamGraph::keyedSource",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "keyColumn",
                        "name": "keyColumn"
                    },
                    {
                        "full": "colNames",
                        "name": "colNames"
                    },
                    {
                        "full": "colTypes",
                        "name": "colTypes"
                    },
                    {
                        "full": "[asyncWrite=true]",
                        "name": "asyncWrite",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[compress=true]",
                        "name": "compress",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[cacheSize]",
                        "name": "cacheSize",
                        "optional": true
                    },
                    {
                        "full": "[retentionMinutes=1440]",
                        "name": "retentionMinutes",
                        "optional": true,
                        "default": "1440"
                    },
                    {
                        "full": "[flushMode=0]",
                        "name": "flushMode",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[preCache]",
                        "name": "preCache",
                        "optional": true
                    },
                    {
                        "full": "[cachePurgeTimeColumn]",
                        "name": "cachePurgeTimeColumn",
                        "optional": true
                    },
                    {
                        "full": "[cachePurgeInterval]",
                        "name": "cachePurgeInterval",
                        "optional": true
                    },
                    {
                        "full": "[cacheRetentionTime]",
                        "name": "cacheRetentionTime",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [StreamGraph::keyedSource](https://docs.dolphindb.cn/zh/funcs/s/StreamGraph_keyedSource.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nStreamGraph::keyedSource(name, keyColumn, colNames, colTypes, \\[asyncWrite=true], \\[compress=true], \\[cacheSize], \\[retentionMinutes=1440], \\[flushMode=0], \\[preCache], \\[cachePurgeTimeColumn], \\[cachePurgeInterval], \\[cacheRetentionTime])\n\n#### 详情\n\n创建一个持久化键值流数据表。参考 [keyedStreamTable](https://docs.dolphindb.cn/zh/funcs/k/keyedStreamTable.html) 和 [enableTableShareAndPersistence](https://docs.dolphindb.cn/zh/funcs/e/enableTableShareAndPersistence.html)。\n\n#### 参数\n\n**name** 表示流表的名称。字符串标量，可以传入完整的流表全限定名（如 \"trading.orca\\_table.trades\"）；也可以仅提供流表名（如 \"trades\"），系统会根据当前的 catalog 设置自动补全为对应的全限定名。\n\n**keyColumn** 是一个字符串或向量，表示主键。主键的数据类型必须属于以下类别：INTEGRAL, TEMPORAL, LITERAL 或 FLOATING。\n\n**colNames** 是一个向量，表示列名。\n\n**colTypes** 是一个向量，表示每列的数据类型，支持数组向量类型和元组（ANY）类型。可使用表示数据类型的系统保留字或相应的字符串。\n\n**asyncWrite** 可选参数，是一个布尔值，表示是否异步持久化数据到磁盘。默认值为 true，流数据写入内存即为写入成功，持久化到磁盘的操作将会由另一个线程执行。\n\n**Note:**\n\n持久化数据到磁盘包含两个步骤：\n\n* 写内存数据到操作系统缓存\n\n* 写缓存数据到磁盘（是否开启同步刷盘由参数 *flushMode* 决定）\n\n**compress** 可选参数，是一个布尔值，表示是否以压缩模式模式保存至磁盘。默认值为 true。\n\n**cacheSize** 可选参数，整数，表示流数据表在内存中最多保留多少行。如果未指定该参数，则所有记录行都会保存在内存中。如果 *cacheSize* 小于 1000，它会被自动调整为 1000。\n\n**retentionMinutes** 可选参数，是一个整数，表示文件大小超过 1GB的 log 文件的保留时间(从文件的最后修改时间开始计算)，单位是分钟。默认值是 1440，即一天。如果 log 文件未达 1GB，则会一直保留至大小达到 1GB。\n\n**flushMode** 可选参数，是一个整数，表示是否开启同步刷盘，取值只能为 0 或 1。默认值是 0，表示异步刷盘，内存中的流数据写入操作系统缓存即为写入成功，并进行下一批数据的写入。 若为 1，则表示同步刷盘，当前批次的流数据必须落盘完成，才会进行下一批数据的写入。\n\n**preCache** 可选参数，是一个整数，表示从磁盘加载到内存的记录条数。如果没有指定该参数，重启后实际加载到内存的数据量受 *cacheSize* 限制。\n\n**cachePurgeTimeColumn** 可选参数，字符串标量，需要指定为持久化流表中的时间列名称。\n\n**cachePurgeInterval** 可选参数，DURATION 类型标量，表示触发清理内存中数据的时间间隔。\n\n**cacheRetentionTime** 可选参数，DURATION 类型标量，表示内存中数据的最长保留期限。\n\n#### 返回值\n\n一个 DStream 对象。\n\n#### 例子\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\ng = createStreamGraph(\"indicators\")\ng.keyedSource(\"trade\", `symbol, `time`symbol`price`volume, [DATETIME,SYMBOL,DOUBLE,LONG])\n```\n"
    },
    "StreamGraph::latestKeyedSource": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/StreamGraph_latestKeyedSource.html",
        "signatures": [
            {
                "full": "StreamGraph::latestKeyedSource(name, keyColumn, timeColumn, colNames, colTypes, [asyncWrite=true], [compress=true], [cacheSize], [retentionMinutes=1440], [flushMode=0], [preCache], [cachePurgeTimeColumn], [cachePurgeInterval], [cacheRetentionTime])",
                "name": "StreamGraph::latestKeyedSource",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "keyColumn",
                        "name": "keyColumn"
                    },
                    {
                        "full": "timeColumn",
                        "name": "timeColumn"
                    },
                    {
                        "full": "colNames",
                        "name": "colNames"
                    },
                    {
                        "full": "colTypes",
                        "name": "colTypes"
                    },
                    {
                        "full": "[asyncWrite=true]",
                        "name": "asyncWrite",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[compress=true]",
                        "name": "compress",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[cacheSize]",
                        "name": "cacheSize",
                        "optional": true
                    },
                    {
                        "full": "[retentionMinutes=1440]",
                        "name": "retentionMinutes",
                        "optional": true,
                        "default": "1440"
                    },
                    {
                        "full": "[flushMode=0]",
                        "name": "flushMode",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[preCache]",
                        "name": "preCache",
                        "optional": true
                    },
                    {
                        "full": "[cachePurgeTimeColumn]",
                        "name": "cachePurgeTimeColumn",
                        "optional": true
                    },
                    {
                        "full": "[cachePurgeInterval]",
                        "name": "cachePurgeInterval",
                        "optional": true
                    },
                    {
                        "full": "[cacheRetentionTime]",
                        "name": "cacheRetentionTime",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [StreamGraph::latestKeyedSource](https://docs.dolphindb.cn/zh/funcs/s/StreamGraph_latestKeyedSource.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nStreamGraph::latestKeyedSource(name, keyColumn, timeColumn, colNames, colTypes, \\[asyncWrite=true], \\[compress=true], \\[cacheSize], \\[retentionMinutes=1440], \\[flushMode=0], \\[preCache], \\[cachePurgeTimeColumn], \\[cachePurgeInterval], \\[cacheRetentionTime])\n\n#### 详情\n\n创建一个最新值键值流数据表，并将它持久化到磁盘上。参考 [latestKeyedStreamTable](https://docs.dolphindb.cn/zh/funcs/l/latestkeyedstreamtable.html) 和 [enableTableShareAndPersistence](https://docs.dolphindb.cn/zh/funcs/e/enableTableShareAndPersistence.html)。\n\n#### 参数\n\n**name** 表示流表的名称。字符串标量，可以传入完整的流表全限定名（如 \"trading.orca\\_table.trades\"）；也可以仅提供流表名（如 \"trades\"），系统会根据当前的 catalog 设置自动补全为对应的全限定名。\n\n**timeColumn** 字符串标量或长度为 2 的向量，分别用于指定 1 个或 2 个时间列。当仅指定 1 个时间列时，该列可以为整型或时间类型；当指定 2 个时间列时，第 1 列必须是 DATE 类型，第 2 列则是 TIME, SECOND 或 NANOTIME 类型。通过这两列，可以共同确定唯一的时间值。\n\n**colNames** 是一个向量，表示列名。\n\n**colTypes** 是一个向量，表示每列的数据类型，支持数组向量类型和元组（ANY）类型。可使用表示数据类型的系统保留字或相应的字符串。\n\n**asyncWrite** 可选参数，是一个布尔值，表示是否异步持久化数据到磁盘。默认值为 true，流数据写入内存即为写入成功，持久化到磁盘的操作将会由另一个线程执行。\n\n**Note:**\n\n持久化数据到磁盘包含两个步骤：\n\n* 写内存数据到操作系统缓存\n\n* 写缓存数据到磁盘（是否开启同步刷盘由参数 *flushMode* 决定）\n\n**compress** 可选参数，是一个布尔值，表示是否以压缩模式模式保存至磁盘。默认值为 true。\n\n**cacheSize** 可选参数，整数，表示流数据表在内存中最多保留多少行。如果未指定该参数，则所有记录行都会保存在内存中。如果 *cacheSize* 小于 1000，它会被自动调整为 1000。\n\n**retentionMinutes** 可选参数，是一个整数，表示文件大小超过 1GB的 log 文件的保留时间(从文件的最后修改时间开始计算)，单位是分钟。默认值是 1440，即一天。如果 log 文件未达 1GB，则会一直保留至大小达到 1GB。\n\n**flushMode** 可选参数，是一个整数，表示是否开启同步刷盘，取值只能为 0 或 1。默认值是 0，表示异步刷盘，内存中的流数据写入操作系统缓存即为写入成功，并进行下一批数据的写入。 若为 1，则表示同步刷盘，当前批次的流数据必须落盘完成，才会进行下一批数据的写入。\n\n**preCache** 可选参数，是一个整数，表示从磁盘加载到内存的记录条数。如果没有指定该参数，重启后实际加载到内存的数据量受 *cacheSize* 限制。\n\n**cachePurgeTimeColumn** 可选参数，字符串标量，需要指定为持久化流表中的时间列名称。\n\n**cachePurgeInterval** 可选参数，DURATION 类型标量，表示触发清理内存中数据的时间间隔。\n\n**cacheRetentionTime** 可选参数，DURATION 类型标量，表示内存中数据的最长保留期限。\n\n#### 返回值\n\n一个 DStream 对象。\n\n#### 例子\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\ng = createStreamGraph(\"indicators\")\ng.latestKeyedSource(\"trade\", `symbol, `time, `time`symbol`price`volume, [DATETIME,SYMBOL,DOUBLE,LONG])\n```\n"
    },
    "StreamGraph::name": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/StreamGraph_name.html",
        "signatures": [
            {
                "full": "StreamGraph::name()",
                "name": "StreamGraph::name",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [StreamGraph::name](https://docs.dolphindb.cn/zh/funcs/s/StreamGraph_name.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nStreamGraph::name()\n\n#### 详情\n\n获取流图的全限定名（Fully Qualified Name, FQN）。\n\n#### 返回值\n\nSTRING 类型标量。\n\n#### 例子\n\n获取 [StreamGraph::submit](https://docs.dolphindb.cn/zh/funcs/s/StreamGraph_submit.html) 函数文档的例子中所提交流图 g 的全限定名：\n\n```\ng.name()\n// Output: 'demo.orca_graph.indicators'\n```\n"
    },
    "StreamGraph::setConfigMap": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/StreamGraph_setConfigMap.html",
        "signatures": [
            {
                "full": "StreamGraph::setConfigMap(dict)",
                "name": "StreamGraph::setConfigMap",
                "parameters": [
                    {
                        "full": "dict",
                        "name": "dict"
                    }
                ]
            }
        ],
        "markdown": "### [StreamGraph::setConfigMap](https://docs.dolphindb.cn/zh/funcs/s/StreamGraph_setConfigMap.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nStreamGraph::setConfigMap(dict)\n\n#### 详情\n\n用于设置流图中私有流表和订阅的相关配置。在生成流图的过程中，系统会自动添加用于数据重分布（shuffle）的私有流表及订阅关系，这些组件无需用户手动声明。若需修改这些自动生成组件的运行参数，可通过 `setConfigMap` 传入配置项。\n\n#### 参数\n\n**dict** 一个字典，目前支持如下键值对：\n\n| **键名**                    | **类型** | **默认值** | **说明**                                               |\n| ------------------------- | ------ | ------- | ---------------------------------------------------- |\n| subscription.batchSize    | INT    | 0       | 设置该流图中所有订阅的 *batchSize* 参数                           |\n| subscription.throttle     | INT    | 1       | 设置该流图中所有订阅的 *throttle* 参数                            |\n| subscription.timeTrigger  | BOOL   | false   | 设置该流图中所有订阅的 *timeTrigger* 参数                         |\n| subscription.sourceOffset | INT    | -3      | 设置流图中所有由 `StreamGraph::source` 创建的流表订阅的 *offset* 参数。 |\n| privateTable.cacheSize    | INT    | 1000    | 设置该流图中所有启用持久化的私有流表的 *cacheSize* 参数                   |\n\n#### 返回值\n\n一个 DGraph 对象。\n\n#### 例子\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\ng = createStreamGraph(\"orca\")\n  .setConfigMap({\n    \"subscription.throttle\": 1,\n    \"privateTable.cacheSize\": 1000\n  })\n```\n"
    },
    "StreamGraph::setLocalConfigOnce": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/StreamGraph_setLocalConfigOnce.html",
        "signatures": [
            {
                "full": "StreamGraph::setLocalConfigOnce(dict)",
                "name": "StreamGraph::setLocalConfigOnce",
                "parameters": [
                    {
                        "full": "dict",
                        "name": "dict"
                    }
                ]
            }
        ],
        "markdown": "### [StreamGraph::setLocalConfigOnce](https://docs.dolphindb.cn/zh/funcs/s/StreamGraph_setLocalConfigOnce.html)\n\n首发版本：3.00.3.1\n\n\n\n#### 语法\n\nStreamGraph::setLocalConfigOnce(dict)\n\n#### 详情\n\n设置流图中相邻节点之间的订阅配置。调用该函数后，配置将覆盖通过 `StreamGraph::setConfigMap` 设置的全局配置，或新增之前未设置的配置。配置仅在调用节点与其直接连接的下游节点之间生效一次；若两个节点之间存在级联关系，则配置不生效。\n\n注意：由于 `sink` 和 `map` 操作不生成新的节点，配置会延续生效至下一个实际节点。\n\n#### 参数\n\n**dict** 一个字典，目前支持如下键值对：\n\n| 键名                        | 类型   | 默认值   | 说明                                                            |\n| ------------------------- | ---- | ----- | ------------------------------------------------------------- |\n| subscription.batchSize    | INT  | 0     | 设置该流图中相邻节点间订阅的 *batchSize* 参数                                 |\n| subscription.throttle     | INT  | 1     | 设置该流图中相邻节点间订阅的 *throttle* 参数                                  |\n| subscription.timeTrigger  | BOOL | false | 设置该流图中相邻节点间订阅的 *timeTrigger* 参数                               |\n| subscription.sourceOffset | INT  | -3    | 设置流图中由 `StreamGraph::source` 创建的节点与其相邻的下游节点之间订阅的 *offset* 参数。 |\n\n#### 返回值\n\n一个 DStream 对象。\n\n#### 例子\n\n下例将流图中用于计算 1分钟 K 线的订阅参数 *batchSize* 设置为100，其余节点订阅参数 *batchSize* 仍然为默认值。\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\n\nuse catalog orca\n\ng = createStreamGraph(\"indicators\")\nsourceStreams = g.source(\"trade\", `symbol`datetime`price`volume, [SYMBOL, TIMESTAMP,DOUBLE, INT])\n    .fork(2)\nstream_1min = sourceStreams[0]\n    .setLocalConfigOnce({\n      \"subscription.batchSize\": 100\n    })\n    .timeSeriesEngine(60*1000, 60*1000, <[first(price),max(price),min(price),last(price),sum(volume)]>, \"datetime\", false, \"symbol\")\n    .reactiveStateEngine(<[datetime, first_price, max_price, min_price, last_price, sum_volume, mmax(max_price, 5), mavg(sum_volume, 5)]>, `symbol)\n    .sink(\"output_1min\")\nstream_5min = sourceStreams[1]\n    .timeSeriesEngine(5*60*1000, 5*60*1000, <[first(price),max(price),min(price),last(price),sum(volume)]>, \"datetime\", false, \"symbol\")\n    .reactiveStateEngine(<[datetime, first_price, max_price, min_price, last_price, sum_volume, mmax(max_price, 5), mavg(sum_volume, 5)]>, `symbol)\n    .sink(\"output_5min\")\n\n```\n"
    },
    "StreamGraph::source": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/StreamGraph_source.html",
        "signatures": [
            {
                "full": "StreamGraph::source(name, colNames, colTypes, [asyncWrite=true], [compress=true], [cacheSize], [retentionMinutes=1440], [flushMode=0], [preCache], [cachePurgeTimeColumn], [cachePurgeInterval], [cacheRetentionTime])",
                "name": "StreamGraph::source",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "colNames",
                        "name": "colNames"
                    },
                    {
                        "full": "colTypes",
                        "name": "colTypes"
                    },
                    {
                        "full": "[asyncWrite=true]",
                        "name": "asyncWrite",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[compress=true]",
                        "name": "compress",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[cacheSize]",
                        "name": "cacheSize",
                        "optional": true
                    },
                    {
                        "full": "[retentionMinutes=1440]",
                        "name": "retentionMinutes",
                        "optional": true,
                        "default": "1440"
                    },
                    {
                        "full": "[flushMode=0]",
                        "name": "flushMode",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[preCache]",
                        "name": "preCache",
                        "optional": true
                    },
                    {
                        "full": "[cachePurgeTimeColumn]",
                        "name": "cachePurgeTimeColumn",
                        "optional": true
                    },
                    {
                        "full": "[cachePurgeInterval]",
                        "name": "cachePurgeInterval",
                        "optional": true
                    },
                    {
                        "full": "[cacheRetentionTime]",
                        "name": "cacheRetentionTime",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [StreamGraph::source](https://docs.dolphindb.cn/zh/funcs/s/StreamGraph_source.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nStreamGraph::source(name, colNames, colTypes, \\[asyncWrite=true], \\[compress=true], \\[cacheSize], \\[retentionMinutes=1440], \\[flushMode=0], \\[preCache], \\[cachePurgeTimeColumn], \\[cachePurgeInterval], \\[cacheRetentionTime])\n\n#### 详情\n\n在 Orca 中，`source` 接口用于创建持久化共享流数据表，并将其作为流图输入节点。\n\n当指定的流表已存在时，source 将直接绑定该已有流表，并校验提供的 schema 与已存在表的 schema 是否一致，不一致时将抛出 schema 冲突错误。\n\n关于持久化共享流数据表，请参考 [enableTableShareAndPersistence](https://docs.dolphindb.cn/zh/funcs/e/enableTableShareAndPersistence.html)。\n\n#### 参数\n\n**name** 表示流表的名称。字符串标量，可以传入完整的流表全限定名（如 \"trading.orca\\_table.trades\"）；也可以仅提供流表名（如 \"trades\"），系统会根据当前的 catalog 设置自动补全为对应的全限定名。\n\n**colNames** 是一个向量，表示列名。\n\n**colTypes** 是一个向量，表示每列的数据类型，支持数组向量类型和元组（ANY）类型。可使用表示数据类型的系统保留字或相应的字符串。\n\n**asyncWrite** 可选参数，是一个布尔值，表示是否异步持久化数据到磁盘。默认值为 true，流数据写入内存即为写入成功，持久化到磁盘的操作将会由另一个线程执行。\n\n**Note:**\n\n持久化数据到磁盘包含两个步骤：\n\n* 写内存数据到操作系统缓存\n\n* 写缓存数据到磁盘（是否开启同步刷盘由参数 *flushMode* 决定）\n\n**compress** 可选参数，是一个布尔值，表示是否以压缩模式模式保存至磁盘。默认值为 true。\n\n**cacheSize** 可选参数，整数，表示流数据表在内存中最多保留多少行。如果未指定该参数，则所有记录行都会保存在内存中。如果 *cacheSize* 小于 1000，它会被自动调整为 1000。\n\n**retentionMinutes** 可选参数，是一个整数，表示文件大小超过 1GB的 log 文件的保留时间(从文件的最后修改时间开始计算)，单位是分钟。默认值是 1440，即一天。如果 log 文件未达 1GB，则会一直保留至大小达到 1GB。\n\n**flushMode** 可选参数，是一个整数，表示是否开启同步刷盘，取值只能为 0 或 1。默认值是 0，表示异步刷盘，内存中的流数据写入操作系统缓存即为写入成功，并进行下一批数据的写入。 若为 1，则表示同步刷盘，当前批次的流数据必须落盘完成，才会进行下一批数据的写入。\n\n**preCache** 可选参数，是一个整数，表示从磁盘加载到内存的记录条数。如果没有指定该参数，重启后实际加载到内存的数据量受 *cacheSize* 限制。\n\n**cachePurgeTimeColumn** 可选参数，字符串标量，需要指定为持久化流表中的时间列名称。\n\n**cachePurgeInterval** 可选参数，DURATION 类型标量，表示触发清理内存中数据的时间间隔。\n\n**cacheRetentionTime** 可选参数，DURATION 类型标量，表示内存中数据的最长保留期限。\n\n#### 返回值\n\n一个 DStream 对象。\n\n#### 例子\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\ng = createStreamGraph(\"indicators\")\ng.source(\"trade\", `time`symbol`price`volume, [DATETIME,SYMBOL,DOUBLE,LONG])\n```\n"
    },
    "StreamGraph::sourceByName": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/StreamGraph_sourceByName.html",
        "signatures": [
            {
                "full": "StreamGraph::sourceByName(name)",
                "name": "StreamGraph::sourceByName",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    }
                ]
            }
        ],
        "markdown": "### [StreamGraph::sourceByName](https://docs.dolphindb.cn/zh/funcs/s/StreamGraph_sourceByName.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nStreamGraph::sourceByName(name)\n\n#### 详情\n\n按表名引用流图中已提交（即已经通过 submit 注册）的共享流表对象。\n\n#### 参数\n\n**name** 表示流表的名称。字符串标量，可以传入完整的流表全限定名（如 \"trading.orca\\_table.trades\"）；也可以仅提供流表名（如 \"trades\"），系统会根据当前的 catalog 设置自动补全为对应的全限定名。\n\n#### 返回值\n\n一个 DStream 对象。\n\n#### 例子\n\n首先创建并提交流图 “aggregation”。\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\naggGraph = createStreamGraph(\"aggregation\")\naggGraph.source(\"trade\", `time`sym`price, [TIMESTAMP, SYMBOL, FLOAT])\n  .timeSeriesEngine(windowSize=60, step=60, metrics=[<sum(price) as price>], timeColumn=\"time\", keyColumn=\"sym\")\n  .sink(\"aggregated\")\naggGraph.submit()\n```\n\n在另一个流图中，通过 `sourceByName` 引用已提交流图 “aggregation” 中的输出流表 \"aggregated\"。\n\n```\ndef EMA(S, N) {\n\treturn ::ewmMean(S, span = N, adjust = false)\n}\nindicatorGraph = createStreamGraph(\"indicators\")\nindicatorGraph.sourceByName(\"aggregated\")\n  .reactiveStateEngine(metrics=[<EMA(price, 20)>], keyColumn=`sym)\n  .sink(\"indicators\")\nindicatorGraph.submit()\n```\n"
    },
    "StreamGraph::str": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/StreamGraph_str.html",
        "signatures": [
            {
                "full": "StreamGraph::str()",
                "name": "StreamGraph::str",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [StreamGraph::str](https://docs.dolphindb.cn/zh/funcs/s/StreamGraph_str.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nStreamGraph::str()\n\n#### 详情\n\n以字符串格式输出流图拓扑结构。\n\n#### 返回值\n\nSTRING 类型标量。\n\n#### 例子\n\n```\n// g 是流图\ng.str()\n\n/*\n当 g 尚未提交\n{name=engine_3, id=3, subgraphId=-1, taskId=-1, type=REACTIVE_STATE_ENGINE, parallelism=1} ---> {name=mycl.orca_table.one_min_indicators, id=4, subgraphId=-1, taskId=-1, type=TABLE, parallelism=1}\n    properties(from)={type=REACTIVE_STATE_ENGINE, schema=[SYMBOL,DATETIME,DOUBLE,DOUBLE,DOUBLE,LONG,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE], arguments= [engine_3,(< time >,< high >,< low >,< close >,< volume >,< EMA(close, 20) as ema20 >,< EMA(close, 60) as ema60 >,< MACD(close) as `dif`dea`macd >,< KDJ(close, high, low) as `k`d`j >),[DATETIME,SYMBOL,DOUBLE,DOUBLE,DOUBLE,DOUBLE,LONG],[SYMBOL,DATETIME,DOUBLE,DOUBLE,DOUBLE,LONG,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE],symbol,,,,,,,,,,]}\n    properties(to)={type=TABLE, id_=76ed5cea-16b3-22a9-3446-3a2eaf2d7083, schema=[SYMBOL,DATETIME,DOUBLE,DOUBLE,DOUBLE,LONG,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE], filterColumn_=}\n    edge={id=3, partition=FORWARD, handler=[]}\n{name=mycl.orca_table.one_min_bar, id=2, subgraphId=-1, taskId=-1, type=TABLE, parallelism=1} ---> {name=engine_3, id=3, subgraphId=-1, taskId=-1, type=REACTIVE_STATE_ENGINE, parallelism=1}\n    properties(from)={type=TABLE, id_=39008be5-47a0-b09f-6045-58e2abe24d72, schema=[DATETIME,SYMBOL,DOUBLE,DOUBLE,DOUBLE,DOUBLE,LONG], filterColumn_=}\n    properties(to)={type=REACTIVE_STATE_ENGINE, schema=[SYMBOL,DATETIME,DOUBLE,DOUBLE,DOUBLE,LONG,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE], arguments= [engine_3,(< time >,< high >,< low >,< close >,< volume >,< EMA(close, 20) as ema20 >,< EMA(close, 60) as ema60 >,< MACD(close) as `dif`dea`macd >,< KDJ(close, high, low) as `k`d`j >),[DATETIME,SYMBOL,DOUBLE,DOUBLE,DOUBLE,DOUBLE,LONG],[SYMBOL,DATETIME,DOUBLE,DOUBLE,DOUBLE,LONG,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE],symbol,,,,,,,,,,]}\n    edge={id=2, partition=FORWARD, handler=[]}\n{name=mycl.orca_table.trade, id=0, subgraphId=-1, taskId=-1, type=TABLE, parallelism=1} ---> {name=engine_1, id=1, subgraphId=-1, taskId=-1, type=TIME_SERIES_ENGINE, parallelism=1}\n    properties(from)={type=TABLE, id_=1d690e44-22aa-049c-ad47-83aa48f75add, schema=[DATETIME,SYMBOL,DOUBLE,LONG], filterColumn_=}\n    properties(to)={type=TIME_SERIES_ENGINE, schema=[DATETIME,SYMBOL,DOUBLE,DOUBLE,DOUBLE,DOUBLE,LONG], arguments= [engine_1,60,60,(< first(price) as open >,< max(price) as high >,< min(price) as low >,< last(price) as close >,< sum(volume) as volume >),[DATETIME,SYMBOL,DOUBLE,LONG],[DATETIME,SYMBOL,DOUBLE,DOUBLE,DOUBLE,DOUBLE,LONG],time,,symbol,,,,,,,,,,,,,,,]}\n    edge={id=0, partition=FORWARD, handler=[]}\n{name=engine_1, id=1, subgraphId=-1, taskId=-1, type=TIME_SERIES_ENGINE, parallelism=1} ---> {name=mycl.orca_table.one_min_bar, id=2, subgraphId=-1, taskId=-1, type=TABLE, parallelism=1}\n    properties(from)={type=TIME_SERIES_ENGINE, schema=[DATETIME,SYMBOL,DOUBLE,DOUBLE,DOUBLE,DOUBLE,LONG], arguments= [engine_1,60,60,(< first(price) as open >,< max(price) as high >,< min(price) as low >,< last(price) as close >,< sum(volume) as volume >),[DATETIME,SYMBOL,DOUBLE,LONG],[DATETIME,SYMBOL,DOUBLE,DOUBLE,DOUBLE,DOUBLE,LONG],time,,symbol,,,,,,,,,,,,,,,]}\n    properties(to)={type=TABLE, id_=39008be5-47a0-b09f-6045-58e2abe24d72, schema=[DATETIME,SYMBOL,DOUBLE,DOUBLE,DOUBLE,DOUBLE,LONG], filterColumn_=}\n    edge={id=1, partition=FORWARD, handler=[]}  \n*/\n\n\n/*\n当 g 已经提交\n{name=channel_6, id=6, subgraphId=2, taskId=0, type=CHANNEL, parallelism=1} ---> {name=engine_3, id=3, subgraphId=2, taskId=0, type=REACTIVE_STATE_ENGINE, parallelism=1}\n    properties(from)={type=CHANNEL, schema=[SYMBOL,DATETIME,DOUBLE,DOUBLE,DOUBLE,LONG,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE], arguments= [channel_6,[SYMBOL,DATETIME,DOUBLE,DOUBLE,DOUBLE,LONG,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE],aebdc8bf-1fe8-c0a5-6149-3b1b250d66d3,[SYMBOL,DATETIME,DOUBLE,DOUBLE,DOUBLE,LONG,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE]]}\n    properties(to)={type=REACTIVE_STATE_ENGINE, schema=[SYMBOL,DATETIME,DOUBLE,DOUBLE,DOUBLE,LONG,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE], arguments= [engine_3,(< time >,< high >,< low >,< close >,< volume >,< EMA(close, 20) as ema20 >,< EMA(close, 60) as ema60 >,< MACD(close) as `dif`dea`macd >,< KDJ(close, high, low) as `k`d`j >),[DATETIME,SYMBOL,DOUBLE,DOUBLE,DOUBLE,DOUBLE,LONG],[SYMBOL,DATETIME,DOUBLE,DOUBLE,DOUBLE,LONG,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE],symbol,,,,,,,,,,]}\n    edge={id=7, partition=FORWARD, handler=[]}\n{name=engine_3, id=3, subgraphId=2, taskId=0, type=REACTIVE_STATE_ENGINE, parallelism=1} ---> {name=mycl.orca_table.one_min_indicators, id=4, subgraphId=2, taskId=0, type=TABLE, parallelism=1}\n    properties(from)={type=REACTIVE_STATE_ENGINE, schema=[SYMBOL,DATETIME,DOUBLE,DOUBLE,DOUBLE,LONG,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE], arguments= [engine_3,(< time >,< high >,< low >,< close >,< volume >,< EMA(close, 20) as ema20 >,< EMA(close, 60) as ema60 >,< MACD(close) as `dif`dea`macd >,< KDJ(close, high, low) as `k`d`j >),[DATETIME,SYMBOL,DOUBLE,DOUBLE,DOUBLE,DOUBLE,LONG],[SYMBOL,DATETIME,DOUBLE,DOUBLE,DOUBLE,LONG,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE],symbol,,,,,,,,,,]}\n    properties(to)={type=TABLE, id_=76ed5cea-16b3-22a9-3446-3a2eaf2d7083, schema=[SYMBOL,DATETIME,DOUBLE,DOUBLE,DOUBLE,LONG,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE], filterColumn_=}\n    edge={id=3, partition=FORWARD, handler=[]}\n{name=engine_1, id=1, subgraphId=1, taskId=2, type=TIME_SERIES_ENGINE, parallelism=1} ---> {name=mycl.orca_table.one_min_bar, id=2, subgraphId=1, taskId=2, type=TABLE, parallelism=1}\n    properties(from)={type=TIME_SERIES_ENGINE, schema=[DATETIME,SYMBOL,DOUBLE,DOUBLE,DOUBLE,DOUBLE,LONG], arguments= [engine_1,60,60,(< first(price) as open >,< max(price) as high >,< min(price) as low >,< last(price) as close >,< sum(volume) as volume >),[DATETIME,SYMBOL,DOUBLE,LONG],[DATETIME,SYMBOL,DOUBLE,DOUBLE,DOUBLE,DOUBLE,LONG],time,,symbol,,,,,,,,,,,,,,,]}\n    properties(to)={type=TABLE, id_=39008be5-47a0-b09f-6045-58e2abe24d72, schema=[DATETIME,SYMBOL,DOUBLE,DOUBLE,DOUBLE,DOUBLE,LONG], filterColumn_=}\n    edge={id=1, partition=FORWARD, handler=[]}\n{name=mycl.orca_table.trade, id=0, subgraphId=0, taskId=1, type=TABLE, parallelism=1} ---> {name=channel_5, id=5, subgraphId=1, taskId=2, type=CHANNEL, parallelism=1}\n    properties(from)={type=TABLE, id_=1d690e44-22aa-049c-ad47-83aa48f75add, schema=[DATETIME,SYMBOL,DOUBLE,LONG], filterColumn_=}\n    properties(to)={type=CHANNEL, schema=[DATETIME,SYMBOL,DOUBLE,DOUBLE,DOUBLE,DOUBLE,LONG], arguments= [channel_5,[DATETIME,SYMBOL,DOUBLE,DOUBLE,DOUBLE,DOUBLE,LONG],e57e4a2d-663f-9eb6-004d-e777b4adda89,[DATETIME,SYMBOL,DOUBLE,DOUBLE,DOUBLE,DOUBLE,LONG]]}\n    edge={id=4, partition=FORWARD, handler=[]}\n{name=channel_5, id=5, subgraphId=1, taskId=2, type=CHANNEL, parallelism=1} ---> {name=engine_1, id=1, subgraphId=1, taskId=2, type=TIME_SERIES_ENGINE, parallelism=1}\n    properties(from)={type=CHANNEL, schema=[DATETIME,SYMBOL,DOUBLE,DOUBLE,DOUBLE,DOUBLE,LONG], arguments= [channel_5,[DATETIME,SYMBOL,DOUBLE,DOUBLE,DOUBLE,DOUBLE,LONG],e57e4a2d-663f-9eb6-004d-e777b4adda89,[DATETIME,SYMBOL,DOUBLE,DOUBLE,DOUBLE,DOUBLE,LONG]]}\n    properties(to)={type=TIME_SERIES_ENGINE, schema=[DATETIME,SYMBOL,DOUBLE,DOUBLE,DOUBLE,DOUBLE,LONG], arguments= [engine_1,60,60,(< first(price) as open >,< max(price) as high >,< min(price) as low >,< last(price) as close >,< sum(volume) as volume >),[DATETIME,SYMBOL,DOUBLE,LONG],[DATETIME,SYMBOL,DOUBLE,DOUBLE,DOUBLE,DOUBLE,LONG],time,,symbol,,,,,,,,,,,,,,,]}\n    edge={id=5, partition=FORWARD, handler=[]}\n{name=mycl.orca_table.one_min_bar, id=2, subgraphId=1, taskId=2, type=TABLE, parallelism=1} ---> {name=channel_6, id=6, subgraphId=2, taskId=0, type=CHANNEL, parallelism=1}\n    properties(from)={type=TABLE, id_=39008be5-47a0-b09f-6045-58e2abe24d72, schema=[DATETIME,SYMBOL,DOUBLE,DOUBLE,DOUBLE,DOUBLE,LONG], filterColumn_=}\n    properties(to)={type=CHANNEL, schema=[SYMBOL,DATETIME,DOUBLE,DOUBLE,DOUBLE,LONG,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE], arguments= [channel_6,[SYMBOL,DATETIME,DOUBLE,DOUBLE,DOUBLE,LONG,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE],aebdc8bf-1fe8-c0a5-6149-3b1b250d66d3,[SYMBOL,DATETIME,DOUBLE,DOUBLE,DOUBLE,LONG,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE]]}\n    edge={id=6, partition=FORWARD, handler=[]}  \n*/\n```\n"
    },
    "StreamGraph::submit": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/StreamGraph_submit.html",
        "signatures": [
            {
                "full": "StreamGraph::submit([checkpointConfig])",
                "name": "StreamGraph::submit",
                "parameters": [
                    {
                        "full": "[checkpointConfig]",
                        "name": "checkpointConfig",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [StreamGraph::submit](https://docs.dolphindb.cn/zh/funcs/s/StreamGraph_submit.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nStreamGraph::submit(\\[checkpointConfig])\n\n#### 详情\n\n提交流图。\n\n在集群部署模式下，必须在计算节点上执行该函数，且执行用户必须是管理员用户或具备 COMPUTE\\_GROUP\\_EXEC 权限的用户，才能成功提交任务。若在单节点部署环境中使用，则无需进行权限校验，可直接提交。\n\n#### 参数\n\n**checkpointConfig** 可选参数，一个字典，指定了流图 checkpoint 相关配置。可用配置如下：\n\n| **key**                  | **解释**                                                         | **value 取值** | **默认值** |\n| ------------------------ | -------------------------------------------------------------- | ------------ | ------- |\n| enable                   | 是否开启 Checkpoint                                                | true/false   | false   |\n| interval                 | 触发 Checkpoint 的时间间隔，单位为毫秒                                      | \\[10秒, 1年]   | 1小时     |\n| timeout                  | Checkpoint 的超时时间，即在指定时间内无法完成的 Checkpoint 将判定为失败，单位毫秒           | \\[1秒，1小时]    | 10分钟    |\n| alignedTimeout           | Barrier 对齐的超时时间，即在指定时间内无法完成 Barrier 对齐的Checkpoint 将被判定为失败，单位毫秒 | \\[100毫秒，1小时] | 10分钟    |\n| minIntervalBetweenCkpt   | 从上一个 Checkpoint 完成到下一个 Checkpoint 发起之间的最小时间间隔                  | \\[0，1年]      | 0       |\n| consecutiveFailures      | Checkpoint 最大连续失败次数。超过该次数后会导致整个流图的状态转换为 ERROR。                 | \\[0, 102400] | 3       |\n| maxConcurrentCheckpoints | 允许 Checkpoint 并发个数。请注意，允许并发Checkpoint可能会对运行中的流计算任务产生影响。        | \\[1, 102400] | 1       |\n| maxRetainedCheckpoints   | 系统会定期清理历史 Checkpoint 的数据，该配置项用于设置最多保留多少个最新的 Checkpoint 数据。     | \\[1， 1024]   | 3       |\n\n#### 例子\n\n提交流图 g 并通过参数指定 checkpoint 设置。\n\n关于提交与使用流图的详细说明，请参见[主题页](https://docs.dolphindb.cn/zh/stream/orca.html)。\n\n```\nif (!existsCatalog(\"demo\")) {\n\tcreateCatalog(\"demo\")\n}\ngo\nuse catalog demo\n\n// 配置参数字典\nckptConfig = {\n    \"enable\":true,\n    \"interval\": 10000,\n    \"timeout\": 36000,\n    \"maxConcurrentCheckpoints\": 1\n};\n\n// 指定要计算的指标，此处仅作简单示意\naggregators = [\n    <first(price) as open>,\n    <max(price) as high>,\n    <min(price) as low>,\n    <last(price) as close>,\n    <sum(volume) as volume>\n]\nindicators = [\n    <time>,\n    <high>,\n    <low>,\n    <close>,\n    <volume>\n]\n\n// 定义流图\ng = createStreamGraph(\"indicators\") \ng.source(\"trade\", `time`symbol`price`volume, [DATETIME,SYMBOL,DOUBLE,LONG])\n    .timeSeriesEngine(windowSize=60, step=60, metrics=aggregators, timeColumn=`time, keyColumn=`symbol)\n    .buffer(\"one_min_bar\")\n    .reactiveStateEngine(metrics=indicators, keyColumn=`symbol)\n    .buffer(\"one_min_indicators\")\n\n// 提交流图，同时配置 checkpoint \ng.submit(ckptConfig)\n```\n\n**相关函数：**[getOrcaCheckpointConfig](https://docs.dolphindb.cn/zh/funcs/g/getOrcaCheckpointConfig.html), [setOrcaCheckpointConfig](https://docs.dolphindb.cn/zh/funcs/s/setOrcaCheckpointConfig.html) （更多相关函数，请参见[主题页](https://docs.dolphindb.cn/zh/stream/orca.html)）\n"
    },
    "StreamGraph::toGraphviz": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/StreamGraph_toGraphviz.html",
        "signatures": [
            {
                "full": "StreamGraph::toGraphviz()",
                "name": "StreamGraph::toGraphviz",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [StreamGraph::toGraphviz](https://docs.dolphindb.cn/zh/funcs/s/StreamGraph_toGraphviz.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nStreamGraph::toGraphviz()\n\n#### 详情\n\n以 Graphviz 格式输出流图拓扑结构。\n\n#### 返回值\n\nSTRING 类型标量。\n\n#### 例子\n\n```\n// g 是流图\ng.toGraphviz()\n\n/*\n当 g 尚未提交\ndigraph G {\n  \"4: demo.orca_table.one_min_indicators\" [shape=box];\n  \"3: engine_3\" [shape=ellipse];\n  \"2: demo.orca_table.one_min_bar\" [shape=box];\n  \"0: demo.orca_table.trade\" [shape=box];\n  \"1: engine_1\" [shape=ellipse];\n  \"3: engine_3\" -> \"4: demo.orca_table.one_min_indicators\";\n  \"2: demo.orca_table.one_min_bar\" -> \"3: engine_3\";\n  \"0: demo.orca_table.trade\" -> \"1: engine_1\";\n  \"1: engine_1\" -> \"2: demo.orca_table.one_min_bar\";\n}\n*/\n\n/*\n当 g 已经提交\ndigraph G {\n  subgraph cluster_graph_2 { subgraph cluster_task_0 { label=\"task_0\" \"6: channel_6\" [shape=ellipse]; } }\n  subgraph cluster_graph_2 { subgraph cluster_task_0 { label=\"task_0\" \"3: engine_3\" [shape=ellipse]; } }\n  subgraph cluster_graph_2 { subgraph cluster_task_0 { label=\"task_0\" \"4: demo.orca_table.one_min_indicators\" [shape=box]; } }\n  subgraph cluster_graph_1 { subgraph cluster_task_2 { label=\"task_2\" \"2: demo.orca_table.one_min_bar\" [shape=box]; } }\n  subgraph cluster_graph_0 { subgraph cluster_task_1 { label=\"task_1\" \"0: demo.orca_table.trade\" [shape=box]; } }\n  subgraph cluster_graph_1 { subgraph cluster_task_2 { label=\"task_2\" \"1: engine_1\" [shape=ellipse]; } }\n  subgraph cluster_graph_1 { subgraph cluster_task_2 { label=\"task_2\" \"5: channel_5\" [shape=ellipse]; } }\n  \"6: channel_6\" -> \"3: engine_3\" [label=\"FORWARD\"];\n  \"3: engine_3\" -> \"4: demo.orca_table.one_min_indicators\" [label=\"FORWARD\"];\n  \"1: engine_1\" -> \"2: demo.orca_table.one_min_bar\" [label=\"FORWARD\"];\n  \"0: demo.orca_table.trade\" -> \"5: channel_5\" [label=\"FORWARD\"];\n  \"5: channel_5\" -> \"1: engine_1\" [label=\"FORWARD\"];\n  \"2: demo.orca_table.one_min_bar\" -> \"6: channel_6\" [label=\"FORWARD\"];\n}\n*/\n```\n"
    },
    "StreamGraph::updateRule": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/StreamGraph_updateRule.html",
        "signatures": [
            {
                "full": "StreamGraph::updateRule(engineName, key, rules)",
                "name": "StreamGraph::updateRule",
                "parameters": [
                    {
                        "full": "engineName",
                        "name": "engineName"
                    },
                    {
                        "full": "key",
                        "name": "key"
                    },
                    {
                        "full": "rules",
                        "name": "rules"
                    }
                ]
            }
        ],
        "markdown": "### [StreamGraph::updateRule](https://docs.dolphindb.cn/zh/funcs/s/StreamGraph_updateRule.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\nStreamGraph::updateRule(engineName, key, rules)\n\n#### 详情\n\n更新流图中规则引擎的规则集：\n\n* 如果此规则引擎中存在指定的规则 *key*，则修改其 value 为输入参数 *rules*。\n\n* 如果此规则引擎中不存在这个规则 *key*，则向其增加此规则 *key* 及其 *rules*。\n\n与接口 `updateRule` 的核心区别在于：\n\n* 通过 `StreamGraph::updateRule` 执行的规则变更会被系统自动持久化，确保服务重启后所有已提交的规则修改能被加载并继续生效。\n\n* 通过 `updateRule` 对规则的变更仅限于内存，修改将在服务重启后失效。\n\n#### 参数\n\n**engineName** STRING 类型标量，引擎的全限定名（如 \"catalog\\_name.orca\\_engine.engine\\_name\"）。\n\n**key** 是 STRING 或 INT 类型的标量，表示要更新的规则对应的 key 。\n\n**rules** 是一个元代码元组，表示要更新的规则对应的 value。\n\n#### 例子\n\n```\ncreateCatalog(\"demo\")\ngo\nuse catalog demo\n\n// 设置规则集\nx = [1, 2, NULL]\ny = [ [ < value > 1 > ], [ < price < 2 >, < price > 6 > ], [ < value*price > 10 > ] ]\nruleSets = dict(x, y)\n\n// 创建并提交流图\ng = createStreamGraph(\"updateRuleDemo\")\ng.source(\"trades\", `sym`value`price`quantity, [INT, DOUBLE, DOUBLE, DOUBLE])\n    .ruleEngine(ruleSets=ruleSets, outputColumns=[\"sym\",\"value\",\"price\"], policy=\"all\", ruleSetColumn=\"sym\")\n    .setEngineName(\"myRuleEngine\")\n    .sink(\"output\")\ng.submit()\n\n// 修改规则\ng.updateRule(\"demo.orca_engine.myRuleEngine\", 1, [<value>=0>])\n```\n\n相关函数：[StreamGraph::deleteRule](https://docs.dolphindb.cn/zh/funcs/s/StreamGraph_deleteRule.html), [updateRule](https://docs.dolphindb.cn/zh/funcs/u/updateRule.html)\n"
    },
    "streamTable": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/streamTable.html",
        "signatures": [
            {
                "full": "streamTable(X, [X1], [X2], .....)",
                "name": "streamTable",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[X1]",
                        "name": "X1",
                        "optional": true
                    },
                    {
                        "full": "[X2]",
                        "name": "X2",
                        "optional": true
                    },
                    {
                        "full": ".....",
                        "name": "....."
                    }
                ]
            },
            {
                "full": "streamTable(capacity:size, colNames, colTypes)",
                "name": "streamTable",
                "parameters": [
                    {
                        "full": "capacity:size",
                        "name": "capacity:size"
                    },
                    {
                        "full": "colNames",
                        "name": "colNames"
                    },
                    {
                        "full": "colTypes",
                        "name": "colTypes"
                    }
                ]
            }
        ],
        "markdown": "### [streamTable](https://docs.dolphindb.cn/zh/funcs/s/streamTable.html)\n\n\n\n#### 语法\n\nstreamTable(X, \\[X1], \\[X2], .....)\n\n或\n\nstreamTable(capacity:size, colNames, colTypes)\n\n#### 详情\n\n创建[流数据表](https://docs.dolphindb.cn/zh/stream/str_table.html)。流数据表可处理并发的读写操作。\n\n#### 参数\n\n第一种用法中，**X**, **X1**, **X2** ... 可以是向量、数组向量、矩阵或元组。每个向量、元组、数组向量的长度，以及矩阵中每列长度都必须相同。**当 Xk 是元组时：**\n\n* 若 Xk 的元素是等长的向量，\\*\\*元组的每个元素将作为表的一列。\\*\\*元组的长度必须等于表的行数。\n\n* 若 Xk 包含不同类型或不等长元素，\\*\\*则将单独作为表的一列（列类型为 ANY），其每个元素将作为该列每行的元素值。\\*\\*Xk 的长度仍然必须和表的行数保持一致。\n\n第二种用法中：\n\n* **capacity** 是正整数，表示建表时系统为该表分配的内存（以记录数为单位）。当记录数超过 *capacity* 时，系统首先会分配 *capacity* 1.2\\~2倍的新的内存空间，然后复制数据到新的内存空间，最后释放原来的内存。对于规模较大的表，此类操作的内存占用会很高。因此，建议建表时预先分配一个合理的 *capacity*。\n\n* **size** 是整数，表示该表新建时的行数。若 *size* =0，创建一个空表。 若 *size*>0，则建立一个只包含 size 条记录的表，记录初始值如下：\n\n  * BOOL 类型默认值为 false；\n\n  * 数值类型、时间类型、IPADDR、COMPLEX、POINT 的默认值为 0；\n\n  * Literal, INT128 类型的默认值为 NULL。\n\n  **Note:** 如果 *colTypes* 指定为数组向量， *size* 必须为0。\n\n* **colNames** 是一个向量，表示列名。\n\n* **colTypes** 是一个向量，表示每列的数据类型，支持数组向量类型和元组（ANY）类型。可使用表示数据类型的系统保留字或相应的字符串。\n\n#### 返回值\n\n一个流表对象。\n\n#### 例子\n\n```\nid=`XOM`GS`AAPL\nx=102.1 33.4 73.6\n\nrt=streamTable(id, x);\n\nrt=streamTable(`XOM`GS`AAPL as id, 102.1 33.4 73.6 as x);\n\ncolName=[\"Name\",\"Age\"]\ncolType=[\"string\",\"int\"]\nrt=streamTable(100:10, colName, colType);\n```\n"
    },
    "stretch": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/stretch.html",
        "signatures": [
            {
                "full": "stretch(X, n)",
                "name": "stretch",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "n",
                        "name": "n"
                    }
                ]
            }
        ],
        "markdown": "### [stretch](https://docs.dolphindb.cn/zh/funcs/s/stretch.html)\n\n\n\n#### 语法\n\nstretch(X, n)\n\n#### 详情\n\n*X* 是向量/元组时，将 *X* 均匀拉伸为长度为 n 的向量/元组。\n\n*X* 是矩阵/表时，将 *X* 均匀拉伸为行数为 *n* 的矩阵/表。\n\n该函数与 [take](https://docs.dolphindb.cn/zh/funcs/t/take.html) 的区别为：\n\n`take` 是对向量整体进行循环拼接，而 `stretch` 则是对向量的每一个元素进行复制达到拉伸的效果。\n\n#### 参数\n\n**X** 向量/元组/矩阵/表。\n\n**n** 非负整数。\n\n#### 返回值\n\n与 *X* 形式相同的对象。\n\n#### 例子\n\n```\nX = 1 NULL 2 3\nprint stretch(X, 11)\n```\n\n返回：\\[1,1,1,,,,2,2,2,3,3]\n\n```\nprint stretch(X, 12)\n```\n\n返回：\\[1,1,1,,,,2,2,2,3,3,3]\n\n以下用 `take` 做比较：\n\n```\nprint take(X, 10)\n```\n\n返回：\\[1,,2,3,1,,2,3,1,]\n\n另一个例子：\n\n```\nY=array(INT[], 0, 10).append!([1 NULL 3, 4 5, 6 NULL 8, 9 10]);\nprint stretch(Y,7)\n```\n\n返回：\\[\\[1,00i,3],\\[1,00i,3],\\[4,5],\\[4,5],\\[6,00i,8],\\[6,00i,8],\\[9,10]]\n\n```\ns=[1 2 3, 4 5 6]\nstretch(s, 5)\n```\n\n返回：\n\n|       | 0          | 1          | 2          | 3          | 4          |\n| ----- | ---------- | ---------- | ---------- | ---------- | ---------- |\n| **0** | \\[1, 2, 3] | \\[1, 2, 3] | \\[1, 2, 3] | \\[4, 5, 6] | \\[4, 5, 6] |\n\n```\nm=matrix(1 2 3, 4 5 6)\nstretch(m,5)\n```\n\n返回：\n\n| col1 | col2 |\n| ---- | ---- |\n| 1    | 4    |\n| 1    | 4    |\n| 2    | 5    |\n| 2    | 5    |\n| 3    | 6    |\n\n```\nt=table(1 2 3 as a, 4 5 6 as b)\nstretch(t,5)\n```\n\n返回：\n\n| a | b |\n| - | - |\n| 1 | 4 |\n| 1 | 4 |\n| 2 | 5 |\n| 2 | 5 |\n| 3 | 6 |\n"
    },
    "string": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/string.html",
        "signatures": [
            {
                "full": "string(X)",
                "name": "string",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [string](https://docs.dolphindb.cn/zh/funcs/s/string.html)\n\n\n\n#### 语法\n\nstring(X)\n\n#### 详情\n\n将输入转化为一个字符串。\n\n#### 参数\n\n**X** 可以是任何数据类型。\n\n#### 返回值\n\n返回值的数据形式与 *X* 一致。\n\n#### 例子\n\n```\nstring()==\"\";  // 创建一个新的字符串，默认值为\"\"。\n```\n\n返回：true\n\n```\nstring(10);\n```\n\n返回：10\n\n```\ntypestr string(108.5);\n```\n\n返回：STRING\n\n```\nstring(now());\n```\n\n返回：2024.02.22T15:09:40.931\n\n**Note:** 以 字符串形式返回当前系统时间。\n"
    },
    "stringFormat": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/stringFormat.html",
        "signatures": [
            {
                "full": "stringFormat(format, [args...])",
                "name": "stringFormat",
                "parameters": [
                    {
                        "full": "format",
                        "name": "format"
                    },
                    {
                        "full": "[args...]",
                        "name": "[args...]"
                    }
                ]
            }
        ],
        "markdown": "### [stringFormat](https://docs.dolphindb.cn/zh/funcs/s/stringFormat.html)\n\n\n\n#### 语法\n\nstringFormat(format, \\[args...])\n\n#### 详情\n\n对字符串进行格式化处理，即将用户传入的值按指定的格式进行处理后填充到字符串中。在占位符内部，可以通过格式符指定进制格式、字段宽度、精度、对齐方式等选项，以便对输出进行更精确的控制。\n\n表一：占位符支持的数据类型列表\n\n| 类型            | 占位符(%数据类型符号) | args 示例                                                      |\n| ------------- | ------------ | ------------------------------------------------------------ |\n| BOOL          | %b           | 1b, 0b, true, false                                          |\n| CHAR          | %c           | 'a', 97c                                                     |\n| SHORT         | %h           | 122h                                                         |\n| 十进制整数（INT）    | %i           | 21                                                           |\n| 八进制整数         | %o           | 31                                                           |\n| 十六进制整数（小写）    | %x           | 2f                                                           |\n| 十六进制整数（大写）    | %X           | 2F                                                           |\n| LONG          | %l           | 25l                                                          |\n| DATE          | %d           | 2022.01.01                                                   |\n| MONTH         | %M           | 2022.05M                                                     |\n| TIME          | %t           | 13:00:10.706                                                 |\n| MINUTE        | %m           | 13:30m                                                       |\n| SECOND        | %s           | 13:30:10                                                     |\n| DATETIME      | %D           | 2012.06.13 13:30:10, 2012.06.13T13:30:10                     |\n| TIMESTAMP     | %T           | 2012.06.13 13:30:10.008, 2012.06.13T13:30:10.008             |\n| NANOTIME      | %n           | 13:30:10.008007006                                           |\n| NANOTIMESTAMP | %N           | 2012.06.13 13:30:10.008007006, 2012.06.13T13:30:10.008007006 |\n| FLOAT         | %f           | 2.1f                                                         |\n| DOUBLE        | %F           | 2.1                                                          |\n| SYMBOL        | %S           | symbol(\\[\"aaa\",\"bbb\"])                                       |\n| STRING        | %W           | \"Hello\"                                                      |\n| ANY（元组）       | %A           | (1, 45, 'sah')                                               |\n\n注意：若字符串包含 \"%\" ，则须通过百分号进行转义，即写为 \"%%\" 。\n\n在占位符内部（即在`%`与数据类型符号之间）插入一个或多个格式化操作符，对输出格式进行控制，书写形式为 `%[(var)][#][±][0][m/*][.][n/*]数据类型符号`。\n\n表二：以小数点为分隔，下表解释小数点前的部分支持的符号：\n\n| 符号        | 功能                                                                                                                                                                                                               | 用法示例                                                                                                                                                      |\n| --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| m （一个正整数） | 支持在 %f, %F, %W 中使用。- 当占位符类型是 f 或 F 时，表示输出字符串的**最小**总宽度，默认使用空格填充宽度。 当 m 小于浮点数实际位数时，输出完整的浮点数（保留至小数点后六位）；当 m 大于浮点数实际位数时，默认填充空格。- 当占位符类型是 W 时，表示输出字符串的**最小**位数：当 m 小于字符串长度时，输出完整的字符串；当 m 大于字符串长度时，默认填充空格。默认对齐方式为右对齐。 | `stringFormat(\"%10f\", pi)`输出：`··3.141593` `stringFormat(\"%2f\", 12345.0)`输出：`12345.000000``stringFormat(\"%10W\", \"6chars\")`输出：`····6chars`                  |\n| \\*        | 与 m 功能类似，通过参数（*args*）指定输出字符串的宽度。在对应的 *args* 中指定具体宽度数值，形式为一个元组：`(宽度值，格式化字符串)`。                                                                                                                                    | 定义宽度：`stringFormat(\"%*f\", (10,pi))`输出：\\`··3.141593\\`                                                                                                      |\n| 0         | 当宽度不足时，在输出的字符串前填充“0”来实现指定宽度（左对齐时，从右边开始填充）。若不指定，则使用空格填充。                                                                                                                                                          | `stringFormat(\"%010f\", pi)`输出：`003.141593`                                                                                                                |\n| -         | 左对齐，仅适用于数值类型。若不指定该符号，则默认为右对齐。                                                                                                                                                                                    | `stringFormat(\"%-10.3f\", pi)`输出：`3.142`                                                                                                                   |\n| +         | 在正数前显示加号（+）。                                                                                                                                                                                                     | `stringFormat('%+f', pi)`输出：`+3.141593`                                                                                                                   |\n| (var)     | 映射变量，var 只能是字典形式。不可与其他操作符混用。                                                                                                                                                                                     | `employee = {\"name\":\"Lisa Mill\", \"year\":2010} stringFormat(\"%(name)W joined the company in %(year)i\", employee)`输出：`Lisa Mill joined the company in 2010` |\n| #         | 在八进制数前显示 “0o”；在十六进制前显示 ”0x“ （当数据类型符号为 “x“时）或者 “0X”（当数据类型符号为 “X” 时）。                                                                                                                                              | `stringFormat(\"%#o\", 33)`输出：`0o41``stringFormat(\"%#X\", 33)`输出：`0X21`                                                                                      |\n\n表三：小数点后的部分支持的符号（**仅支持在 %f, %F 和 %W 中使用**）：\n\n| 符号       | 功能                                                                                                                                      | 用法示例                                                                                                                                   |\n| -------- | --------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------- |\n| n（一个正整数） | - 当占位符类型是 f 或 F 时，表示小数点后保留位数。若 n 小于浮点数的小数位数，则会将浮点数四舍五入至指定位数；若该数字大于浮点数的小数位数，则会补零对齐。- 当占位符类型是 W 时，表示保留字符串位数。n 小于字符串长度时对字符串截断，大于字符串长度时不补充。 | `stringFormat(\"%10.5f\", pi)`输出：`···3.14159` `stringFormat('%10.3f' , 3.1)`输出：`·····3.100``stringFormat(\"%2.10W\", \"6chars\")`输出：`6chars` |\n| \\*       | 与 n 功能类似，在对应的 *args* 中指定输出字符串的小数点后的位数，形式为一个元组：`([宽度], [精度值], 格式化字符串的值)`。                                                                | 定义小数点后位数：`stringFormat(\"%.*f\", (5,pi))`输出：`3.14159`同时定义宽度与小数点位数：`stringFormat(\"%0*.*f\", (10,5,pi))`输出：`···3.14159`                     |\n\n#### 参数\n\n**format** 包含0个或多个占位符的字符串。\n\n**args...** 可选参数，1个或多个填入格式化字符串的值。若指定，则其数量和数据类型必须与 *format* 中的占位符的数量和类型一致。若不指定，则直接输出 *format*。\n\n#### 返回值\n\nSTRING 类型标量。\n\n#### 例子\n\n```\nstringFormat(\"date: %d, time: %t\", 2022.12.01, 10:12:45.065)\n```\n\n输出返回：date: 2022.12.01, time: 10:12:45.065\n\n```\nstringFormat(\"Students account for %i%% of our customers.\", 50)\n```\n\n输出返回：Students account for 50% of our customers.\n\n```\nt = datetime(now())\nstringFormat(\"The current time is %D.\", t)\n```\n\n输出返回：The current time is 2023.01.02T20:36:03.\n\n```\na = 7.596\nstringFormat(\"%-+10.5f\", a)\n```\n\n输出返回：+7.59600\n\n```\nstringFormat(\"%010.3f\", a) \n```\n\n输出返回：000007.596\n\n```\nproduct = {\"item\":\"Eggs\", \"price_per_unit\":2}\nstringFormat(\"%(item)W: $ %(price_per_unit)i\", product)\n```\n\n输出返回：Eggs: $ 2\n"
    },
    "strip": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/strip.html",
        "signatures": [
            {
                "full": "strip(X)",
                "name": "strip",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [strip](https://docs.dolphindb.cn/zh/funcs/s/strip.html)\n\n\n\n#### 语法\n\nstrip(X)\n\n#### 详情\n\n去掉首尾所有空格，制表符，换行和回车符号。\n\n#### 参数\n\n**X** 是字符串标量或向量。\n\n#### 返回值\n\nSTRING 类型，数据形式与输入参数相同。\n\n#### 例子\n\n```\nx=\"\\nhello world\\t\\n\";\nx;\n\n// output\nhello world\n\nstrip x;\n// output\nhello world\n```\n\n相关函数：[trim](https://docs.dolphindb.cn/zh/funcs/t/trim.html)\n"
    },
    "strlen": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/strlen.html",
        "signatures": [
            {
                "full": "strlen(X)",
                "name": "strlen",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [strlen](https://docs.dolphindb.cn/zh/funcs/s/strlen.html)\n\n\n\n#### 语法\n\nstrlen(X)\n\n#### 详情\n\n获取目标字符串的长度。\n\n#### 参数\n\n**X** 是目标字符串。它可以是标量或向量。\n\n#### 返回值\n\nINT 类型标量或向量。\n\n#### 例子\n\n```\nstrlen('abcdefg');\n// output\n7\n\nstrlen(\"I am a boy.\");\n// output\n11\n\nstrlen([\"abc\",\"123456789\"]);\n// output\n[3,9]\n```\n"
    },
    "strlenu": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/strlenu.html",
        "signatures": [
            {
                "full": "strlenu(X)",
                "name": "strlenu",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [strlenu](https://docs.dolphindb.cn/zh/funcs/s/strlenu.html)\n\n\n\n#### 语法\n\nstrlenu(X)\n\n#### 详情\n\n用于获取 Unicode 编码的目标字符串的长度。\n\n#### 参数\n\n**X** 是一个字符串标量或向量。\n\n#### 返回值\n\nINT 类型标量或向量。\n\n#### 例子\n\n```\nstrlenu(\"高性能分布式时序数据库\")\n// output\n11\n\n\nstrlenu([\"高性能分布式时序数据库\",\"DolphinDB\"])\n// output\n[11,9]\n```\n"
    },
    "strpos": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/strpos.html",
        "signatures": [
            {
                "full": "strpos(X, str)",
                "name": "strpos",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "str",
                        "name": "str"
                    }
                ]
            }
        ],
        "markdown": "### [strpos](https://docs.dolphindb.cn/zh/funcs/s/strpos.html)\n\n\n\n#### 语法\n\nstrpos(X, str)\n\n别名：strFind\n\n#### 详情\n\n检查 *X* 是否包含 *str*。\n\n#### 参数\n\n**X** 是在该字符串中搜索。它可以是标量或向量。\n\n**str** 是被搜索的目标字符串。它可以是标量或向量。\n\n#### 返回值\n\n如果 X 中包含 str，返回 str 在 X 中的起始位置； 否则返回-1。\n\n#### 例子\n\n```\nstrpos(\"abcdefg\",\"cd\");\n// output\n2\n\nstrpos(\"abcdefg\",\"d\");\n// output\n3\n\nstrpos(\"abcdefg\",\"ah\");\n// output\n-1\n```\n"
    },
    "strReplace": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/strReplace.html",
        "signatures": [
            {
                "full": "strReplace(str, pattern, replacement)",
                "name": "strReplace",
                "parameters": [
                    {
                        "full": "str",
                        "name": "str"
                    },
                    {
                        "full": "pattern",
                        "name": "pattern"
                    },
                    {
                        "full": "replacement",
                        "name": "replacement"
                    }
                ]
            }
        ],
        "markdown": "### [strReplace](https://docs.dolphindb.cn/zh/funcs/s/strReplace.html)\n\n\n\n#### 语法\n\nstrReplace(str, pattern, replacement)\n\n#### 详情\n\n返回 *str* 的副本。如果 *str* 包含 *pattern*，则将 *pattern* 替换为 *replacement*。\n\n#### 参数\n\n**str** 是目标字符串。它可以是标量或向量。\n\n**pattern** 是被替换的字符串。\n\n**replacement** 是替换的字符串。\n\n#### 返回值\n\nSTRING 类型标量或向量。\n\n#### 例子\n\n```\nstrReplace(\"The ball is red.\", \"red\", \"green\");\n// output\nThe ball is green.\n\nstrReplace([\"The ball is red.\", \"The car is red too.\"], \"red\", \"yellow\");\n// output\n[\"The ball is yellow.\",\"The car is yellow too.\"]\n```\n"
    },
    "sub": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/sub.html",
        "signatures": [
            {
                "full": "sub(X, Y)",
                "name": "sub",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [sub](https://docs.dolphindb.cn/zh/funcs/s/sub.html)\n\n\n\n#### 语法\n\nsub(X, Y) 或 X-Y\n\n#### 详情\n\n逐元素地返回 *X* 和 *Y* 的差。如果 *X* 和 *Y* 是集合， `sub` 返回一个集合，它是从 *X* 中减去 *X* 和 *Y* 相同元素后的集合。\n\n#### 参数\n\n**X** 和 **Y** 可以是标量、数据对、向量、矩阵或集合。如果 *X* 或 *Y* 的其中一个是数据对、向量或矩阵，另一个参数可以是标量或具有相同长度或维度的数据对、向量或矩阵。\n\n#### 返回值\n\n一个标量、数据对、向量、矩阵或集合。\n\n#### 例子\n\n```\n4:5-2;\n// output\n2 : 3\n\n4:5-1:2;\n// output\n3 : 3\n\nx=1 2 3;\nx-1;\n// output\n[0,1,2]\n\n1 sub x;\n// output\n[0,-1,-2]\n\ny=4 5 6;\nsub(x,y);\n// output\n[-3,-3,-3]\n\nm1=1..6$2:3;\nm1;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1  | 3  | 5  |\n| 2  | 4  | 6  |\n\n```\nm-2;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| -1 | 1  | 3  |\n| 0  | 2  | 4  |\n\n```\nm2=6..1$2:3;\nm2;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 6  | 4  | 2  |\n| 5  | 3  | 1  |\n\n```\nm1-m2;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| -5 | -1 | 3  |\n| -3 | 1  | 5  |\n\n```\nx=set([5,3,4]);\ny=set(8 9 4 6);\nx-y;\n// output\nset(3,5)\n\ny-x;\n// output\nset(6,9,8)\n```\n"
    },
    "subarray": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/subarray.html",
        "signatures": [
            {
                "full": "subarray(X, range)",
                "name": "subarray",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "range",
                        "name": "range"
                    }
                ]
            }
        ],
        "markdown": "### [subarray](https://docs.dolphindb.cn/zh/funcs/s/subarray.html)\n\n\n\n#### 语法\n\nsubarray(X, range)\n\n#### 详情\n\n当使用某个向量的一部分元素进行计算时，例如若使用 close\\[10:].avg() 的语句，系统会从向量 close 中复制数据产生一个新的向量 close\\[10:] 再进行计算，不仅占用更多内存而且耗时。\n\n`subarray` 函数返回输入向量的一个子向量。它是原向量的一个视图，只记录了原向量的指针以及子向量的开始和结束位置。由于并没有分配大块内存来存储新向量，所以没有发生数据复制。所有向量的只读操作都可直接应用于 `subarray` 。\n\n#### 参数\n\n**X** 可以是向量或矩阵。\n\n**range** 是表示范围的数据对，范围包括下限，不包括上限。若 *range* 不在 \\[0, size(X)-1] 内，则超出 \\[0, size(X)-1] 的值所对应的位置返回空值。\n\n#### 返回值\n\n一个向量。\n\n#### 例子\n\n```\nx=1..100\nsubarray(x, 10:20);\n// output\n[11,12,13,14,15,16,17,18,19,20]\n\n\nsubarray(x, 90:);\n// output\n[91,92,93,94,95,96,97,98,99,100]\n\n\nsubarray(x, :10);\n// output\n[1,2,3,4,5,6,7,8,9,10]\n\n\na=rand(1000.0,20000000);\ntimer a.subarray(0:1000000).avg();\n// output\nTime elapsed: 1.5 ms\n\ntimer a[0:1000000].avg();\n// output\nTime elapsed: 8 ms\n\n\n// subarray is read-only:\nb=a.subarray(0:1000000);\nb[0]=1;\n// output\nb[0] = 1 => Immutable sub vector doesn't support method set\n```\n"
    },
    "submitJob": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/submitJob.html",
        "signatures": [
            {
                "full": "submitJob(jobId, jobDesc, jobDef, args...)",
                "name": "submitJob",
                "parameters": [
                    {
                        "full": "jobId",
                        "name": "jobId"
                    },
                    {
                        "full": "jobDesc",
                        "name": "jobDesc"
                    },
                    {
                        "full": "jobDef",
                        "name": "jobDef"
                    },
                    {
                        "full": "args...",
                        "name": "args..."
                    }
                ]
            }
        ],
        "markdown": "### [submitJob](https://docs.dolphindb.cn/zh/funcs/s/submitJob.html)\n\n\n\n#### 语法\n\nsubmitJob(jobId, jobDesc, jobDef, args...)\n\n#### 详情\n\n把批处理作业提交到本地节点并且返回作业的 ID。如果要把批处理作业提交到远程节点，需要结合使用 `rpc` 或 [remoteRun](https://docs.dolphindb.cn/zh/funcs/r/remoteRun.html) 函数。详情请参考 [BatchJobManagement](https://docs.dolphindb.cn/zh/sys_man/BatchJobManagement.html)。\n\n注意：递归函数体内不可调用 `submitJob` 异步提交任务，否则可能导致节点 crash。\n\n#### 参数\n\n**jobId** 是作业的 ID，是字符串类型。\n\n**jobDesc** 是字符串，用于描述作业。\n\n**jobDef** 是用于定义作业的本地函数。请注意，该参数是一个函数对象，而不是表示函数名的字符串，因此不可使用引号。\n\n**args...** 是函数的参数。如果函数没有参数，可以不指定。\n\n#### 返回值\n\nSTRING 类型标量，表示作业的 ID。\n\n#### 例子\n\n把作业提交到本地节点：\n\n```\ndef jobDemo(n){\n    s = 0\n    for (x in 1 : n) {\n        s += sum(sin rand(1.0, 100000000)-0.5)\n        print(\"iteration \" + x + \" \" + s)\n    }\n    return s\n};\n\nsubmitJob(\"jobDemo1\",\"job demo\", jobDemo, 100);\n// output\njobDemo1\n\ngetJobStatus(\"jobDemo1\");\n```\n\n| node      | userID | jobId    | rootJobId                            | jobDesc  | priority | parallelism | clientIp  | clientPort | receivedTime            | startTime               | endTime | errorMsg |\n| --------- | ------ | -------- | ------------------------------------ | -------- | -------- | ----------- | --------- | ---------- | ----------------------- | ----------------------- | ------- | -------- |\n| local8848 | guest  | jobDemo1 | d1d76cad-d46f-338c-4179-21cface3ce7c | job demo | 4        | 2           | 127.0.0.1 | 62016      | 2023.12.12T17:52:01.576 | 2023.12.12T17:52:01.585 |         |          |\n\n在作业的状态中，endTime 为空，这意味着作业还在执行中。作业完成后，就能在状态中看到 endTime 的值。\n\n```\ngetJobStatus(\"jobDemo1\");\n```\n\n| node      | userID | jobId    | rootJobId                            | jobDesc  | priority | parallelism | clientIp  | clientPort | receivedTime            | startTime               | endTime                 | errorMsg |\n| --------- | ------ | -------- | ------------------------------------ | -------- | -------- | ----------- | --------- | ---------- | ----------------------- | ----------------------- | ----------------------- | -------- |\n| local8848 | guest  | jobDemo1 | d1d76cad-d46f-338c-4179-21cface3ce7c | job demo | 4        | 2           | 127.0.0.1 | 62016      | 2023.12.12T17:52:01.576 | 2023.12.12T17:52:01.585 | 2023.12.12T17:53:23.204 |          |\n\n```\ngetJobMessage(\"jobDemo1\");\n\n// output\n2023-12-12 17:52:01.586399 Start the job [jobDemo1]: job demo\n2023-12-12 17:52:02.550241 iteration 1 1094.345887943766229\n2023-12-12 17:52:03.417464 iteration 2 3167.431462436133642\n2023-12-12 17:52:04.463558 iteration 3 5265.929786668073575\n...\n2023-12-12 17:53:21.609843 iteration 97 25681.096442654183192\n2023-12-12 17:53:22.401263 iteration 98 25609.952331757223873\n2023-12-12 17:53:23.204495 iteration 99 23660.316042780508723\n2023-12-12 17:53:23.204495 The job is done.\n\ngetJobReturn(\"jobDemo1\");\n// output\n924.915703\n\nsubmitJob(\"jobDemo2\",, jobDemo, 10);\n// output\njobDemo2\n\ngetRecentJobs();\n```\n\n| node      | userID | jobId    | rootJobId                            | jobDesc  | priority | parallelism | clientIp  | clientPort | receivedTime            | startTime               | endTime                 | errorMsg |\n| --------- | ------ | -------- | ------------------------------------ | -------- | -------- | ----------- | --------- | ---------- | ----------------------- | ----------------------- | ----------------------- | -------- |\n| local8848 | guest  | jobDemo1 | d1d76cad-d46f-338c-4179-21cface3ce7c | job demo | 4        | 2           | 127.0.0.1 | 62016      | 2023.12.12T17:52:01.576 | 2023.12.12T17:52:01.585 | 2023.12.12T17:53:23.204 |          |\n| local8848 | guest  | jobDemo2 | def84639-5b21-c6b0-47be-986b4563e192 | jobDemo  | 4        | 2           | 127.0.0.1 | 62016      | 2023.12.12T17:57:42.325 | 2023.12.12T17:57:42.327 | 2023.12.12T17:57:49.995 |          |\n\n把作业提交到远程节点：\n\n使用 `rpc` 函数（\"DFS\\_NODE2\" 与本地节点在同一集群）：\n\n```\ndef jobDemo(n){\n    s = 0\n    for (x in 1 : n) {\n        s += sum(sin rand(1.0, 100000000)-0.5)\n        print(\"iteration \" + x + \" \" + s)\n    }\n    return s\n}\n\nrpc(\"DFS_NODE2\", submitJob, \"jobDemo3\", \"job demo\", jobDemo, 10);\n// output\nOutput: jobDemo3\n\n\nrpc(\"DFS_NODE2\", getJobReturn, \"jobDemo3\");\n// output\nOutput: -3426.577521\n```\n\n* 使用 `remoteRun` 函数或 `remoteRunWithCompression` 函数，这里以 `remoteRun` 为例：\n\n```\nconn = xdb(\"DFS_NODE2\")\nconn.remoteRun(submitJob, \"jobDemo4\", \"job demo\", jobDemo, 10);\n// output\nOutput: jobDemo4\n\nconn.remoteRun(getJobReturn, \"jobDemo4\");\n// output\nOutput: 4238.832005\n```\n"
    },
    "submitJobEx": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/submitJobEx.html",
        "signatures": [
            {
                "full": "submitJobEx(jobId, jobDesc, priority, parallelism, jobDef, args...)",
                "name": "submitJobEx",
                "parameters": [
                    {
                        "full": "jobId",
                        "name": "jobId"
                    },
                    {
                        "full": "jobDesc",
                        "name": "jobDesc"
                    },
                    {
                        "full": "priority",
                        "name": "priority"
                    },
                    {
                        "full": "parallelism",
                        "name": "parallelism"
                    },
                    {
                        "full": "jobDef",
                        "name": "jobDef"
                    },
                    {
                        "full": "args...",
                        "name": "args..."
                    }
                ]
            }
        ],
        "markdown": "### [submitJobEx](https://docs.dolphindb.cn/zh/funcs/s/submitJobEx.html)\n\n\n\n#### 语法\n\nsubmitJobEx(jobId, jobDesc, priority, parallelism, jobDef, args...)\n\n#### 详情\n\n把批处理作业提交到本地节点并且返回作业的ID。`submitJobEx` 与 [submitJob](https://docs.dolphindb.cn/zh/funcs/s/submitJob.html) 的唯一区别在于 `submitJobEx` 中可以指定参数 *priority* 与 *parallelism*。\n\n注意：递归函数体内不可调用 `submitJobEx` 异步提交任务，否则可能导致节点 crash。\n\n#### 参数\n\n**jobId** 是作业的 ID，是字符串类型。\n\n**jobDesc** 是字符串，用于描述作业。\n\n**priority** 是0到9之间的整数，表示作业的优先级。9表示优先级最高。\n\n**parallelism** 是正整数，表示分配给该作业的线程数上限。\n\n**jobDef** 是用于定义作业的本地函数。请注意，该参数是一个函数对象，而不是表示函数名的字符串，因此不可使用引号。\n\n**args...** 是函数的参数。如果函数没有参数，它可以不指定。\n\n#### 返回值\n\nSTRING 类型标量，表示作业的 ID。\n\n#### 例子\n\n```\ndef jobDemo(n){\n    s = 0\n    for (x in 1 : n) {\n        s += sum(sin rand(1.0, 100000000)-0.5)\n        print(\"iteration \" + x + \" \" + s)\n    }\n    return s\n};\n\nsubmitJobEx(\"jobDemo1\",\"job demo\", 8, 12, jobDemo, 100);\n```\n"
    },
    "submitJobEx2": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/submitJobEx2.html",
        "signatures": [
            {
                "full": "submitJobEx2(jobId, jobDesc, priority, parallelism, onComplete, jobDef, args...)",
                "name": "submitJobEx2",
                "parameters": [
                    {
                        "full": "jobId",
                        "name": "jobId"
                    },
                    {
                        "full": "jobDesc",
                        "name": "jobDesc"
                    },
                    {
                        "full": "priority",
                        "name": "priority"
                    },
                    {
                        "full": "parallelism",
                        "name": "parallelism"
                    },
                    {
                        "full": "onComplete",
                        "name": "onComplete"
                    },
                    {
                        "full": "jobDef",
                        "name": "jobDef"
                    },
                    {
                        "full": "args...",
                        "name": "args..."
                    }
                ]
            }
        ],
        "markdown": "### [submitJobEx2](https://docs.dolphindb.cn/zh/funcs/s/submitJobEx2.html)\n\n\n\n#### 语法\n\nsubmitJobEx2(jobId, jobDesc, priority, parallelism, onComplete, jobDef, args...)\n\n#### 详情\n\n提交批处理作业到本地节点并返回作业的 ID，待作业完成后，执行回调函数。\n\n**Note:**\n\n* `submitJobEx2` 与 [submitJobEx](https://docs.dolphindb.cn/zh/funcs/s/submitJobEx.html) 的区别在于：执行完成后，`submitJobEx2` 会执行回调函数。\n* 注意：递归函数体内不可调用 `submitJobEx2` 异步提交任务，否则可能导致节点 crash。\n\n#### 参数\n\n**jobId** 是作业的 ID，字符串类型。\n\n**jobDesc** 是字符串，用于描述作业。\n\n**priority** 是 0 到 9 之间的整数，表示作业的优先级。9 表示优先级最高。\n\n**parallelism** 是正整数，表示分配给该作业的线程数上限。\n\n**onComplete** 是回调函数，当批处理作业执行完毕（包括有异常的情况）后，会执行该函数。该函数接受 4 个参数：\n\n* jobId：作业的ID\n\n* jobDesc：作业的描述。\n\n* success：布尔值，表示作业是否执行成功。\n\n* result：作业的结果。\n\n**jobDef** 是用于定义作业的本地函数。\n\n**Note:** 该参数是一个函数对象，而非表示函数名的字符串，因此不可使用引号。\n\n**args…** 是函数的参数。如果函数没有参数，它可以不指定。\n\n#### 返回值\n\nSTRING 类型标量，表示作业的 ID。\n\n#### 例子\n\n```\ndef jobDemo(n){\n    s = 0\n    for (x in 1 : n) {\n        s += sum(sin rand(1.0, 100000000)-0.5)\n        print(\"iteration \" + x + \" \" + s)\n    }\n    return s\n}\n\ndef cbFunc(jobId, jobDesc, success, result){\n    desc = jobId + \" \" + jobDesc\n    if(success){\n        desc += \" successful \" + result\n    }\n    else{\n        desc += \" with error: \" + result\n    }\n    writeLog(desc)\n}\n\nsubmitJobEx2(\"jobDemo1\",\"job demo\", 8, 12, cbFunc, jobDemo, 100)\n```\n"
    },
    "subscribeStreamingSQL": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/subscribeStreamingSQL.html",
        "signatures": [
            {
                "full": "subscribeStreamingSQL([server], queryId,[batchSize=0],[throttle=1],[hash=-1])",
                "name": "subscribeStreamingSQL",
                "parameters": [
                    {
                        "full": "[server]",
                        "name": "server",
                        "optional": true
                    },
                    {
                        "full": "queryId",
                        "name": "queryId"
                    },
                    {
                        "full": "[batchSize=0]",
                        "name": "batchSize",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[throttle=1]",
                        "name": "throttle",
                        "optional": true,
                        "default": "1"
                    },
                    {
                        "full": "[hash=-1]",
                        "name": "hash",
                        "optional": true,
                        "default": "-1"
                    }
                ]
            }
        ],
        "markdown": "### [subscribeStreamingSQL](https://docs.dolphindb.cn/zh/funcs/s/subscribeStreamingSQL.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\nsubscribeStreamingSQL(\\[server], queryId,\\[batchSize=0],\\[throttle=1],\\[hash=-1])\n\n#### 详情\n\n订阅指定的流式 SQL 查询结果。订阅端会接收增量日志，并基于这些日志维护一个实时更新的共享结果表，保证查询结果随数据变更持续刷新。\n\n#### 参数\n\n**server** 可选参数，字符串标量，表示运行流式 SQL 查询的节点（即注册该查询的服务器）的别名或远程连接句柄。如果未指定或者为空字符串，表示流式 SQL 查询所在的服务器是本地实例。\n\n**queryId** 字符串标量，表示要订阅的流式 SQL 查询 ID。\n\n**batchSize** 可选参数，整数标量，默认值为0。\n\n* 正数：累计未处理日志数达到 *batchSize* 时才处理。\n* 非正数或未指定：每批日志到达即处理。\n\n**throttle** 可选参数，浮点数，单位为秒，默认值为1。表示继上次处理日志消息之后，若 *batchSize* 条件一直未达到，多久后再次处理消息。\n\n* 如果没有指定 *batchSize*，*throttle* 即使指定，也不起作用。\n* 若 *throttle* 需要设置小于1秒，则需要先修改配置项 *subThrottle*。\n\n**hash** 可选参数，非负整数，指定由某个订阅线程处理进入的日志消息。如果没有指定该参数，系统会自动分配一个线程。如果需要使用同一个线程来处理多个订阅任务的消息，可把这些订阅任务的 hash 设置为相同的值。\n\n#### 返回值\n\n一个表，包含流式 SQL 查询结果列。\n\n#### 例子\n\n```\nt=table(1..10 as id,rand(100,10) as val)\nshare t as st\ndeclareStreamingSQLTable(st)\nregisterStreamingSQL(\"select avg(val) from st\",\"sql_avg\") \n\nsubscribeStreamingSQL(queryId=\"sql_avg\")\n```\n\n| avg\\_val |\n| -------- |\n| 64.3     |\n\n**相关函数：**[declareStreamingSQLTable](https://docs.dolphindb.cn/zh/funcs/d/declareStreamingSQLTable.html), [registerStreamingSQL](https://docs.dolphindb.cn/zh/funcs/r/registerStreamingSQL.html), [unsubscribeStreamingSQL](https://docs.dolphindb.cn/zh/funcs/u/unsubscribeStreamingSQL.html)\n"
    },
    "subscribeTable": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/subscribeTable.html",
        "signatures": [
            {
                "full": "subscribeTable([server],tableName,[actionName],[offset=-1],handler,[msgAsTable=false],[batchSize=0],[throttle=1],[hash=-1],[reconnect=false],[filter],[persistOffset=false],[timeTrigger=false],[handlerNeedMsgId=false],[raftGroup],[userId=\"\"],[password=\"\"],[udpMulticast=false])",
                "name": "subscribeTable",
                "parameters": [
                    {
                        "full": "[server]",
                        "name": "server",
                        "optional": true
                    },
                    {
                        "full": "tableName",
                        "name": "tableName"
                    },
                    {
                        "full": "[actionName]",
                        "name": "actionName",
                        "optional": true
                    },
                    {
                        "full": "[offset=-1]",
                        "name": "offset",
                        "optional": true,
                        "default": "-1"
                    },
                    {
                        "full": "handler",
                        "name": "handler"
                    },
                    {
                        "full": "[msgAsTable=false]",
                        "name": "msgAsTable",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[batchSize=0]",
                        "name": "batchSize",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[throttle=1]",
                        "name": "throttle",
                        "optional": true,
                        "default": "1"
                    },
                    {
                        "full": "[hash=-1]",
                        "name": "hash",
                        "optional": true,
                        "default": "-1"
                    },
                    {
                        "full": "[reconnect=false]",
                        "name": "reconnect",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[filter]",
                        "name": "filter",
                        "optional": true
                    },
                    {
                        "full": "[persistOffset=false]",
                        "name": "persistOffset",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[timeTrigger=false]",
                        "name": "timeTrigger",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[handlerNeedMsgId=false]",
                        "name": "handlerNeedMsgId",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[raftGroup]",
                        "name": "raftGroup",
                        "optional": true
                    },
                    {
                        "full": "[userId=\"\"]",
                        "name": "userId",
                        "optional": true,
                        "default": "\"\""
                    },
                    {
                        "full": "[password=\"\"]",
                        "name": "password",
                        "optional": true,
                        "default": "\"\""
                    },
                    {
                        "full": "[udpMulticast=false]",
                        "name": "udpMulticast",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [subscribeTable](https://docs.dolphindb.cn/zh/funcs/s/subscribeTable.html)\n\n\n\n#### 语法\n\nsubscribeTable(\\[server],tableName,\\[actionName],\\[offset=-1],handler,\\[msgAsTable=false],\\[batchSize=0],\\[throttle=1],\\[hash=-1],\\[reconnect=false],\\[filter],\\[persistOffset=false],\\[timeTrigger=false],\\[handlerNeedMsgId=false],\\[raftGroup],\\[userId=\"\"],\\[password=\"\"],\\[udpMulticast=false])\n\n#### 详情\n\n从客户端节点订阅本地或远程服务器的流数据表。可在 *handler* 调用函数来处理订阅数据。\n\n跨集群订阅 Orca 流表，需先完成多集群配置，通过指定 *tableName* 实现。若跨集群订阅的 Orca 表是一个高可用流表，其所属的 *raftGroup* 在本地集群存在一个 Learner，则订阅时将优先订阅本地副本。\n\n* 如果指定了 *batchSize*，当未处理消息数量达到 *batchSize* 或距离上次 *handler* 被触发已过去 *throttle* 秒，*handler* 将会被触发。\n\n* 如果订阅的表被重定义了，为了保证订阅能够正常使用，需要使用 [unsubscribeTable](https://docs.dolphindb.cn/zh/funcs/u/unsubscribeTable.html) 命令取消订阅，然后重新创建订阅。\n\n* 在高可用订阅流数据写入分布式表的场景下，订阅节点构成的 raft 组发生 leader 切换或集群重启时，可能导致之前登录的用户退出。由于 guest 用户无权限写入分布式表，写入会被中断（可以通过 [getCurrentSessionAndUser](https://docs.dolphindb.cn/zh/funcs/g/getCurrentSessionAndUser.html) 函数查看当前的用户）。若配置 *userId* 和 *password* 参数，用户退出后系统会自动尝试重新登录，以保证订阅数据成功写入分布式表。需要注意的是，从 2.00.10.10 开始，用户可以通过配置项 *enhancedSecurityVerification* 控制在登录时是否约束密码重试的次数。若不设置 *enhancedSecurityVerification*，则不约束；若设置 *enhancedSecurityVerification*=true，则当用户登录时，在1分钟内连续5次使用了错误密码，会导致用户被锁定，必须等待10分钟后才可以再次登录。\n\n如果使用 UDP 组播作为订阅发布方式，为保证组播性能，需要为发布端所在服务器的 socket 缓冲区设置合理的数值，推荐数值大于或等于 1MB。在 Linux 中的 socket 缓冲区的设置方法如下：\n\n* 在 Linux 终端中，运行以下命令：\n\n  ```\n  sudo sysctl -w net.core.rmem_default=1048576\n  sudo sysctl -w net.core.rmem_max=1048576\n  sudo sysctl -w net.core.wmem_default=1048576\n  sudo sysctl -w net.core.wmem_max=1048576\n  ```\n\n* 也可以编辑 */etc/sysctl.conf* 文件，添加或修改 *net.core.rmem\\_default*, *net.core.rmem\\_max*, *net.core.wmem\\_default* 和 *net.core.wmem\\_max* 的值为 1048576 后运行\n\n  ```\n  sudo sysctl -p\n  ```\n\n**Note:** 在 TCP 和 UDP 之间切换订阅发布方式时，需要先使用 `unsubscibeTable` 取消已有订阅，再使用 `subscribeTable` 建立新的订阅任务。\n\n**Note:** 为流数据 join 引擎订阅数据时，*handler* 参数需要为 `appendForJoin`、[getLeftStream](https://docs.dolphindb.cn/zh/funcs/g/getLeftStream.html) 或 [getRightStream](https://docs.dolphindb.cn/zh/funcs/g/getRightStream.html) 函数。\n\n#### 参数\n\n只有 **tableName** 和 **handler** 两个参数是必选参数。其他所有参数都是可选参数。\n\n**server** 是一个字符串，表示服务器的别名，实现集群内跨节点订阅；或是远程连接的句柄（通过函数 [xdb](https://docs.dolphindb.cn/zh/funcs/x/xdb.html) 获取），实现跨集群订阅。如果未指定或者为空字符串，表示流数据所在的服务器是本地实例。\n\n**tableName** 是被订阅的数据表名。该表必须为共享的流数据表。跨集群订阅 Orca 流表时，格式为`fqn@cluster_identifier`，例如 `demo.orca_table.trades@cluster_BeiJing`。\n\n**actionName** 是一个字符串，表示订阅任务的名称。它可以包含字母，数字和下划线，并以字母开头。如果一个节点有多个订阅任务均订阅了同一张表，则每个订阅必须指定唯一的 *actionName*。\n\n**offset** 是一个整数，指定订阅任务的起始位置，对应流数据表中的一行记录。正整数表示从指定位置的记录开始订阅。其特殊取值含义如下：\n\n* 当 *offset* = -1（默认）时，订阅将从流数据表的**当前最新行**开始，接收实时新增的数据。\n* 当 *offset* = 0 时，系统将从流表的**第一条记录**开始订阅。注意：若流表开启了持久化，系统会清理超过指定保留时间的数据，此时设置*offset* = 0 可能会导致订阅失败，建议指定 offset = [getPersistenceMeta](https://docs.dolphindb.cn/zh/funcs/g/getPersistenceMeta.html)(StreamTable).diskOffset，从持久化流表**磁盘上的第一行记录**开始订阅。\n* 若流表开启持久化，指定 *offset* = -2，且 *persistOffset* = true，系统会从**最后一条成功处理的消息的下一条记录**开始订阅。例如：上次成功处理了偏移量为 100 的记录，重新订阅时从偏移量 101 开始消费。\n* 当 *offset* = -3 时，从流表的**当前可获取的最早一条记录**开始订阅，包括内存中和持久化在磁盘上的数据。\n\n注意：*offset* 是相对于流数据表创建时的第一行的定位，内存数据回收不会影响持久化数据的定位。\n\n**handler** 是一元函数、二元函数或数据表，用于处理订阅的数据。\n\n* 一元函数：它唯一的参数是订阅的数据。订阅的数据可以是一个表或元组，订阅数据表的每个列是元组的一个元素。\n* *handlerNeedMsgId* = true 时，*handler* 必须是二元函数，其两个参数分别是订阅的数据（msgBody）和数据偏移量（msgId）。详见 *handlerNeedMsgId* 参数说明。\n* 数据表：可以是流数据引擎、共享流数据表、共享内存表、共享键值表、共享索引表或 DFS 表。订阅数据会直接插入到该表中。\n\n**msgAsTable** 是布尔值，表示订阅的数据是否为表。默认值是 false，表示订阅的数据是由列组成的元组。\n\n**batchSize** 是一个整数，用于指定触发消息处理的最小未处理消息数。\n\n* 当 *batchSize* > 0 时，表示当未处理消息数量累计达到或超过 *batchSize* 时，*handler* 才会处理消息。\n* 当 *batchSize* 未指定或 ≤ 0 时，*handler* 会在每批消息到达后立即处理。\n\n**Note:** *batchSize* 并不是严格的分批大小，而是一个**触发阈值**。设置 *batchSize* = n 时，*handler* **可能处理 n 条或更多消息**，而不会对上游单次发布的数据进行强制拆分。比如 *batchSize* = 300，若上游一次发布 400 条消息，则 *handler* 会一次性处理 400 条消息；若上游多次发布，每次 200 条，则在未处理的消息累计超过 300 条后触发处理。\n\n**throttle** 是一个浮点数，单位为秒，默认值为1。表示继上次 *handler* 处理消息之后，若 *batchSize* 条件一直未达到，多久后再次处理消息。如果没有指定 *batchSize*，*throttle* 即使指定，也不起作用。 若 *throttle* 需要设置小于1秒，则需要先修改配置项 *subThrottle*。\n\n**hash** 是一个非负整数，指定某个订阅线程处理进来的消息。如果没有指定该参数，系统会自动分配一个线程。如果需要使用同一个线程来处理多个订阅任务的消息，可把这些订阅任务的 hash 设置为相同的值。\n\n**reconnect** 是一个布尔值，表示订阅中断后，是否会自动重新订阅。默认值为 false。如果 *reconnect* = true，有以下三种情况：\n\n* 如果发布端与订阅端处于正常状态，但是网络中断，那么订阅端会在网络正常时，自动从中断位置重新订阅。\n* 如果发布端崩溃，订阅端会在发布端重启后不断尝试重新订阅。\n  * 如果发布端对流数据表启用了持久化，发布端重启后会首先读取硬盘上的数据，直到发布端读取到订阅中断位置的数据，订阅端才能成功重新订阅。\n  * 如果发布端没有对流数据表启用持久化，那么订阅端将自动重新订阅失败。\n* 如果订阅端崩溃，订阅端重启后不会自动重新订阅，需要重新执行 subscribeTable 函数。\n\n**Note:** 如果订阅高可用流数据表，需要设置 *reconnect* 为 true，以保证 leader 发生切换时可以成功连接新的 leader。\n\n**filter**用来指定过滤条件。主要分以下两种用法：\n\n* 若配合 [setStreamTableFilterColumn](https://docs.dolphindb.cn/zh/funcs/s/setStreamTableFilterColumn.html) 函数一起使用来指定流数据表的过滤列，则流数据表过滤列在 *filter* 中的数据才会发布到订阅端，不在 *filter* 中的数据不会发布。*filter* 不支持过滤 BOOL 类型数据。*filter* 参数可以使用以下三种方法指定。\n  * 值过滤：一个向量，向量元素类型必须与过滤列类型一致，STRING / SYMBOL / BLOB 之间可互通。\n  * 范围过滤：一个数据对。范围包含下限值，但不包括上限值。过滤列类型不支持 FLOAT、DOUBLE、DECIMAL32 / 64 / 128、UUID、IPADDR、INT128。\n  * 哈希过滤：一个元组。第一个元素表示 bucket 的个数；第二个元素是一个标量或数据对，其中标量表示 bucket 的索引（从0开始），数据对表示 bucket 的索引范围（包含下限值，但不包括上限值）。过滤列类型不支持 FLOAT、DOUBLE、DECIMAL32 / 64 / 128。\n* 若传入自定义函数进行灵活过滤，可以通过如下两种方式传入：\n\n  * 函数：直接传入一个函数，则订阅的数据会以表的形式传入函数，并把函数返回的结果发送给订阅者。\n\n  * 字符串：传入表示函数名称的字符串、匿名函数字符串、或者 lambda 表达式字符串。\n\n**persistOffset** 是一个布尔值，表示是否持久化保存最新一条已经处理的订阅数据的偏移量。持久化保存的偏移量用于重订阅，可通过 [getTopicProcessedOffset](https://docs.dolphindb.cn/zh/funcs/g/getTopicProcessedOffset.html) 函数获取。默认值为 false。\n\n**Note:**\n\n* 若要订阅高可用流数据表，需要设置 *persistOffset* 为 true，以防止订阅端丢失数据。\n* 设置 *persistOffset* 为 true，且取消订阅（`unsubscribeTable`）时，设置 *removeOffset* = false，再次订阅时才会从持久化保存的偏移量开始订阅。\n\n**timeTrigger** 是一个布尔值。若设为 true，表示即使没有新的消息进入，*handler* 也会在 *throttle* 参数所设定的时间间隔被触发。\n\n**handlerNeedMsgId** 是一个布尔值，默认值为 false。\n\n* 若设为 true，*handler* 必须支持两个参数：一个是 msgBody（传入的消息），一个是 msgId（消息的偏移量）。如：以部分应用的形式固定 [appendMsg](https://docs.dolphindb.cn/zh/funcs/a/appendMsg.html) 的 *engine* 参数后，将其作为二元应用传入 *handler*。\n* 若设为 false，*handler* 仅支持一个参数：msgBody。调用 *handler* 时，只传入消息本身。\n\n**raftGroup** 是 raft 组的 ID。设置该参数表示开启订阅端高可用，不设置则表示普通订阅。设置 *raftGroup* 参数以指定 raft 组后，在对应 raft 组内 leader 发生切换时，新的 leader 会重新订阅。\n\n**Note:** `subscribeTable` 函数如果指定了 *raftGroup*，则只能在 leader 上执行。若同时指定 *handlerNeedMsgId* = true，则 *handler* 只能是计算引擎，即 *handler* = engine(创建引擎时的句柄变量)或 *handler* = getStreamEngine(engineName)。\n\n**userId** 字符串，表示用户名。\n\n**password** 字符串，表示用户密码。\n\n**udpMulticast** 布尔值，默认为 false。用于设置是否开启 UDP （User Datagram Protocol）Multicast 数据传输协议。设置为 true 后，发布端将通过 UDP 协议、以组播的方式将订阅数据发布到组播通道上。\n\n使用 TCP 和 UDP 组播进行发布订阅的性能差异如下：\n\n<table id=\"table_tjd_4pc_bbc\"><thead><tr><th>\n\n协议\n\n</th><th>\n\n优点\n\n</th><th>\n\n缺点\n\n</th><th>\n\n适用场景\n\n</th></tr></thead><tbody><tr><td>\n\nTCP\n\n</td><td>\n\n* 数据传输可靠，能够确保按序到达订阅端\n* 能够检测和纠正传输中的错误\n\n</td><td>\n\n一对一的连接方式决定了当订阅端为多个时，需要占用发布端大量的服务器资源及网络带宽\n\n</td><td>\n\n* 可靠性要求高\n* 顺序性要求高\n\n</td></tr><tr><td>\n\nUDP Multicast\n\n</td><td>\n\n* 可以一次性将数据发布给多个订阅端，适合实时数据传输\n* 发布端服务器资源和网络带宽占用少\n\n</td><td>\n\n数据包可能会缺失或乱序\n\n</td><td>\n\n有多个订阅端、要求快速实时传输数据\n\n</td></tr></tbody>\n</table>**Note:**\n\n1. 启用该参数前，需要确保 *reconnect*, *persisitOffset*, *timeTrigger* 设置为 false，以及 *raftGroup* 设置为 -1。\n2. 目前仅 Linux 版本的 DolphinDB Server 支持该参数。\n3. 在使用该参数前，请确保发布端和接收端所在的网络的路由器或交换机是否支持 UDP Multicast 协议栈。\n\n#### 返回值\n\n字符串标量，表示订阅主题（topic），即一个订阅的名称。\n\n* 普通订阅非高可用流表时，topic 的格式为 host:port:nodeAlias/tableName/actionName。\n\n* 普通订阅高可用流表时，topic 的格式为 clusterName\\_RaftGroupId/tableName/actionName。\n\n* 高可用订阅非高可用流表时，topic 的格式为 host:port:nodeAlias/tableName/actionName/subscriberNode。\n\n* 高可用订阅高可用流表时，topic 的格式为 clusterName\\_RaftGroupId/tableName/actionName/subscriberNode\n\n#### 例子\n\n例1\n\n下面是关于流计算的例子。在本例中，集群有两个节点：DFS\\_NODE1 和 DFS\\_NODE2。我们需要在 cluster.cfg 中指定 *maxPubConnections和subPort* 参数来启动发布/订阅功能。例如：\n\n```\nmaxPubConnections=32\nDFS_NODE1.subPort=9010\nDFS_NODE1.persistenceDir=C:/DolphinDB/Data\nDFS_NODE2.subPort=9011\n```\n\n在 DFS\\_NODE1 上执行以下脚本：\n\n1. 创建一个共享的流数据表 trades\\_stream，并以同步模式保存。此时，表 trades\\_stream 有0行记录。\n\n   ```\n   n=20000000\n   colNames = `time`sym`qty`price\n   colTypes = [TIME,SYMBOL,INT,DOUBLE]\n   enableTableShareAndPersistence(table=streamTable(n:0, colNames, colTypes), tableName=\"trades_stream\", asynWrite=false, cacheSize=n)\n   go\n   ```\n\n2. 创建一个分布式表 trades。此时，表 trades 有0行记录。\n\n   ```\n   if(existsDatabase(\"dfs://STREAM_TEST\")){\n        dropDatabase(\"dfs://STREAM_TEST\")\n   }\n   dbDate = database(directory=\"\", partitionType=VALUE, partitionScheme=temporalAdd(date(today()),0..30,'d'))\n   dbSym= database(directory=\"\", partitionType=RANGE, partitionScheme=string('A'..'Z') join \"ZZZZ\")\n   db = database(directory=\"dfs://STREAM_TEST\", partitionType=COMPO, partitionScheme=[dbDate, dbSym])\n   colNames = `date`time`sym`qty`price\n   colTypes = [DATE,TIME,SYMBOL,INT,DOUBLE]\n   trades = db.createPartitionedTable(table=table(1:0, colNames, colTypes), tableName=\"trades\", partitionColumns=`date`sym)\n   ```\n\n3. 创建表 trades\\_stream 的本地订阅。使用 saveTradesToDFS 函数把表 trades\\_stream 的流数据和今天的日期保存至表 trades。\n\n   ```\n   def saveTradesToDFS(mutable dfsTrades, msg): dfsTrades.append!(select today() as date,* from msg)\n   subscribeTable(tableName=\"trades_stream\", actionName=\"trades\", offset=0, handler=saveTradesToDFS{trades}, msgAsTable=true, batchSize=100000, throttle=60)\n   ```\n\n4. 创建表 trades\\_stream 的另一个本地订阅。使用每分钟的流数据计算成交量加权平均价格（vwap），并以异步模式把结果保存至共享的流数据表 vwap\\_stream 中。\n\n   ```\n   n=1000000\n   tmpTrades = table(n:0, colNames, colTypes)\n   lastMinute = [00:00:00.000]\n   colNames = `time`sym`vwap\n   colTypes = [MINUTE,SYMBOL,DOUBLE]\n   enableTableShareAndPersistence(table=streamTable(n:0, colNames, colTypes), tableName=\"vwap_stream\")\n   go\n\n   def calcVwap(mutable vwap, mutable tmpTrades, mutable lastMinute, msg){\n       tmpTrades.append!(msg)\n       curMinute = time(msg.time.last().minute()*60000l)\n       t = select wavg(price, qty) as vwap from tmpTrades where time < curMinute, time >= lastMinute[0] group by time.minute(), sym\n       if(t.size() == 0) return\n       vwap.append!(t)\n       t = select * from tmpTrades where time >= curMinute\n       tmpTrades.clear!()\n       lastMinute[0] = curMinute\n       if(t.size() > 0) tmpTrades.append!(t)\n   }\n   subscribeTable(tableName=\"trades_stream\", actionName=\"vwap\", offset=0, handler=calcVwap{vwap_stream, tmpTrades, lastMinute}, msgAsTable=true, batchSize=100000, throttle=60)\n   ```\n\n在 DFS\\_NODE2 上执行以下脚本，创建表 trades\\_stream 的远程订阅，并以异步模式把流数据保存至表 trades\\_stream\\_slave 中。\n\n```\nn=20000000\ncolNames = `time`sym`qty`price\ncolTypes = [TIME,SYMBOL,INT,DOUBLE]\nenableTableShareAndPersistence(table=streamTable(n:0, colNames, colTypes), tableName=\"trades_stream_slave\", cacheSize=n)\ngo\nsubscribeTable(server=\"DFS_NODE1\", tableName=\"trades_stream\", actionName=\"slave\", offset=0, handler=trades_stream_slave)\n```\n\n在 DFS\\_NODE1 上执行以下脚本，模拟3支股票在10分钟内的流数据。每支股票每分钟生成2,000,000条记录。每分钟的数据被插入到流数据表 trades\\_stream 的600个数据块中。每两个数据块有100毫秒的时间间隔。\n\n```\nn=10\nticks = 2000000\nrows = ticks*3\nstartMinute = 09:30:00.000\nblocks=600\nfor(x in 0:n){\n    time = startMinute + x*60000 + rand(60000, rows)\n    indices = isort(time)\n    time = time[indices]\n    sym = array(SYMBOL,0,rows).append!(take(`IBM,ticks)).append!(take(`MSFT,ticks)).append!(take(`GOOG,ticks))[indices]\n    price = array(DOUBLE,0,rows).append!(norm(153,1,ticks)).append!(norm(91,1,ticks)).append!(norm(1106,20,ticks))[indices]\n    indices = NULL\n    blockSize = rows / blocks\n    for(y in 0:blocks){\n        range =pair(y * blockSize, (y+1)* blockSize)\n        insert into trades_stream values(subarray(time,range), subarray(sym,range), 10+ rand(100, blockSize), subarray(price,range))\n        sleep(100)\n    }\n\n    blockSize = rows % blocks\n    if(blockSize > 0){\n        range =pair(rows - blockSize, rows)\n        insert into trades_stream values(subarray(time,range), subarray(sym,range), 10+ rand(100, blockSize), subarray(price,range))\n    }\n}\n```\n\n在 DFS\\_NODE1 上执行以下脚本来检查结果：\n\n```\ntrades=loadTable(\"dfs://STREAM_TEST\", `trades)\nselect count(*) from trades\n```\n\n预期结果有 60,000,000 条记录。\n\n```\nselect * from vwap_stream\n```\n\n表 vwap\\_stream 预期有 27 条记录。\n\n在 DFS\\_NODE2 上执行以下脚本：\n\n```\nselect count(*) from trades_stream_slave\n```\n\n我们看到的结果小于 60,000,000 行，因为部分表的记录已经保存到磁盘中。\n"
    },
    "substr": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/substr.html",
        "signatures": [
            {
                "full": "substr(X, offset, [length])",
                "name": "substr",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "offset",
                        "name": "offset"
                    },
                    {
                        "full": "[length]",
                        "name": "length",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [substr](https://docs.dolphindb.cn/zh/funcs/s/substr.html)\n\n\n\n#### 语法\n\nsubstr(X, offset, \\[length])\n\n#### 详情\n\n从 *X* 的指定位置开始截取指定长度的字符串。*X* 的第一个字符的位置为0。如果 *length* 超过了 *X* 的长度，则到 *X* 的尾部结束。\n\n#### 参数\n\n**X** 是一个字符串。它可以是标量或向量。\n\n**offset** 是一个非负整数。\n\n**length** 是一个正整数。\n\n#### 返回值\n\nSTRING 类型标量或向量。\n\n#### 例子\n\n```\nsubstr(\"This is a test\", 0, 4);\n// output\nThis\n\nsubstr(\"This is a test\", 5, 2);\n// output\nis\n\nsubstr(\"This is a test\", 5);\n// output\nis a test\n\nsubstr(\"This is a test\", 8, 100);\n// output\na test\n```\n"
    },
    "substru": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/substru.html",
        "signatures": [
            {
                "full": "substru(X, offset, [length])",
                "name": "substru",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "offset",
                        "name": "offset"
                    },
                    {
                        "full": "[length]",
                        "name": "length",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [substru](https://docs.dolphindb.cn/zh/funcs/s/substru.html)\n\n\n\n#### 语法\n\nsubstru(X, offset, \\[length])\n\n#### 详情\n\n从 *X* 的指定位置开始截取指定长度的字符串。*X* 的第一个字符的位置为0。 如果 *length* 超过了 *X* 的长度，则到 *X* 的尾部结束。\n\n#### 参数\n\n**X** 是 Unicode 编码的字符串。它可以是标量或向量。\n\n**offset** 是一个非负整数。\n\n**length** 是一个正整数。\n\n#### 返回值\n\nSTRING 类型标量或向量。\n\n#### 例子\n\n```\nsubstru(\"这是测试字符串\",0,4)\n// output\n这是测试\n\nsubstru(\"这是测试字符串\",4,3)\n// output\n字符\n\nsubstru(\"这是测试字符串\",2)\n// output\n测试字符串\n\nsubstru(\"这是测试字符串\",2,10)\n// output\n测试字符串\n```\n\n相关函数：[substr](https://docs.dolphindb.cn/zh/funcs/s/substr.html)\n"
    },
    "subtuple": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/subtuple.html",
        "signatures": [
            {
                "full": "subtuple(X, range)",
                "name": "subtuple",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "range",
                        "name": "range"
                    }
                ]
            }
        ],
        "markdown": "### [subtuple](https://docs.dolphindb.cn/zh/funcs/s/subtuple.html)\n\n\n\n#### 语法\n\nsubtuple(X, range)\n\n#### 详情\n\n创建 *X* 的只读子元组。*subtuple* 几乎能在瞬间创建一个只读向量，相比之下，创建一个新的元组需要耗费更多时间。\n\n#### 参数\n\n**X** 是一个元组，它的每个元素必须是长度相同的向量。\n\n**range** 是一个整型数据对，表示范围，只包含下限不包含上限。\n\n#### 返回值\n\n一个元组。\n\n#### 例子\n\n例1：\n\n```\nx=(1..10, 11..20, 21..30, 31..40)\nsubtuple(x, 2:4);\n// output\n([3,4],[13,14],[23,24],[33,34])\n```\n\n例2：\n\n```\nm=1000.0\nn=20000000\na=(rand(m,n), rand(m,n))\nk=10000000;\ntimer each(avg, a.subtuple(0:k));\n// output\nTime elapsed: 30.87 ms\n\ntimer each(avg, (a[0][0:k], a[1][0:k]));\n// output\nTime elapsed: 46.508 ms\n```\n\n例3：\n\n```\nx=(1..10, 11..20)\nsubtuple(x, 2:4)=([4, 5], [14, 15]);\n// output\nSyntax Error: [line #2] Please use '==' rather than '=' as equal operator in non-sql expression.\n```\n\n`subtuple` 函数创建的元组只能读取，不能写入。\n"
    },
    "sum": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/sum.html",
        "signatures": [
            {
                "full": "sum(X)",
                "name": "sum",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [sum](https://docs.dolphindb.cn/zh/funcs/s/sum.html)\n\n\n\n#### 语法\n\nsum(X)\n\n#### 详情\n\n* 若 *X* 为向量，返回 *X* 中所有元素之和。\n\n* 若 *X* 为矩阵，计算每列元素之和，返回一个向量。\n\n* 若 *X* 为表，计算每列元素之和，返回一个表。\n\n与所有其它聚合函数一致，计算时忽略 NULL 值。\n\n如果 *X* 中的所有元素为 NULL，`sum` 返回的结果为 NULL。\n\n**Note:**\n\nDolphinDB `sum`、[numpy.sum](https://numpy.org/doc/stable/reference/generated/numpy.sum.html) 和 Python 内置 [sum](https://docs.python.org/3/library/functions.html#sum) 都用于求和。区别如下：\n\n* DolphinDB `sum` 是聚合函数，支持标量、向量、矩阵和表，矩阵和表按列求和，并忽略 NULL。\n* `numpy.sum` 是数组归约函数，默认对所有元素求和，可通过 *axis* 指定维度，并支持 *dtype*、*out*、*keepdims*、*initial*、*where* 等参数。\n* Python 内置 `sum` 只是对可迭代对象从左到右累加，不支持轴向计算，也不会自动忽略缺失值。\n\n#### 参数\n\n**X** 可以是标量、向量、矩阵或表。\n\n#### 返回值\n\n返回标量、向量或表。\n\n#### 例子\n\n```\nsum(1 2 3 NULL 4);\n// output\n10\n\nm=matrix(1 2 3, 4 5 6);\nm;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 4  |\n| 2  | 5  |\n| 3  | 6  |\n\n```\nsum(m);\n// output\n[6,15]\n```\n"
    },
    "sum2": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/sum2.html",
        "signatures": [
            {
                "full": "sum2(X)",
                "name": "sum2",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [sum2](https://docs.dolphindb.cn/zh/funcs/s/sum2.html)\n\n\n\n#### 语法\n\nsum2(X)\n\n#### 详情\n\n若 *X* 为向量，返回 *X* 中所有元素的平方和。\n\n若 *X* 为矩阵，计算每列元素的平方和，返回一个向量。\n\n若 *X* 为表，计算每列元素的平方和，返回一个表。\n\n与所有其它聚合函数一致，计算时忽略 NULL 值。\n\n即使 *X* 的数据类型是 INT 或 LONG, `sum2` 返回结果的数据类型总是 DOUBLE 类型。如果 *X* 中的所有元素为 NULL, `sum2` 返回的结果为 NULL。\n\n#### 参数\n\n**X** 可以是标量、向量、矩阵或表。\n\n#### 返回值\n\n返回标量、向量或表。\n\n#### 例子\n\n```\nsum2(1 2 3);\n// output\n14\n\nsum2(1 NULL NULL);\n// output\n1\n\nsum2(1.5 4.6 7.8);\n// output\n84.25\n\nm=matrix(1 2 3, 4 5 6);\nm;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 4  |\n| 2  | 5  |\n| 3  | 6  |\n\n```\nsum2(m);\n// output\n[14,77]\n```\n"
    },
    "sum3": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/sum3.html",
        "signatures": [
            {
                "full": "sum3(X)",
                "name": "sum3",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [sum3](https://docs.dolphindb.cn/zh/funcs/s/sum3.html)\n\n\n\n#### 语法\n\nsum3(X)\n\n#### 详情\n\n若 *X* 为向量，返回 *X* 中所有元素的立方和。\n\n若 *X* 为矩阵，计算每列元素的立方和，返回一个向量。\n\n若 *X* 为表，计算每列元素的立方和，返回一个表。\n\n与所有其它聚合函数一致，计算时忽略 NULL 值。\n\n即使 *X* 的数据类型是 INT 或 LONG，返回结果的数据类型总是 DOUBLE 类型。如果 *X* 中的所有元素为 NULL，返回的结果为 NULL。\n\n#### 参数\n\n**X** 可以是标量、向量、矩阵或表。\n\n#### 返回值\n\n返回标量、向量或表。\n\n#### 例子\n\n```\nsum3(1 2 3);\n// output\n36\n\nsum3(1 NULL NULL);\n// output\n1\n\nsum3(1.5 4.6 7.8);\n// output\n575.263\n\nm=matrix(1 2 3, 4 5 6);\nm;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 4  |\n| 2  | 5  |\n| 3  | 6  |\n\n```\nsum3(m);\n// output\n[36,405]\n```\n"
    },
    "sum4": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/sum4.html",
        "signatures": [
            {
                "full": "sum4(X)",
                "name": "sum4",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [sum4](https://docs.dolphindb.cn/zh/funcs/s/sum4.html)\n\n\n\n#### 语法\n\nsum4(X)\n\n#### 详情\n\n若 *X* 为向量，返回 *X* 中所有元素的四次方和。\n\n若 *X* 为矩阵，计算每列元素的四次方和，返回一个向量。\n\n若 *X* 为表，计算每列元素的四次方和，返回一个表。\n\n与所有其它聚合函数一致，计算时忽略 NULL 值。\n\n即使 *X* 的数据类型是 INT 或 LONG，返回结果的数据类型总是 DOUBLE 类型。如果 *X* 中的所有元素为 NULL，返回的结果为 NULL。\n\n#### 参数\n\n**X** 可以是标量、向量、矩阵或表。\n\n#### 返回值\n\n返回标量、向量或表。\n\n#### 例子\n\n```\nsum4(1 2 3);\n// output\n98\n\nsum4(1 NULL NULL);\n// output\n1\n\nsum4(1.5 4.6 7.8);\n// output\n4154.3137\n\nm=matrix(1 2 3, 4 5 6);\nm;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 4  |\n| 2  | 5  |\n| 3  | 6  |\n\n```\nsum4(m);\n// output\n[98,2177]\n```\n"
    },
    "sumbars": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/sumbars.html",
        "signatures": [
            {
                "full": "sumbars(X, Y)",
                "name": "sumbars",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [sumbars](https://docs.dolphindb.cn/zh/funcs/s/sumbars.html)\n\n\n\n#### 语法\n\nsumbars(X, Y)\n\n#### 详情\n\n对 *X* 中每个元素，计算其向前累加直到不小于指定值 *Y* 时经过的周期数。若 *X* 向前的所有元素累加后的值仍不能大于等于 *Y*，则返回0。\n\n#### 参数\n\n**X** 向量/矩阵/元组/表。其元素必须为非负数。\n\n**Y** 标量，表示累加和的阈值。\n\n#### 返回值\n\n返回 INT 类型向量或矩阵。\n\n#### 例子\n\n```\nsumbars(1 2 3.3 2 5, 3)\n// output\n[0,2,1,2,1]\n\nsumbars(matrix(5 3 6 2 3, 2 6 1 5 4), 5)\n```\n\n| col1 | col2 |\n| ---- | ---- |\n| 1    | 0    |\n| 2    | 1    |\n| 1    | 2    |\n| 2    | 1    |\n| 2    | 2    |\n\n```\n# 求完全换手到现在的周期数。\n# calculate the turnover period\nid = `A`A`B`A`C`B`A`C`A`B\ntime = 2022.01.01T09:00:00 + 0..9\nvolume = 100 150 80 120 220 200 180 90 100 125\nt = table(id, time, volume)\ncapital = 300\nre = select *, sumbars(volume, capital) as period from t\nre;\n```\n\n| id | time                | volume | period |\n| -- | ------------------- | ------ | ------ |\n| A  | 2022.01.01T09:00:00 | 100    | 0      |\n| A  | 2022.01.01T09:00:01 | 150    | 0      |\n| B  | 2022.01.01T09:00:02 | 80     | 3      |\n| A  | 2022.01.01T09:00:03 | 120    | 3      |\n| C  | 2022.01.01T09:00:04 | 220    | 2      |\n| B  | 2022.01.01T09:00:05 | 200    | 2      |\n| A  | 2022.01.01T09:00:06 | 180    | 2      |\n| C  | 2022.01.01T09:00:07 | 90     | 3      |\n| A  | 2022.01.01T09:00:08 | 100    | 3      |\n| B  | 2022.01.01T09:00:09 | 125    | 3      |\n"
    },
    "summary": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/summary.html",
        "signatures": [
            {
                "full": "summary(X,[interpolation],[characteristic],[percentile],[precision],[partitionSampling])",
                "name": "summary",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[interpolation]",
                        "name": "interpolation",
                        "optional": true
                    },
                    {
                        "full": "[characteristic]",
                        "name": "characteristic",
                        "optional": true
                    },
                    {
                        "full": "[percentile]",
                        "name": "percentile",
                        "optional": true
                    },
                    {
                        "full": "[precision]",
                        "name": "precision",
                        "optional": true
                    },
                    {
                        "full": "[partitionSampling]",
                        "name": "partitionSampling",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [summary](https://docs.dolphindb.cn/zh/funcs/s/summary.html)\n\n\n\n#### 语法\n\nsummary(X,\\[interpolation],\\[characteristic],\\[percentile],\\[precision],\\[partitionSampling])\n\n#### 详情\n\n生成数据的汇总统计信息。\n\n**Note:**\n\n* 若 *X* 是表，则 `summary` 只统计表中数值类型的列，忽略非数值类型的列。\n\n* 若 *X* 是数据源，则数据源只能包含数值类型的列，否则在进行 `summary` 统计时会报错。\n\n#### 参数\n\n**X** 可以是内存表、DFS 表或由 [sqlDS](https://docs.dolphindb.cn/zh/funcs/s/sqlDS.html) 函数生成的数据源。注意：暂不支持由 `sqlDS` 生成的包含表连接的数据源。\n\n**interpolation** 字符串，表示计算百分位采用的插值方法，可以是 'linear'（默认值）, 'nearest', 'lower', 'higher', 'midpoint'。\n\n**characteristic** 字符串标量或向量，表示需要输出的统计特征。可选值为 'avg', 'std'。若不指定该参数，则默认同时输出 'avg' 和 'std'。\n\n**percentile** DOUBLE 类型向量，范围是\\[0,100]。默认值为 \\[25, 50, 75]，表示返回第25, 50和75百分位数。\n\n**precision** 大于0的 DOUBLE 类型标量，表示插值计算百分位时的迭代精度。默认值为 1e-3。当前计算结果与上一次迭代计算结果的差值小于等于该值时，将退出迭代。建议取值范围为\\[1.000e-3, 1.000e-9]，若值较小，则可能因迭代次数过多而导致性能下降；若值较大，则可能导致计算的结果不精确。\n\n**partitionSampling** 正整数或(0,1]之间的浮点数。正整数表示随机选取的分区个数；浮点数表示随机选取相应比例的分区。若不指定，则表示选取所有分区。指定该参数时需要注意以下事项：\n\n* 对于分区表：\n\n  * 至少会选择1个分区，即当 *partitionSampling* 是浮点数，且 partitionSampling \\* 分区总个数小于1时，会选取1个分区；当 *partitionSampling* \\* 分区总个数是大于1，但不是一个整数时，则向下取整。比如 *partitionSampling*=0.26，分区总个数为10，则会随机选取2个分区。\n\n  * 若指定的分区个数大于实际分区数量，则会选择所有分区。\n\n* 对于非分区表，指定该参数不会生效；\n\n#### 返回值\n\n返回一个内存表，包含最小值、最大值、计数、均值、标准差和指定的百分位数（以升序输出）。\n\n#### 例子\n\n```\nn=2022\ndata=1..n\nvalue=take(1..3,n)\nname=take(`APPLE`IBM`INTEL,n)\nt=table(data,value,name);\nsummary(t, precision=0.001); \n// name 非数值类型，不会输出到表中 \n\n```\n\n输出返回：\n\n| name  | min | max   | nonNullCount | count | avg     | std      | percentile                |\n| ----- | --- | ----- | ------------ | ----- | ------- | -------- | ------------------------- |\n| data  | 1   | 2,022 | 2,022        | 2,022 | 1,011.5 | 583.8454 | \\[506.24,1011.50,1516.75] |\n| value | 1   | 3     | 2,022        | 2,022 | 2       | 0.8167   | \\[1.00,1.99,2.99]         |\n\n```\n\nn = 5000\ndata1 = take(1..5000000, n)\ndata2 = rand(10000000, n)\ndata3 = take(\"A\" + string(0..10), n)\n\nt = table(data1, data2, data3)\ndbname = \"dfs://summary\"\nif(existsDatabase(dbname)) {\n    dropDatabase(dbname)\n}\ndb = database(dbname, HASH, [INT, 10])\npt = createPartitionedTable(db, t, `pt, `data1)\npt.append!(t)\n\nds = sqlDS(<select data1,data2 from loadTable(db, `pt)>)\nquery_percentile = [25,50,75,90]\n\nds_re1 = summary(ds);\n\n// 返回第25, 50, 75, 90 百分位值\nds_re2 = summary(ds, percentile=query_percentile, precision=0.0001);\n\n// 分区占比为 0.6，即统计6个分区数据的信息\nds_re3 = summary(loadTable(db, `pt), percentile=query_percentile, precision=0.0001, partitionSampling=0.6);\n```\n"
    },
    "suspendRecovery": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/suspendRecovery.html",
        "signatures": [
            {
                "full": "suspendRecovery()",
                "name": "suspendRecovery",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [suspendRecovery](https://docs.dolphindb.cn/zh/funcs/s/suspendRecovery.html)\n\n\n\n#### 语法\n\nsuspendRecovery()\n\n#### 详情\n\n用于暂停在线恢复节点的进程。恢复进程中，处于 \"In-Progress\" 状态的数据会继续恢复，\"Waiting\" 状态的数据会暂停恢复。暂停后，恢复进程的源节点可以继续写入数据。该函数只能由管理员在控制节点上调用。\n\n**Note:**\n\n启用高可用集群时，需要在 raft 组内每个节点执行该命令。\n\n相关命令： [resumeRecovery](https://docs.dolphindb.cn/zh/funcs/r/resumeRecovery.html)\n"
    },
    "svd": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/svd.html",
        "signatures": [
            {
                "full": "svd(obj, [fullMatrices=true], [computeUV=true])",
                "name": "svd",
                "parameters": [
                    {
                        "full": "obj",
                        "name": "obj"
                    },
                    {
                        "full": "[fullMatrices=true]",
                        "name": "fullMatrices",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[computeUV=true]",
                        "name": "computeUV",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [svd](https://docs.dolphindb.cn/zh/funcs/s/svd.html)\n\n\n\n#### 语法\n\nsvd(obj, \\[fullMatrices=true], \\[computeUV=true])\n\n#### 详情\n\n计算矩阵的奇异分解。\n\n**Note:**\n\nDolphinDB `svd` 和 [scipy.linalg.svd](https://docs.scipy.org/doc/scipy-1.17.0/reference/generated/scipy.linalg.svd.html) 的核心功能相同。区别在于 DolphinDB 面向 DolphinDB 矩阵；SciPy 面向 NumPy array\\_like 输入，并额外提供 *overwrite\\_a*、*check\\_finite*、*lapack\\_driver* 等计算控制参数。\n\n#### 参数\n\n**obj** 是一个矩阵。\n\n**fullMatrices** 是一个布尔值，其默认值为 true。\n\n**computeUV** 是一个布尔值，默认值为 true。\n\n#### 返回值\n\n假设输入矩阵 A 的行数为 m，列数为 n：\n\n* 若 *fullMatrices*=true，结果为一个 m\\*m 矩阵 U（以左奇异向量为列的矩阵），一个 n\\*n 矩阵 V（以右奇异向量为行的矩阵）和一个向量 s（按降序排列的奇异值），并满足以下条件：A=U\\*S\\*V。其中 S 是一个 m\\*n 矩阵，其对角线元素为s。\n\n* 若 *fullMatrices*=false，S 矩阵仅保留有奇异值的那部分方阵，即矩阵 S 为 k\\*k，其中 k=min(m,n)，并将与删除的这些行或列相乘的 U 与 V 中的行或列删除。矩阵 U 为 m\\*k，矩阵 V 为 k\\*n。\n\n* 若 *computeUV*=false时，只返回向量 s。\n\n#### 例子\n\n```\nm=matrix([[2,1,0],[1,3,1],[0,1,4],[1,2,3]]);\nU,s,V=svd(m);\nU;\n```\n\n| #0        | #1       | #2        |\n| --------- | -------- | --------- |\n| -0.233976 | 0.57735  | -0.782254 |\n| -0.560464 | 0.57735  | 0.593756  |\n| -0.79444  | -0.57735 | -0.188498 |\n\n```\ns;\n// output\n[6.029042,3,1.284776]\n\nV;\n```\n\n| #0        | #1        | #2        | #3        |\n| --------- | --------- | --------- | --------- |\n| -0.170577 | -0.449459 | -0.620036 | -0.620036 |\n| 0.57735   | 0.57735   | -0.57735  | 0         |\n| -0.755582 | 0.630862  | -0.12472  | -0.12472  |\n| -0.258199 | -0.258199 | -0.516398 | 0.774597  |\n\n```\nU,s,V=svd(m,fullMatrices=false);\nV;\n```\n\n| #0        | #1        | #2        | #3        |\n| --------- | --------- | --------- | --------- |\n| -0.170577 | -0.449459 | -0.620036 | -0.620036 |\n| 0.57735   | 0.57735   | -0.57735  | 0         |\n| -0.755582 | 0.630862  | -0.12472  | -0.12472  |\n"
    },
    "symbol": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/symbol.html",
        "signatures": [
            {
                "full": "symbol(X)",
                "name": "symbol",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [symbol](https://docs.dolphindb.cn/zh/funcs/s/symbol.html)\n\n\n\n#### 语法\n\nsymbol(X)\n\n#### 详情\n\n把输入转换为一个符号向量。\n\n#### 参数\n\n**X** 是字符串或符号的向量。\n\n#### 返回值\n\n一个 SYMBOL 向量。\n\n#### 例子\n\n```\nx=`XOM`y;\ntypestr(x);\n```\n\n返回：STRING VECTOR\n\n```\ny=symbol(x);\ny;\n```\n\n返回：\\[\"XOM\",\"y\"]\n\n```\ntypestr(y);\n```\n\n返回：FAST SYMBOL VECTOR\n"
    },
    "symbolCode": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/symbolCode.html",
        "signatures": [
            {
                "full": "symbolCode(X)",
                "name": "symbolCode",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [symbolCode](https://docs.dolphindb.cn/zh/funcs/s/symbolCode.html)\n\n\n\n#### 语法\n\nsymbolCode(X)\n\n#### 详情\n\n查看 SYMBOL 类型数据的内部编码。空字符串的内部编码为0。\n\nSYMBOL 类型是特殊的字符串类型，在系统内部的存储结构为一个编码字典。将设备名，股票名等字符串重复较多的向量存储为 SYMBOL 类型，可以达到向量压缩的目的。\n\n#### 参数\n\n**X** 是 SYMBOL 类型的向量或矩阵。\n\n#### 返回值\n\n一个与 *X* 相同维度的整型向量或矩阵。\n\n#### 例子\n\n```\na=symbol(`IBM`APPL)\nsymbolCode(a)\n```\n\n输出返回：\\[1,2]\n\n```\nx=symbol(`MS`AMZN`AAPL`MS`IBM`AAPL)$3:2\nsymbolCode(x)\n```\n\n输出返回：\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 1  |\n| 2  | 4  |\n| 3  | 3  |\n"
    },
    "symmetricDifference": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/symmetricDifference.html",
        "signatures": [
            {
                "full": "symmetricDifference(X, Y)",
                "name": "symmetricDifference",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [symmetricDifference](https://docs.dolphindb.cn/zh/funcs/s/symmetricDifference.html)\n\n\n\n#### 语法\n\nsymmetricDifference(X, Y) 或 X^Y\n\n#### 详情\n\n返回两个集合的并集减去两个集合的交集。\n\n#### 参数\n\n**X** 和 **Y** 是集合。\n\n#### 返回值\n\n一个集合。\n\n#### 例子\n\n```\nx=set([5,3,4])\ny=set(8 9 4 6);\n\ny^x;\n// output\nset(5,8,3,9,6)\n\nx^y;\n// output\nset(8,5,3,6,9)\n```\n"
    },
    "syncDict": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/syncDict.html",
        "signatures": [
            {
                "full": "syncDict(keyObj, valueObj, [sharedName], [ordered=false])",
                "name": "syncDict",
                "parameters": [
                    {
                        "full": "keyObj",
                        "name": "keyObj"
                    },
                    {
                        "full": "valueObj",
                        "name": "valueObj"
                    },
                    {
                        "full": "[sharedName]",
                        "name": "sharedName",
                        "optional": true
                    },
                    {
                        "full": "[ordered=false]",
                        "name": "ordered",
                        "optional": true,
                        "default": "false"
                    }
                ]
            },
            {
                "full": "syncDict(keyType, valueType, [sharedName], [ordered=false])",
                "name": "syncDict",
                "parameters": [
                    {
                        "full": "keyType",
                        "name": "keyType"
                    },
                    {
                        "full": "valueType",
                        "name": "valueType"
                    },
                    {
                        "full": "[sharedName]",
                        "name": "sharedName",
                        "optional": true
                    },
                    {
                        "full": "[ordered=false]",
                        "name": "ordered",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [syncDict](https://docs.dolphindb.cn/zh/funcs/s/syncDict.html)\n\n\n\n#### 语法\n\nsyncDict(keyObj, valueObj, \\[sharedName], \\[ordered=false])\n\n或\n\nsyncDict(keyType, valueType, \\[sharedName], \\[ordered=false])\n\n#### 详情\n\n创建一个线程安全的同步字典。同步字典允许多个线程对其进行并发读写。\n\n#### 参数\n\n* 第一种用法中，**keyObj** 是表示键的标量或向量，**valueObj** 是表示值的标量或向量。\n\n* 第二种用法中，**keyType** 是字典键的数据类型； **valueType** 是字典值的数据类型。系统支持以下键的数据类型：INTEGRAL（COMPRESSED 除外）、TEMPORAL、FLOATING、LITERAL。字典中的值不支持 COMPLEX、POINT 。\n\n**sharedName** 为一个字符串。指定后此字典会被共享，共享的字典名为 *sharedName*。\n\n**ordered** 一个布尔值，默认为 false，表示创建一个无序字典。当 *ordered* = true 时，创建一个有序字典。无序字典在输出或进行遍历时，其键值对不保留输入时的顺序；有序字典在输出或进行遍历时，键值对的顺序与输入顺序保持一致。\n\n#### 返回值\n\n一个字典。\n\n#### 例子\n\n例1：\n\n```\nx=1 6 3\ny=4.5 7.8 4.3\nz=syncDict(x,y);\n/* output:\n3->4.3\n1->4.5\n6->7.8\n*/\n\nz=syncDict(INT,DOUBLE)\nz[5]=7.9\nz;\n// output: 5->7.9\n\nz=syncDict(SYMBOL,DOUBLE)\nz[`IBM]=237.82\nz;\n// output: IBM->237.82\n\n\nsyncDict(INT,DOUBLE, `sn)\nsn[5 6]=10.99 2.33\nsn[5];\n// output: 10.99\n\n\n// y 为 DECIMAL32 类型的向量，将 y 作为 value 值创建有序字典 z\nx=1 3 2\ny = decimal32\\(1.23 3 3.14, 3\\)\nz=dict\\(x,y,true\\);\nz;\n/\\* output:\n1-&gt;1.230\n3-&gt;3.000\n2-&gt;3.140\n\\*/\n```\n\n下面的例子中，我们分别对普通字典 z1 和同步字典 z2 并发写入。\n\n对普通字典 z1 进行多线程并发写入会造成节点崩溃：\n\n```\ndef task1(mutable d,n){\n    for(i in 0..n){\n        d[i]=i*2\n    }\n}\n\ndef task2(mutable d,n){\n    for(i in 0..n){\n        d[i]=i+1\n    }\n}\nn=10000000\n\nz1=dict(INT,INT)\njobId1=submitJob(\"task1\",,task1,z1,n)\njobId2=submitJob(\"task2\",,task2,z1,n);\n```\n\n同步字典 z2 允许多线程并发写入：\n\n```\nz2=syncDict(INT,INT)\njobId3=submitJob(\"task1\",,task1,z2,n)\njobId4=submitJob(\"task2\",,task2,z2,n)\ngetJobReturn(jobId3, true)\ngetJobReturn(jobId4, true)\nz2;\n```\n\n相关函数：[array](https://docs.dolphindb.cn/zh/funcs/a/array.html), [matrix](https://docs.dolphindb.cn/zh/funcs/m/matrix.html), [dictUpdate!](https://docs.dolphindb.cn/zh/funcs/d/dictUpdate_.html), [dict](https://docs.dolphindb.cn/zh/funcs/d/dict.html)\n\n例 2：syncDict 与 [go](https://docs.dolphindb.cn/zh/progr/statements/go.html) 配合使用：\n\n```\nsyncDict(SYMBOL,RESOURCE,`resDict)\ngo\nresDict[`a]=10\n```\n"
    },
    "syntax": {
        "url": "https://docs.dolphindb.cn/zh/funcs/s/syntax.html",
        "signatures": [
            {
                "full": "syntax(X)",
                "name": "syntax",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [syntax](https://docs.dolphindb.cn/zh/funcs/s/syntax.html)\n\n\n\n#### 语法\n\nsyntax(X)\n\n#### 详情\n\n返回 *X* 表示的函数或命令的语法。\n\n#### 参数\n\n**X** 是 DolphinDB 函数或命令。\n\n#### 返回值\n\nSTRING 类型标量。\n\n#### 例子\n\n```\nsyntax(createPartitionedTable);\n// output\ncreatePartitionedTable(dbHandle, table, tableName, [partitionColumns], [compressMethods])\n```\n"
    },
    "t3": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/t3.html",
        "signatures": [
            {
                "full": "t3(X, window, [vfactor=1.0])",
                "name": "t3",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "[vfactor=1.0]",
                        "name": "vfactor",
                        "optional": true,
                        "default": "1.0"
                    }
                ]
            }
        ],
        "markdown": "### [t3](https://docs.dolphindb.cn/zh/funcs/t/t3.html)\n\n\n\n#### 语法\n\nt3(X, window, \\[vfactor=1.0])\n\nTA-lib 系列函数参数说明和窗口计算规则请参考：[TAlib](https://docs.dolphindb.cn/zh/funcs/themes/TAlib.html)\n\n#### 详情\n\n在给定长度（以元素个数衡量）的滑动窗口内，计算 *X* 的三重指数移动平均（Triple Exponential Moving Average）。\n\n其计算公式为：\n\n![ema1](https://docs.dolphindb.cn/zh/images/ema1.png)\n\n![ema2](https://docs.dolphindb.cn/zh/images/ema2.png) ![gd](https://docs.dolphindb.cn/zh/images/gd.png) ![t3](https://docs.dolphindb.cn/zh/images/t3.png)\n\nDolphinDB t3 和 TA-Lib T3 功能相同，在实现上存在以下区别：\n\n* DolphinDB `t3` 支持向量、矩阵和表作为输入，而 TA-Lib `T3` 仅支持一维数组输入。\n* 参数 *vfactor* 的默认值不同。\n* 空值处理不同：二者在前置空值处理上基本一致：保留序列开头的空值，并从首个非空值开始进行窗口计算。二者在中间空值处理上存在差异：DolphinDB `t3` 通常会继续按其移动平均规则计算并输出结果；TA-Lib 在首个非空值之后遇到 NaN 时，部分指标可能从该位置起输出 NaN，并影响后续结果。\n\n#### 参数\n\n**vfactor** 是一个0-1之间的浮点数。 默认值是1.0。\n\n#### 返回值\n\nDOUBLE 类型，数据形式同 *X*。\n\n#### 例子\n\n```\nx=12.1 12.2 12.6 12.8 11.9 11.6 11.2 16.9 55.6 5.6 3.3 66 6 57\nt3(x, 3, 0.5);\n// output\n[,,,,,,,,,,,,26.8447,33.209]\n\nx=matrix(12.1 12.2 12.6 12.8 11.9 11.6 11.2 15.7 18.6 13.2 19.6 20.3 22.4 11, 14 15 18 19 21 12 10 6 5.5 7 11 16 15 9.9)\nt3(x, 3, 0.8);\n```\n\n| col1    | col2    |\n| ------- | ------- |\n|         |         |\n|         |         |\n|         |         |\n|         |         |\n|         |         |\n|         |         |\n|         |         |\n|         |         |\n|         |         |\n|         |         |\n|         |         |\n|         |         |\n| 20.7584 | 13.4706 |\n| 18.242  | 13.2408 |\n\n相关函数：[tema](https://docs.dolphindb.cn/zh/funcs/t/tema.html)\n"
    },
    "table": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/table.html",
        "signatures": [
            {
                "full": "table(X, [X1], [X2], .....)",
                "name": "table",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[X1]",
                        "name": "X1",
                        "optional": true
                    },
                    {
                        "full": "[X2]",
                        "name": "X2",
                        "optional": true
                    },
                    {
                        "full": ".....",
                        "name": "....."
                    }
                ]
            }
        ],
        "markdown": "### [table](https://docs.dolphindb.cn/zh/funcs/t/table.html)\n\n\n\n#### 语法\n\ntable(X, \\[X1], \\[X2], .....) 或 table(capacity:size, colNames, colTypes)\n\n#### 详情\n\n* 用法一：将单个或多个向量/矩阵/元组，或多个向量和元组的混合数据形式转换成表。\n* 用法二：创建一个固定数据类型的空表或初始化的表。\n\n#### 参数\n\n第一种用法中，**X**, **X1**, **X2** ... 可以是向量、数组向量、矩阵或元组。每个向量、元组、数组向量的长度，以及矩阵中每列长度都必须相同。**当 Xk 是元组时：**\n\n* 若 Xk 的元素是等长的向量，\\*\\*元组的每个元素将作为表的一列。\\*\\*元组的长度必须等于表的行数。\n\n* 若 Xk 包含不同类型或不等长元素，\\*\\*则将单独作为表的一列（列类型为 ANY），其每个元素将作为该列每行的元素值。\\*\\*Xk 的长度仍然必须和表的行数保持一致。\n\n第二种用法中：\n\n* **capacity** 是正整数，表示建表时系统为该表分配的内存（以记录数为单位）。当记录数超过 *capacity* 时，系统首先会分配 *capacity* 1.2\\~2倍的新的内存空间，然后复制数据到新的内存空间，最后释放原来的内存。对于规模较大的表，此类操作的内存占用会很高。因此，建议建表时预先分配一个合理的 *capacity*。\n\n* **size** 是整数，表示该表新建时的行数。若 *size* =0，创建一个空表。 若 *size*>0，则建立一个只包含 size 条记录的表，记录初始值如下：\n\n  * BOOL 类型默认值为 false；\n\n  * 数值类型、时间类型、IPADDR、COMPLEX、POINT 的默认值为 0；\n\n  * Literal, INT128 类型的默认值为 NULL。\n\n  **Note:** 如果 *colTypes* 指定为数组向量， *size* 必须为0。\n\n* **colNames** 是一个向量，表示列名。\n\n* **colTypes** 是一个向量，表示每列的数据类型，支持数组向量类型和元组（ANY）类型。可使用表示数据类型的系统保留字或相应的字符串。\n\n#### 返回值\n\n返回一个表，数据类型同 *Xk*/*colTypes*。\n\n#### 例子\n\n第一种用法：\n\n```\nid=`XOM`GS`AAPL\nx=102.1 33.4 73.6\ntable(id, x);\n```\n\n| id   | x     |\n| ---- | ----- |\n| XOM  | 102.1 |\n| GS   | 33.4  |\n| AAPL | 73.6  |\n\n```\ntable(`XOM`GS`AAPL as id, 102.1 33.4 73.6 as x);\n```\n\n| id   | x     |\n| ---- | ----- |\n| XOM  | 102.1 |\n| GS   | 33.4  |\n| AAPL | 73.6  |\n\n```\nm=matrix(1 2, 3 4, 5 6);\nm;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1  | 3  | 5  |\n| 2  | 4  | 6  |\n\n```\ntable(m);\n```\n\n| C0 | C1 | C2 |\n| -- | -- | -- |\n| 1  | 3  | 5  |\n| 2  | 4  | 6  |\n\n```\nm.rename!(1 2, `a`b`x);\nm;\n```\n\n|   | a | b | x |\n| - | - | - | - |\n| 1 | 1 | 3 | 5 |\n| 2 | 2 | 4 | 6 |\n\n```\ntable(m);\n```\n\n| a | b | x |\n| - | - | - |\n| 1 | 3 | 5 |\n| 2 | 4 | 6 |\n\n```\nx=1..6\ny=matrix(11..16, 17..22)\nz=(101..106, 201..206)\nt=table(x,y,z)\nt.rename!(`x`y1`y2`z1`z2);\n\nt;\n```\n\n| x | y1 | y2 | z1  | z2  |\n| - | -- | -- | --- | --- |\n| 1 | 11 | 17 | 101 | 201 |\n| 2 | 12 | 18 | 102 | 202 |\n| 3 | 13 | 19 | 103 | 203 |\n| 4 | 14 | 20 | 104 | 204 |\n| 5 | 15 | 21 | 105 | 205 |\n| 6 | 16 | 22 | 106 | 206 |\n\n元素类型相同且等长的元组将转换为多列（每个元素为一列），混合类型或元素长度不等的元组将转换为 ANY 类型的列：\n\n```\nid = 1 2 3\nval = [[1,2,3], [4,5,6],[7,8,9]]\nmetrics = [`A,[2.2 3.2], 3.2]\nt = table(id, val, metrics)\n```\n\n<table id=\"table_evm_hpm_1fc\"><tbody><tr><td>\n\n**id**\n\n</td><td>\n\n**col1**\n\n</td><td>\n\n**col2**\n\n</td><td>\n\n**col3**\n\n</td><td>\n\n**metrics**\n\n</td></tr><tr><td>\n\n1\n\n</td><td>\n\n1\n\n</td><td>\n\n4\n\n</td><td>\n\n7\n\n</td><td>\n\nA\n\n</td></tr><tr><td>\n\n2\n\n</td><td>\n\n2\n\n</td><td>\n\n5\n\n</td><td>\n\n8\n\n</td><td>\n\n(\\[2.2,3.2])\n\n</td></tr><tr><td>\n\n3\n\n</td><td>\n\n3\n\n</td><td>\n\n6\n\n</td><td>\n\n9\n\n</td><td>\n\n3.2\n\n</td></tr></tbody>\n</table>第二种用法：\n\n```\ntable(100:5, `name`id`value, [STRING,INT,DOUBLE]);\n```\n\n| name | id | value |\n| ---- | -- | ----- |\n|      | 0  | 0     |\n|      | 0  | 0     |\n|      | 0  | 0     |\n|      | 0  | 0     |\n|      | 0  | 0     |\n\n```\ntable(100:5, `name`id`value, `STRING`INT`DOUBLE);\n```\n\n| name | id | value |\n| ---- | -- | ----- |\n|      | 0  | 0     |\n|      | 0  | 0     |\n|      | 0  | 0     |\n|      | 0  | 0     |\n|      | 0  | 0     |\n\n```\ntable(100:1, [`value], [DOUBLE]);\n```\n\n| value |\n| ----- |\n| 0     |\n"
    },
    "tableInsert": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tableInsert.html",
        "signatures": [
            {
                "full": "tableInsert(table, args...)",
                "name": "tableInsert",
                "parameters": [
                    {
                        "full": "table",
                        "name": "table"
                    },
                    {
                        "full": "args...",
                        "name": "args..."
                    }
                ]
            }
        ],
        "markdown": "### [tableInsert](https://docs.dolphindb.cn/zh/funcs/t/tableInsert.html)\n\n\n\n#### 语法\n\ntableInsert(table, args...)\n\n#### 详情\n\n将*args...* 插入到 *table* 中，并返回插入的行数。\n\n如果 *args...* 是一个表，它的结构必须与 *table* 的结构相同。若 *table* 是分区表，*args...* 只能是一个表。\n\n如果 *args...* 是一个元组，那么它的元素个数必须与 *table* 的列数相同，并且每个元素的数据类型必须与 *table* 中与之对应的每列的数据类型相同。\n\n如果 *args...* 是多个向量或元组，那么向量与元组的个数必须与 *table* 中列数一致，且每个向量或元组的数据类型必须与 *table* 中与之对应的每列的数据类型相同。\n\n如果 *args...* 是一个字典，那么它的 keys 对应 *table* 的列名，values 对应 *table* 中每列的值，且 values 必须为元组。这种用法只适用于 *table* 为内存表的情况。\n\n**Note:** 若数据库为 VALUE 分区，且分区列为字符串类型，则追加的分区列数据不能包含空格，“/n”, “/r”, “/t”。\n\n#### 参数\n\n**table** 是表对象或表名。该表可为内存表或 DFS 表。在远程调用中，由于得不到远程表对象的引用，因此必须使用表名。\n\n**args...** 可以是一个表、元组或字典，或多个向量或元组。\n\n#### 返回值\n\nINT 类型标量。\n\n#### 例子\n\n```\ncolName=[\"Name\",\"Age\"]\ncolType=[\"string\",\"int\"]\nt1=table(100:0,colName, colType);\n\nname=`Tom`Jerry`John\nage=24 25 26\nt2=table(name, age)\n\ntableInsert(t1, t2);\n// output\n3\n\nt1;\n```\n\n| Name  | Age |\n| ----- | --- |\n| Tom   | 24  |\n| Jerry | 25  |\n| John  | 26  |\n\n```\ntableInsert(t1, (`George, 29));\n// output\n1\n\nt1;\n```\n\n| Name   | Age |\n| ------ | --- |\n| Tom    | 24  |\n| Jerry  | 25  |\n| John   | 26  |\n| George | 29  |\n\n```\ntableInsert(t1, (`Frank`Henry, 31 32));\n// output\n2\n\ntableInsert(t1, `Nicole`Nancy, 28 29);\n// output\n2\n\nt1.tableInsert(dict(`Name`Age, [`Patrick, 22]));\n// output\n1\n```\n\n使用 `tableInsert` 函数向分布式表中插入批量数据：\n\n```\ndb=database(\"dfs://db1\",RANGE,0 20 50 101)\nn=100000\nid=rand(100,n)\nval=rand(100.0,n)\nt=table(id,val)\npt=db.createPartitionedTable(t,`pt,`id).append!(t);\n\ntmp=table(rand(100,10000) as id,take(200.0,10000) as val);\n\ntableInsert(pt,tmp);\n// output\n10000\n```\n"
    },
    "tableUpsert": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tableUpsert.html",
        "signatures": [
            {
                "full": "tableUpsert(obj, newData, [ignoreNull=false], [keyColNames], [sortColumns])",
                "name": "tableUpsert",
                "parameters": [
                    {
                        "full": "obj",
                        "name": "obj"
                    },
                    {
                        "full": "newData",
                        "name": "newData"
                    },
                    {
                        "full": "[ignoreNull=false]",
                        "name": "ignoreNull",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[keyColNames]",
                        "name": "keyColNames",
                        "optional": true
                    },
                    {
                        "full": "[sortColumns]",
                        "name": "sortColumns",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [tableUpsert](https://docs.dolphindb.cn/zh/funcs/t/tableUpsert.html)\n\n\n\n#### 语法\n\ntableUpsert(obj, newData, \\[ignoreNull=false], \\[keyColNames], \\[sortColumns])\n\n#### 详情\n\n将新数据写入索引内存表、键值内存表，或者 DFS 表。若新数据的主键值已存在，更新该主键值的数据；否则添加数据。\n\n`tableUpsert` 与 `upsert!` 的用法一致，区别在于 `tableUpsert` 会返回操作行数，而 `upsert!` 进行了就地修改，用于链式操作。\n\n**Note:**\n\n* 调用该函数时，需要保证 *newData* 和 *obj* 两表各列的顺序一致，否则可能产生错误结果或报错。\n\n* 若 *keyColNames* 指定的列存在重复值，对重复值进行 `tableUpsert` 操作，仅会更新第一个值所在行，其余值所在行不会更新。\n\n* 函数行为会受到配置参数 *enableNullSafeJoin* 的影响：\n\n  * 当 *enableNullSafeJoin*=true 时，连接列中的 NULL 值可以匹配成功，`tableUpsert` 可能会更新包含 NULL 的记录；\n\n  * 当 *enableNullSafeJoin*=false 时，连接列中的 NULL 值无法匹配，`tableUpsert` 不会更新此类记录。\n\n#### 参数\n\n**obj** 是一个索引内存表、键值内存表，或者 DFS 表（分布式表或维度表）。\n\n**newData** 是一个内存表，且与 *obj* 的结构一样。\n\n**ignoreNull** 是一个布尔值，表示若 *newData* 中某元素为 NULL 值，是否忽略对目标表中的相应数据进行更新。默认值为 false。\n\n**keyColNames** 是一个字符串标量或向量。由于 DFS 表没有键值列，对 DFS 表进行更新时，将该参数指定的列和分区列一起视为键值列。\n\n**sortColumns** 是一个字符串标量或向量。设置该参数，更新的分区内的所有数据会根据指定的列进行排序。排序在每个分区内部进行，不会跨分区排序。\n\n**Note:**\n\n* 仅 OLAP 引擎下使用 `upsert!` 时，才支持设置 *sortColumns*。\n* 要设置 *sortColumns*， *obj* 必须为分布式表。\n* 仅对同一个分区内的数据 按照 *sortColumns* 进行排序，不同分区之间的数据不会进行排序。\n* *obj* 为一个空表时，设置 *sortColumns* 无效，即更新后不对新插入的数据进行排序。\n* 在 PKEY 引擎下不支持设置 *ignoreNull*, *keyColNames*, *sortColumns*。\n\n#### 返回值\n\nLONG 类型数据对，第一个元素表示新插入的记录数，第二个元素表示更新的记录数。\n\n#### 例子\n\n对键值内存表使用 `tableUpsert`：\n\n```\nsym=`A`B`C\ndate=take(2021.01.06, 3)\nx=1 2 3\ny=5 6 7\nt=keyedTable(`sym`date, sym, date, x, y)\nnewData = table(`A`B`C`D as sym1, take(2021.01.06, 4) as date1, NULL NULL 300 400 as x1, NULL 600 700 800 as y1);\ntableUpsert(t, newData, ignoreNull=true)\n// output\n1:2\n```\n\n对索引内存表使用 `tableUpsert`：\n\n```\nsym=`A`B`C\ndate=take(2021.01.06, 3)\nx=1 2 3\ny=5 6 7\nt=indexedTable(`sym`date, sym, date, x, y)\nnewData = table(`A`B`C`D as sym1, take(2021.01.06, 4) as date1, NULL NULL 300 400 as x1, NULL 600 700 800 as y1);\ntableUpsert(t, newData, ignoreNull=true)\n// output\n1:2\n```\n\n对 DFS 表使用 `tableUpsert`：\n\n```\nID=0 1 2 2\nx=0.1*0..3\nt=table(ID, x)\ndb=database(\"dfs://rangedb128\", VALUE,  0..10)\npt=db.createPartitionedTable(t, `pt, `ID)\npt.append!(t)\nt1=table(1 as ID, 111 as x)\ntableUpsert(pt, t1, keyColNames=`ID)\n// output\n0:1\n```\n"
    },
    "tail": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tail.html",
        "signatures": [
            {
                "full": "tail(obj, [n=1])",
                "name": "tail",
                "parameters": [
                    {
                        "full": "obj",
                        "name": "obj"
                    },
                    {
                        "full": "[n=1]",
                        "name": "n",
                        "optional": true,
                        "default": "1"
                    }
                ]
            }
        ],
        "markdown": "### [tail](https://docs.dolphindb.cn/zh/funcs/t/tail.html)\n\n\n\n#### 语法\n\ntail(obj, \\[n=1])\n\n#### 详情\n\n*tail* 返回向量的最后 *n* 个元素，或者矩阵的最后 *n* 列，或者表的最后 *n* 行。如果 *n* 没有指定，*n* 取默认值 1。\n\n#### 参数\n\n* **obj** 可以是向量、矩阵或表。\n\n* **n** 是一个正整数。\n\n#### 返回值\n\n返回一个与输入 *obj* 相同数据类型和形式的对象。\n\n#### 例子\n\n```\nx=1..10;\ntail(x);\n// output\n10\n\ntail(x,2);\n// output\n[9,10]\n\nx=1..10$2:5;\nx;\n```\n\n| #0 | #1 | #2 | #3 | #4 |\n| -- | -- | -- | -- | -- |\n| 1  | 3  | 5  | 7  | 9  |\n| 2  | 4  | 6  | 8  | 10 |\n\n```\nx.tail();\n// output\n[9,10]\n\ntail(x,2);\n```\n\n| #0 | #1 |\n| -- | -- |\n| 7  | 9  |\n| 8  | 10 |\n\n```\nx=table(1..5 as a, 6..10 as b);\nx;\n```\n\n| a | b  |\n| - | -- |\n| 1 | 6  |\n| 2 | 7  |\n| 3 | 8  |\n| 4 | 9  |\n| 5 | 10 |\n\n```\ntail(x);\n// output\nb->10\na->5\n\n\nx.tail(2);\n```\n\n| a | b  |\n| - | -- |\n| 4 | 9  |\n| 5 | 10 |\n\n相关函数：[head](https://docs.dolphindb.cn/zh/funcs/h/head.html)\n"
    },
    "take": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/take.html",
        "signatures": [
            {
                "full": "take(X, n)",
                "name": "take",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "n",
                        "name": "n"
                    }
                ]
            }
        ],
        "markdown": "### [take](https://docs.dolphindb.cn/zh/funcs/t/take.html)\n\n\n\n#### 语法\n\ntake(X, n)\n\n#### 详情\n\n如果 *X* 是标量，则 *n* 必须是标量，返回由 *n* 个 *X* 组成的向量。\n\n如果 *X* 是向量/元组：\n\n* *n* 标量：从 *X* 中循环地依次取值，共取 *n* 个值。结果是一个向量。*n* 是正数时，从左到右取数，*n* 是负数时，从右到左取数。\n\n* *n* 是向量：*n* 的长度必须和 *X* 相同。从 *X* 中依次取出 n\\[i] 个 X\\[i]。当 n\\[i] <=0 时，不会取 X\\[i]。结果是一个向量。\n\n如果 *X* 是矩阵/表：\n\n* *n* 标量：从 *X* 中循环地依次逐行取值，共取 *n* 行。结果是一个矩阵/表。*n* 是正数时，从上到下取数，*n* 是负数时，则从下到上取数。\n\n* *n* 是向量：*n* 的长度必须和 *X* 的行数相同。从 *X* 中依次取出 n\\[i] 个第 i 行的元素。当 n\\[i] <=0 时，不会取第 i 行元素。结果是一个矩阵/表。\n\n**Note:**\n\nDolphinDB `take` 和 [numpy.take](https://numpy.org/doc/stable/reference/generated/numpy.take.html) 都用于取值。区别如下：\n\n* DolphinDB `take` 用于从标量、向量、矩阵或表中按顺序取指定数量的元素或行，数量超过原对象长度时会循环取值；当 *n* 为向量时，表示按元素或按行重复指定次数。\n* `numpy.take` 用于按照索引从数组中抽取元素，第二个参数 *indices* 表示索引位置而不是取值数量，并支持 *axis* 和 *mode* 参数。\n\n#### 参数\n\n**X** 可以是标量、向量、元组、矩阵或表。\n\n**n** 是一个整数标量或向量。\n\n#### 返回值\n\n数据类型同 *X*，数据形式见[详情](https://docs.dolphindb.cn/zh/funcs/t/take.html#详情)。\n\n#### 例子\n\n```\ntake(10,5);\n// output\n[10,10,10,10,10]\n\nx=`IBM`C`AAPL`BABA;\ntake(x,10);\n// output\n[\"IBM\",\"C\",\"AAPL\",\"BABA\",\"IBM\",\"C\",\"AAPL\",\"BABA\",\"IBM\",\"C\"]\n# sequentially and iteratively take 10 elements from vector x\n\nx=3 5 4 6 9;\ntake(x,3);\n// output\n[3,5,4]\n\n\nx=1..3;\nx.take(10);\n// output\n[1,2,3,1,2,3,1,2,3,1]\n\ntake(1 2 3, 10);\n// output\n[1,2,3,1,2,3,1,2,3,1]\n\n\ntake(1,10);\n// output\n[1,1,1,1,1,1,1,1,1,1]\n# an efficient way to generate a vector with default values.\n\n\nx=take(1,0);\n# return an empty INT VECTOR\n\nx;\n// output\n[]\n\ntypestr x;\n// output\nFAST INT VECTOR\n```\n\n```\nx=1..12$3:4;\ntake(x,2);\n```\n\n| col1 | col2 | col3 | col4 |\n| ---- | ---- | ---- | ---- |\n| 1    | 4    | 7    | 10   |\n| 2    | 5    | 8    | 11   |\n\n```\ntake(x,-2);\n```\n\n| col1 | col2 | col3 | col4 |\n| ---- | ---- | ---- | ---- |\n| 2    | 5    | 8    | 11   |\n| 3    | 6    | 9    | 12   |\n\n```\ntake(1..3,2 0 2)\n// output\n[1,1,3,3]\n```\n\n```\nm=matrix(1 2 3, 4 5 6)\ntake(m,5)\n```\n\n| col1 | col2 |\n| ---- | ---- |\n| 1    | 4    |\n| 2    | 5    |\n| 3    | 6    |\n| 1    | 4    |\n| 2    | 5    |\n\n```\ntake(m, 0 2 1)\n```\n\n| col1 | col2 |\n| ---- | ---- |\n| 2    | 5    |\n| 2    | 5    |\n| 3    | 6    |\n\n```\nt=table(1 2 3 as a, 4 5 6 as b)\ntake(t,-4)\n```\n\n| a | b |\n| - | - |\n| 3 | 6 |\n| 1 | 4 |\n| 2 | 5 |\n| 3 | 6 |\n\n```\ntake(t, -2 2 1)\n```\n\n| a | b |\n| - | - |\n| 2 | 5 |\n| 2 | 5 |\n| 3 | 6 |\n"
    },
    "talibNull": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/talibNull.html",
        "signatures": [
            {
                "full": "talibNull(args...)",
                "name": "talibNull",
                "parameters": [
                    {
                        "full": "args...",
                        "name": "args..."
                    }
                ]
            }
        ],
        "markdown": "### [talibNull](https://docs.dolphindb.cn/zh/funcs/t/talibNull.html)\n\n\n\n#### 语法\n\ntalibNull(args...)\n\n#### 详情\n\n该函数对输入的每个 vector 处理后，返回一个由处理结果组成的 tuple。处理方式如下：\n\n从0开始遍历每个 vector (v1, v2, …, vn) 的下标，若存在某个下标 i，满足 v1\\[i], v2\\[i], ..., vn\\[i] 均为非 NULL 值，则结果中下标对应 0 \\~ i 的元素均取 NULL 值，下标 i 及之后的元素与原向量对应下标的元素保持一致。\n\n#### 参数\n\n**args...** 是两个及以上的 vector，所有 vector 长度需保持一致。\n\n#### 返回值\n\n返回一个元组，数据类型同输入的向量 *args...*。\n\n#### 例子\n\n下标为2时，所有向量对应元素满足全部非空，因此输出结果，在下标2之前的元素均被置为空。\n\n```\ntalibNull(2 3 4 5 6, NULL 1 2 NULL 4, 7 NULL 9 10 11)\n// output\n([,,4,5,6],[,,2,,4],[,,9,10,11])\n```\n"
    },
    "tan": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tan.html",
        "signatures": [
            {
                "full": "tan(X)",
                "name": "tan",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [tan](https://docs.dolphindb.cn/zh/funcs/t/tan.html)\n\n\n\n#### 语法\n\ntan(X)\n\n#### 详情\n\n返回 *X* 的正切。\n\n**Note:**\n\n* DolphinDB 的 `tan` 函数仅单一参数，支持标量、向量及矩阵计算；而 NumPy 的 `tan` 函数作为通用 ufunc，支持任意维度的 N 维数组，并可通过 *out*、*where*等参数实现指定输出与条件计算。\n* DolphinDB `tan` 与 TA-Lib `TAN` 功能相同，区别在于前者支持向量、矩阵和表作为输入，后者仅支持一维数组输入。\n\n#### 参数\n\n**X** 可以是标量、向量或矩阵。\n\n#### 返回值\n\nDOUBLE 类型，数据形式同 *X*。\n\n#### 例子\n\n```\ntan(0 1 2);\n// output\n[0,1.557408,-2.185040]\n```\n\n相关函数：[asin](https://docs.dolphindb.cn/zh/funcs/a/asin.html), [acos](https://docs.dolphindb.cn/zh/funcs/a/acos.html), [atan](https://docs.dolphindb.cn/zh/funcs/a/atan.html), [sin](https://docs.dolphindb.cn/zh/funcs/s/sin.html), [cos](https://docs.dolphindb.cn/zh/funcs/c/cos.html), [asinh](https://docs.dolphindb.cn/zh/funcs/a/asinh.html), [acosh](https://docs.dolphindb.cn/zh/funcs/a/acosh.html), [atanh](https://docs.dolphindb.cn/zh/funcs/a/atanh.html), [sinh](https://docs.dolphindb.cn/zh/funcs/s/sinh.html), [cosh](https://docs.dolphindb.cn/zh/funcs/c/cosh.html), [tanh](https://docs.dolphindb.cn/zh/funcs/t/tanh.html)\n"
    },
    "tanh": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tanh.html",
        "signatures": [
            {
                "full": "tanh(X)",
                "name": "tanh",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [tanh](https://docs.dolphindb.cn/zh/funcs/t/tanh.html)\n\n\n\n#### 语法\n\ntanh(X)\n\n#### 详情\n\n返回 *X* 的双曲正切。\n\n**Note:** DolphinDB 的 `tanh` 函数仅单一参数，支持标量、向量及矩阵计算；而 NumPy 的 `tanh` 函数作为通用 ufunc，支持任意维度的 N 维数组，并可通过 *out*、*where*等参数实现指定输出与条件计算。TA-Lib 的 `TANH` 是 Math Transform 函数，输入参数 *close* 和输出主要为一维数组\n\n#### 参数\n\n**X** 可以是标量、向量或矩阵。\n\n#### 返回值\n\nDOUBLE 类型，数据形式同 *X*。\n\n#### 例子\n\n```\ntanh(0 1 2);\n// output\n[0,0.761594,0.964028]\n```\n\n相关函数：[asin](https://docs.dolphindb.cn/zh/funcs/a/asin.html), [acos](https://docs.dolphindb.cn/zh/funcs/a/acos.html), [atan](https://docs.dolphindb.cn/zh/funcs/a/atan.html), [sin](https://docs.dolphindb.cn/zh/funcs/s/sin.html), [cos](https://docs.dolphindb.cn/zh/funcs/c/cos.html), [tan](https://docs.dolphindb.cn/zh/funcs/t/tan.html), [asinh](https://docs.dolphindb.cn/zh/funcs/a/asinh.html), [acosh](https://docs.dolphindb.cn/zh/funcs/a/acosh.html), [atanh](https://docs.dolphindb.cn/zh/funcs/a/atanh.html), [sinh](https://docs.dolphindb.cn/zh/funcs/s/sinh.html), [cosh](https://docs.dolphindb.cn/zh/funcs/c/cosh.html)\n"
    },
    "tanimoto": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tanimoto.html",
        "signatures": [
            {
                "full": "tanimoto(X, Y)",
                "name": "tanimoto",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [tanimoto](https://docs.dolphindb.cn/zh/funcs/t/tanimoto.html)\n\n\n\n#### 语法\n\ntanimoto(X, Y)\n\n#### 详情\n\n若 *X* 和 *Y* 是标量或向量，计算 *X* 和 *Y* 之间的谷本距离。\n\n若 *X* 或 *Y* 是矩阵，计算每列元素之间的谷本距离，返回一个向量。 注意，若 *X* 或 *Y* 同时为索引矩阵或索引序列，会自动对齐标签，返回标签相同的行的计算结果，忽略标签不同的行。\n\n与所有其它聚合函数一致，计算时忽略 NULL 值。\n\n#### 参数\n\n**X** 和 **Y** 是长度相同的数值型标量/向量/矩阵。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n```\na=[10.5, 11.8, 9]\nb=[11.3, 15.1, 8.9]\ntanimoto(a,b)\n// output\n0.029706\n\ns1=indexedSeries(2020.01.01..2020.01.03, 10.4 11.2 9)\ns2=indexedSeries(2020.01.01 2020.01.03 2020.01.04, 23.5 31.2 26)\ntanimoto(s1,s2)\n// output\n0.5585\n\nm=matrix(23 56 47, 112 94 59)\nm1=matrix(11 15 89, 52 41 63)\ntanimoto(m,m1)\n// output\n[0.40490.3242]\n\nm.rename!(2020.01.01..2020.01.03, `A`B)\nm.setIndexedMatrix!()\nm1.rename!(2020.01.01 2020.01.03 2020.01.04, `A`B)\nm1.setIndexedMatrix!()\ntanimoto(m,m1)\n// output\n[0.5494,0.3225]\n```\n\n相关函数：[rowTanimoto](https://docs.dolphindb.cn/zh/funcs/r/rowTanimoto.html)\n"
    },
    "tema": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tema.html",
        "signatures": [
            {
                "full": "tema(X, window)",
                "name": "tema",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    }
                ]
            }
        ],
        "markdown": "### [tema](https://docs.dolphindb.cn/zh/funcs/t/tema.html)\n\n\n\n#### 语法\n\ntema(X, window)\n\nTA-lib 系列函数参数说明和窗口计算规则请参考：[TAlib](https://docs.dolphindb.cn/zh/funcs/themes/TAlib.html)\n\n#### 详情\n\n在给定长度（以元素个数衡量）的滑动窗口内，计算 *X* 的三重指数移动平均（Triple Exponential Moving Average）。\n\n其计算公式为：\n\n![ema1](https://docs.dolphindb.cn/zh/images/ema1.png)\n\n![ema2](https://docs.dolphindb.cn/zh/images/ema2.png) ![tema](https://docs.dolphindb.cn/zh/images/tema.png)\n\n与 Python TA-Lib 中 `TEMA` 的区别：二者均计算三重指数移动平均。TA-Lib 的 `TEMA` 是 Overlap Studies 指标，参数 *timeperiod* 默认值为 30，输入 *close* 和输出主要为一维数组；DolphinDB 的 `tema` 使用必填参数 *window* 表示窗口长度，可用于向量、矩阵或表，返回数据形式同 *X*，未填满窗口的位置为 NULL。\n\n#### 返回值\n\nDOUBLE 类型，数据形式同 *X*。\n\n#### 例子\n\n```\nx=12.1 12.2 12.6 12.8 11.9 11.6 11.2\ntema(x,3);\n// output\n[,,,,,,11.24444444444444]\n\nx=matrix(12.1 12.2 12.6 12.8 11.9 11.6 11.2, 14 15 18 19 21 12 10)\ntema(x,3);\n```\n\n| col1    | col2    |\n| ------- | ------- |\n|         |         |\n|         |         |\n|         |         |\n|         |         |\n|         |         |\n|         |         |\n| 11.2444 | 10.6296 |\n\n相关函数：[ema](https://docs.dolphindb.cn/zh/funcs/e/ema.html), [dema](https://docs.dolphindb.cn/zh/funcs/d/dema.html)\n"
    },
    "temporalAdd": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/temporalAdd.html",
        "signatures": [
            {
                "full": "temporalAdd(obj, duration, [unit])",
                "name": "temporalAdd",
                "parameters": [
                    {
                        "full": "obj",
                        "name": "obj"
                    },
                    {
                        "full": "duration",
                        "name": "duration"
                    },
                    {
                        "full": "[unit]",
                        "name": "unit",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [temporalAdd](https://docs.dolphindb.cn/zh/funcs/t/temporalAdd.html)\n\n\n\n#### 语法\n\ntemporalAdd(obj, duration, \\[unit])\n\n别名：datetimeAdd\n\n#### 详情\n\n为时间变量加上一个指定的值。\n\n#### 参数\n\n**obj** 是时间类型的标量或向量。\n\n**duration** 是一个整数或 DURATION 类型数据。\n\n**unit** 是一个字符串标量。\n\n* *duration* 是整数时，*unit* 表示：\n\n  * *duration* 的单位，取值可以是：\"ns\"(nanosecond), \"us\"(microsecond), \"ms\"(millisecond), \"s\"(second), \"m\"(minute), \"H\"(hour), \"d\"(day), \"w\"(week), \"M\"(month), \"y\"(year), “B”(business day)\n\n  * 交易日历的标识，例如：国外交易所的 ISO Code、国内交易所简称或自定义交易日历名称。对应的文件必须保存在 marketHolidayDir 中。\n\n* *duration* 是 DURATION 类型数据时，*unit* 无需设置。\n\n**Note:** 时间单位为 year 或 month 时，计算结果与 mysql 保持一致。Pandas 提供了一个时间偏移对象（Date offsets）来完成时间偏移工作，当 DateOffset 参数取 months 或 years 时，与 `temporalAdd` 单位为 M 或 y 的计算结果也一致。\n\n#### 返回值\n\n时间类型标量或向量。\n\n#### 例子\n\n```\ntemporalAdd(2017.01.16,1,\"d\");\n// output\n2017.01.17\n\ntemporalAdd(2017.01.16,1,\"w\");\n// output\n2017.01.23\n\ntemporalAdd(2016.12M,2,\"M\");\n// output\n2017.02M\n\ntemporalAdd(2012.07.31T13:30:10.008,-1,'M');\n// output\n2012.06.30T13:30:10.008\n\ntemporalAdd(2012.07.31T13:30:10.008,1,'y');\n// output\n2013.07.31T13:30:10.008\n\ntemporalAdd(13:30:10.008007006,100,\"ns\");\n// output\n13:30:10.008007106\n\nx=[12:23:34, 23:34:45];\ntemporalAdd(x, 10m);\n// output\n[12:33:34,23:44:45]\n```\n\n为 2021.08.06 增加 4 个工作日。\n\n```\ntemporalAdd(2021.08.06, 4B)\n// output\n2021.08.12\n```\n\n按照 CFFEX 的交易日历，为 date 增加 2 个交易日。\n\n```\ndate=[2023.01.01, 2023.01.02, 2023.01.03, 2023.01.04]\ntemporalAdd(date,2,`CFFEX)\n// output\n[2023.01.04,2023.01.04,2023.01.05,2023.01.06]\n```\n\n```\ntemporalAdd(datetime(2020.08.31), -2M)\n// output\n2020.06.30T00:00:00\n\n# pandas中 DateOffset 传入参数 months，计算结果一致\npd1 = pd.Timestamp(\"2020.08.31\")\nprint(pd1 -pd.offsets.DateOffset(months=2))\n// output\n2020-06-30 00:00:00\n\ntemporalAdd(datetime(2020.02.29), -1y)\n// output\n2019.02.28T00:00:00\ntemporalAdd(datetime(2020.02.29), -4y)\n// output\n2016.02.29T00:00:00\n\n// pandas 中 offset 设为1年\npd1 = pd.Timestamp(\"2020.02.29\")\nprint(pd1 - pd.offsets.DateOffset(years=1))\n// output\n2019-02-28 00:00:00\n// pandas 中 offset 设为4年\npd2 = pd.Timestamp(\"2020.02.29\")\nprint(pd2 - pd.offsets.DateOffset(years=4))\n// output\n2016-02-29 00:00:00\n```\n"
    },
    "temporalDeltas": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/temporalDeltas.html",
        "signatures": [
            {
                "full": "temporalDeltas(X, [unit])",
                "name": "temporalDeltas",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[unit]",
                        "name": "unit",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [temporalDeltas](https://docs.dolphindb.cn/zh/funcs/t/temporalDeltas.html)\n\n别名：datetimeDeltas\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\ntemporalDeltas(X, \\[unit])\n\n#### 详情\n\n`temporalDeltas` 函数计算*X* 中每个元素与前一个元素之间的时间差，NULL 值在计算中返回 NULL，且输出的第一个值总是 NULL。\n\n* 若*X* 是向量，返回一个包含 *X* 中两个元素之差的向量。\n* 若 *X* 是矩阵，在每列内进行上述计算，返回一个与 *X* 维度相同的矩阵。\n* 若 *X* 是表，在每个时间类型列内进行上述计算，返回一个与 *X* 行数与列数都相同的表。\n\n当提供 *unit*参数时，时间差的计算将基于指定的时间单位（天、工作日或特定交易所的交易日）。\n\n#### 参数\n\n**X** 是一个时间类型的向量、矩阵，或包含时间类型列的表。\n\n**unit**可选参数，是一个字符串标量，指定时间单位。取值可以是：\n\n* \"d\" 表示自然日\n* \"B\" 表示工作日\n* 一个交易日历标识，例如 \"XNYS\"，对应的交易日历文件必须保存在 *marketHolidayDir*配置项指定的目录中。\n\n**Note:** 若指定 *unit*，*X* 必须是 DATE 类型。\n\n#### 返回值\n\nINT 类型，数据形式同 *X*。\n\n#### 例子\n\n```\ntimestamps = [2020.06.13T13:30:10.000, 2020.06.13T13:30:10.010, 2020.06.13T13:30:10.021, 2020.06.13T13:30:10.033, 2020.06.13T13:30:10.046]\ntemporalDeltas(timestamps)\n// Output: [,10,11,12,13]\n```\n\n若指定 *unit* 参数，*X* 必须为日期（DATE）类型：\n\n```\ntimes = [2019.12.31, 2020.01.03, 2020.01.10, 2020.01.15, 2020.01.17]\ntemporalDeltas(times, \"d\");\n// Output: [NULL, 3, 7, 5, 2] \n\ntemporalDeltas(times, \"B\");\n// Output: [NULL, 3, 5, 3, 2] \n\ntemporalDeltas(times, \"XNYS\");\n// Output: [NULL, 2, 5, 3, 2]\n\nsym = `A`B`C`D`E\nnum = 5 4 3 2 1\nt = table(times, sym, num)\ntemporalDeltas(t);\n\n/*\ntimes sym num\n----- --- ---\n      A   5  \n3     B   4  \n7     C   3  \n5     D   2  \n2     E   1  \n*/\n```\n"
    },
    "temporalDiff": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/temporalDiff.html",
        "signatures": [
            {
                "full": "temporalDiff(X, Y, [unit])",
                "name": "temporalDiff",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "[unit]",
                        "name": "unit",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [temporalDiff](https://docs.dolphindb.cn/zh/funcs/t/temporalDiff.html)\n\n别名：datetimeDiff\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\ntemporalDiff(X, Y, \\[unit])\n\n#### 详情\n\n`temporalDiff` 函数计算 *X* 和 *Y* 之间的时间差。\n\n当提供 *unit*参数时，时间差的计算将基于指定的时间单位（天、工作日或特定交易所的交易日）。\n\n#### 参数\n\n**X** 是一个时间类型的标量、向量、矩阵，或包含时间类型列的表。\n\n**Y** 是一个标量，或和 *X* 相同长度的向量、维度相同的矩阵或表。其类型必须与 *X* 严格相同。\n\n**unit**可选参数，是一个字符串标量，指定时间单位。取值可以是：\n\n* \"d\" 表示自然日\n* \"B\" 表示工作日\n* 一个交易日历标识，例如 \"XNYS\"，对应的交易日历文件必须保存在 *marketHolidayDir*配置项指定的目录中。\n\n**Note:** 若指定 *unit*，*X* 和 *Y* 必须是 DATE 类型。\n\n#### 返回值\n\n返回与 *X* 形状相同的标量/向量/矩阵/表。\n\n#### 例子\n\n```\ntimestamps = [13:30:49,13:30:39,13:30:50,13:30:57,13:30:35]\ntemporalDiff(timestamps, 13:30:00)\n// Output: [49,39,50,57,35]\n```\n\n若指定 *unit* 参数，*X* 和 *Y* 必须为日期（DATE）类型：\n\n```\ndates = [2019.12.31, 2020.01.03, 2020.01.10, 2020.01.15, 2020.01.17]\n\ntemporalDiff(dates, 2019.12.30, \"d\") // Output: [1,4,11,16,18]\ntemporalDiff(dates, 2019.12.30, \"B\") // Output: [1,4,9,12,14]\ntemporalDiff(dates, 2019.12.30, \"XNYS\") // Output: [1,3,8,11,13]\n```\n"
    },
    "temporalFormat": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/temporalFormat.html",
        "signatures": [
            {
                "full": "temporalFormat(X, format)",
                "name": "temporalFormat",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "format",
                        "name": "format"
                    }
                ]
            }
        ],
        "markdown": "### [temporalFormat](https://docs.dolphindb.cn/zh/funcs/t/temporalFormat.html)\n\n\n\n#### 语法\n\ntemporalFormat(X, format)\n\n别名：datetimeFormat\n\n#### 详情\n\n把 DolphinDB 时序类型的数据转换成指定格式的字符串。详情请参考： [日期和时间的调整及格式](https://docs.dolphindb.cn/zh/progr/data_mani/format_temp_obj.html)。\n\n#### 参数\n\n**X** 是一个时间序列标量或向量。\n\n**format** 是表示时间格式的字符串。\n\n#### 返回值\n\nSTRING 类型标量或向量。\n\n#### 例子\n\n```\ntemporalFormat(2018.02.14,\"dd-MM-yyyy\");\n// output: 14-02-2018\n\ntemporalFormat(2018.02.14,\"dd-MMM-yy\");\n// output: 14-FEB-18\n\ntemporalFormat(02:19:06,\"HH.mm.ss\");\n// output: 02.19.06\n\ntemporalFormat(2018.02.06T13:30:10.001, \"y-M-d-H-m-s-SSS\");\n// output: 2018-2-6-13-30-10-001\n\ntemporalFormat(14:19:06,\"hhmmssaa\");\n// output: 021906PM\n```\n"
    },
    "temporalParse": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/temporalParse.html",
        "signatures": [
            {
                "full": "temporalParse(X, format)",
                "name": "temporalParse",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "format",
                        "name": "format"
                    }
                ]
            }
        ],
        "markdown": "### [temporalParse](https://docs.dolphindb.cn/zh/funcs/t/temporalParse.html)\n\n\n\n#### 语法\n\ntemporalParse(X, format)\n\n别名：datetimeParse\n\n#### 详情\n\n把字符串转换成 DolphinDB 中的时序类型数据。如果系统不能识别时序格式，将返回 NULL。\n\nDolphinDB 具有以下时序格式：\n\n| 格式        | 含义       | 范围                                          |\n| --------- | -------- | ------------------------------------------- |\n| yyyy      | 年份（4个数字） | 1000-9999                                   |\n| yy        | 年份（2个数字） | 00-99. (00-39: 2000-2039; 40-99: 1940-1999) |\n| MM        | 月份       | 1月12日                                       |\n| MMM       | 月份       | JAN, FEB, ... DEC （不区分大小写）                  |\n| dd        | 日期       | 1月31日                                       |\n| HH        | 时（24小时制） | 0-23                                        |\n| hh        | 时（12小时制） | 0-11                                        |\n| mm        | 分钟       | 0-59                                        |\n| ss        | 秒        | 0-59                                        |\n| aa        | 上午/下午    | AM, PM. （不区分大小写）                            |\n| SSS       | 毫秒       | 0-999                                       |\n| nnnnnn    | 微秒       | 0-999999                                    |\n| nnnnnnnnn | 纳秒       | 0-999999999                                 |\n\n`temporalParse` 函数中的 *format* 参数有以下两种表示方式：\n\n* 使用分隔符\n\n  对于 *format* 参数 ，除了 y, M, d, H, h, m, s, a, S, n 以外的符号的字符都可以作为分隔符。*format* 参数中的分隔符需要与输入字符串中的分隔符一致。\n\n  ```\n  temporalParse(\"14-02-2018\",\"dd-MM-yyyy\");\n  // output\n  2018.02.14\n\n  temporalParse(\"14-02-2018\",\"dd/MM/yyyy\");\n  // output\n  00d\n\n  temporalParse(\"14//02//2018\",\"dd//MM//yyyy\");\n  // output\n  2018.02.14\n\n  temporalParse(\"14//02//2018\",\"dd/MM/yyyy\");\n  // output\n  00d\n\n  temporalParse(\"14//02//2018\",\"dd..MM..yyyy\");\n  // output\n  00d\n  ```\n\n  我们可以使用单个字母来简化格式。例如，使用 \"y/M/d\" 代替 \"yyyy/MM/dd\"。因为 \"y\" 可以表示 \"yyyy\" 和 \"yy\", 系统会根据数字的个数采用 \"yyyy\" 或 \"yy\"。\n\n  ```\n  temporalParse(\"14-02-18\",\"d-M-y\");\n  // output\n  2018.02.14\n\n  temporalParse(\"2018/2/6 02:33:01 PM\",\"y/M/d h:m:s a\");\n  // output\n  2018.02.06T14:33:01\n  ```\n\n  \"MMM\",\"SSS\", \"nnnnnn\" , \"nnnnnnnnn\" 不能使用单个字母。\n\n  ```\n  temporalParse(\"02-FEB-2018\",\"d-MMM-y\");\n  // output\n  2018.02.02\n\n  temporalParse(\"02-FEB-2018\",\"d-M-y\");\n  // output\n  00d\n\n  temporalParse(\"13:30:10.001\",\"H:m:s.SSS\");\n  // output\n  13:30:10.001\n\n  temporalParse(\"13:30:10.001\",\"H:m:s.S\");\n  // output\n  Invalid temporal format: 'H:m:s.S'. Millisecond (S) must have three digits.\n\n  temporalParse(\"13:30:10.008001\",\"H:m:s.nnnnnn\");\n  // output\n  13:30:10.008001000\n\n  temporalParse(\"13:30:10.008001\",\"H:m:s.n\");\n  // output\n  Invalid temporal format: 'H:m:s.n'. Nanosecond (n) must have six or nine digits.\n  ```\n\n  `temporalParse` 函数解释输入字符串中数字个数的方式是非常灵活的。\n\n  ```\n  temporalParse(\"2-4-18\",\"d-M-yy\");\n  // output\n  2018.04.02\n\n  temporalParse(\"2-19-6\",\"H-m-s\");\n  // output\n  02:19:06\n\n  temporalParse(\"002-019-006\",\"H-m-s\");\n  // output\n  02:19:06\n  ```\n\n  对于毫秒，微秒和纳秒，对应的数字位个数必须是3, 6, 9。\n\n  ```\n  temporalParse(\"2018/2/6 13:30:10.001\",\"y/M/d H:m:s.SSS\");\n  // output\n  2018.02.06T13:30:10.001\n\n  temporalParse(\"2018/2/6 13:30:10.01\",\"y/M/d H:m:s.SSS\");\n  // output\n  00T\n\n  temporalParse(\"2018/2/6 13:30:10.000001\",\"y/M/d H:m:s.nnnnnn\");\n  // output\n  2018.02.06T13:30:10.000001000\n\n  temporalParse(\"2018/2/6 13:30:10.0000010\",\"y/M/d H:m:s.nnnnnn\");\n  // output\n  00N\n  ```\n\n* 不使用分隔符\n\n  对于这种表示方式，*format* 参数必须与上述表格中的格式对应，不能使用单个字母来表示格式。\n\n  ```\n  temporalParse(\"20180214\",\"yyyyMMdd\");\n  // output\n  2018.02.14\n\n  temporalParse(\"122506\",\"MMddyy\");\n  // output\n  2006.12.25\n\n  temporalParse(\"155950\",\"HHmmss\");\n  // output\n  15:59:50\n\n  temporalParse(\"035901PM\",\"hhmmssaa\");\n  // output\n  15:59:01\n\n  temporalParse(\"02062018155956001000001\",\"MMddyyyyHHmmssnnnnnnnnn\");\n  // output\n  2018.02.06T15:59:56.001000001\n  ```\n\n#### 参数\n\n**X** 是一个字符串。\n\n**format** 是表示时间序列对象格式的字符串。\n\n#### 返回值\n\n时序类型标量或向量。\n"
    },
    "temporalSeq": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/temporalSeq.html",
        "signatures": [
            {
                "full": "temporalSeq(start, end, rule, [closed], [label], [origin='start_day'])",
                "name": "temporalSeq",
                "parameters": [
                    {
                        "full": "start",
                        "name": "start"
                    },
                    {
                        "full": "end",
                        "name": "end"
                    },
                    {
                        "full": "rule",
                        "name": "rule"
                    },
                    {
                        "full": "[closed]",
                        "name": "closed",
                        "optional": true
                    },
                    {
                        "full": "[label]",
                        "name": "label",
                        "optional": true
                    },
                    {
                        "full": "[origin='start_day']",
                        "name": "origin",
                        "optional": true,
                        "default": "'start_day'"
                    }
                ]
            }
        ],
        "markdown": "### [temporalSeq](https://docs.dolphindb.cn/zh/funcs/t/temporalSeq.html)\n\n\n\n#### 语法\n\ntemporalSeq(start, end, rule, \\[closed], \\[label], \\[origin='start\\_day'])\n\n#### 详情\n\n根据 *rule* 指定的频率，对由 *start* 开始，*end* 结尾的时间序列进行重采样，并返回新生成的时间序列。\n\n#### 参数\n\n**start** 时间类型标量。\n\n**end** 时间类型标量。必须和 *start* 的类型相同，且值必须大于 *start*。\n\n**rule** 字符串，可取以下值：\n\n| rule 参数取值 | 对应 DolphinDB 函数      |\n| --------- | -------------------- |\n| \"B\"       | businessDay          |\n| \"W\"       | weekEnd              |\n| \"WOM\"     | weekOfMonth          |\n| \"LWOM\"    | lastWeekOfMonth      |\n| \"M\"       | monthEnd             |\n| \"MS\"      | monthBegin           |\n| \"BM\"      | businessMonthEnd     |\n| \"BMS\"     | businessMonthBegin   |\n| \"SM\"      | semiMonthEnd         |\n| \"SMS\"     | semiMonthBegin       |\n| \"Q\"       | quarterEnd           |\n| \"QS\"      | quarterBegin         |\n| \"BQ\"      | businessQuarterEnd   |\n| \"BQS\"     | businessQuarterBegin |\n| \"REQ\"     | fy5253Quarter        |\n| \"A\"       | yearEnd              |\n| \"AS\"      | yearBegin            |\n| \"BA\"      | businessYearEnd      |\n| \"BAS\"     | businessYearBegin    |\n| \"RE\"      | fy5253               |\n| \"D\"       | date                 |\n| \"H\"       | hourOfDay            |\n| \"U\"       | microsecond          |\n| \"L\"       | millisecond          |\n| \"min\"     | minuteOfHour         |\n| \"N\"       | nanosecond           |\n| \"S\"       | secondOfMinute       |\n| \"SA\"      | semiannualEnd        |\n| \"SAS\"     | semiannualBegin      |\n\n上述字符串亦可配合使用数字，例如 \"2M\" 表示频率为每两个月月末。此外，*rule* 也可以是交易日历标识，例如：国外交易所的 ISO Code、国内交易所简称或自定义交易日历名称。\n\n**closed** 字符串，表示重采样时间窗口的闭合边界。可取值为 \"left\", \"right\"。\n\n* *rule* 为 'M', 'A', 'Q', 'BM', 'BA', 'BQ' 和 'W' 时，*closed* 的默认取值为 'right' ，否则，*closed* 的默认取值为 'left'。\n* *origin* 取 'end' 或者 'end\\_day' 时，*closed* 的默认值为 'right'。\n\n**label** 字符串，表示重采样时间窗口的标签位置。可取值为 \"left\", \"right\"。\n\n* *rule* 为 'M', 'A', 'Q', 'BM', 'BA', 'BQ' 和 'W' 时，label 的默认取值为 'right' ，否则，*label* 的默认取值为 'left'。\n\n* *origin* 取 'end' 或者 'end\\_day' 时，*label* 的默认值为 'right'。\n\n**origin** 字符串或与 *start/end* 具有相同时间类型的标量，表示重采样的基准时间点，即重采样的起始点。*origin* 的取值为 'epoch', start', 'start\\_day', 'end', 'end\\_day' 或自定义的时间对象，默认值为 'start\\_day'。 字符串，表示重采样时间窗口的标签位置。可取值为 \"left\", \"right\"。\n\n* 'epoch'：分组起始点为1970-01-01。\n\n* 'start'：分组起始点为 *start* 参数指定的值。\n\n* 'start\\_day'：分组起始点是 *start* 参数指定值对应日期的午夜零点。\n\n* 'end'：分组起始点是 *end* 参数指定的值。\n\n* 'end\\_day'：分组起始点是 *end* 参数指定值对应日期的午夜24点（即下一日的零点）。\n\n#### 返回值\n\nTemporal 类型向量。\n\n#### 例子\n\n例1. 从00:01:00开始，到00:08:00，按3分钟间隔取样，默认左闭右开区间（*closed*='left'），默认取时间窗口的左边界（*label*='left'）。\n\n```\ntemporalSeq(start=2022.01.01 00:01:00,end=2022.01.01 00:08:00,rule=\"3min\")\n```\n\n输出返回：`[2022.01.01T00:00:00,2022.01.01T00:03:00,2022.01.01T00:06:00]`\n\n例2. 基于例1，设置 *closed*=\\`right，为左开右闭。由于此时 *label* 的取值默认为 'left'，结果与例1相同。\n\n```\ntemporalSeq(start=2022.01.01 00:01:00, end=2022.01.01 00:08:00, rule=\"3min\", closed=`right)\n```\n\n输出返回：`[2022.01.01T00:00:00,2022.01.01T00:03:00,2022.01.01T00:06:00]`\n\n例3. 基于例2，设置 *label*=\\`right，即输出每个窗口的右边界，因此生成3分、6分、9分三个时间点。\n\n```\ntemporalSeq(start=2022.01.01 00:01:00, end=2022.01.01 00:08:00, rule=\"3min\", closed=`right, label=`right)\n```\n\n输出返回：`[2022.01.01T00:03:00,2022.01.01T00:06:00,2022.01.01T00:09:00]`\n\n例4. 基于例2，设置 *origin*='end'，以结束时间00:08:00为基准向前取样，此时默认为左开右闭，因此生成2分、5分、8分三个时间点。\n\n```\ntemporalSeq(start=2022.01.01 00:01:00, end=2022.01.01 00:08:00, rule=\"3min\", closed=`right, origin=`end)\n```\n\n输出返回：`[2022.01.01T00:02:00,2022.01.01T00:05:00,2022.01.01T00:08:00]`\n\n例5. 与例4不同的是，本例设置 *origin*=2022.10.01 00:00:10，以自定义的10秒为基准点，生成了00:00:10、00:03:10、00:06:10三个时间点。\n\n```\ntemporalSeq(start=2022.01.01 00:01:00, end=2022.01.01 00:08:00, rule=\"3min\", closed=`right, origin=2022.10.01 00:00:10)\n```\n\n输出返回：`[2022.01.01T00:00:10,2022.01.01T00:03:10,2022.01.01T00:06:10]`\n"
    },
    "tensor": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tensor.html",
        "signatures": [
            {
                "full": "tensor(X)",
                "name": "tensor",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [tensor](https://docs.dolphindb.cn/zh/funcs/t/tensor.html)\n\n\n\n#### 语法\n\ntensor(X)\n\n#### 详情\n\n将 *X* 转换为一个 tensor。转换规则如下：\n\n<table id=\"table_hpg_f52_xbc\"><thead><tr><th>\n\n**X**\n\n</th><th>\n\n**转换结果**\n\n</th></tr></thead><tbody><tr><td>\n\n标量\n\n</td><td>\n\n1 维 tensor\n\n</td></tr><tr><td>\n\n常规向量\n\n</td><td>\n\n1 维 tensor\n\n</td></tr><tr><td>\n\n列式元组\n\n</td><td>\n\n2 维 tensor\n\n</td></tr><tr><td>\n\n矩阵\n\n</td><td>\n\n2 维 tensor\n\n</td></tr><tr><td>\n\n表（每一列具有相同类型）\n\n</td><td>\n\n2 维 tensor\n\n</td></tr><tr><td>\n\ntuple（每个元素都是具有相同类型的向量，tuple of vector）\n\n</td><td>\n\n2 维 tensor\n\n</td></tr><tr><td>\n\ntuple（每个元素都是维度和类型都相同的矩阵，tuple of matrix）\n\n</td><td>\n\n3 维 tensor\n\n</td></tr><tr><td>\n\ntuple（每个元素都是 tuple，且子 tuple 的每个元素都是类型相同的向量，tuple of tuple）\n\n</td><td>\n\n3 维 tensor\n\n</td></tr><tr><td>\n\n多个 tuple 嵌套\n\n</td><td>\n\nn 维 tensor，n<=10\n\n</td></tr></tbody>\n</table>目前 tensor 主要应用于 DolphinDB 插件（如 LibTorch 等），与深度学习框架进行数据交换。DolphinDB 中的 tensor 目前暂不支持直接存储和计算，并且不支持直接访问和修改其元素。\n\n#### 参数\n\n**X** 可以是标量、向量、元组、列式元组、矩阵或表。目前仅支持以下数据类型：BOOL, CHAR, SHORT, INT, LONG, FLOAT, DOUBLE。\n\n#### 返回值\n\n返回一个数据类型同 *X* 的张量。\n\n#### 例子\n\n```\n// 标量转为 tensor\ntensor(3)\n/* 输出一个长度为 1 的 1 维 tensor<int[1]>:\n0: int 3\n*/\n\n// 向量转为 tensor\ntensor(1 2 3)\n/* 输出一个长度为 3 的 1 维 tensor<int[3]>：\n0: int 1\n1: int 2\n2: int 3\n*/\n\n//列式元组转为 tensor\ntp = [[1.3,2.5,2.3], [4.1,5.3,5], [4.1,5.3,5]]\ntp.setColumnarTuple!()\ntensor(tp)\n\n/* 输出一个 2 维 tensor<double[3][3]>：\n0: double[3] [1.3, 2.5, 2.3]\n1: double[3] [4.1, 5.3, 5]\n2: double[3] [4.1, 5.3, 5] \n */\n\n//矩阵转为 tensor\nm= 1..6$2:3\ntensor(m)\n\n/* 输出一个 2 维 tensor<int[2][3]>：\n0: int[3] [1, 3, 5]\n1: int[3] [2, 4, 6]\n*/\n\n// 表转为 tensor\nt=table(1..5 as id1, 6..10 as id2)\ntensor(t)\n\n/* 输出一个 2 维 tensor<int[5][2]>：\n0: int[2] [1, 6]\n1: int[2] [2, 7]\n2: int[2] [3, 8]\n3: int[2] [4, 9]\n4: int[2] [5, 10]\n*/\n\n// 元组转为 tensor\ntp1 = [[1.3,2.5,2.3], [4.1,5.3,5], [4.1,5.3,5]]\ntensor(tp1)\n\n/* 输出一个 2 维 tensor<double[3][3]>：\n0: double[3] [1.3, 4.1, 4.1]\n1: double[3] [2.5, 5.3, 5.3]\n2: double[3] [2.3, 5, 5]\n*/\n\n// tuple of matrix 转为 tensor\nm1= 1..6$2:3\nm2=4..9$2:3\ntensor([m1,m2])\n\n/* 输出一个 3 维 tensor<int[2][2][3]>:\n0: int[2][3]\n1: int[2][3]\n*/\n\n// tuple of tuple 转为 tensor\ntp1 = [[1.3,2.5,2.3], [4.1,5.3,5], [4.1,5.3,5]]\ntp2 = [[1.1,1.2,1.4], [1.5,1.2,1.6], [1.3,1.5,1.8]]\ntensor([tp1, tp2])\n\n/* 输出一个 3 维 tensor<double[2][3][3]>:\n0: double[3][3]\n1: double[3][3]\n*/\n\n// tuple 嵌套转为 tensor\ntp1 = [[1.3,2.5,2.3], [4.1,5.3,5], [4.1,5.3,5]]\ntp2 = [[1.1,1.2,1.4], [1.5,1.2,1.6], [1.3,1.5,1.8]]\ntp3 = [[2.1,6.2,4.4], [3.5,1.9,3.6], [1.8,3.5,9.8]]\ntensor([[tp1, tp2],[tp1, tp3]])\n\n/* 输出一个 4 维 tensor<double[2][2][3][3]>:\n0: double[2][3][3]\n1: double[2][3][3]\n*/\n```\n"
    },
    "terminate": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/terminate.html",
        "signatures": [
            {
                "full": "terminate()",
                "name": "terminate",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [terminate](https://docs.dolphindb.cn/zh/funcs/t/terminate.html)\n\n\n\n#### 语法\n\nterminate()\n\n#### 详情\n\n`terminate` 是 EventListener 类的方法，用于停止当前事件监听器的运行。调用后，该监听器将不再继续接收或处理新的事件，即便其匹配条件仍满足也不会再触发回调函数。通常用于在运行过程中根据业务逻辑动态取消某些不再需要的事件监听，以避免资源占用或重复处理。\n\n#### 参数\n\n无。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\nclass trades{\n    trader :: STRING\n    market :: STRING\n    code :: STRING\n    price :: DOUBLE\n    qty :: INT\n    eventTime :: TIMESTAMP\n    def trades(t, m, c, p, q){\n        trader = t\n        market = m\n        code = c\n        price = p\n        qty = q\n        eventTime = now()\n    }\n}\n\nclass mainMonitor:CEPMonitor{\n    tradesTable :: ANY\n    isBusy :: BOOL\n    def mainMonitor(){\n        tradesTable = array(ANY, 0)\n        isBusy = false\n    }\n\n    def updateTrades(event)\n\n    def updateTrades2(event)\n\n    def unOnload(){\n        undef('traderDV', SHARED)\n    }\n\n    def onload(){\n        addEventListener(updateTrades, `trades, , \"all\",,,,,\"trades1\")\n        addEventListener(updateTrades2, `trades, , \"all\",,,,,\"trades2\")\n        traderDV = streamTable(array(STRING, 0) as trader, array(STRING, 0) as market, array(SYMBOL, 0) as code, array(DOUBLE, 0) as price, array(INT, 0) as qty, array(INT, 0) as tradeCount, array(BOOL, 0) as busy, array(DATE, 0) as orderDate, array(TIMESTAMP, 0) as updateTime)\n        share(traderDV, 'traderDV')\n        createDataViewEngine('traderDV', objByName('traderDV'), `trader, `updateTime, true)\n    }\n\n    def updateTrades(event) {\n        tradesTable.append!([event.trader, event.market, event.code, event.price, event.qty])\n        getDataViewEngine('traderDV').append!(table(event.trader as trader, string() as market, string() as code, 0.0 as price, 0 as qty, 0 as tradeCount, false as busy, date(event.eventTime) as orderDate))\n        updateDataViewItems('traderDV', event.trader, ['market', 'code', 'price', 'qty', 'tradeCount'], [event.market, event.code, event.price, event.qty, tradesTable.size()])\n    }\n\n    def updateTrades2(event) {\n        tradesTable.append!([event.trader, event.market, event.code, event.price, event.qty])\n        getDataViewEngine('traderDV').append!(table(event.trader as trader, string() as market, string() as code, 0.0 as price, 0 as qty, 0 as tradeCount, false as busy, date(event.eventTime) as orderDate))\n        updateDataViewItems('traderDV', event.trader, ['market', 'code', 'price', 'qty', 'tradeCount'], [event.market, event.code, event.price, event.qty, tradesTable.size()])\n    }\n}\n\ndummy = table(array(TIMESTAMP, 0) as eventTime, array(STRING, 0) as eventType, array(BLOB, 0) as blobs)\nengineCep = createCEPEngine('cep1', <mainMonitor()>, dummy, [trades], 1, 'eventTime', 10000)\ntrade1 = trades('t1', 'sz', 's001', 11.0, 10)\ngo\nappendEvent(engineCep, trade1)\n// 查看 monitor\nmonitors = getCEPEngineMonitor('cep1',\"cep1\",\"mainMonitor\")\n// 查看 listener\nlisteners = monitors.getEventListener()\nprint(listeners)\n// 终止 listener\nlisteners['trades1'].terminate()\nprint(listeners)\n```\n\n**相关函数**：[addEventListener](https://docs.dolphindb.cn/zh/funcs/a/addEventListener.html)\n"
    },
    "test": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/test.html",
        "signatures": [
            {
                "full": "test(scriptFile, [outputFile], [testMemLeaking=false])",
                "name": "test",
                "parameters": [
                    {
                        "full": "scriptFile",
                        "name": "scriptFile"
                    },
                    {
                        "full": "[outputFile]",
                        "name": "outputFile",
                        "optional": true
                    },
                    {
                        "full": "[testMemLeaking=false]",
                        "name": "testMemLeaking",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [test](https://docs.dolphindb.cn/zh/funcs/t/test.html)\n\n\n\n#### 语法\n\ntest(scriptFile, \\[outputFile], \\[testMemLeaking=false])\n\n#### 详情\n\n用于单元测试的系统命令。该命令必须要用户登录后才能执行。\n\n如果 *scriptFile* 是一个目录，将执行测试目录中所有脚本文件，不会执行子目录中的文件。\n\n如果 *outputFile* 没有指定，测试结果将会显示在屏幕上。如果 *outputFile* 指定为相对路径，则测试结果文件输出到 \\<HomeDir>。\n\n**Note:**\n\nDolphinDB 的 `test` 函数用于执行指定的测试脚本文件并返回结果；`numpy.test` 可以发现并运行模块及其子模块中定义的测试用例；`pandas.test` 用于运行 pandas 自身的测试套件，通过 pytest 验证库的功能是否正常，并可选择性地执行文档测试；`scipy.test` 提供了更多参数精细化控制，如快慢标签、并行执行、覆盖率统计及子模块定向测试；`statsmodels.test` 用于验证已安装的库是否完整可用，主要用于发布构建而非开发。\n\n#### 参数\n\n**scriptFile** 是字符串，表示服务器端的测试脚本文件或目录。可以是相对路径或绝对路径。\n\n**outputFile** 是字符串，表示服务器端的测试结果输出文件。可以是相对路径或绝对路径。\n\n**testMemLeaking** 是布尔值，表示是否测试内存泄漏。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\ntest(\"/home/Data/test.dos\", \"/home/Data/result.dos\");\ntest(\"/home/Data\");\n```\n"
    },
    "textChunkDS": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/textChunkDS.html",
        "signatures": [
            {
                "full": "textChunkDS(filename, chunkSize, [delimiter], [schema], [skipRows=0], [arrayDelimiter], [containHeader], [arrayMarker])",
                "name": "textChunkDS",
                "parameters": [
                    {
                        "full": "filename",
                        "name": "filename"
                    },
                    {
                        "full": "chunkSize",
                        "name": "chunkSize"
                    },
                    {
                        "full": "[delimiter]",
                        "name": "delimiter",
                        "optional": true
                    },
                    {
                        "full": "[schema]",
                        "name": "schema",
                        "optional": true
                    },
                    {
                        "full": "[skipRows=0]",
                        "name": "skipRows",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[arrayDelimiter]",
                        "name": "arrayDelimiter",
                        "optional": true
                    },
                    {
                        "full": "[containHeader]",
                        "name": "containHeader",
                        "optional": true
                    },
                    {
                        "full": "[arrayMarker]",
                        "name": "arrayMarker",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [textChunkDS](https://docs.dolphindb.cn/zh/funcs/t/textChunkDS.html)\n\n\n\n#### 语法\n\ntextChunkDS(filename, chunkSize, \\[delimiter], \\[schema], \\[skipRows=0], \\[arrayDelimiter], \\[containHeader], \\[arrayMarker])\n\n#### 详情\n\n将文件划分为多个数据源，每个数据源的大小为 *chunkSize*。如果需要将大文本文件加载到 DolphinDB, 可以使用 *textChunkDS* 函数将文本文件划分为多个小文件数据源，再通过 [mr](https://docs.dolphindb.cn/zh/funcs/m/mr.html) 函数写入到数据库中。与直接把大文本文件加载到数据库对比，这种方法占用的内存更少。\n\n当 DolphinDB 加载数据文件时，会进行随机抽样，并基于样本决定每列的数据类型。这个方法不一定每次都能准确决定各列的数据类型。因此我们建议，在加载数据前，使用 [extractTextSchema](https://docs.dolphindb.cn/zh/funcs/e/extractTextSchema.html) 函数查看 DolphinDB 识别每列的数据类型。如果 DolphinDB 识别的数据类型不符合预期，可以在 *schema* 的 type 列中指定数据类型。对于日期列或时间列，如果 DolphinDB 识别的数据类型不符合预期，不仅需要在 *schema* 的 type 列指定时间类型，还需要在 format 列中指定数据文件中日期或时间的格式（用字符串表示），如 \"MM/dd/yyyy\"。如何表示日期和时间格式请参考 [日期和时间的调整及格式](https://docs.dolphindb.cn/zh/progr/data_mani/format_temp_obj.html)。\n\n#### 参数\n\n**filename** 一个字符串，表示文件的绝对路径。仅支持 CSV 格式的文件。若传入其他格式文件，则无法保证数据准确性。\n\n**chunkSize** 1 到 2048 之间的整数，表示文件块的大小，单位是 MB。\n\n**delimiter** 字符串标量，表示数据文件中各列的分隔符。分隔符可以是一个或多个字符，默认是逗号（\",\"）。\n\n**schema** 表对象，用于指定各字段的数据类型。具体请参考 [loadText](https://docs.dolphindb.cn/zh/funcs/l/loadText.html) 的 *schema* 参数。\n\n**skipRows** 0 到 1024 之间的整数，表示从文件头开始忽略的行数。它是一个可选参数。默认值为 0。\n\n**arrayDelimiter** 数据文件中数组向量列的分隔符。默认是逗号。由于不支持自动识别数组向量，必须同步修改 *schema* 的 type 列修为数组向量类型。\n\n**containHeader** 布尔值，表示数据文件是否包含标题行，默认为空。具体请参考 [loadText](https://docs.dolphindb.cn/zh/funcs/l/loadText.html) 的 *containHeader* 参数。\n\n**arrayMarker** 包含两个字符的字符串或或 CHAR 类型数据对，两个字符分别表示数组向量左右边界的标识符。默认标识符为双引号（\"）。\n\n* 不能包含空格、Tab(`\\t`) 和换行符(`\\t`和`\\n`)。\n\n* 不能包含数字或字母。\n\n* 如果其中一个为双引号(\")，另一个也必须为双引号。\n\n* 如果标识符为 `'`，`\"` 或`\\` ，需视情况添加转义符。例如 `arrayMarker=\"\\\"\\\"\"`。\n\n* 如果 *delimiter*是单个字符，则 *arrayMarker*不能包含与其相同的字符。\n\n* 如果 *delimiter*是多个字符，则 *arrayMarker* 左边界不能与 *delimiter*的首个字符相同。\n\n#### 返回值\n\nDATASOURCE 元组。\n\n#### 例子\n\n首先，通过以下脚本生成一个大约 3.2G 的文本文件：\n\n```\nn=30000000\nworkDir = \"/home/DolphinDB\"\nif(!exists(workDir)) mkdir(workDir)\ntrades=table(rand(`IBM`MSFT`GM`C`FB`GOOG`V`F`XOM`AMZN`TSLA`PG`S,n) as sym, 2000.01.01+rand(365,n) as date, 10.0+rand(2.0,n) as price1, 100.0+rand(20.0,n) as price2, 1000.0+rand(200.0,n) as price3, 10000.0+rand(2000.0,n) as price4, 10000.0+rand(3000.0,n) as price5, 10000.0+rand(4000.0,n) as price6, rand(10,n) as qty1, rand(100,n) as qty2, rand(1000,n) as qty3, rand(10000,n) as qty4, rand(10000,n) as qty5, rand(10000,n) as qty6)\ntrades.saveText(workDir + \"/trades.txt\");\n```\n\n通过 `textChunkDS` 函数和 `mr` 函数将该文件导入到分布式数据库中：\n\n```\ndb=database(\"dfs://db1\",VALUE, `IBM`MSFT`GM`C`FB`GOOG`V`F`XOM`AMZN`TSLA`PG`S)\npt=db.createPartitionedTable(trades,`pt,`sym)\nds=textChunkDS(workDir + \"/trades.txt\",500)\nmr(ds,append!{pt},,,false)\n```\n\n**Note:** 每个小文件数据源可能包含相同分区的数据。DolphinDB 不允许多个线程同时对相同分区进行写入，因此要将 `mr` 函数 *parallel* 参数设置为 false，否则会抛出异常。\n"
    },
    "til": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/til.html",
        "signatures": [
            {
                "full": "til(n)",
                "name": "til",
                "parameters": [
                    {
                        "full": "n",
                        "name": "n"
                    }
                ]
            }
        ],
        "markdown": "### [til](https://docs.dolphindb.cn/zh/funcs/t/til.html)\n\n\n\n#### 语法\n\ntil(n)\n\n#### 详情\n\n返回 0 到 *n*-1 的整型向量。注意：若 *n* 为 0，则返回空向量。\n\n**Note:**\n\n返回值的类型与 *n* 的类型保持一致，如：若 *n* 类型是 LONG，则返回值的类型是 FAST LONG VECTOR。\n\n#### 参数\n\n**n** 非负整数。\n\n#### 例子\n\n```\ntil(0);\n// output\n[]\n\ntil(5);\n// output\n[0,1,2,3,4]\n\nn = 10;\nt = table(2022.01.01 + til(n) as date, rand(10.0, n) as val);\nt;\n// output\ndate        val\n2022.01.01  8.403\n2022.01.02  9.424\n2022.01.03  0.4779\n2022.01.04  1.8934\n2022.01.05  9.6637\n2022.01.06  1.7993\n2022.01.07  7.1143\n2022.01.08  8.3044\n2022.01.09  2.6919\n2022.01.10  1.9294\n```\n\n相关函数：[take](https://docs.dolphindb.cn/zh/funcs/t/take.html), [rand](https://docs.dolphindb.cn/zh/funcs/r/rand.html)\n"
    },
    "time": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/time.html",
        "signatures": [
            {
                "full": "time(X)",
                "name": "time",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [time](https://docs.dolphindb.cn/zh/funcs/t/time.html)\n\n\n\n#### 语法\n\ntime(X)\n\n#### 详情\n\n返回毫秒精度时间。\n\n#### 参数\n\n**X** 是一个时间标量/向量。\n\n#### 返回值\n\nTIME 类型标量或向量。\n\n#### 例子\n\n```\ntime();\n```\n\n返回：null\n\n```\ntime(1)\n```\n\n返回：00:00:00.001\n\n```\ntime(\"12:32:56.356\");\n```\n\n返回：12:32:56.356\n\n```\ntime(now());\n```\n\n返回：16:03:36.529\n"
    },
    "timestamp": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/timestamp.html",
        "signatures": [
            {
                "full": "timestamp(X)",
                "name": "timestamp",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [timestamp](https://docs.dolphindb.cn/zh/funcs/t/timestamp.html)\n\n\n\n#### 语法\n\ntimestamp(X)\n\n#### 详情\n\n返回由日期和精确到毫秒的时间组成的时间戳。返回的数据类型是 TIMESTAMP，一个时间值。如果参数 *X* 不是日期和时间，则返回值是 1970.01.01 00:00:00.000 + *X* 毫秒的时间戳。\n\n#### 参数\n\n**X** 是一个时间标量或向量。\n\n**Note:** 自 2.00.12 版本起，支持转换 MONTH 类型的数据。\n\n#### 返回值\n\nTIMESTAMP 类型标量或向量。\n\n#### 例子\n\n```\ntimestamp(1)\n```\n\n返回：1970.01.01 00:00:00.001\n\n```\ntimestamp(2016.10.12);\n```\n\n返回：2016.10.12 00:00:00.000\n\n```\ntimestamp(2016.10.12)+1;\n```\n\n返回：2016.10.12 00:00:00.001\n\n```\ntimestamp(now());\n```\n\n返回：2024.02.22 15:57:33.291\n\n```\ntimestamp(2012.01M)\n```\n\n返回：2012.01.01T00:00:00.000\n"
    },
    "tmavg": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tmavg.html",
        "signatures": [
            {
                "full": "tmavg(T, X, window)",
                "name": "tmavg",
                "parameters": [
                    {
                        "full": "T",
                        "name": "T"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    }
                ]
            }
        ],
        "markdown": "### [tmavg](https://docs.dolphindb.cn/zh/funcs/t/tmavg.html)\n\n\n\n#### 语法\n\ntmavg(T, X, window)\n\n参数说明和窗口计算规则请参考：[tmFunctions](https://docs.dolphindb.cn/zh/funcs/themes/tmFunctions.html)\n\n#### 详情\n\n在给定长度（以时间 *T* 衡量）的滑动窗口内计算 *X* 元素的平均值。\n\n#### 返回值\n\nDOUBLE 类型向量。\n\n#### 例子\n\n```\nT = 1 1 1 2 5 6\nX = 1 4 2 -1 2 4\nm = table(T as t,X as x)\nselect *, tmavg(t, x, 3) from m\n```\n\n| t | x  | tmavg\\_t |\n| - | -- | -------- |\n| 1 | 1  | 1        |\n| 1 | 4  | 2.5      |\n| 1 | 2  | 2.3333   |\n| 2 | -1 | 1.5      |\n| 5 | 2  | 2        |\n| 6 | 4  | 3        |\n\n```\nT = 2021.01.02 2021.01.02  2021.01.04  2021.01.05 2021.01.07 2021.01.08\nX = 1 4 2 -1 2 4\nm = table(T as t,X as x)\nselect *, tmavg(t, x, 3d) from m\n```\n\n| t          | x  | tmavg\\_t |\n| ---------- | -- | -------- |\n| 2021.01.02 | 1  | 1        |\n| 2021.01.02 | 4  | 2.5      |\n| 2021.01.04 | 2  | 2.3333   |\n| 2021.01.05 | -1 | 0.5      |\n| 2021.01.07 | 2  | 0.5      |\n| 2021.01.08 | 4  | 3        |\n\n```\nselect *, tmavg(t, x, 1w) from m\n```\n\n| t          | x  | tmavg\\_t |\n| ---------- | -- | -------- |\n| 2021.01.02 | 1  | 1        |\n| 2021.01.02 | 4  | 2.5      |\n| 2021.01.04 | 2  | 2.3333   |\n| 2021.01.05 | -1 | 1.5      |\n| 2021.01.07 | 2  | 1.6      |\n| 2021.01.08 | 4  | 2        |\n\n相关函数：[mavg](https://docs.dolphindb.cn/zh/funcs/m/mavg.html), [avg](https://docs.dolphindb.cn/zh/funcs/a/avg.html)\n"
    },
    "tmavgTopN": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tmavgTopN.html",
        "signatures": [
            {
                "full": "tmavgTopN(T, X, S, window, top, [ascending=true], [tiesMethod='latest'])",
                "name": "tmavgTopN",
                "parameters": [
                    {
                        "full": "T",
                        "name": "T"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "S",
                        "name": "S"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "top",
                        "name": "top"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[tiesMethod='latest']",
                        "name": "tiesMethod",
                        "optional": true,
                        "default": "'latest'"
                    }
                ]
            }
        ],
        "markdown": "### [tmavgTopN](https://docs.dolphindb.cn/zh/funcs/t/tmavgTopN.html)\n\n\n\n#### 语法\n\ntmavgTopN(T, X, S, window, top, \\[ascending=true], \\[tiesMethod='latest'])\n\n参数说明和窗口计算规则请参考：[tmTopN](https://docs.dolphindb.cn/zh/funcs/themes/tmTopN.html)\n\n#### 详情\n\n在给定长度（以时间 *T* 衡量）的滑动窗口内，根据 *ascending* 指定的排序方式将 *X* 按照 *S* 进行稳定排序后，计算前 *top* 个元素的平均值。\n\n#### 返回值\n\nDOUBLE 类型向量。\n\n#### 例子\n\n```\nT=2023.01.03+1..7\nX = [2, 1, 4, 3, 4, 3, 1]\nS = [5, 8, 1, , 1, 1, 3]  // S 中包含的空值不参与排序，对应位置的 X 不参与计算\ntmavgTopN(T,X,S,6,4)\n// output\n[2,1.5,2.3333,2.3333,2.75,3.25,3]\n\nT=2023.01.03 2023.01.07 2023.01.08 2023.01.10 2023.01.11 2023.01.12\nX=8 3 1 2 5 2\nS=1 5 2 3 1 1\nt=table(T as time, X as val, S as id)\nselect tmavgTopN(time,val,id,4,3) as topN from t\n```\n\n| topN   |\n| ------ |\n| 8      |\n| 3      |\n| 2      |\n| 2      |\n| 2.6666 |\n| 3      |\n\n相关函数：[tmavg](https://docs.dolphindb.cn/zh/funcs/t/tmavg.html)\n"
    },
    "tmbeta": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tmbeta.html",
        "signatures": [
            {
                "full": "tmbeta(T, Y, X, window)",
                "name": "tmbeta",
                "parameters": [
                    {
                        "full": "T",
                        "name": "T"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    }
                ]
            }
        ],
        "markdown": "### [tmbeta](https://docs.dolphindb.cn/zh/funcs/t/tmbeta.html)\n\n\n\n#### 语法\n\ntmbeta(T, Y, X, window)\n\n参数说明和窗口计算规则请参考：[tmFunctions](https://docs.dolphindb.cn/zh/funcs/themes/tmFunctions.html)\n\n#### 详情\n\n在给定长度（以时间长度衡量）的移动窗口中，计算 *Y* 在 *X* 上的回归系数的最小二乘估计。\n\n#### 返回值\n\nDOUBLE 类型向量。\n\n#### 例子\n\n```\nT = 1 1 1 2 5 6\nX = 1 4 2 -1 2 4\nY = 2 5 -3 6 9 1\nm = table(T as t,X as x, Y as y)\nselect *, tmbeta(t, y, x, 3) from m\n```\n\n| t | x  | y  | tmbeta\\_t |\n| - | -- | -- | --------- |\n| 1 | 1  | 2  |           |\n| 1 | 4  | 5  | 1         |\n| 1 | 2  | -3 | 1.4286    |\n| 2 | -1 | 6  | -0.3846   |\n| 5 | 2  | 9  |           |\n| 6 | 4  | 1  | -4        |\n\n```\nT = 2021.01.02 2021.01.02  2021.01.04  2021.01.05 2021.01.07 2021.01.08\nX = 1 4 2 -1 2 4\nY = 2 5 -3 6 9 1\nm = table(T as t,X as x, Y as y)\nselect *, tmbeta(t, y, x, 3d) from m\n```\n\n| t          | x  | y  | tmbeta\\_t |\n| ---------- | -- | -- | --------- |\n| 2021.01.02 | 1  | 2  |           |\n| 2021.01.02 | 4  | 5  | 1         |\n| 2021.01.04 | 2  | -3 | 1.4286    |\n| 2021.01.05 | -1 | 6  | -3        |\n| 2021.01.07 | 2  | 9  | 1         |\n| 2021.01.08 | 4  | 1  | -4        |\n\n```\nselect *, tmbeta(t, y, x, 1w) from m\n```\n\n| t          | x  | y  | tmbeta\\_t |\n| ---------- | -- | -- | --------- |\n| 2021.01.02 | 1  | 2  |           |\n| 2021.01.02 | 4  | 5  | 1         |\n| 2021.01.04 | 2  | -3 | 1.4286    |\n| 2021.01.05 | -1 | 6  | -0.3846   |\n| 2021.01.07 | 2  | 9  | -0.1818   |\n| 2021.01.08 | 4  | 1  | -0.4444   |\n\n相关函数：[mbeta](https://docs.dolphindb.cn/zh/funcs/m/mbeta.html), [beta](https://docs.dolphindb.cn/zh/funcs/b/beta.html)\n"
    },
    "tmbetaTopN": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tmbetaTopN.html",
        "signatures": [
            {
                "full": "tmbetaTopN(T, X, Y, S, window, top, [ascending=true], [tiesMethod='latest'])",
                "name": "tmbetaTopN",
                "parameters": [
                    {
                        "full": "T",
                        "name": "T"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "S",
                        "name": "S"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "top",
                        "name": "top"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[tiesMethod='latest']",
                        "name": "tiesMethod",
                        "optional": true,
                        "default": "'latest'"
                    }
                ]
            }
        ],
        "markdown": "### [tmbetaTopN](https://docs.dolphindb.cn/zh/funcs/t/tmbetaTopN.html)\n\n\n\n#### 语法\n\ntmbetaTopN(T, X, Y, S, window, top, \\[ascending=true], \\[tiesMethod='latest'])\n\n参数说明和窗口计算规则请参考：[tmTopN](https://docs.dolphindb.cn/zh/funcs/themes/tmTopN.html)\n\n#### 详情\n\n在给定长度（以时间 *T* 衡量）的滑动窗口内，根据 *ascending* 指定的排序方式将 *X* 和 *Y* 按照 *S* 进行稳定排序后，取前 *top* 个元素，计算 *Y* 在 *X* 上的回归系数的最小二乘估计。\n\n#### 返回值\n\nDOUBLE 类型向量。\n\n#### 例子\n\n```\nT=2023.01.03+1..7\nX = [2, 1, 4, 3, 4, 3, 1]\nY=[1, 7, 8, 9, 0, 5, 8]\nS = [5, 8, 1, , 1, 1, 3]  // S 中包含的空值不参与排序，对应位置的 X 和 Y不参与计算\ntmbetaTopN(T,X,Y,S,6,4)\n// output\n[,-0.1666,0.1279,0.1279,-0.06,0.0853,-0.1871]\n\nT=2023.01.03 2023.01.07 2023.01.08 2023.01.10 2023.01.11 2023.01.12\nX=8 3 1 2 5 2\nY=1 7 8 9 0 5\nS=1 5 2 3 1 1\nt=table(T as time, X as val1, Y as val2, S as id)\nselect tmbetaTopN(time,val1,val2,id,4,3) as topN from t\n```\n\n| topN    |\n| ------- |\n|         |\n|         |\n| -2      |\n| -0.5    |\n| -0.3972 |\n| -0.3442 |\n\n相关函数：[tmbeta](https://docs.dolphindb.cn/zh/funcs/t/tmbeta.html)\n"
    },
    "tmcorr": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tmcorr.html",
        "signatures": [
            {
                "full": "tmcorr(T, X, Y, window)",
                "name": "tmcorr",
                "parameters": [
                    {
                        "full": "T",
                        "name": "T"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    }
                ]
            }
        ],
        "markdown": "### [tmcorr](https://docs.dolphindb.cn/zh/funcs/t/tmcorr.html)\n\n\n\n#### 语法\n\ntmcorr(T, X, Y, window)\n\n参数说明和窗口计算规则请参考：[tmFunctions](https://docs.dolphindb.cn/zh/funcs/themes/tmFunctions.html)\n\n#### 详情\n\n在给定长度（以时间长度衡量）的滑动窗口内，计算 *X* 和 *Y* 元素的相关性。\n\n#### 返回值\n\nDOUBLE 类型向量。\n\n#### 例子\n\n```\nT = 1 1 1 2 5 6\nX = 1 4 2 -1 2 4\nY = 2 5 -3 6 9 1\nm = table(T as t,X as x, Y as y)\nselect *, tmcorr(t, y, x, 3) from m\n```\n\n| t | x  | y  | tmcorr\\_t |\n| - | -- | -- | --------- |\n| 1 | 1  | 2  |           |\n| 1 | 4  | 5  | 1         |\n| 1 | 2  | -3 | 0.5399    |\n| 2 | -1 | 6  | -0.1981   |\n| 5 | 2  | 9  |           |\n| 6 | 4  | 1  | -1        |\n\n```\nT = 2021.01.02 2021.01.02  2021.01.04  2021.01.05 2021.01.07 2021.01.08\nX = 1 4 2 -1 2 4\nY = 2 5 -3 6 9 1\nm = table(T as t,X as x, Y as y)\nselect *, tmcorr(t, y, x, 3d) from m\n```\n\n| t          | x  | y  | tmcorr\\_t |\n| ---------- | -- | -- | --------- |\n| 2021.01.02 | 1  | 2  |           |\n| 2021.01.02 | 4  | 5  | 1         |\n| 2021.01.04 | 2  | -3 | 0.5399    |\n| 2021.01.05 | -1 | 6  | -1        |\n| 2021.01.07 | 2  | 9  | 1         |\n| 2021.01.08 | 4  | 1  | -1        |\n\n```\nselect *, tmcorr(t, y, x, 1w) from m\n```\n\n| t          | x  | y  | tmcorr\\_t |\n| ---------- | -- | -- | --------- |\n| 2021.01.02 | 1  | 2  |           |\n| 2021.01.02 | 4  | 5  | 1         |\n| 2021.01.04 | 2  | -3 | 0.5399    |\n| 2021.01.05 | -1 | 6  | -0.1981   |\n| 2021.01.07 | 2  | 9  | -0.0726   |\n| 2021.01.08 | 4  | 1  | -0.1995   |\n\n相关函数：[mcorr](https://docs.dolphindb.cn/zh/funcs/m/mcorr.html), [corr](https://docs.dolphindb.cn/zh/funcs/c/corr.html)\n"
    },
    "tmcorrTopN": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tmcorrTopN.html",
        "signatures": [
            {
                "full": "tmcorrTopN(T, X, Y, S, window, top, [ascending=true], [tiesMethod='latest'])",
                "name": "tmcorrTopN",
                "parameters": [
                    {
                        "full": "T",
                        "name": "T"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "S",
                        "name": "S"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "top",
                        "name": "top"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[tiesMethod='latest']",
                        "name": "tiesMethod",
                        "optional": true,
                        "default": "'latest'"
                    }
                ]
            }
        ],
        "markdown": "### [tmcorrTopN](https://docs.dolphindb.cn/zh/funcs/t/tmcorrTopN.html)\n\n\n\n#### 语法\n\ntmcorrTopN(T, X, Y, S, window, top, \\[ascending=true], \\[tiesMethod='latest'])\n\n参数说明和窗口计算规则请参考：[tmTopN](https://docs.dolphindb.cn/zh/funcs/themes/tmTopN.html)\n\n#### 详情\n\n在给定长度（以时间 *T* 衡量）的滑动窗口内，根据 *ascending* 指定的排序方式将 *X* 和 *Y* 按照 *S* 进行稳定排序后，取前 *top* 个元素，计算 *X* 和 *Y* 之间的相关性。\n\n#### 返回值\n\nDOUBLE 类型向量。\n\n#### 例子\n\n```\nT=2023.01.03+1..7\nX = [2, 1, 4, 3, 4, 3, 1]\nY=[1, 7, 8, 9, 0, 5, 8]\nS = [5, 8, 1, , 1, 1, 3]  // S 中包含的空值不参与排序，对应位置的 X 和 Y不参与计算\ntmcorrTopN(T,X,Y,S,6,4)\n// output\n[,-1,0.317,0.317,-0.16329,0.3296,-0.4995]\n\nT=2023.01.03 2023.01.07 2023.01.08 2023.01.10 2023.01.11 2023.01.12\nX=8 3 1 2 5 2\nY=1 7 8 9 0 5\nS=1 5 2 3 1 1\nt=table(T as time, X as val1, Y as val2, S as id)\nselect tmcorrTopN(time,val1,val2,id,4,3) as topN from t\n```\n\n| topN    |\n| ------- |\n|         |\n|         |\n| -1      |\n| -0.5    |\n| -0.9413 |\n| -0.8962 |\n\n相关函数：[tmcorr](https://docs.dolphindb.cn/zh/funcs/t/tmcorr.html)\n"
    },
    "tmcount": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tmcount.html",
        "signatures": [
            {
                "full": "tmcount(T, X, window)",
                "name": "tmcount",
                "parameters": [
                    {
                        "full": "T",
                        "name": "T"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    }
                ]
            }
        ],
        "markdown": "### [tmcount](https://docs.dolphindb.cn/zh/funcs/t/tmcount.html)\n\n\n\n#### 语法\n\ntmcount(T, X, window)\n\n参数说明和窗口计算规则请参考：[tmFunctions](https://docs.dolphindb.cn/zh/funcs/themes/tmFunctions.html)\n\n#### 详情\n\n在给定长度（以时间 *T* 衡量）的滑动窗口内统计 *X* 中的非 NULL 元素个数。\n\n#### 返回值\n\nINT 类型向量。\n\n#### 例子\n\n```\nT = 1 1 1 2 5 6\nX = 1 4 NULL -1 NULL 4\nm = table(T as t,X as x)\nselect *, tmcount(t, x, 3) from m\n```\n\n| t | x  | tmcount\\_t |\n| - | -- | ---------- |\n| 1 | 1  | 1          |\n| 1 | 4  | 2          |\n| 1 |    | 2          |\n| 2 | -1 | 3          |\n| 5 |    | 0          |\n| 6 | 4  | 1          |\n\n```\nT = 2021.01.02 2021.01.02  2021.01.04  2021.01.05 2021.01.07 2021.01.09\nX = NULL 4 NULL -1 2 4\nm = table(T as t,X as x)\nselect *, tmcount(t, x, 3d) from m\n```\n\n| t          | x  | tmcount\\_t |\n| ---------- | -- | ---------- |\n| 2021.01.02 |    | 0          |\n| 2021.01.02 | 4  | 1          |\n| 2021.01.04 |    | 1          |\n| 2021.01.05 | -1 | 1          |\n| 2021.01.07 | 2  | 2          |\n| 2021.01.09 | 4  | 2          |\n\n```\nselect *, tmcount(t, x, 1w) from m\n```\n\n| t          | x  | tmcount\\_t |\n| ---------- | -- | ---------- |\n| 2021.01.02 |    | 0          |\n| 2021.01.02 | 4  | 1          |\n| 2021.01.04 |    | 1          |\n| 2021.01.05 | -1 | 2          |\n| 2021.01.07 | 2  | 3          |\n| 2021.01.09 | 4  | 3          |\n\n相关函数：[mcount](https://docs.dolphindb.cn/zh/funcs/m/mcount.html), [count](https://docs.dolphindb.cn/zh/funcs/c/count.html)\n"
    },
    "tmcovar": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tmcovar.html",
        "signatures": [
            {
                "full": "tmcovar(T, X, Y, window)",
                "name": "tmcovar",
                "parameters": [
                    {
                        "full": "T",
                        "name": "T"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    }
                ]
            }
        ],
        "markdown": "### [tmcovar](https://docs.dolphindb.cn/zh/funcs/t/tmcovar.html)\n\n\n\n#### 语法\n\ntmcovar(T, X, Y, window)\n\n参数说明和窗口计算规则请参考：[tmFunctions](https://docs.dolphindb.cn/zh/funcs/themes/tmFunctions.html)\n\n#### 详情\n\n在给定长度（以时间长度衡量）的滑动窗口内，计算 *X* 和 *Y* 元素的协方差。\n\n#### 返回值\n\nDOUBLE 类型向量。\n\n#### 例子\n\n```\nT = 1 1 1 2 5 6\nX = 1 4 2 -1 2 4\nY = 2 5 -3 6 9 1\nm = table(T as t,X as x, Y as y)\nselect *, tmcovar(t, y, x, 3) from m\n```\n\n| t | x  | y  | tmcovar\\_t |\n| - | -- | -- | ---------- |\n| 1 | 1  | 2  |            |\n| 1 | 4  | 5  | 4.5        |\n| 1 | 2  | -3 | 3.3333     |\n| 2 | -1 | 6  | -1.6667    |\n| 5 | 2  | 9  |            |\n| 6 | 4  | 1  | -8         |\n\n```\nT = 2021.01.02 2021.01.02  2021.01.04  2021.01.05 2021.01.07 2021.01.08\nX = 1 4 2 -1 2 4\nY = 2 5 -3 6 9 1\nm = table(T as t,X as x, Y as y)\nselect *, tmcovar(t, y, x, 3d) from m\n```\n\n| t          | x  | y  | tmcovar\\_t |\n| ---------- | -- | -- | ---------- |\n| 2021.01.02 | 1  | 2  |            |\n| 2021.01.02 | 4  | 5  | 4.5        |\n| 2021.01.04 | 2  | -3 | 3.3333     |\n| 2021.01.05 | -1 | 6  | -13.5      |\n| 2021.01.07 | 2  | 9  | 4.5        |\n| 2021.01.08 | 4  | 1  | -8         |\n\n```\nselect *, tmcovar(t, y, x, 1w) from m\n```\n\n| t          | x  | y  | tmcovar\\_t |\n| ---------- | -- | -- | ---------- |\n| 2021.01.02 | 1  | 2  |            |\n| 2021.01.02 | 4  | 5  | 4.5        |\n| 2021.01.04 | 2  | -3 | 3.3333     |\n| 2021.01.05 | -1 | 6  | -1.6667    |\n| 2021.01.07 | 2  | 9  | -0.6       |\n| 2021.01.08 | 4  | 1  | -1.6       |\n\n相关函数：[mcovar](https://docs.dolphindb.cn/zh/funcs/m/mcovar.html), [covar](https://docs.dolphindb.cn/zh/funcs/c/covar.html)\n"
    },
    "tmcovarp": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tmcovarp.html",
        "signatures": [
            {
                "full": "tmcovarp(T, X, Y, window)",
                "name": "tmcovarp",
                "parameters": [
                    {
                        "full": "T",
                        "name": "T"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    }
                ]
            }
        ],
        "markdown": "### [tmcovarp](https://docs.dolphindb.cn/zh/funcs/t/tmcovarp.html)\n\n首发版本：3.00.5\n\n\n\n#### 语法\n\ntmcovarp(T, X, Y, window)\n\n参数说明和窗口计算规则请参考：[tmFunctions](https://docs.dolphindb.cn/zh/funcs/themes/tmFunctions.html)\n\n#### 详情\n\n在给定长度（以时间长度衡量）的滑动窗口内，计算 *X* 和 *Y* 元素的总体协方差。\n\n#### 返回值\n\nDOUBLE 类型向量。\n\n#### 例子\n\n```\nT = 1 1 1 2 5 6\nX = 1 4 2 -1 2 4\nY = 2 5 -3 6 9 1\nm = table(T as t,X as x, Y as y)\nselect *, tmcovarp(t, y, x, 3) from m\n```\n\n| t | x  | y  | tmcovarp\\_t        |\n| - | -- | -- | ------------------ |\n| 1 | 1  | 2  | 0                  |\n| 1 | 4  | 5  | 2.25               |\n| 1 | 2  | -3 | 2.2222222222222223 |\n| 2 | -1 | 6  | -1.25              |\n| 5 | 2  | 9  | 0                  |\n| 6 | 4  | 1  | -4                 |\n\n```\nT = 2026.01.02 2026.01.02  2026.01.04  2026.01.05 2026.01.07 2026.01.08\nX = 1 4 2 -1 2 4\nY = 2 5 -3 6 9 1\nm = table(T as t,X as x, Y as y)\nselect *, tmcovarp(t, y, x, 3d) from m\n```\n\n| t          | x  | y  | tmcovarp\\_t        |\n| ---------- | -- | -- | ------------------ |\n| 2026.01.02 | 1  | 2  | 0                  |\n| 2026.01.02 | 4  | 5  | 2.25               |\n| 2026.01.04 | 2  | -3 | 2.2222222222222223 |\n| 2026.01.05 | -1 | 6  | -6.75              |\n| 2026.01.07 | 2  | 9  | 2.25               |\n| 2026.01.08 | 4  | 1  | -4                 |\n\n```\nselect *, tmcovarp(t, y, x, 1w) from m\n```\n\n| t          | x  | y  | tmcovarp\\_t         |\n| ---------- | -- | -- | ------------------- |\n| 2026.01.02 | 1  | 2  | 0                   |\n| 2026.01.02 | 4  | 5  | 2.25                |\n| 2026.01.04 | 2  | -3 | 2.2222222222222223  |\n| 2026.01.05 | -1 | 6  | -1.25               |\n| 2026.01.07 | 2  | 9  | -0.48               |\n| 2026.01.08 | 4  | 1  | -1.3333333333333333 |\n\n相关函数：[covarp](https://docs.dolphindb.cn/zh/funcs/c/covarp.html)\n"
    },
    "tmcovarpTopN": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tmcovarpTopN.html",
        "signatures": [
            {
                "full": "tmcovarpTopN(T, X, Y, S, window, top, [ascending=true], [tiesMethod='latest'])",
                "name": "tmcovarpTopN",
                "parameters": [
                    {
                        "full": "T",
                        "name": "T"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "S",
                        "name": "S"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "top",
                        "name": "top"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[tiesMethod='latest']",
                        "name": "tiesMethod",
                        "optional": true,
                        "default": "'latest'"
                    }
                ]
            }
        ],
        "markdown": "### [tmcovarpTopN](https://docs.dolphindb.cn/zh/funcs/t/tmcovarpTopN.html)\n\n首发版本：3.00.5\n\n\n\n#### 语法\n\ntmcovarpTopN(T, X, Y, S, window, top, \\[ascending=true], \\[tiesMethod='latest'])\n\n参数说明和窗口计算规则请参考：[tmTopN](https://docs.dolphindb.cn/zh/funcs/themes/tmTopN.html)\n\n#### 详情\n\n在给定长度（以时间 *T* 衡量）的滑动窗口内，根据 *ascending* 指定的排序方式将 *X* 和 *Y* 按照 *S* 进行稳定排序后，取前 *top* 个元素，计算 *X* 和 *Y* 的总体协方差。\n\n#### 返回值\n\nDOUBLE 类型向量。\n\n#### 例子\n\n```\nT=2026.01.03+1..7\nX = [2, 1, 4, 3, 4, 3, 1]\nY=[1, 7, 8, 9, 0, 5, 8]\nS = [5, 8, 1, , 1, 1, 3]  //S 中包含的空值不参与排序，对应位置的 X 和 Y 不参与计算\ntmcovarpTopN(T,X,Y,S,6,4)\n// output: [0,-1.5,1.22,1.22,-0.75,0.875,-2]\n\nT=2026.01.03 2026.01.07 2026.01.08 2026.01.10 2026.01.11 2026.01.12\nX=8 3 1 2 5 2\nY=1 7 8 9 0 5\nS=1 5 2 3 1 1\nt=table(T as time, X as val1, Y as val2, S as id)\nselect tmcovarpTopN(time,val1,val2,id,4,3) as topN from t\n```\n\n| topN  |\n| ----- |\n| 0     |\n| 0     |\n| -0.5  |\n| -0.33 |\n| -6.44 |\n| -4.67 |\n\n相关函数：[covarp](https://docs.dolphindb.cn/zh/funcs/c/covarp.html)\n"
    },
    "tmcovarTopN": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tmcovarTopN.html",
        "signatures": [
            {
                "full": "tmcovarTopN(T, X, Y, S, window, top, [ascending=true], [tiesMethod='latest'])",
                "name": "tmcovarTopN",
                "parameters": [
                    {
                        "full": "T",
                        "name": "T"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "S",
                        "name": "S"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "top",
                        "name": "top"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[tiesMethod='latest']",
                        "name": "tiesMethod",
                        "optional": true,
                        "default": "'latest'"
                    }
                ]
            }
        ],
        "markdown": "### [tmcovarTopN](https://docs.dolphindb.cn/zh/funcs/t/tmcovarTopN.html)\n\n\n\n#### 语法\n\ntmcovarTopN(T, X, Y, S, window, top, \\[ascending=true], \\[tiesMethod='latest'])\n\n参数说明和窗口计算规则请参考：[tmTopN](https://docs.dolphindb.cn/zh/funcs/themes/tmTopN.html)\n\n#### 详情\n\n在给定长度（以时间 *T* 衡量）的滑动窗口内，根据 *ascending* 指定的排序方式将 *X* 和 *Y* 按照 *S* 进行稳定排序后，取前 *top* 个元素，计算 *X* 和 *Y* 的协方差。\n\n#### 返回值\n\nDOUBLE 类型向量。\n\n#### 例子\n\n```\nT=2023.01.03+1..7\nX = [2, 1, 4, 3, 4, 3, 1]\nY=[1, 7, 8, 9, 0, 5, 8]\nS = [5, 8, 1, , 1, 1, 3]  //S 中包含的空值不参与排序，对应位置的 X 和 Y 不参与计算\ntmcovarTopN(T,X,Y,S,6,4)\n// output\n[,-3,1.8333,1.8333,-1,1.1666,-2.6666]\n\nT=2023.01.03 2023.01.07 2023.01.08 2023.01.10 2023.01.11 2023.01.12\nX=8 3 1 2 5 2\nY=1 7 8 9 0 5\nS=1 5 2 3 1 1\nt=table(T as time, X as val1, Y as val2, S as id)\nselect tmcovarTopN(time,val1,val2,id,4,3) as topN from t\n```\n\n| topN    |\n| ------- |\n|         |\n|         |\n| -1      |\n| -0.5    |\n| -9.6666 |\n| -7      |\n\n相关函数：[tmcovar](https://docs.dolphindb.cn/zh/funcs/t/tmcovar.html)\n"
    },
    "tmfirst": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tmfirst.html",
        "signatures": [
            {
                "full": "tmfirst(T, X, window)",
                "name": "tmfirst",
                "parameters": [
                    {
                        "full": "T",
                        "name": "T"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    }
                ]
            }
        ],
        "markdown": "### [tmfirst](https://docs.dolphindb.cn/zh/funcs/t/tmfirst.html)\n\n\n\n#### 语法\n\ntmfirst(T, X, window)\n\n参数说明和窗口计算规则请参考：[tmFunctions](https://docs.dolphindb.cn/zh/funcs/themes/tmFunctions.html)\n\n#### 详情\n\n在给定长度（以时间 *T* 衡量）的滑动窗口内计算 *X* 的第一个元素。\n\n#### 返回值\n\n返回一个与输入 *X* 相同数据类型的向量。\n\n#### 例子\n\n```\nT = 1 1 1 2 5 6\nX = 1 4 NULL -1 NULL 4\nm = table(T as t,X as x)\nselect *, tmfirst(t, x, 3) from m\n```\n\n| t | x  | tmfirst\\_t |\n| - | -- | ---------- |\n| 1 | 1  | 1          |\n| 1 | 4  | 1          |\n| 1 |    | 1          |\n| 2 | -1 | 1          |\n| 5 |    |            |\n| 6 | 4  |            |\n\n```\nT = 2021.01.02 2021.01.02  2021.01.04  2021.01.05 2021.01.07 2021.01.08\nX = 3 4 NULL -1 2 4\nm = table(T as t,X as x)\nselect *, tmfirst(t, x, 3d) from m\n```\n\n| t          | x  | tmfirst\\_t |\n| ---------- | -- | ---------- |\n| 2021.01.02 | 3  | 3          |\n| 2021.01.02 | 4  | 3          |\n| 2021.01.04 |    | 3          |\n| 2021.01.05 | -1 |            |\n| 2021.01.07 | 2  | -1         |\n| 2021.01.08 | 4  | 2          |\n\n```\nselect *, tmfirst(t, x, 1w) from m\n```\n\n| t          | x  | tmfirst\\_t |\n| ---------- | -- | ---------- |\n| 2021.01.02 | 3  | 3          |\n| 2021.01.02 | 4  | 3          |\n| 2021.01.04 |    | 3          |\n| 2021.01.05 | -1 | 3          |\n| 2021.01.07 | 2  | 3          |\n| 2021.01.08 | 4  | 3          |\n\n相关函数：[mfirst](https://docs.dolphindb.cn/zh/funcs/m/mfirst.html), [first](https://docs.dolphindb.cn/zh/funcs/f/first.html)\n"
    },
    "tmkurtosis": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tmkurtosis.html",
        "signatures": [
            {
                "full": "tmkurtosis(T, X, window, [biased=true])",
                "name": "tmkurtosis",
                "parameters": [
                    {
                        "full": "T",
                        "name": "T"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "[biased=true]",
                        "name": "biased",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [tmkurtosis](https://docs.dolphindb.cn/zh/funcs/t/tmkurtosis.html)\n\n\n\n#### 语法\n\ntmkurtosis(T, X, window, \\[biased=true])\n\n部分通用参数说明和窗口计算规则请参考：[tmFunctions](https://docs.dolphindb.cn/zh/funcs/themes/tmFunctions.html)\n\n#### 详情\n\n在给定长度（以时间 *T* 衡量）的滑动窗口内计算 *X* 的峰度。\n\n#### 参数\n\n**biased** 是一个布尔值，表示是否是有偏估计。默认值为 true，表示有偏估计。\n\n#### 返回值\n\nDOUBLE 类型向量。\n\n#### 例子\n\n```\nT = 1 1 1 2 5 6\nX = 1 4 NULL -1 NULL 4\nm = table(T as t, X as x)\nselect *, tmkurtosis(t, x, 3) from m\n```\n\n| t | x  | tmkurtosis\\_t |\n| - | -- | ------------- |\n| 1 | 1  |               |\n| 1 | 4  |               |\n| 1 |    |               |\n| 2 | -1 | 1.5           |\n| 5 |    |               |\n| 6 | 4  |               |\n\n```\nT = take(datehour(2019.06.13 13:30:10),4) join (datehour(2019.06.13 13:30:10)+1..6)\nX = 1 NULL 3 4 5 NULL 3 NULL 5 3\nm = table(T as t,X as x)\nselect *, tmkurtosis(t, x, 3d) from m\n```\n\n| t             | x | tmkurtosis\\_t |\n| ------------- | - | ------------- |\n| 2019.06.13T13 | 1 |               |\n| 2019.06.13T13 |   |               |\n| 2019.06.13T13 | 3 |               |\n| 2019.06.13T13 | 4 | 1.5           |\n| 2019.06.13T14 | 5 | 1.8457        |\n| 2019.06.13T15 |   | 1.8457        |\n| 2019.06.13T16 | 3 | 2.2169        |\n| 2019.06.13T17 |   | 2.2169        |\n| 2019.06.13T18 | 5 | 2.2401        |\n| 2019.06.13T19 | 3 | 2.4072        |\n\n```\nselect *, tmkurtosis(t, x, 1w) from m\n```\n\n| t             | x | tmkurtosis\\_t |\n| ------------- | - | ------------- |\n| 2019.06.13T13 | 1 |               |\n| 2019.06.13T13 |   |               |\n| 2019.06.13T13 | 3 |               |\n| 2019.06.13T13 | 4 | 1.5           |\n| 2019.06.13T14 | 5 | 1.8457        |\n| 2019.06.13T15 |   | 1.8457        |\n| 2019.06.13T16 | 3 | 2.2169        |\n| 2019.06.13T17 |   | 2.2169        |\n| 2019.06.13T18 | 5 | 2.2401        |\n| 2019.06.13T19 | 3 | 2.4072        |\n\n相关函数：[mkurtosis](https://docs.dolphindb.cn/zh/funcs/m/mkurtosis.html), [kurtosis](https://docs.dolphindb.cn/zh/funcs/k/kurtosis.html)\n"
    },
    "tmkurtosisTopN": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tmkurtosisTopN.html",
        "signatures": [
            {
                "full": "tmkurtosisTopN(T, X, S, window, top, [biased=true], [ascending=true], [tiesMethod='latest'])",
                "name": "tmkurtosisTopN",
                "parameters": [
                    {
                        "full": "T",
                        "name": "T"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "S",
                        "name": "S"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "top",
                        "name": "top"
                    },
                    {
                        "full": "[biased=true]",
                        "name": "biased",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[tiesMethod='latest']",
                        "name": "tiesMethod",
                        "optional": true,
                        "default": "'latest'"
                    }
                ]
            }
        ],
        "markdown": "### [tmkurtosisTopN](https://docs.dolphindb.cn/zh/funcs/t/tmkurtosisTopN.html)\n\n\n\n#### 语法\n\ntmkurtosisTopN(T, X, S, window, top, \\[biased=true], \\[ascending=true], \\[tiesMethod='latest'])\n\n参数说明和窗口计算规则请参考：[tmTopN](https://docs.dolphindb.cn/zh/funcs/themes/tmTopN.html)\n\n#### 详情\n\n在给定长度（以时间 *T* 衡量）的滑动窗口内，根据 *ascending* 指定的排序方式将 *X* 按照 *S* 进行稳定排序后，计算前 *top* 个元素的峰度。\n\n#### 参数\n\n**biased** 是一个布尔值，表示是否是有偏估计。默认值为 true，表示有偏估计。\n\n#### 返回值\n\nDOUBLE 类型向量。\n\n#### 例子\n\n```\nT=2023.01.03+1..10\nX = [2, 1, 4, 3, 4, 3, 1, 5, 8, 2]\nS = [5, 8, 1, , 1, 1, 3, 2, 5 ,1]  //S 中包含的空值不参与排序，对应位置的 X 不参与计算\ntmkurtosisTopN(T,X,S,6,4)\n// output\n[,,1.5,1.5,1.2798,1.628,2,2,1.8457,1.64]\n\nT=2023.01.03 2023.01.07 2023.01.08 2023.01.10 2023.01.11 2023.01.12 2023.01.13 2023.01.14 2023.01.15 2023.01.16\nX=8 3 1 2 5 2 5 4 2 6\nS=1 5 2 3 1 1 2 4 5 3\nt=table(T as time, X as val, S as id)\nselect tmkurtosisTopN(time,val,id,6,4) as topN from t\n```\n\n| topN   |\n| ------ |\n|        |\n|        |\n| 1.5    |\n| 1.5    |\n| 1.8457 |\n| 2.1852 |\n| 1.1522 |\n| 1      |\n| 1      |\n| 2.1852 |\n\n相关函数：[tmkurtosis](https://docs.dolphindb.cn/zh/funcs/t/tmkurtosis.html)\n"
    },
    "tmlast": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tmlast.html",
        "signatures": [
            {
                "full": "tmlast(T, X, window)",
                "name": "tmlast",
                "parameters": [
                    {
                        "full": "T",
                        "name": "T"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    }
                ]
            }
        ],
        "markdown": "### [tmlast](https://docs.dolphindb.cn/zh/funcs/t/tmlast.html)\n\n\n\n#### 语法\n\ntmlast(T, X, window)\n\n参数说明和窗口计算规则请参考：[tmFunctions](https://docs.dolphindb.cn/zh/funcs/themes/tmFunctions.html)\n\n#### 详情\n\n在给定长度（以时间 *T* 衡量）的滑动窗口内计算 *X* 的最后一个元素。\n\n#### 返回值\n\n返回一个与输入 *X* 相同数据类型的向量。\n\n#### 例子\n\n```\nT = 1 1 1 2 5 6\nX = 1 4 NULL -1 NULL 4\nm = table(T as t,X as x)\nselect *, tmlast(t, x, 3) from m\n```\n\n| t | x  | tmlast\\_t |\n| - | -- | --------- |\n| 1 | 1  | 1         |\n| 1 | 4  | 4         |\n| 1 |    |           |\n| 2 | -1 | -1        |\n| 5 |    |           |\n| 6 | 4  | 4         |\n\n```\nT = 2021.01.02 2021.01.02  2021.01.04  2021.01.05 2021.01.07 2021.01.08\nX = NULL 4 NULL -1 2 4\nm = table(T as t,X as x)\nselect *, tmlast(t, x, 3d) from m\n```\n\n| t          | x  | tmlast\\_t |\n| ---------- | -- | --------- |\n| 2021.01.02 |    |           |\n| 2021.01.02 | 4  | 4         |\n| 2021.01.04 |    |           |\n| 2021.01.05 | -1 | -1        |\n| 2021.01.07 | 2  | 2         |\n| 2021.01.08 | 4  | 4         |\n\n```\nselect *, tmlast(t, x, 1w) from m\n```\n\n| t          | x  | tmlast\\_t |\n| ---------- | -- | --------- |\n| 2021.01.02 |    |           |\n| 2021.01.02 | 4  | 4         |\n| 2021.01.04 |    |           |\n| 2021.01.05 | -1 | -1        |\n| 2021.01.07 | 2  | 2         |\n| 2021.01.08 | 4  | 4         |\n\n相关函数：[mlast](https://docs.dolphindb.cn/zh/funcs/m/mlast.html), [last](https://docs.dolphindb.cn/zh/funcs/l/last.html)\n"
    },
    "tmLowRange": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tmlowrange.html",
        "signatures": [
            {
                "full": "tmLowRange(T, X, window)",
                "name": "tmLowRange",
                "parameters": [
                    {
                        "full": "T",
                        "name": "T"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    }
                ]
            }
        ],
        "markdown": "### [tmLowRange](https://docs.dolphindb.cn/zh/funcs/t/tmlowrange.html)\n\n#### 语法\n\ntmLowRange(T, X, window)\n\n参数说明和窗口计算规则请参考：[tmFunctions](https://docs.dolphindb.cn/zh/funcs/themes/tmFunctions.html)\n\n#### 详情\n\n在给定长度（以时间 *T* 衡量）的滑动窗口内，统计每个元素 Xi 左侧相邻且连续大于它的元素个数。NULL 被视为最小值。\n\n#### 返回值\n\n长度与 *X* 相同的 INT 类型向量。\n\n#### 例子\n\n```\nt = [0, 1, 2, 3, 7, 8, 9, 10, 11]\nx = [NULL, 3.1, NULL, 3.0, 2.9, 2.8, 3.1, NULL, 3.2]\ntmLowRange(t, x, window=3)\n// output: [,0,1,0,0,1,0,2,0]\n\ntmLowRange(t, x, window=4)\n// output: [,0,1,0,0,1,0,3,0]\n\nindex = take(datehour(2019.06.13 13:30:10),4) join (datehour(2019.06.13 13:30:10)+1..6)\ndata = 1 NULL 3 4 5 NULL 3 NULL 5 3\ntmLowRange(index, data, 4h)\n// output: [0,1,0,0,0,3,0,1,0,1]\n```\n\n"
    },
    "tmmax": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tmmax.html",
        "signatures": [
            {
                "full": "tmmax(T, X, window)",
                "name": "tmmax",
                "parameters": [
                    {
                        "full": "T",
                        "name": "T"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    }
                ]
            }
        ],
        "markdown": "### [tmmax](https://docs.dolphindb.cn/zh/funcs/t/tmmax.html)\n\n\n\n#### 语法\n\ntmmax(T, X, window)\n\n参数说明和窗口计算规则请参考：[tmFunctions](https://docs.dolphindb.cn/zh/funcs/themes/tmFunctions.html)\n\n#### 详情\n\n在给定长度（以时间 *T* 衡量）的滑动窗口内计算 *X* 元素的最大值。\n\n#### 返回值\n\n*X* 为整型，返回 LONG 类型向量，*X* 为浮点数，返回 DOUBLE 类型向量。\n\n#### 例子\n\n```\nT = 1 1 1 2 5 6\nX = 1 4 NULL -1 NULL 4\nm = table(T as t,X as x)\nselect *, tmmax(t, x, 3) from m\n```\n\n| t | x  | tmmax\\_t |\n| - | -- | -------- |\n| 1 | 1  | 1        |\n| 1 | 4  | 4        |\n| 1 |    | 4        |\n| 2 | -1 | 4        |\n| 5 |    |          |\n| 6 | 4  | 4        |\n\n```\nT = 2021.01.02 2021.01.02  2021.01.04  2021.01.05 2021.01.07 2021.01.08\nX = NULL 4 NULL -1 2 4\nm = table(T as t,X as x)\nselect *, tmmax(t, x, 3d) from m\n```\n\n| t          | x  | tmmax\\_t |\n| ---------- | -- | -------- |\n| 2021.01.02 |    |          |\n| 2021.01.02 | 4  | 4        |\n| 2021.01.04 |    | 4        |\n| 2021.01.05 | -1 | -1       |\n| 2021.01.07 | 2  | 2        |\n| 2021.01.08 | 4  | 4        |\n\n```\nselect *, tmmax(t, x, 1w) from m\n```\n\n| t          | x  | tmmax\\_t |\n| ---------- | -- | -------- |\n| 2021.01.02 |    |          |\n| 2021.01.02 | 4  | 4        |\n| 2021.01.04 |    | 4        |\n| 2021.01.05 | -1 | 4        |\n| 2021.01.07 | 2  | 4        |\n| 2021.01.08 | 4  | 4        |\n\n相关函数：[mmax](https://docs.dolphindb.cn/zh/funcs/m/mmax.html), [max](https://docs.dolphindb.cn/zh/funcs/m/max.html)\n"
    },
    "tmmed": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tmmed.html",
        "signatures": [
            {
                "full": "tmmed(T, X, window)",
                "name": "tmmed",
                "parameters": [
                    {
                        "full": "T",
                        "name": "T"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    }
                ]
            }
        ],
        "markdown": "### [tmmed](https://docs.dolphindb.cn/zh/funcs/t/tmmed.html)\n\n\n\n#### 语法\n\ntmmed(T, X, window)\n\n参数说明和窗口计算规则请参考：[tmFunctions](https://docs.dolphindb.cn/zh/funcs/themes/tmFunctions.html)\n\n#### 详情\n\n在给定长度（以时间 *T* 衡量）的滑动窗口内计算 *X* 元素的中位数。\n\n#### 返回值\n\nDOUBLE 类型向量。\n\n#### 例子\n\n```\nT = 1 1 1 2 5 6\nX = 1 4 NULL -1 NULL 4\nm = table(T as t,X as x)\nselect *, tmmed(t, x, 3) from m\n```\n\n| t | x  | tmmed\\_t |\n| - | -- | -------- |\n| 1 | 1  | 1        |\n| 1 | 4  | 2.5      |\n| 1 |    | 2.5      |\n| 2 | -1 | 1        |\n| 5 |    |          |\n| 6 | 4  | 4        |\n\n```\nT = 2021.01.02 2021.01.02  2021.01.04  2021.01.05 2021.01.07 2021.01.08\nX = NULL 4 NULL -1 2 4\nm = table(T as t,X as x)\nselect *, tmmed(t, x, 3d) from m\n```\n\n| t          | x  | tmmed\\_t |\n| ---------- | -- | -------- |\n| 2021.01.02 |    |          |\n| 2021.01.02 | 4  | 4        |\n| 2021.01.04 |    | 4        |\n| 2021.01.05 | -1 | -1       |\n| 2021.01.07 | 2  | 0.5      |\n| 2021.01.08 | 4  | 3        |\n\n```\nselect *, tmmed(t, x, 1w) from m\n```\n\n| t          | x  | tmmed\\_t |\n| ---------- | -- | -------- |\n| 2021.01.02 |    |          |\n| 2021.01.02 | 4  | 4        |\n| 2021.01.04 |    | 4        |\n| 2021.01.05 | -1 | 1.5      |\n| 2021.01.07 | 2  | 2        |\n| 2021.01.08 | 4  | 3        |\n\n相关函数：[mmed](https://docs.dolphindb.cn/zh/funcs/m/mmed.html), [med](https://docs.dolphindb.cn/zh/funcs/m/med.html)\n"
    },
    "tmmin": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tmmin.html",
        "signatures": [
            {
                "full": "tmmin(T, X, window)",
                "name": "tmmin",
                "parameters": [
                    {
                        "full": "T",
                        "name": "T"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    }
                ]
            }
        ],
        "markdown": "### [tmmin](https://docs.dolphindb.cn/zh/funcs/t/tmmin.html)\n\n\n\n#### 语法\n\ntmmin(T, X, window)\n\n参数说明和窗口计算规则请参考：[tmFunctions](https://docs.dolphindb.cn/zh/funcs/themes/tmFunctions.html)\n\n#### 详情\n\n在给定长度（以时间 *T* 衡量）的滑动窗口内计算 *X* 元素的最小值。\n\n#### 返回值\n\n*X* 为整型，返回 LONG 类型向量，*X* 为浮点数，返回 DOUBLE 类型向量。\n\n#### 例子\n\n```\nT = 1 1 1 2 5 6\nX = 1 4 NULL -1 NULL 4\nm = table(T as t,X as x)\nselect *, tmmin(t, x, 3) from m\n```\n\n| t | x  | tmmin\\_t |\n| - | -- | -------- |\n| 1 | 1  | 1        |\n| 1 | 4  | 1        |\n| 1 |    | 1        |\n| 2 | -1 | -1       |\n| 5 |    |          |\n| 6 | 4  | 4        |\n\n```\nT = 2021.01.02 2021.01.02  2021.01.04  2021.01.05 2021.01.07 2021.01.08\nX = NULL 4 NULL -1 2 4\nm = table(T as t,X as x)\nselect *, tmmin(t, x, 3d) from m\n```\n\n| t          | x  | tmmin\\_t |\n| ---------- | -- | -------- |\n| 2021.01.02 |    |          |\n| 2021.01.02 | 4  | 4        |\n| 2021.01.04 |    | 4        |\n| 2021.01.05 | -1 | -1       |\n| 2021.01.07 | 2  | -1       |\n| 2021.01.08 | 4  | 2        |\n\n```\nselect *, tmmin(t, x, 1w) from m\n```\n\n| t          | x  | tmmin\\_t |\n| ---------- | -- | -------- |\n| 2021.01.02 |    |          |\n| 2021.01.02 | 4  | 4        |\n| 2021.01.04 |    | 4        |\n| 2021.01.05 | -1 | -1       |\n| 2021.01.07 | 2  | -1       |\n| 2021.01.08 | 4  | -1       |\n\n相关函数：[mmin](https://docs.dolphindb.cn/zh/funcs/m/mmin.html), [min](https://docs.dolphindb.cn/zh/funcs/m/min.html)\n"
    },
    "tmove": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tmove.html",
        "signatures": [
            {
                "full": "tmove(T, X, window)",
                "name": "tmove",
                "parameters": [
                    {
                        "full": "T",
                        "name": "T"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    }
                ]
            }
        ],
        "markdown": "### [tmove](https://docs.dolphindb.cn/zh/funcs/t/tmove.html)\n\n\n\n#### 语法\n\ntmove(T, X, window)\n\n#### 详情\n\n返回 *T* 向前偏移 *window* 后对应的 *X* 中元素。即：对于 *T* 中每个时间T i，向前偏移 *window* 后为T i - *window*, 返回T i - *window* 对应的 *X* 中的元素，若 *T* 中无对应时间，则返回Ti - *window* 前一个临近时间对应的 *X* 中的元素。\n\n#### 参数\n\n**T** 是一个递增的整型或时间类型的向量，且不能包含 NULL 值。\n\n**X** 是一个与 *T* 长度相同的向量。\n\n**window** 是一个正整数或一个 [duration](https://docs.dolphindb.cn/zh/funcs/d/duration.html)。表示向前移动的区间。\n\n#### 返回值\n\n返回一个与输入 *X* 相同数据类型的向量。\n\n#### 例子\n\n```\nT = 1 1 1 2 5 6\nX = 1 4 NULL -1 NULL 4\nm = table(T as t,X as x)\nselect *, tmove(t, x, 3) from m\n```\n\n| t | x  | tmove\\_t |\n| - | -- | -------- |\n| 1 | 1  |          |\n| 1 | 4  |          |\n| 1 |    |          |\n| 2 | -1 |          |\n| 5 |    | -1       |\n| 6 | 4  | -1       |\n\n```\nT = 2021.01.02 2021.01.02  2021.01.04  2021.01.05 2021.01.07 2021.01.09\nX = 5 4 NULL -1 2 4\nm = table(T as t,X as x)\nselect *, tmove(t, x, 3d) from m\n```\n\n| t          | x  | tmove\\_t |\n| ---------- | -- | -------- |\n| 2021.01.02 | 5  |          |\n| 2021.01.02 | 4  |          |\n| 2021.01.04 |    |          |\n| 2021.01.05 | -1 | 4        |\n| 2021.01.07 | 2  |          |\n| 2021.01.09 | 4  | -1       |\n\n```\nselect *, tmove(t, x, 1w) from m\n```\n\n| t          | x  | tmove\\_t |\n| ---------- | -- | -------- |\n| 2021.01.02 | 5  |          |\n| 2021.01.02 | 4  |          |\n| 2021.01.04 |    |          |\n| 2021.01.05 | -1 |          |\n| 2021.01.07 | 2  |          |\n| 2021.01.09 | 4  | 4        |\n\n**Related information**\n\n[move](https://docs.dolphindb.cn/zh/funcs/m/move.html)\n"
    },
    "tmovingWindowData": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tmovingWindowData.html",
        "signatures": [
            {
                "full": "tmovingWindowData(T, X, window, [leftClosed = false])",
                "name": "tmovingWindowData",
                "parameters": [
                    {
                        "full": "T",
                        "name": "T"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "[leftClosed = false]",
                        "name": "[leftClosed = false]"
                    }
                ]
            }
        ],
        "markdown": "### [tmovingWindowData](https://docs.dolphindb.cn/zh/funcs/t/tmovingWindowData.html)\n\n\n\n#### 语法\n\ntmovingWindowData(T, X, window, \\[leftClosed = false])\n\n#### 详情\n\n返回一个数组向量，其每行元素表示 *X* 每个滑动窗口的元素。\n\n#### 参数\n\n**T** 是一个非严格递增的整型或时间类型的向量。\n\n**X** 是一个与 T 长度相同的向量。\n\n**window** 是一个正整型或 DURATION 标量，表示以时间衡量的窗口的长度。\n\n**leftClosed** 是一个布尔值，表示窗口是否包含左边界的数据，默认为 false。\n\n#### 例子\n\n```\nT = 2022.01.01T09:00:00 + 1 1 2 3 6 7 9 10 13 14\nS = 1..10\ntmovingWindowData(T, S, 3s)\n[[1],[1,2],[1,2,3],[1,2,3,4],[5],[5,6],[6,7],[7,8],[9],[9,10]]\n\ntmovingWindowData(T, S, 3s, leftClosed=true)\n[[1],[1,2],[1,2,3],[1,2,3,4],[4,5],[5,6],[5,6,7],[6,7,8],[8,9],[9,10]]\n\n// 在响应式引擎中获取10分钟滑动窗口的数据\nn = 100\nDateTime = 2023.01.01T09:00:00 + rand(10000, n).sort!()\nSecurityID = take(`600021`600022`600023`600024`600025, n)\nPrice = 1.0 + rand(1.0, n) \nt = table(1:0, `DateTime`SecurityID`Price, [TIMESTAMP, SYMBOL, DOUBLE])\ntableInsert(t, DateTime, SecurityID, Price)\noutput = table(100:0, `SecurityID`DateTime`PriceNew, [SYMBOL, DATETIME, DOUBLE[]])\n\nengine = createReactiveStateEngine(name=\"rseEngine\", metrics=[<DateTime>, <tmovingWindowData(DateTime, Price,10m)>], dummyTable=t, outputTable=output, keyColumn=`SecurityID, keepOrder=true)\nengine.append!(t)\ndropStreamEngine(`rseEngine)\n```\n"
    },
    "tmpercentile": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tmpercentile.html",
        "signatures": [
            {
                "full": "tmpercentile(T, X, percent, window, [interpolation='linear'])",
                "name": "tmpercentile",
                "parameters": [
                    {
                        "full": "T",
                        "name": "T"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "percent",
                        "name": "percent"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "[interpolation='linear']",
                        "name": "interpolation",
                        "optional": true,
                        "default": "'linear'"
                    }
                ]
            }
        ],
        "markdown": "### [tmpercentile](https://docs.dolphindb.cn/zh/funcs/t/tmpercentile.html)\n\n\n\n#### 语法\n\ntmpercentile(T, X, percent, window, \\[interpolation='linear'])\n\n部分通用参数说明和窗口计算规则请参考：[tmFunctions](https://docs.dolphindb.cn/zh/funcs/themes/tmFunctions.html)\n\n#### 详情\n\n在给定长度（以时间 *T* 衡量）的滑动窗口内计算 *X* 元素在其对应窗口内的百分位数。\n\n#### 参数\n\n**percent** 是0到100之间的整数或小数。\n\n**interpolation** 是一个字符串，表示当选中的分位点位于在 *X* 的第 i 和第 i+1 个元素之间时，采用的插值方法。它具有以下取值：\n\n* 'linear': ![linear](https://docs.dolphindb.cn/zh/images/tmlinear.png) 其中 ![fraction](https://docs.dolphindb.cn/zh/images/tmfraction.png)\n\n* 'lower': ![lower](https://docs.dolphindb.cn/zh/images/xi.png)\n\n* 'higher': ![higher](https://docs.dolphindb.cn/zh/images/higher.png)\n\n* 'nearest': ![lower](https://docs.dolphindb.cn/zh/images/xi.png) 和![higher](https://docs.dolphindb.cn/zh/images/higher.png)之中最接近分位点的数据\n\n* 'midpoint': ![midpoint](https://docs.dolphindb.cn/zh/images/midpoint.png)\n\n如果没有指定 *interpolation*，默认采用 'linear'。\n\n#### 返回值\n\nDOUBLE 类型向量。\n\n#### 例子\n\n```\nT = 1 1 1 2 5 6\nX = 1 4 NULL -1 NULL 4\nm = table(T as t,X as x)\nselect *, tmpercentile(t, x, 50, 3) from m\n```\n\n| t | x  | tmpercentile\\_t |\n| - | -- | --------------- |\n| 1 | 1  | 1               |\n| 1 | 4  | 2.5             |\n| 1 |    | 2.5             |\n| 2 | -1 | 1               |\n| 5 |    |                 |\n| 6 | 4  | 4               |\n\n```\nT = 2021.01.02 2021.01.02  2021.01.04  2021.01.05 2021.01.07 2021.01.08\nX = NULL 4 NULL -1 2 4\nm = table(T as t,X as x)\nselect *, tmpercentile(t, x, 50, 3d) from m\n```\n\n| t          | x  | tmpercentile\\_t |\n| ---------- | -- | --------------- |\n| 2021.01.02 |    |                 |\n| 2021.01.02 | 4  | 4               |\n| 2021.01.04 |    | 4               |\n| 2021.01.05 | -1 | -1              |\n| 2021.01.07 | 2  | 0.5             |\n| 2021.01.08 | 4  | 3               |\n\n```\nselect *, tmpercentile(t, x, 50, 1w) from m\n```\n\n| t          | x  | tmpercentile\\_t |\n| ---------- | -- | --------------- |\n| 2021.01.02 |    |                 |\n| 2021.01.02 | 4  | 4               |\n| 2021.01.04 |    | 4               |\n| 2021.01.05 | -1 | 1.5             |\n| 2021.01.07 | 2  | 2               |\n| 2021.01.08 | 4  | 3               |\n\n相关函数：[percentile](https://docs.dolphindb.cn/zh/funcs/p/percentile.html), [mpercentile](https://docs.dolphindb.cn/zh/funcs/m/mpercentile.html)\n"
    },
    "tmprod": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tmprod.html",
        "signatures": [
            {
                "full": "tmprod(T, X, window)",
                "name": "tmprod",
                "parameters": [
                    {
                        "full": "T",
                        "name": "T"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    }
                ]
            }
        ],
        "markdown": "### [tmprod](https://docs.dolphindb.cn/zh/funcs/t/tmprod.html)\n\n\n\n#### 语法\n\ntmprod(T, X, window)\n\n参数说明和窗口计算规则请参考：[tmFunctions](https://docs.dolphindb.cn/zh/funcs/themes/tmFunctions.html)\n\n#### 详情\n\n在给定长度（以时间 *T* 衡量）的滑动窗口内计算 *X* 元素的乘积。\n\n#### 返回值\n\n与 *X* 长度相同的 DOUBLE 类型向量。\n\n#### 例子\n\n```\nT = 1 1 3 5 8 15 15 20\nX = 5 2 4 1 2 8 9 10\nm=table(T as t, X as x)\nselect *, tmprod(t, x, 3) from m\n```\n\n| t  | x  | tmprod\\_t |\n| -- | -- | --------- |\n| 1  | 5  | 5         |\n| 1  | 2  | 10        |\n| 3  | 4  | 40        |\n| 5  | 1  | 4         |\n| 8  | 2  | 2         |\n| 15 | 8  | 8         |\n| 15 | 9  | 72        |\n| 20 | 10 | 10        |\n\n```\nT = 2021.01.02 2021.01.02  2021.01.04  2021.01.05 2021.01.07 2021.01.08\nX = NULL 4 NULL -1 2 4\nm = table(T as t,X as x)\nselect *, tmprod(t, x, 3d) from m\n```\n\n| t          | x  | tmprod\\_t |\n| ---------- | -- | --------- |\n| 2021.01.02 |    |           |\n| 2021.01.02 | 4  | 4         |\n| 2021.01.04 |    | 4         |\n| 2021.01.05 | -1 | -1        |\n| 2021.01.07 | 2  | -2        |\n| 2021.01.08 | 4  | 8         |\n\n```\nselect *, tmprod(t, x, 1w) from m\n```\n\n| t          | x  | tmprod\\_t |\n| ---------- | -- | --------- |\n| 2021.01.02 |    |           |\n| 2021.01.02 | 4  | 4         |\n| 2021.01.04 |    | 4         |\n| 2021.01.05 | -1 | -1        |\n| 2021.01.07 | 2  | -2        |\n| 2021.01.08 | 4  | 8         |\n\n相关函数：[mprod](https://docs.dolphindb.cn/zh/funcs/m/mprod.html), [prod](https://docs.dolphindb.cn/zh/funcs/p/prod.html)\n"
    },
    "tmrank": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tmrank.html",
        "signatures": [
            {
                "full": "tmrank(T, X, ascending, window, [ignoreNA=true], [tiesMethod='min'], [percent=false])",
                "name": "tmrank",
                "parameters": [
                    {
                        "full": "T",
                        "name": "T"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "ascending",
                        "name": "ascending"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "[ignoreNA=true]",
                        "name": "ignoreNA",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[tiesMethod='min']",
                        "name": "tiesMethod",
                        "optional": true,
                        "default": "'min'"
                    },
                    {
                        "full": "[percent=false]",
                        "name": "percent",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [tmrank](https://docs.dolphindb.cn/zh/funcs/t/tmrank.html)\n\n\n\n#### 语法\n\ntmrank(T, X, ascending, window, \\[ignoreNA=true], \\[tiesMethod='min'], \\[percent=false])\n\n部分通用参数说明和窗口计算规则请参考：[tmFunctions](https://docs.dolphindb.cn/zh/funcs/themes/tmFunctions.html)\n\n#### 详情\n\n在给定长度（以时间 *T* 衡量）的滑动窗口内计算 *X* 元素在其对应窗口内的排名。\n\n#### 参数\n\n**ascending** 是一个布尔值，表示是否按升序排序。默认值是 true。\n\n**ignoreNA** 是一个布尔值，表示是否忽略 NULL 值。true 表示忽略 NULL 值（默认值），false 表示 NULL 值参与排名，此时 NULL 值为最小值。\n\n**tiesMethod** 是一个字符串，表示窗口内若存在重复值时，排名如何选取。\n\n* 'min'表示取最小排名。\n\n* 'max'表示取最大排名。\n\n* 'average'表示取排名的均值。\n\n**percent** 是一个布尔值，表示是否以百分比形式显示返回的排名，默认值为 false。\n\n#### 返回值\n\n与 *X* 长度相同的 INT 类型向量。\n\n#### 例子\n\n```\ntmrank(1 1 3 5 8 15 15 20, 5 2 4 1 2 8 9 10, ascending=true, window=3)\n// output\n[0,0,1,0,0,0,1,0]\n\nindex = take(datehour(2019.06.13 13:30:10),4) join (datehour(2019.06.14 13:30:10)+1..6)\ndata = 1 NULL 3 4 5 NULL 3 NULL 5 3\n\ntmrank(index, data, ascending=true, window=4h)\n// output\n[0,,1,2,0,,0,,1,0]\n\ntmrank(index, data, ascending=true, window=2d)\n// output\n[0,,1,2,3,,1,,4,1]\n```\n\n相关函数：[mrank](https://docs.dolphindb.cn/zh/funcs/m/mrank.html), [rank](https://docs.dolphindb.cn/zh/funcs/r/rank.html)\n"
    },
    "tmskew": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tmskew.html",
        "signatures": [
            {
                "full": "tmskew(T, X, window, [biased=true])",
                "name": "tmskew",
                "parameters": [
                    {
                        "full": "T",
                        "name": "T"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "[biased=true]",
                        "name": "biased",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [tmskew](https://docs.dolphindb.cn/zh/funcs/t/tmskew.html)\n\n\n\n#### 语法\n\ntmskew(T, X, window, \\[biased=true])\n\n部分通用参数说明和窗口计算规则请参考：[tmFunctions](https://docs.dolphindb.cn/zh/funcs/themes/tmFunctions.html)\n\n#### 详情\n\n在给定长度（以时间 *T* 衡量）的滑动窗口内计算 *X* 的斜度。\n\n#### 参数\n\n**biased** 是一个布尔值，表示是否是有偏估计。默认值为 true，表示有偏估计。\n\n#### 返回值\n\nDOUBLE 类型向量。\n\n#### 例子\n\n```\ntmskew(1 1 3 5 8 15 15 20, 5 2 4 1 2 8 9 10, 3)\n// output\n[,0,-0.381801774160607,0,,,0,]\nindex = take(datehour(2019.06.13 13:30:10),4) join (datehour(2019.06.13 13:30:10)+1..6)\ndata = 1 NULL 3 4 5 NULL 3 NULL 5 3\ntmskew(index, data, 4h)\n// output\n[,,,-0.3818,,,0,0,0,0.7071]\ntmskew(index, data, 2d)\n// output\n[,,0,-0.3818,-0.4347,-0.4347,-0.37,-0.37,-0.5653,-0.4363]\n```\n\n相关函数：[mskew](https://docs.dolphindb.cn/zh/funcs/m/mskew.html), [skew](https://docs.dolphindb.cn/zh/funcs/s/skew.html)\n"
    },
    "tmskewTopN": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tmskewTopN.html",
        "signatures": [
            {
                "full": "tmskewTopN(T, X, S, window, top, [biased=true], [ascending=true], [tiesMethod='latest'])",
                "name": "tmskewTopN",
                "parameters": [
                    {
                        "full": "T",
                        "name": "T"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "S",
                        "name": "S"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "top",
                        "name": "top"
                    },
                    {
                        "full": "[biased=true]",
                        "name": "biased",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[tiesMethod='latest']",
                        "name": "tiesMethod",
                        "optional": true,
                        "default": "'latest'"
                    }
                ]
            }
        ],
        "markdown": "### [tmskewTopN](https://docs.dolphindb.cn/zh/funcs/t/tmskewTopN.html)\n\n\n\n#### 语法\n\ntmskewTopN(T, X, S, window, top, \\[biased=true], \\[ascending=true], \\[tiesMethod='latest'])\n\n参数说明和窗口计算规则请参考：[tmTopN](https://docs.dolphindb.cn/zh/funcs/themes/tmTopN.html)\n\n#### 详情\n\n在给定长度（以时间 *T* 衡量）的滑动窗口内，根据 *ascending* 指定的排序方式将 *X* 按照 *S* 进行稳定排序后，计算前 *top* 个元素的斜度。\n\n#### 参数\n\n**biased** 是一个布尔值，表示是否是有偏估计。默认值为 true，表示有偏估计。\n\n#### 返回值\n\nDOUBLE 类型向量。\n\n#### 例子\n\n```\nT=2023.01.03+1..7\nX = [2, 1, 4, 3, 4, 3, 1]\nS = [5, 8, 1, , 1, 1, 3]  //S 中包含的空值不参与排序，对应位置的 X 不参与计算\ntmskewTopN(T,X,S,6,4)\n// output\n[,0,0.3818,0.3818,-0.2138,-0.4933,-0.8164]\n\nT=2023.01.03 2023.01.07 2023.01.08 2023.01.10 2023.01.11 2023.01.12\nX=8 3 1 2 5 2\nS=1 5 2 3 1 1\nt=table(T as time, X as val, S as id)\nselect tmskewTopN(time,val,id,4,3) as topN from t\n```\n\n| topN   |\n| ------ |\n|        |\n|        |\n| 0      |\n| 0      |\n| 0.5280 |\n| 0.7071 |\n\n相关函数：[tmskew](https://docs.dolphindb.cn/zh/funcs/t/tmskew.html)\n"
    },
    "tmstd": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tmstd.html",
        "signatures": [
            {
                "full": "tmstd(T, X, window)",
                "name": "tmstd",
                "parameters": [
                    {
                        "full": "T",
                        "name": "T"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    }
                ]
            }
        ],
        "markdown": "### [tmstd](https://docs.dolphindb.cn/zh/funcs/t/tmstd.html)\n\n\n\n#### 语法\n\ntmstd(T, X, window)\n\n参数说明和窗口计算规则请参考：[tmFunctions](https://docs.dolphindb.cn/zh/funcs/themes/tmFunctions.html)\n\n#### 详情\n\n在给定长度（以时间 *T* 衡量）的滑动窗口内计算 *X* 的样本标准差。\n\n**空值处理**\n\n忽略空值，仅基于窗口内的非空值进行计算。\n\n| 场景               | 行为                       |\n| ---------------- | ------------------------ |\n| 参数 *X* 中的空值      | 在窗口计算中被直接忽略，不参与样本标准差的计算。 |\n| 窗口内全为空值或非空值少于2个时 | 计算结果为空值。                 |\n\n#### 返回值\n\nDOUBLE 类型向量。\n\n#### 例子\n\n```\nT = 1 1 3 5 8 15 15 20\nX = 5 2 4 1 2 8 9 10\nm=table(T as t, X as x)\nselect *, tmstd(t, x, 3) from m\n```\n\n| t  | x  | tmstd\\_t |\n| -- | -- | -------- |\n| 1  | 5  |          |\n| 1  | 2  | 2.1213   |\n| 3  | 4  | 1.5275   |\n| 5  | 1  | 2.1213   |\n| 8  | 2  |          |\n| 15 | 8  |          |\n| 15 | 9  | 0.7071   |\n| 20 | 10 |          |\n\n```\nT = 2021.01.02 2021.01.02  2021.01.04  2021.01.05 2021.01.07 2021.01.08\nX = NULL 4 NULL -1 2 4\nm = table(T as t,X as x)\nselect *, tmstd(t, x, 3d) from m\n```\n\n| t          | x  | tmstd\\_t |\n| ---------- | -- | -------- |\n| 2021.01.02 |    |          |\n| 2021.01.02 | 4  |          |\n| 2021.01.04 |    |          |\n| 2021.01.05 | -1 |          |\n| 2021.01.07 | 2  | 2.1213   |\n| 2021.01.08 | 4  | 1.4142   |\n\n```\nselect *, tmstd(t, x, 1w) from m\n```\n\n| t          | x  | tmstd\\_t |\n| ---------- | -- | -------- |\n| 2021.01.02 |    |          |\n| 2021.01.02 | 4  |          |\n| 2021.01.04 |    |          |\n| 2021.01.05 | -1 | 3.5355   |\n| 2021.01.07 | 2  | 2.5166   |\n| 2021.01.08 | 4  | 2.3629   |\n\n相关函数：[mstd](https://docs.dolphindb.cn/zh/funcs/m/mstd.html), [std](https://docs.dolphindb.cn/zh/funcs/s/std.html)\n"
    },
    "tmstdp": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tmstdp.html",
        "signatures": [
            {
                "full": "tmstdp(T, X, window)",
                "name": "tmstdp",
                "parameters": [
                    {
                        "full": "T",
                        "name": "T"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    }
                ]
            }
        ],
        "markdown": "### [tmstdp](https://docs.dolphindb.cn/zh/funcs/t/tmstdp.html)\n\n\n\n#### 语法\n\ntmstdp(T, X, window)\n\n参数说明和窗口计算规则请参考：[tmFunctions](https://docs.dolphindb.cn/zh/funcs/themes/tmFunctions.html)\n\n#### 详情\n\n在给定长度（以时间 *T* 衡量）的滑动窗口内计算 *X* 的总体标准差。\n\n#### 返回值\n\nDOUBLE 类型向量。\n\n#### 例子\n\n```\nT = 1 1 3 5 8 15 15 20\nX = 5 2 4 1 2 8 9 10\nm=table(T as t, X as x)\nselect *, tmstdp(t, x, 3) from m\n```\n\n| t  | x  | tmstdp\\_t |\n| -- | -- | --------- |\n| 1  | 5  | 0         |\n| 1  | 2  | 1.5       |\n| 3  | 4  | 1.2472    |\n| 5  | 1  | 1.5       |\n| 8  | 2  | 0         |\n| 15 | 8  | 0         |\n| 15 | 9  | 0.5       |\n| 20 | 10 | 0         |\n\n```\nT = 2021.01.02 2021.01.02  2021.01.04  2021.01.05 2021.01.07 2021.01.08\nX = NULL 4 NULL -1 2 4\nm = table(T as t,X as x)\nselect *, tmstdp(t, x, 3d) from m\n```\n\n| t          | x  | tmstdp\\_t |\n| ---------- | -- | --------- |\n| 2021.01.02 |    |           |\n| 2021.01.02 | 4  | 0         |\n| 2021.01.04 |    | 0         |\n| 2021.01.05 | -1 | 0         |\n| 2021.01.07 | 2  | 1.5       |\n| 2021.01.08 | 4  | 1         |\n\n```\nselect *, tmstdp(t, x, 1w) from m\n```\n\n| t          | x  | tmstdp\\_t |\n| ---------- | -- | --------- |\n| 2021.01.02 |    |           |\n| 2021.01.02 | 4  | 0         |\n| 2021.01.04 |    | 0         |\n| 2021.01.05 | -1 | 2.5       |\n| 2021.01.07 | 2  | 2.0548    |\n| 2021.01.08 | 4  | 2.0463    |\n\n相关函数：[mstdp](https://docs.dolphindb.cn/zh/funcs/m/mstdp.html), [stdp](https://docs.dolphindb.cn/zh/funcs/s/stdp.html)\n"
    },
    "tmstdpTopN": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tmstdpTopN.html",
        "signatures": [
            {
                "full": "tmstdpTopN(T, X, S, window, top, [ascending=true], [tiesMethod='latest'])",
                "name": "tmstdpTopN",
                "parameters": [
                    {
                        "full": "T",
                        "name": "T"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "S",
                        "name": "S"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "top",
                        "name": "top"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[tiesMethod='latest']",
                        "name": "tiesMethod",
                        "optional": true,
                        "default": "'latest'"
                    }
                ]
            }
        ],
        "markdown": "### [tmstdpTopN](https://docs.dolphindb.cn/zh/funcs/t/tmstdpTopN.html)\n\n\n\n#### 语法\n\ntmstdpTopN(T, X, S, window, top, \\[ascending=true], \\[tiesMethod='latest'])\n\n参数说明和窗口计算规则请参考：[tmTopN](https://docs.dolphindb.cn/zh/funcs/themes/tmTopN.html)\n\n#### 详情\n\n在给定长度（以时间 *T* 衡量）的滑动窗口内，根据 *ascending* 指定的排序方式将 *X* 按照 *S* 进行稳定排序后，计算前 *top* 个元素的总体标准差。\n\n#### 返回值\n\nDOUBLE 类型向量。\n\n#### 例子\n\n```\nT=2023.01.03+1..7\nX = [2, 1, 4, 3, 4, 3, 1]\nS = [5, 8, 1, , 1, 1, 3]  //S 中包含的空值不参与排序，对应位置的 X 不参与计算\ntmstdpTopN(T,X,S,6,4)\n// output\n[0,0.5,1.2472,1.2472,1.299,0.8291,1.2247]\n\nT=2023.01.03 2023.01.07 2023.01.08 2023.01.10 2023.01.11 2023.01.12\nX=8 3 1 2 5 2\nS=1 5 2 3 1 1\nt=table(T as time, X as val, S as id)\nselect tmstdpTopN(time,val,id,4,3) as topN from t\n```\n\n| topN   |\n| ------ |\n| 0      |\n| 0      |\n| 1      |\n| 0.8164 |\n| 1.6996 |\n| 1.4142 |\n\n相关函数：[tmstdp](https://docs.dolphindb.cn/zh/funcs/t/tmstdp.html)\n"
    },
    "tmstdTopN": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tmstdTopN.html",
        "signatures": [
            {
                "full": "tmstdTopN(T, X, S, window, top, [ascending=true], [tiesMethod='latest'])",
                "name": "tmstdTopN",
                "parameters": [
                    {
                        "full": "T",
                        "name": "T"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "S",
                        "name": "S"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "top",
                        "name": "top"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[tiesMethod='latest']",
                        "name": "tiesMethod",
                        "optional": true,
                        "default": "'latest'"
                    }
                ]
            }
        ],
        "markdown": "### [tmstdTopN](https://docs.dolphindb.cn/zh/funcs/t/tmstdTopN.html)\n\n\n\n#### 语法\n\ntmstdTopN(T, X, S, window, top, \\[ascending=true], \\[tiesMethod='latest'])\n\n参数说明和窗口计算规则请参考：[tmTopN](https://docs.dolphindb.cn/zh/funcs/themes/tmTopN.html)\n\n#### 详情\n\n在给定长度（以时间 *T* 衡量）的滑动窗口内，根据 *ascending* 指定的排序方式将 *X* 按照 *S* 进行稳定排序后，计算前 *top* 个元素的标准差。\n\n#### 返回值\n\nDOUBLE 类型向量。\n\n#### 例子\n\n```\nT=2023.01.03+1..7\nX = [2, 1, 4, 3, 4, 3, 1]\nS = [5, 8, 1, , 1, 1, 3]  //S 中包含的空值不参与排序，对应位置的 X 不参与计算\ntmstdTopN(T,X,S,6,4)\n// output\n[,0.7071,1.5275,1.5275,1.5,0.9574,1.4142]\n\nT=2023.01.03 2023.01.07 2023.01.08 2023.01.10 2023.01.11 2023.01.12\nX=8 3 1 2 5 2\nS=1 5 2 3 1 1\nt=table(T as time, X as val, S as id)\nselect tmstdTopN(time,val,id,4,3) as topN from t\n```\n\n| topN   |\n| ------ |\n|        |\n|        |\n| 1.4142 |\n| 1      |\n| 2.0816 |\n| 1.732  |\n\n相关函数：[tmstd](https://docs.dolphindb.cn/zh/funcs/t/tmstd.html)\n"
    },
    "tmsum": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tmsum.html",
        "signatures": [
            {
                "full": "tmsum(T, X, window)",
                "name": "tmsum",
                "parameters": [
                    {
                        "full": "T",
                        "name": "T"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    }
                ]
            }
        ],
        "markdown": "### [tmsum](https://docs.dolphindb.cn/zh/funcs/t/tmsum.html)\n\n\n\n#### 语法\n\ntmsum(T, X, window)\n\n参数说明和窗口计算规则请参考：[tmFunctions](https://docs.dolphindb.cn/zh/funcs/themes/tmFunctions.html)\n\n#### 详情\n\n在给定长度（以时间 *T* 衡量）的滑动窗口内计算 *X* 的元素和。\n\n#### 返回值\n\n*X* 为整型，返回 LONG 类型向量，*X* 为浮点数，返回 DOUBLE 类型向量。\n\n#### 例子\n\n```\ntmsum(1 1 3 5 8 15 15 20, 5 2 4 1 2 8 9 10, 3)\n// output\n[5,7,11,5,2,8,17,10]\nindex = take(datehour(2019.06.13 13:30:10),4) join (datehour(2019.06.13 13:30:10)+1..6)\ndata = 1 NULL 3 4 5 NULL 3 NULL 5 3\ntmsum(index, data, 4h)\n// output\n[1,1,4,8,13,13,16,8,8,11]\ntmsum(index, data, 1d)\n// output\n[1,1,4,8,13,13,16,16,21,24]\n```\n\n相关函数：[msum](https://docs.dolphindb.cn/zh/funcs/m/msum.html), [sum](https://docs.dolphindb.cn/zh/funcs/s/sum.html)\n"
    },
    "tmsum2": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tmsum2.html",
        "signatures": [
            {
                "full": "tmsum2(T, X, window)",
                "name": "tmsum2",
                "parameters": [
                    {
                        "full": "T",
                        "name": "T"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    }
                ]
            }
        ],
        "markdown": "### [tmsum2](https://docs.dolphindb.cn/zh/funcs/t/tmsum2.html)\n\n\n\n#### 语法\n\ntmsum2(T, X, window)\n\n参数说明和窗口计算规则请参考：[tmFunctions](https://docs.dolphindb.cn/zh/funcs/themes/tmFunctions.html)\n\n#### 详情\n\n在给定长度（以时间 *T* 衡量）的滑动窗口内计算 *X* 元素的平方和。\n\n#### 返回值\n\nDOUBLE 类型向量。\n\n#### 例子\n\n```\ntmsum2(1 1 3 5 8 15 15 20, 5 2 4 1 2 8 9 10, 3)\n// output\n[25,29,45,17,4,64,145,100]\n\nindex = take(datehour(2019.06.13 13:30:10),4) join (datehour(2019.06.13 13:30:10)+1..6)\ndata = 1 NULL 3 4 5 NULL 3 NULL 5 3\ntmsum2(index, data, 4h)\n// output\n[1,1,10,26,51,51,60,34,34,43]\n\ntmsum2(index, data, 1d)\n// output\n[1,1,10,26,51,51,60,60,85,94]\n```\n\n相关函数：[msum2](https://docs.dolphindb.cn/zh/funcs/m/msum2.html), [sum2](https://docs.dolphindb.cn/zh/funcs/s/sum2.html)\n"
    },
    "tmsumTopN": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tmsumTopN.html",
        "signatures": [
            {
                "full": "tmsumTopN(T, X, S, window, top, [ascending=true], [tiesMethod='latest'])",
                "name": "tmsumTopN",
                "parameters": [
                    {
                        "full": "T",
                        "name": "T"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "S",
                        "name": "S"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "top",
                        "name": "top"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[tiesMethod='latest']",
                        "name": "tiesMethod",
                        "optional": true,
                        "default": "'latest'"
                    }
                ]
            }
        ],
        "markdown": "### [tmsumTopN](https://docs.dolphindb.cn/zh/funcs/t/tmsumTopN.html)\n\n\n\n#### 语法\n\ntmsumTopN(T, X, S, window, top, \\[ascending=true], \\[tiesMethod='latest'])\n\n参数说明和窗口计算规则请参考：[tmTopN](https://docs.dolphindb.cn/zh/funcs/themes/tmTopN.html)\n\n#### 详情\n\n在给定长度（以时间 *T* 衡量）的滑动窗口内，根据 *ascending* 指定的排序方式将 *X* 按照 *S* 进行稳定排序后，取前 *top* 个元素并进行求和计算。\n\n#### 返回值\n\n*X* 为整型，返回 LONG 类型向量，*X* 为浮点数，返回 DOUBLE 类型向量。\n\n#### 例子\n\n```\nT=2023.01.03+1..7\nX = [2, 1, 4, 3, 4, 3, 1]\nS = [5, 8, 1, , 1, 1, 3]  //S 中包含的空值不参与排序，对应位置的 X 不参与计算\ntmsumTopN(T,X,S,6,4)\n// output\n[2,3,7,7,11,13,12]\n\nT=2023.01.03 2023.01.07 2023.01.08 2023.01.10 2023.01.11 2023.01.12\nX=8 3 1 2 5 2\nS=1 5 2 3 1 1\nt=table(T as time, X as val, S as id)\nselect tmsumTopN(time,val,id,4,3) as topN from t\n```\n\n| topN |\n| ---- |\n| 8    |\n| 3    |\n| 4    |\n| 6    |\n| 8    |\n| 9    |\n\n相关函数：[tmsum](https://docs.dolphindb.cn/zh/funcs/t/tmsum.html)\n"
    },
    "tmTopRange": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tmtoprange.html",
        "signatures": [
            {
                "full": "tmTopRange(T, X, window)",
                "name": "tmTopRange",
                "parameters": [
                    {
                        "full": "T",
                        "name": "T"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    }
                ]
            }
        ],
        "markdown": "### [tmTopRange](https://docs.dolphindb.cn/zh/funcs/t/tmtoprange.html)\n\n#### 语法\n\ntmTopRange(T, X, window)\n\n参数说明和窗口计算规则请参考：[tmFunctions](https://docs.dolphindb.cn/zh/funcs/themes/tmFunctions.html)\n\n#### 详情\n\n在给定长度（以时间 *T* 衡量）的滑动窗口内，统计每个元素 Xi 左侧相邻且连续小于它的元素个数。NULL 被视为最小值。\n\n#### 返回值\n\nINT 类型向量。\n\n#### 例子\n\n```\nt = [0, 1, 2, 3, 7, 8, 9, 10, 11]\nx = [NULL, 3.1, NULL, 3.0, 2.9, 2.8, 3.1, NULL, 3.2];\ntmTopRange(t, x, window=3);\n//output: [,1,0,1,0,0,2,0,2]\n\ntmTopRange(t, x, window=4);\n// output: [,1,0,1,0,0,2,0,3]\n\nindex = take(datehour(2019.06.13 13:30:10),4) join (datehour(2019.06.13 13:30:10)+1..6)\ndata = 1 NULL 3 4 5 NULL 3 NULL 5 3\ntmTopRange(index, data, 4h)\n// output: [0,0,2,3,4,0,1,0,3,0]\n```\n\n"
    },
    "tmvar": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tmvar.html",
        "signatures": [
            {
                "full": "tmvar(T, X, window)",
                "name": "tmvar",
                "parameters": [
                    {
                        "full": "T",
                        "name": "T"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    }
                ]
            }
        ],
        "markdown": "### [tmvar](https://docs.dolphindb.cn/zh/funcs/t/tmvar.html)\n\n\n\n#### 语法\n\ntmvar(T, X, window)\n\n参数说明和窗口计算规则请参考：[tmFunctions](https://docs.dolphindb.cn/zh/funcs/themes/tmFunctions.html)\n\n#### 详情\n\n在给定长度（以时间 *T* 衡量）的滑动窗口内计算 *X* 的样本方差。\n\n#### 返回值\n\nDOUBLE 类型向量。\n\n#### 例子\n\n```\nT = 1 1 3 5 8 15 15 20\nX = 5 2 4 1 2 8 9 10\nm=table(T as t, X as x)\nselect *, tmvar(t, x, 3) from m\n```\n\n| t  | x  | tmvar\\_t |\n| -- | -- | -------- |\n| 1  | 5  |          |\n| 1  | 2  | 4.5      |\n| 3  | 4  | 2.3333   |\n| 5  | 1  | 4.5      |\n| 8  | 2  |          |\n| 15 | 8  |          |\n| 15 | 9  | 0.5      |\n| 20 | 10 |          |\n\n```\nT = 2021.01.02 2021.01.02  2021.01.04  2021.01.05 2021.01.07 2021.01.08\nX = NULL 4 NULL -1 2 4\nm = table(T as t,X as x)\nselect *, tmvar(t, x, 3d) from m\n```\n\n| t          | x  | tmvar\\_t |\n| ---------- | -- | -------- |\n| 2021.01.02 |    |          |\n| 2021.01.02 | 4  |          |\n| 2021.01.04 |    |          |\n| 2021.01.05 | -1 |          |\n| 2021.01.07 | 2  | 4.5      |\n| 2021.01.08 | 4  | 2        |\n\n```\nselect *, tmvar(t, x, 1w) from m\n```\n\n| t          | x  | tmvar\\_t |\n| ---------- | -- | -------- |\n| 2021.01.02 |    |          |\n| 2021.01.02 | 4  |          |\n| 2021.01.04 |    |          |\n| 2021.01.05 | -1 | 12.5     |\n| 2021.01.07 | 2  | 6.333    |\n| 2021.01.08 | 4  | 5.5833   |\n\n相关函数：[mvar](https://docs.dolphindb.cn/zh/funcs/m/mvar.html), [var](https://docs.dolphindb.cn/zh/funcs/v/var.html)\n"
    },
    "tmvarp": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tmvarp.html",
        "signatures": [
            {
                "full": "tmvarp(T, X, window)",
                "name": "tmvarp",
                "parameters": [
                    {
                        "full": "T",
                        "name": "T"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    }
                ]
            }
        ],
        "markdown": "### [tmvarp](https://docs.dolphindb.cn/zh/funcs/t/tmvarp.html)\n\n\n\n#### 语法\n\ntmvarp(T, X, window)\n\n参数说明和窗口计算规则请参考：[tmFunctions](https://docs.dolphindb.cn/zh/funcs/themes/tmFunctions.html)\n\n#### 详情\n\n在给定长度（以时间 *T* 衡量）的滑动窗口内计算 *X* 的总体方差。\n\n#### 返回值\n\nDOUBLE 类型向量。\n\n#### 例子\n\n```\nT = 1 1 3 5 8 15 15 20\nX = 5 2 4 1 2 8 9 10\nm=table(T as t, X as x)\nselect *, tmvarp(t, x, 3) from m\n```\n\n| t  | x  | tmvarp\\_t |\n| -- | -- | --------- |\n| 1  | 5  | 0         |\n| 1  | 2  | 2.25      |\n| 3  | 4  | 1.5556    |\n| 5  | 1  | 2.25      |\n| 8  | 2  | 0         |\n| 15 | 8  | 0         |\n| 15 | 9  | 0.25      |\n| 20 | 10 | 0         |\n\n```\nT = 2021.01.02 2021.01.02  2021.01.04  2021.01.05 2021.01.07 2021.01.08\nX = NULL 4 NULL -1 2 4\nm = table(T as t,X as x)\nselect *, tmvarp(t, x, 3d) from m\n```\n\n| t          | x  | tmvarp\\_t |\n| ---------- | -- | --------- |\n| 2021.01.02 |    |           |\n| 2021.01.02 | 4  | 0         |\n| 2021.01.04 |    | 0         |\n| 2021.01.05 | -1 | 0         |\n| 2021.01.07 | 2  | 2.25      |\n| 2021.01.08 | 4  | 1         |\n\n```\nselect *, tmvarp(t, x, 1w) from m\n```\n\n| t          | x  | tmvarp\\_t |\n| ---------- | -- | --------- |\n| 2021.01.02 |    |           |\n| 2021.01.02 | 4  | 0         |\n| 2021.01.04 |    | 0         |\n| 2021.01.05 | -1 | 6.25      |\n| 2021.01.07 | 2  | 4.2222    |\n| 2021.01.08 | 4  | 4.1875    |\n\n相关函数：[mvarp](https://docs.dolphindb.cn/zh/funcs/m/mvarp.html), [varp](https://docs.dolphindb.cn/zh/funcs/v/varp.html)\n"
    },
    "tmvarpTopN": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tmvarpTopN.html",
        "signatures": [
            {
                "full": "tmvarpTopN(T, X, S, window, top, [ascending=true], [tiesMethod='latest'])",
                "name": "tmvarpTopN",
                "parameters": [
                    {
                        "full": "T",
                        "name": "T"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "S",
                        "name": "S"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "top",
                        "name": "top"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[tiesMethod='latest']",
                        "name": "tiesMethod",
                        "optional": true,
                        "default": "'latest'"
                    }
                ]
            }
        ],
        "markdown": "### [tmvarpTopN](https://docs.dolphindb.cn/zh/funcs/t/tmvarpTopN.html)\n\n\n\n#### 语法\n\ntmvarpTopN(T, X, S, window, top, \\[ascending=true], \\[tiesMethod='latest'])\n\n参数说明和窗口计算规则请参考：[tmTopN](https://docs.dolphindb.cn/zh/funcs/themes/tmTopN.html)\n\n#### 详情\n\n在给定长度（以时间 *T* 衡量）的滑动窗口内，根据 *ascending* 指定的排序方式将 *X* 按照 *S* 进行稳定排序后，计算前 *top* 个元素的总体方差。\n\n#### 返回值\n\nDOUBLE 类型向量。\n\n#### 例子\n\n```\nT=2023.01.03+1..7\nX = [2, 1, 4, 3, 4, 3, 1]\nS = [5, 8, 1, , 1, 1, 3]  //S 中包含的空值不参与排序，对应位置的 X 不参与计算\ntmvarpTopN(T,X,S,6,4)\n// output\n[0,0.25,1.5555,1.5555,1.6875,0.6875,1.5]\n\nT=2023.01.03 2023.01.07 2023.01.08 2023.01.10 2023.01.11 2023.01.12\nX=8 3 1 2 5 2\nS=1 5 2 3 1 1\nt=table(T as time, X as val, S as id)\nselect tmvarpTopN(time,val,id,4,3) as topN from t\n```\n\n| topN   |\n| ------ |\n| 0      |\n| 0      |\n| 1      |\n| 0.6666 |\n| 2.8888 |\n| 2      |\n\n相关函数：[tmvarp](https://docs.dolphindb.cn/zh/funcs/t/tmvarp.html)\n"
    },
    "tmvarTopN": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tmvarTopN.html",
        "signatures": [
            {
                "full": "tmvarTopN(T, X, S, window, top, [ascending=true], [tiesMethod='latest'])",
                "name": "tmvarTopN",
                "parameters": [
                    {
                        "full": "T",
                        "name": "T"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "S",
                        "name": "S"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "top",
                        "name": "top"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[tiesMethod='latest']",
                        "name": "tiesMethod",
                        "optional": true,
                        "default": "'latest'"
                    }
                ]
            }
        ],
        "markdown": "### [tmvarTopN](https://docs.dolphindb.cn/zh/funcs/t/tmvarTopN.html)\n\n\n\n#### 语法\n\ntmvarTopN(T, X, S, window, top, \\[ascending=true], \\[tiesMethod='latest'])\n\n参数说明和窗口计算规则请参考：[tmTopN](https://docs.dolphindb.cn/zh/funcs/themes/tmTopN.html)\n\n#### 详情\n\n在给定长度（以时间 *T* 衡量）的滑动窗口内，根据 *ascending* 指定的排序方式将 *X* 按照 *S* 进行稳定排序后，计算前 *top* 个元素的方差。\n\n#### 返回值\n\nDOUBLE 类型向量。\n\n#### 例子\n\n```\nT=2023.01.03+1..7\nX = [2, 1, 4, 3, 4, 3, 1]\nS = [5, 8, 1, , 1, 1, 3]  //S 中包含的空值不参与排序，对应位置的 X 不参与计算\ntmvarTopN(T,X,S,6,4)\n// output\n[,0.5,2.3333,2.3333,2.25,0.9166,2]\n\nT=2023.01.03 2023.01.07 2023.01.08 2023.01.10 2023.01.11 2023.01.12\nX=8 3 1 2 5 2\nS=1 5 2 3 1 1\nt=table(T as time, X as val, S as id)\nselect tmvarTopN(time,val,id,4,3) as topN from t\n```\n\n| topN   |\n| ------ |\n|        |\n|        |\n| 2      |\n| 1      |\n| 4.3333 |\n| 3      |\n\n相关函数：[tmvar](https://docs.dolphindb.cn/zh/funcs/t/tmvar.html)\n"
    },
    "tmwavg": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tmwavg.html",
        "signatures": [
            {
                "full": "tmwavg(T, X, Y, window)",
                "name": "tmwavg",
                "parameters": [
                    {
                        "full": "T",
                        "name": "T"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    }
                ]
            }
        ],
        "markdown": "### [tmwavg](https://docs.dolphindb.cn/zh/funcs/t/tmwavg.html)\n\n\n\n#### 语法\n\ntmwavg(T, X, Y, window)\n\n参数说明和窗口计算规则请参考：[tmFunctions](https://docs.dolphindb.cn/zh/funcs/themes/tmFunctions.html)\n\n#### 详情\n\n在给定长度（以时间长度衡量）的滑动窗口内，以 *Y* 为权重（权重会自动缩放，使其元素之和为1），计算 *X* 元素的加权平均。\n\n#### 返回值\n\nDOUBLE 类型向量。\n\n#### 例子\n\n```\nT= 1 1 1 1 2 5 6 8 9 10\nX = 1..10\nY = double(1..10)\\10\nm = table(T as t,X as x, Y as y)\nselect *, tmwavg(t, x, y, 3) from m\n```\n\n| t  | x  | y   | tmwavg\\_t |\n| -- | -- | --- | --------- |\n| 1  | 1  | 0.1 | 1         |\n| 1  | 2  | 0.2 | 1.6667    |\n| 1  | 3  | 0.3 | 2.3333    |\n| 1  | 4  | 0.4 | 3         |\n| 2  | 5  | 0.5 | 3.6667    |\n| 5  | 6  | 0.6 | 6         |\n| 6  | 7  | 0.7 | 6.5385    |\n| 8  | 8  | 0.8 | 7.5333    |\n| 9  | 9  | 0.9 | 8.5294    |\n| 10 | 10 | 1   | 9.0741    |\n\n```\nT = 2021.01.02 2021.01.06 join 2021.01.07..2021.01.14\nX = 1..10\nY = double(1..10)\\10\nm=table(T as t,X as x, Y as y)\nselect *, tmwavg(t, y, x, 3) from m\n```\n\n| t          | x  | y   | tmwavg\\_t |\n| ---------- | -- | --- | --------- |\n| 2021.01.02 | 1  | 0.1 | 0.1       |\n| 2021.01.06 | 2  | 0.2 | 0.2       |\n| 2021.01.07 | 3  | 0.3 | 0.26      |\n| 2021.01.08 | 4  | 0.4 | 0.3222    |\n| 2021.01.09 | 5  | 0.5 | 0.4167    |\n| 2021.01.10 | 6  | 0.6 | 0.5133    |\n| 2021.01.11 | 7  | 0.7 | 0.6111    |\n| 2021.01.12 | 8  | 0.8 | 0.7095    |\n| 2021.01.13 | 9  | 0.9 | 0.8083    |\n| 2021.01.14 | 10 | 1   | 0.9074    |\n\n```\nselect *, tmwavg(t, y, x, 1w) from m\n```\n\n| t          | x  | y   | tmwavg\\_t |\n| ---------- | -- | --- | --------- |\n| 2021.01.02 | 1  | 0.1 | 0.1       |\n| 2021.01.06 | 2  | 0.2 | 0.1667    |\n| 2021.01.07 | 3  | 0.3 | 0.2333    |\n| 2021.01.08 | 4  | 0.4 | 0.3       |\n| 2021.01.09 | 5  | 0.5 | 0.3857    |\n| 2021.01.10 | 6  | 0.6 | 0.45      |\n| 2021.01.11 | 7  | 0.7 | 0.5148    |\n| 2021.01.12 | 8  | 0.8 | 0.58      |\n| 2021.01.13 | 9  | 0.9 | 0.6667    |\n| 2021.01.14 | 10 | 1   | 0.7571    |\n\n相关函数：[wavg](https://docs.dolphindb.cn/zh/funcs/w/wavg.html), [mwavg](https://docs.dolphindb.cn/zh/funcs/m/mwavg.html)\n"
    },
    "tmwsum": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tmwsum.html",
        "signatures": [
            {
                "full": "tmwsum(T, X, Y, window)",
                "name": "tmwsum",
                "parameters": [
                    {
                        "full": "T",
                        "name": "T"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    }
                ]
            }
        ],
        "markdown": "### [tmwsum](https://docs.dolphindb.cn/zh/funcs/t/tmwsum.html)\n\n\n\n#### 语法\n\ntmwsum(T, X, Y, window)\n\n参数说明和窗口计算规则请参考：[tmFunctions](https://docs.dolphindb.cn/zh/funcs/themes/tmFunctions.html)\n\n#### 详情\n\n在给定长度（以时间长度衡量）的滑动窗口内，计算 *X* 和 *Y* 元素的内积。\n\n#### 返回值\n\nDOUBLE 类型向量。\n\n#### 例子\n\n```\nT = 1 1 1 1 2 5 6 8 9 10\nX = 1..10\nY = double(1..10)\\10\nm = table(T as t,X as x, Y as y)\nselect *, tmwsum(t, y, x, 3) from m\n```\n\n| t  | x  | y   | tmwsum\\_t |\n| -- | -- | --- | --------- |\n| 1  | 1  | 0.1 | 0.1       |\n| 1  | 2  | 0.2 | 0.5       |\n| 1  | 3  | 0.3 | 1.4       |\n| 1  | 4  | 0.4 | 3         |\n| 2  | 5  | 0.5 | 5.5       |\n| 5  | 6  | 0.6 | 3.6       |\n| 6  | 7  | 0.7 | 8.5       |\n| 8  | 8  | 0.8 | 11.3      |\n| 9  | 9  | 0.9 | 14.5      |\n| 10 | 10 | 1   | 24.5      |\n\n```\nT = 2021.01.02 2021.01.06 join 2021.01.07..2021.01.14\nX = 1..10\nY = double(1..10)\\10\nm=table(T as t,X as x, Y as y)\nselect *, tmwsum(t, y, x, 3) from m\n```\n\n| t          | x  | y   | tmwsum\\_t |\n| ---------- | -- | --- | --------- |\n| 2021.01.02 | 1  | 0.1 | 0.1       |\n| 2021.01.06 | 2  | 0.2 | 0.4       |\n| 2021.01.07 | 3  | 0.3 | 1.3       |\n| 2021.01.08 | 4  | 0.4 | 2.9       |\n| 2021.01.09 | 5  | 0.5 | 5         |\n| 2021.01.10 | 6  | 0.6 | 7.7       |\n| 2021.01.11 | 7  | 0.7 | 11        |\n| 2021.01.12 | 8  | 0.8 | 14.9      |\n| 2021.01.13 | 9  | 0.9 | 19.4      |\n| 2021.01.14 | 10 | 1   | 24.5      |\n\n```\nselect *, tmwsum(t, y, x, 1w) from m\n```\n\n| t          | x  | y   | tmwsum\\_t |\n| ---------- | -- | --- | --------- |\n| 2021.01.02 | 1  | 0.1 | 0.1       |\n| 2021.01.06 | 2  | 0.2 | 0.5       |\n| 2021.01.07 | 3  | 0.3 | 1.4       |\n| 2021.01.08 | 4  | 0.4 | 3         |\n| 2021.01.09 | 5  | 0.5 | 5.4       |\n| 2021.01.10 | 6  | 0.6 | 9         |\n| 2021.01.11 | 7  | 0.7 | 13.9      |\n| 2021.01.12 | 8  | 0.8 | 20.3      |\n| 2021.01.13 | 9  | 0.9 | 28        |\n| 2021.01.14 | 10 | 1   | 37.1      |\n\n相关函数：[wsum](https://docs.dolphindb.cn/zh/funcs/w/wsum.html), [mwsum](https://docs.dolphindb.cn/zh/funcs/m/mwsum.html)\n"
    },
    "tmwsumTopN": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tmwsumTopN.html",
        "signatures": [
            {
                "full": "tmwsumTopN(T, X, Y, S, window, top, [ascending=true], [tiesMethod='latest'])",
                "name": "tmwsumTopN",
                "parameters": [
                    {
                        "full": "T",
                        "name": "T"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "S",
                        "name": "S"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "top",
                        "name": "top"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[tiesMethod='latest']",
                        "name": "tiesMethod",
                        "optional": true,
                        "default": "'latest'"
                    }
                ]
            }
        ],
        "markdown": "### [tmwsumTopN](https://docs.dolphindb.cn/zh/funcs/t/tmwsumTopN.html)\n\n\n\n#### 语法\n\ntmwsumTopN(T, X, Y, S, window, top, \\[ascending=true], \\[tiesMethod='latest'])\n\n参数说明和窗口计算规则请参考：[tmTopN](https://docs.dolphindb.cn/zh/funcs/themes/tmTopN.html)\n\n#### 详情\n\n在给定长度（以时间 *T* 衡量）的滑动窗口内，根据 *ascending* 指定的排序方式将 *X* 和 *Y* 按照 *S* 进行稳定排序后，取前 *top* 个元素，计算 *X* 和 *Y* 的内积。\n\n#### 返回值\n\nDOUBLE 类型向量。\n\n#### 例子\n\n```\nT=2023.01.03+1..7\nX = [2, 1, 4, 3, 4, 3, 1]\nY=[1, 7, 8, 9, 0, 5, 8]\nS = [5, 8, 1, , 1, 1, 3]  //S 中包含的空值不参与排序，对应位置的 X 和 Y 不参与计算\ntmwsumTopN(T,X,Y,S,6,4)\n// output\n[2,9,41,41,41,49,55]\n\nT=2023.01.03 2023.01.07 2023.01.08 2023.01.10 2023.01.11 2023.01.12\nX=8 3 1 2 5 2\nY=1 7 8 9 0 5\nS=1 5 2 3 1 1\nt=table(T as time, X as val1, Y as val2, S as id)\nselect tmwsumTopN(time,val1,val2,id,4,3) as topN from t\n```\n\n| topN |\n| ---- |\n| 8    |\n| 21   |\n| 29   |\n| 47   |\n| 26   |\n| 28   |\n\n相关函数：[tmwsum](https://docs.dolphindb.cn/zh/funcs/t/tmwsum.html)\n"
    },
    "toArray": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/toArray.html",
        "signatures": [
            {
                "full": "toArray(X)",
                "name": "toArray",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [toArray](https://docs.dolphindb.cn/zh/funcs/t/toArray.html)\n\n\n\n#### 语法\n\ntoArray(X)\n\n#### 详情\n\n与 [group by](https://docs.dolphindb.cn/zh/progr/sql/groupby.html) 搭配使用，按照分组将 *X* 转换为[数组向量（array vector）](https://docs.dolphindb.cn/zh/progr/data_types_forms/arrayVector.html)。如果单独使用则没有效果。\n\n#### 参数\n\n**X** 是表的列字段名称或包含列字段的计算表达式。\n\n#### 返回值\n\n数据类型同 *X* 的数组向量。\n\n#### 例子\n\n```\nt = table(1 1 3 4 as id, 1 3 5 6 as v1)\nnew_t = select toArray(v1) as newV1 from t group by id\n/* \nid newV1\n-- -----\n1  [1,3]\n3  [5]  \n4  [6]  \n*/\n\n\nnew_t = select toArray(v1+1) as newV1 from t group by id\n/* \nid newV1\n-- -----\n1  [2,4]\n3  [6]  \n4  [7]  \n*/\n```\n\n**相关函数：**[toColumnarTuple](https://docs.dolphindb.cn/zh/funcs/t/tocolumnartuple.html), [toTuple](https://docs.dolphindb.cn/zh/funcs/t/totuple.html)。\n"
    },
    "toCharArray": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/toCharArray.html",
        "signatures": [
            {
                "full": "toCharArray(X)",
                "name": "toCharArray",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [toCharArray](https://docs.dolphindb.cn/zh/funcs/t/toCharArray.html)\n\n\n\n#### 语法\n\ntoCharArray(X)\n\n#### 详情\n\n将字符串拆分字符向量。\n\n#### 参数\n\n**X** STRING/BLOB/SYMBOL 类型标量或向量。\n\n#### 返回值\n\n* 若 *X* 是标量，返回一个 CHAR 类型向量。\n\n* 若 *X* 是向量，返回一个 CHAR 类型数组向量。\n\n#### 例子\n\n```\nstr = \"It is great!\\n\"\nprint str.toCharArray()\n// output\n['I','t',' ','i','s',' ','g','r','e','a','t','!',10]\n\nstr1 = [\"A#\", \"B C\", \"D\\t\"]\nprint str1.toCharArray()\n// output\n[['A','#'],['B',' ','C'],['D',9]]\n```\n\n将一个包含了 BLOB 类型的数据写入文件，需要使用 `toCharArray` 进行转换，以保证写入的数据正确。\n\n```\n//将一个向量压缩后，存入一个二进制文件\nx=1..100\n//BLOB 类型的字符串开头会使用4个字节来标识它的长度\ny=blob(compress(x).concat())\ndir = WORK_DIR+\"/toCharArray.bin\"\ng = file(dir, \"w\")\n//使用 toCharArray 函数对 BLOB 类型的字符串进行转换，则只会将正确的数据写入文件（头部的4个字节不会写入）\ng.write(y.toCharArray())   //实际写入了467个字节\ng.close()\n\n// output\ndir1 = WORK_DIR+\"/toCharArray1.bin\"\ng1 = file(dir1, \"w\")\ng1.write(y)    //实际写入了471个字节\ng1.close()\n```\n\n相关函数：[split](https://docs.dolphindb.cn/zh/funcs/s/split.html)\n"
    },
    "toColumnarTuple": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tocolumnartuple.html",
        "signatures": [
            {
                "full": "toColumnarTuple(X)",
                "name": "toColumnarTuple",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [toColumnarTuple](https://docs.dolphindb.cn/zh/funcs/t/tocolumnartuple.html)\n\n首发版本：3.00.5\n\n\n\n#### 语法\n\ntoColumnarTuple(X)\n\n#### 详情\n\n该函数与 [group by](https://docs.dolphindb.cn/zh/progr/sql/groupby.html) 搭配使用，按照分组将 *X* 转换为列式元组 (columnar tuple)。如果单独使用则没有效果。\n\n#### 参数\n\n**X** 是表的列字段名称或包含列字段的计算表达式。\n\n#### 返回值\n\n列式元组 (columnar tuple)。\n\n#### 例子\n\n```\nt = table([`AAPL, `AAPL, `GOOG, `GOOG, `MSFT, `MSFT] as symbol, \n          [182.5, 183.2, 145.8, 146.5, 412.3, 411.8] as price)\nt\n```\n\n| symbol | price |\n| ------ | ----- |\n| AAPL   | 182.5 |\n| AAPL   | 183.2 |\n| GOOG   | 145.8 |\n| GOOG   | 146.5 |\n| MSFT   | 412.3 |\n| MSFT   | 411.8 |\n\n使用 `toColumnarTuple` 按股票分组，聚合所有价格。聚合后的价格列为 columnar tuple。\n\n```\nresult = select toColumnarTuple(price) as prices from t group by symbol\nresult\n```\n\n| symbol | prices          |\n| ------ | --------------- |\n| AAPL   | \\[182.5, 183.2] |\n| GOOG   | \\[145.8, 146.5] |\n| MSFT   | \\[412.3, 411.8] |\n\n**相关函数：**[toArray](https://docs.dolphindb.cn/zh/funcs/t/toArray.html), [toTuple](https://docs.dolphindb.cn/zh/funcs/t/totuple.html)。\n"
    },
    "today": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/today.html",
        "signatures": [
            {
                "full": "today()",
                "name": "today",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [today](https://docs.dolphindb.cn/zh/funcs/t/today.html)\n\n\n\n#### 语法\n\ntoday()\n\n#### 详情\n\n返回当前系统的日期。\n\n#### 参数\n\n无\n\n#### 返回值\n\nDATE 类型标量。\n"
    },
    "toJson": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/toJson.html",
        "signatures": [
            {
                "full": "toJson(X)",
                "name": "toJson",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [toJson](https://docs.dolphindb.cn/zh/funcs/t/toJson.html)\n\n\n\n#### 语法\n\ntoJson(X)\n\n#### 详情\n\n将 DolphinDB 对象转换为 JSON 字符串。该 JSON 字符串包含了5个键值对：name（变量名），form（数据结构），type（数据类型），size（长度），value（值）。\n\n针对不同数据形式，`toJson` 最大可转换的数据长度不同：\n\n| 数据形式     | 最大长度   |\n| -------- | ------ |\n| matrix   | 300000 |\n| set      | 300000 |\n| vector   | 300000 |\n| dict 键值对 | 300000 |\n| table    | 100000 |\n\n#### 参数\n\n**X** 可以是任意数据类型。\n\n#### 返回值\n\nSTRING 类型标量。\n\n#### 例子\n\n```\nx=1 2 3\ny=toJson(x)\ny;\n// output\n{\"name\":\"x\",\"form\":\"vector\",\"type\":\"int\",\"size\":\"3\",\"value\":[1,2,3]}\n\nt=table(1 2 3 as id, 10 20 30 as val)\ntoJson(t);\n// output\n{\"name\":\"t\",\"form\":\"table\",\"size\":\"3\",\"value\":[{\"name\":\"id\",\"form\":\"vector\",\"type\":\"int\",\"size\":\"3\",\"value\":[1,2,3]},{\"name\":\"val\",\"form\":\"vector\",\"type\":\"int\",\"size\":\"3\",\"value\":[10,20,30]}]}\n\n//set的长度超过30000，toJson最多只能转换前30000个元素\nx=set(1..400001)\ny=toJson(x)\nsize(fromJson(y))\n// output\n300000\n```\n\n相关函数：[fromJson](https://docs.dolphindb.cn/zh/funcs/f/fromJson.html)\n"
    },
    "tokenize": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tokenize.html",
        "signatures": [
            {
                "full": "tokenize(text, parser, [full=false], [lowercase=true], [stem=false])",
                "name": "tokenize",
                "parameters": [
                    {
                        "full": "text",
                        "name": "text"
                    },
                    {
                        "full": "parser",
                        "name": "parser"
                    },
                    {
                        "full": "[full=false]",
                        "name": "full",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[lowercase=true]",
                        "name": "lowercase",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[stem=false]",
                        "name": "stem",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [tokenize](https://docs.dolphindb.cn/zh/funcs/t/tokenize.html)\n\n\n\n#### 语法\n\ntokenize(text, parser, \\[full=false], \\[lowercase=true], \\[stem=false])\n\n#### 详情\n\n此函数可用于检查分词操作的实际效果。\n\n根据指定的设置对输入文本进行分词操作，并返回一个 STRING 类型的向量，包含分词的结果。\n\n#### 参数\n\n**text** STRING 类型标量，表示待分词的文本。\n\n**parser** STRING 类型标量，指定分词器。没有默认值，必须显式指定。可选值为 'none', 'english', 'chinese', 'mixed'：\n\n* none：不分词。\n\n* english：英文分词器，按照空格和标点进行分词。\n\n* chinese：中文分词器，按照中文词库、空格和标点进行分词。\n\n* mixed：混合分词器。英文按单词分词，中文按 Bigram 分词。\n\n**full** 设置中文分词时的分词模式，仅在 parser='chinese' 时有效：\n\n* false：默认模式。词语之间不会重叠和包含。\n\n* true：全分词模式。该模式会尽可能多的分析句子中包含的词语。\n\n**lowercase** 布尔类型标量，表示是否将英文单词转换为小写（不会对原数据造成影响）。该属性在 *parser* 为 english, chinese, mixed 时有效。默认值为 true。\n\n**stem** 是否将英文单词作为词干匹配。该属性仅在 parser='english'，且 lowercase=true 时生效。默认值为 false。\n\n#### 返回值\n\nSTRING 类型向量。\n\n#### 例子\n\n```\ntext1 = \"The sun was shining brightly as I walked down the street, enjoying the warmth of the summer day.\"\ntokenize(text=text1, parser='english', lowercase=false, stem=true)\n// output:[\"The\",\"sun\",\"shine\",\"bright\",\"I\",\"walk\",\"down\",\"street\",\"enjoy\",\"warmth\",\"summer\",\"day\"]\n\ntext2 = \"武汉市长江大桥\"\ntokenize(text=text2, parser='chinese', full=true)\n// output:[\"武汉\",\"武汉市\",\"市长\",\"长江\",\"长江大桥\",\"大桥\"]\n```\n"
    },
    "tokenizeBert": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tokenizeBert.html",
        "signatures": [
            {
                "full": "tokenizeBert(text, vocabName, [addSpecialTokens=true])",
                "name": "tokenizeBert",
                "parameters": [
                    {
                        "full": "text",
                        "name": "text"
                    },
                    {
                        "full": "vocabName",
                        "name": "vocabName"
                    },
                    {
                        "full": "[addSpecialTokens=true]",
                        "name": "addSpecialTokens",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [tokenizeBert](https://docs.dolphindb.cn/zh/funcs/t/tokenizeBert.html)\n\n首发版本：3.00.4，3.00.3.1\n\n\n\n#### 语法\n\ntokenizeBert(text, vocabName, \\[addSpecialTokens=true])\n\n#### 详情\n\n应用指定词库对输入文本 *text* 进行分词。本函数使用 WordPiece 分词算法，适用于 BERT（Bidirectional Encoder Representations from Transformers） 模型。\n\n#### 参数\n\n**text** LITERAL 类型标量，待分词的字符串。\n\n**vocabName** 字符串标量，指定用于分词的词库。\n\n**addSpecialTokens** 可选参数，布尔值，表示是否要在文本的首尾添加特殊 token。目前仅支持在开头加入 `[CLS]`，在结尾加入 `[SEP]`。默认为 true。\n\n#### 返回值\n\n返回一个表，包含以下三列：\n\n* tokens: 分词后的 token 列表。\n\n* input\\_ids: 对应的 token ID 列表。\n\n* attention\\_mask: 目前仅返回值为 1 的掩码，用于模型输入。\n\n#### 例子\n\n````\nloadVocab(\"/home/data/vocab.txt\", \"vocab1\")\ntokenizeBert(\"apple ```\\n—— abcd1234\", \"vocab1\", true)\n````\n\n相关函数：[loadVocab](https://docs.dolphindb.cn/zh/funcs/l/loadVocab.html), [unloadVocab](https://docs.dolphindb.cn/zh/funcs/u/unloadVocab.html)\n"
    },
    "topRange": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/topRange.html",
        "signatures": [
            {
                "full": "topRange(X)",
                "name": "topRange",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [topRange](https://docs.dolphindb.cn/zh/funcs/t/topRange.html)\n\n\n\n#### 语法\n\ntopRange(X)\n\n#### 详情\n\n对于 *X* 中的每个元素 *Xi*，统计 *Xi* 左侧相邻且连续小于它的元素个数。\n\n该函数常用于统计一个序列的当前值是前多少周期（日或分钟等）内的最大值。例如某只股票创几日新高等。\n\n#### 参数\n\n**X** 向量/元组/矩阵/表。\n\n#### 返回值\n\nINT 类型，数据形式同 *X*。\n\n#### 例子\n\n```\ntopRange([13.5, 13.6, 13.4, 13.3, 13.5, 13.9, 13.1, 20.1, 20.2, 20.3])\n// output\n[0,1,0,0,2,5,0,7,8,9]\n\nm = matrix(1.5 2.6 3.2 1.4 2.5 2.2 3.7 2.0, 1.6 2.3 4.2 5.6 4.1 3.2 4.4 6.9)\ntopRange(m)\n```\n\n| #0 | #1 |\n| -- | -- |\n| 0  | 0  |\n| 1  | 1  |\n| 2  | 2  |\n| 0  | 3  |\n| 1  | 0  |\n| 0  | 0  |\n| 6  | 2  |\n| 0  | 7  |\n\n```\n//模拟股票 A 8天的股价，使用 topRange 计算股票 A 当日股价创几日新高\ntrades = table(take(`A, 8) as sym,  2022.01.01 + 1..8 as date, 39.70 39.72 39.80 39.78 39.83 39.92 40.00 40.03 as price)\nselect *, topRange(price) from trades\n```\n\n| id | date       | price | topRange\\_price |\n| -- | ---------- | ----- | --------------- |\n| A  | 2022.01.02 | 39.7  | 0               |\n| A  | 2022.01.03 | 39.72 | 1               |\n| A  | 2022.01.04 | 39.8  | 2               |\n| A  | 2022.01.05 | 39.78 | 0               |\n| A  | 2022.01.06 | 39.83 | 4               |\n| A  | 2022.01.07 | 39.92 | 5               |\n| A  | 2022.01.08 | 40    | 6               |\n| A  | 2022.01.09 | 40.03 | 7               |\n\n相关函数：[lowRange](https://docs.dolphindb.cn/zh/funcs/l/lowRange.html)\n"
    },
    "toStdJson": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/toStdJson.html",
        "signatures": [
            {
                "full": "toStdJson(obj)",
                "name": "toStdJson",
                "parameters": [
                    {
                        "full": "obj",
                        "name": "obj"
                    }
                ]
            }
        ],
        "markdown": "### [toStdJson](https://docs.dolphindb.cn/zh/funcs/t/toStdJson.html)\n\n#### 语法\n\ntoStdJson(obj)\n\n#### 详情\n\n将 DolphinDB 对象转换为标准 JSON 类型。\n\n* 转化 bool 值时，返回 true 或 false 值。\n* 转换空值时，将除了 STRING 类型空值以外的其他所有类型空值都转换为null。\n\n#### 参数\n\n**obj** 的数据形式不可为 matrix 或 pair；数据类型不可为 UUID, IPADDR, INT128, COMPRESSED 以及系统类型。\n\n#### 返回值\n\nSTRING 类型标量。\n\n#### 例子\n\n```\nx=1 2 3\ntoStdJson(x);\n// output: \n[1, 2, 3]\n\nt=table(1 2 3 as id, 10 20 30 as val)\ntoStdJson(t);\n// output: \n[{\"id\": 1,\"val\": 10},{\"id\": 2,\"val\": 20},{\"id\": 3,\"val\": 30}]\n\nb = set(2012.06.13T13:30:10 2017.07.10T14:10:12)\ntoStdJson(b);\n// output: \n[\"2017.07.10 14:10:12\",\"2012.06.13 13:30:10\"]\n\nb = dict(INT,DATETIME)\nb[0] = 2012.06.13 13:30:10\nb[1] = 2017.07.10 14:10:12\ntoStdJson(b);\n// output:\n{\"1\": \"2017.07.10 14:10:12\",\"0\": \"2012.06.13 13:30:10\"}\n\nt1=table(`x`y`z as b, 2012.06.13 13:30:10 2012.06.13 13:30:10 2012.06.13 13:30:10 as c,10.8 7.6 3.5 as F)\ntoStdJson(t1);\n// output:\n[{\"b\": \"x\",\"c\": \"2012.06.13 13:30:10\",\"F\": 10.8},{\"b\": \"y\",\"c\": \"2012.06.13 13:30:10\",\"F\": 7.6},{\"b\": \"z\",\"c\": \"2012.06.13 13:30:10\",\"F\": 3.5}]\n```\n\n相关函数：[toJson](https://docs.dolphindb.cn/zh/funcs/t/toJson.html)\n\n"
    },
    "toTuple": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/totuple.html",
        "signatures": [
            {
                "full": "toTuple(X)",
                "name": "toTuple",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [toTuple](https://docs.dolphindb.cn/zh/funcs/t/totuple.html)\n\n首发版本：3.00.5\n\n\n\n#### 语法\n\ntoTuple(X)\n\n#### 详情\n\n该函数与 [group by](https://docs.dolphindb.cn/zh/progr/sql/groupby.html) 搭配使用，按照分组将 *X* 转换为元组 (tuple)。如果单独使用则没有效果。\n\n[toArray](https://docs.dolphindb.cn/zh/funcs/t/toArray.html) 生成的 Array Vector 后续更新时不能修改长度，而 `toTuple` 无此限制，适用于长度会发生变化的数据分组场景，特别适合需要频繁更新或动态长度的数据处理。\n\n#### 参数\n\n**X** 是表的列字段名称或包含列字段的计算表达式。\n\n#### 返回值\n\n一个元组（tuple）。\n\n#### 例子\n\n```\nt = table(1 1 3 4 as id, 10.1 10.3 9.5 9.6 as price)\nselect toTuple(price) as newPrice from t group by id\n```\n\n| id | newPrice     |\n| -- | ------------ |\n| 1  | \\[10.1,10.3] |\n| 3  | \\[9.5]       |\n| 4  | \\[9.6]       |\n\n模拟投资组合持仓数据：组合ID、股票代码、持仓数量（动态变化）。\n\n```\nt = table([`P1, `P1, `P1, `P2, `P2, `P3, `P3, `P3, `P3] as portfolioId, \n          [`AAPL, `GOOG, `MSFT, `AAPL, `TSLA, `GOOG, `GOOG, `AMZN, `NVDA] as symbol,\n          [100, 50, 200, 150, 75, 80, 120, 90, 60] as position)\n\n// 使用 toTuple 按投资组合分组，聚合所有持仓股票和数量为元组（长度可变）\nresult = select toTuple(symbol) as symbols, toTuple(position) as positions from t group by portfolioId\nresult\n```\n\n| portfolioId | symbols                           | positions          |\n| ----------- | --------------------------------- | ------------------ |\n| P1          | \\['AAPL', 'GOOG', 'MSFT']         | \\[100, 50, 200]    |\n| P2          | \\['AAPL', 'TSLA']                 | \\[150, 75]         |\n| P3          | \\['GOOG', 'GOOG', 'AMZN', 'NVDA'] | \\[80, 120, 90, 60] |\n\n**相关函数：**[toArray](https://docs.dolphindb.cn/zh/funcs/t/toArray.html), [toColumnarTuple](https://docs.dolphindb.cn/zh/funcs/t/tocolumnartuple.html)。\n"
    },
    "toUTF8": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/toUTF8.html",
        "signatures": [
            {
                "full": "toUTF8(str, encode)",
                "name": "toUTF8",
                "parameters": [
                    {
                        "full": "str",
                        "name": "str"
                    },
                    {
                        "full": "encode",
                        "name": "encode"
                    }
                ]
            }
        ],
        "markdown": "### [toUTF8](https://docs.dolphindb.cn/zh/funcs/t/toUTF8.html)\n\n\n\n#### 语法\n\ntoUTF8(str, encode)\n\n#### 详情\n\n把字符串转换为 UTF8 编码。DolphinDB 对编码名称的大小写敏感，所有编码名称必须用小写表示。\n\n因为 Windows 版本目前仅支持 gbk 和 utf-8 两种编码的相互转换，因此在 Windows 中，`toUTF8` 的第二个参数只能是 \"gbk\"。Linux 版本支持任意两种编码之间的转换。\n\n#### 参数\n\n**str** 是一个字符串标量或向量。\n\n**encode** 是一个字符串，表示 *str* 原来的编码名称。\n\n#### 返回值\n\nSTRING 类型标量或向量。\n\n#### 例子\n\n```\ntoUTF8(\"DolphinDB\",\"gbk\");\n// output\nDolphinDB\n\ntoUTF8([\"hello\",\"world\"],\"euc-cn\");\n// output\n[\"hello\",\"world\"]\n```\n\n相关函数：[convertEncode](https://docs.dolphindb.cn/zh/funcs/c/convertEncode.html), [fromUTF8](https://docs.dolphindb.cn/zh/funcs/f/fromUTF8.html)\n"
    },
    "transDS!": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/transDS_.html",
        "signatures": [
            {
                "full": "transDS!(ds, transFunc)",
                "name": "transDS!",
                "parameters": [
                    {
                        "full": "ds",
                        "name": "ds"
                    },
                    {
                        "full": "transFunc",
                        "name": "transFunc"
                    }
                ]
            }
        ],
        "markdown": "### [transDS!](https://docs.dolphindb.cn/zh/funcs/t/transDS_.html)\n\n\n\n#### 语法\n\ntransDS!(ds, transFunc)\n\n#### 详情\n\n将函数应用到数据源。\n\n#### 参数\n\n**ds** 是数据源或数据源列表。\n\n**transFunc** 是一个函数。它的参数必须是一个表。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n下例将分布式表 trades1 的时间列从 TIMESTAMP 类型转换成 NANOTIMESTAMP 类型后插入到分布式表 trades2中。\n\n```\ndb=database(\"dfs://stock1\",VALUE,`A`B`C`D)\nn=200000\ntrade_time=2018.01.02T06:12:03.458+1..n\nsym=rand(`A`B`C`D,n)\nqty=rand(100.0,n)\nprice=rand(100.0,n)\nt=table(trade_time,sym,qty,price)\ntrades1=db.createPartitionedTable(t,`trades1,`sym).append!(t);\n\nds=sqlDS(<select * from trades1>);\n\ndef convertNanotimestamp(t){\n   return select nanotimestamp(trade_time), sym, qty, price from t\n}\n\nds.transDS!(convertNanotimestamp);\n\ndb=database(\"dfs://stock2\",VALUE,`A`B`C`D)\nt=table(1:0,`trade_time`sym`qty`price,[NANOTIMESTAMP,SYMBOL,DOUBLE,DOUBLE])\ntrades2=db.createPartitionedTable(t,`trades2,`sym);\n\nmr(ds,append!{trades2},,,false);\n\nexec count(*) from trades2;\n// output\n200000\n```\n"
    },
    "transFreq": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/transFreq.html",
        "signatures": [
            {
                "full": "transFreq(X, rule, [closed], [label], [origin='start_day'])",
                "name": "transFreq",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "rule",
                        "name": "rule"
                    },
                    {
                        "full": "[closed]",
                        "name": "closed",
                        "optional": true
                    },
                    {
                        "full": "[label]",
                        "name": "label",
                        "optional": true
                    },
                    {
                        "full": "[origin='start_day']",
                        "name": "origin",
                        "optional": true,
                        "default": "'start_day'"
                    }
                ]
            }
        ],
        "markdown": "### [transFreq](https://docs.dolphindb.cn/zh/funcs/t/transFreq.html)\n\n\n\n#### 语法\n\ntransFreq(X, rule, \\[closed], \\[label], \\[origin='start\\_day'])\n\n#### 详情\n\n将给定日期或时间变量转换为给定的时间格式（或对应的交易日）。结果长度与 *X* 相同。\n\n#### 参数\n\n**X** 是表示日期或时间类型的标量或向量。\n\n**rule** 是一个字符串，可取以下值：\n\n| rule 参数取值 | 对应 DolphinDB 函数      |\n| --------- | -------------------- |\n| \"B\"       | businessDay          |\n| \"W\"       | weekEnd              |\n| \"WOM\"     | weekOfMonth          |\n| \"LWOM\"    | lastWeekOfMonth      |\n| \"M\"       | monthEnd             |\n| \"MS\"      | monthBegin           |\n| \"BM\"      | businessMonthEnd     |\n| \"BMS\"     | businessMonthBegin   |\n| \"SM\"      | semiMonthEnd         |\n| \"SMS\"     | semiMonthBegin       |\n| \"Q\"       | quarterEnd           |\n| \"QS\"      | quarterBegin         |\n| \"BQ\"      | businessQuarterEnd   |\n| \"BQS\"     | businessQuarterBegin |\n| \"A\"       | yearEnd              |\n| \"AS\"      | yearBegin            |\n| \"BA\"      | businessYearEnd      |\n| \"BAS\"     | businessYearBegin    |\n| \"D\"       | date                 |\n| \"H\"       | hourOfDay            |\n| \"min\"     | minuteOfHour         |\n| \"S\"       | secondOfMinute       |\n| \"L\"       | millisecond          |\n| \"U\"       | microsecond          |\n| \"N\"       | nanosecond           |\n| \"SA\"      | semiannualEnd        |\n| \"SAS\"     | semiannualBegin      |\n\n上述字符串亦可配合使用数字（必须为正整数），例如 \"2M\" 表示频率为每两个月月末。此外，*rule* 也可以是交易日历标识（国外交易所的 ISO Code、国内交易所简称或自定义交易日历名称），以便基于交易日历进行计算。交易日历也可以配合使用数字，表示多个交易日，此时只能指定由4个大写字母组成的交易日历标识。例如：“2XSHG”，表示上海证券交易所每两个交易日。\n\n**closed** 字符串，表示分组区间哪一个边界是闭合的。\n\n* *rule* 为 'M', 'A', 'Q', 'BM', 'BA', 'BQ' 和 'W' 时，*closed* 的默认取值为 'right' ，否则，*closed* 的默认取值为 'left'。\n\n* *origin* 取 'end' 或者 'end\\_day' 时，*closed* 的默认值为 'right'。\n\n**label** 字符串，表示将分组区间的哪一个边界作为 *label* 输出。\n\n* *rule* 为 'M', 'A', 'Q', 'BM', 'BA', 'BQ' 和 'W' 时，*label* 的默认取值为 'right' ，否则，*label* 的默认取值为 'left'。\n\n* *origin* 取 'end' 或者 'end\\_day' 时，*label* 的默认值为 'right'。\n\n**origin** 字符串或和 *X* 具有相同时间类型的标量，表示基于时间戳调整分组。取值为 'epoch', start', 'start\\_day', 'end', 'end\\_day' 或自定义的时间对象，默认值为 'start\\_day'。\n\n* 'epoch'：分组起始点为1970-01-01。\n\n* 'start'：分组起始点为时间序列的第一个值。\n\n* 'start\\_day'：分组起始点是时间序列的第一个值对应日期的午夜零点。\n\n* 'end'：分组起始点是时间序列的最后一个时间戳。\n\n* 'end\\_day'：分组起始点是时间序列的最后一个时间戳对应日期的午夜24点（即下一日的零点）。\n\n#### 返回值\n\n时间类型标量或向量，其数据类型与形式同 *X*。\n\n#### 例子\n\n```\n// 转换为半月末\ntransFreq(2020.11.08 2020.11.09 2020.11.18, \"SM\");\n// output\n[2020.10.31,2020.10.31,2020.11.15]\n\n// 转换为季末\ntransFreq(2020.08.08 2020.11.18, \"Q\");\n// output\n[2020.09.30,2020.12.31]\n\n// 转换为双季末\ntransFreq(2020.08.08 2020.11.18, \"2Q\");\n// output\n[2020.09.30,2021.03.31]\n```\n\n```\ns = temporalAdd(2022.01.01 00:00:00,1..8,`m);\n\n// 将时间序列按3分钟间隔对齐，默认左闭右开区间（closed='left'），默认输出区间的左边界（label='left'）\ns.transFreq(rule=\"3min\");\n// output\n[2022.01.01T00:00:00,2022.01.01T00:00:00,2022.01.01T00:03:00,2022.01.01T00:03:00,2022.01.01T00:03:00,2022.01.01T00:06:00,2022.01.01T00:06:00,2022.01.01T00:06:00]\n\n// 设置 closed='right' 表示左开右闭区间\ns.transFreq(rule=`3min,closed=`right);\n// output\n[2022.01.01T00:00:00,2022.01.01T00:00:00,2022.01.01T00:00:00,2022.01.01T00:03:00,2022.01.01T00:03:00,2022.01.01T00:03:00,2022.01.01T00:06:00,2022.01.01T00:06:00]\n\n// 设置 label='right' 表示输出区间的右边界\ns.transFreq(rule=\"3min\", label=`right);\n// output\n[2022.01.01T00:03:00,2022.01.01T00:03:00,2022.01.01T00:06:00,2022.01.01T00:06:00,2022.01.01T00:06:00,2022.01.01T00:09:00,2022.01.01T00:09:00,2022.01.01T00:09:00]\n\n// 设置 origin='end' 表示以序列最后一个时间点为基准向前对齐\ns.transFreq(rule=`3min,closed=`right,origin=`end);\n// output\n[2021.12.31T23:59:00,2021.12.31T23:59:00,2022.01.01T00:02:00,2022.01.01T00:02:00,2022.01.01T00:02:00,2022.01.01T00:05:00,2022.01.01T00:05:00,2022.01.01T00:05:00]\n```\n"
    },
    "transpose": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/transpose.html",
        "signatures": [
            {
                "full": "transpose(X)",
                "name": "transpose",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            },
            {
                "full": "flip(X)",
                "name": "flip",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [transpose](https://docs.dolphindb.cn/zh/funcs/t/transpose.html)\n\n\n\n#### 语法\n\ntranspose(X)\n\n别名：flip(X)\n\n#### 详情\n\n本函数用于转置输入数据 *X*：\n\n* 如果 *X* 是一个元组，`transpose` 函数返回的是一个与 *X* 中每个向量长度相同的元组，返回结果中的第 n 个元素是由 *X* 中每个向量的第 n 个值组成的向量。\n\n* 如果 *X* 是一个矩阵，`transpose` 函数返回 *X* 的转置矩阵。\n\n* 如果 *X* 是一个表，`transpose` 函数把表 *X* 转换为一个有序字典（从 2.00.9 版本开始支持有序字典），表中的列名为 key，每列的值为 value。\n\n* 如果 *X* 是一个字典，且 key 是 STRING 类型，`transpose` 函数把字典 *X* 转换为一个表\n\n  * 当value 为标量或等长向量时，表的列名为字典的 key 值，每列的值为对应 value。\n  * 当 value 为字典时，表中第一列的列名为 ”key“，其值为 *X* 的 key 值；后续列的列名为 *X*中第一个子字典的键，其值为各子字典中对应的值。若某个子字典中不包含某键，则表中对应值为空值。\n    **Note:** 不支持将包含超过 32,767 个键的字典转换为表。\n\n* 如果 *X* 是一个数组向量或列式元组，transpose 函数将 *X* 的行和列转置。\n\n#### 参数\n\n**X** 是一个元组、矩阵、表或字典、数组向量或列式元组。\n\n* 如果 X 是元组，则元组中的元素须为长度相等的向量。\n* 如果 *X* 是数组向量或列式元组，则每行包含的元素个数必须相等。\n\n#### 例子\n\n例1. *X* 是一个元组。\n\n```\nx=(`A`B`C,1 2 3);\nx.transpose();\n// output：((\"A\",1),(\"B\",2),(\"C\",3))\n```\n\n例2. *X* 是一个矩阵。\n\n```\nx=1..6 $ 3:2;\nx;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 4  |\n| 2  | 5  |\n| 3  | 6  |\n\n```\ntranspose x;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1  | 2  | 3  |\n| 4  | 5  | 6  |\n\n例3. *X* 是一个表。\n\n```\ntimestamp = [09:34:07,09:36:42,09:36:51,09:36:59,09:32:47,09:35:26,09:34:16,09:34:26,09:38:12]\nsym = `C`MS`MS`MS`IBM`IBM`C`C`C\nprice= 49.6 29.46 29.52 30.02 174.97 175.23 50.76 50.32 51.29\nqty = 2200 1900 2100 3200 6800 5400 1300 2500 8800\nt = table(timestamp, sym, qty, price);\nt;\n```\n\n| timestamp | sym | qty  | price  |\n| --------- | --- | ---- | ------ |\n| 09:34:07  | C   | 2200 | 49.6   |\n| 09:36:42  | MS  | 1900 | 29.46  |\n| 09:36:51  | MS  | 2100 | 29.52  |\n| 09:36:59  | MS  | 3200 | 30.02  |\n| 09:32:47  | IBM | 6800 | 174.97 |\n| 09:35:26  | IBM | 5400 | 175.23 |\n| 09:34:16  | C   | 1300 | 50.76  |\n| 09:34:26  | C   | 2500 | 50.32  |\n| 09:38:12  | C   | 8800 | 51.29  |\n\n```\ntranspose(t);\n/*\ntimestamp->[09:34:07,09:36:42,09:36:51,09:36:59,09:32:47,09:35:26,09:34:16,09:34:26,09:38:12]\nsym->[C,MS,MS,MS,IBM,IBM,C,C,C]\nqty->[2200,1900,2100,3200,6800,5400,1300,2500,8800]\nprice->[49.6,29.46,29.52,30.02,174.97,175.23,50.76,50.32,51.29]\n*/\n```\n\n例4. *X* 是一个字典。\n\n```\nz=dict(`id`val,[`a`b`c,1 2 3]);\nz;\n/*\nval->[1,2,3]\nid->[a,b,c]\n*/\ntranspose(z);\n```\n\n| val | id |\n| --- | -- |\n| 1   | a  |\n| 2   | b  |\n| 3   | c  |\n\n```\n//当字典的 value 既包含标量又包含向量时，transpose 会重复标量的值以匹配向量的长度\nz1=dict(`id`val,[`a,1 2 3]);\nz1;\ntranspose(z1)\n```\n\n<table id=\"table_fx3_3x5_x1c\"><tbody><tr><td>\n\n**val**\n\n</td><td>\n\n**id**\n\n</td></tr><tr><td>\n\n1\n\n</td><td>\n\na\n\n</td></tr><tr><td>\n\n2\n\n</td><td>\n\na\n\n</td></tr><tr><td>\n\n3\n\n</td><td>\n\na\n\n</td></tr></tbody>\n</table>例5. *X* 是一个嵌套字典。\n\n```\nd = {'tag1':{'val1':2,'val2':6},'tag2':{'val2':1, 'val3':3}}\nd\n/*\ntag1->\n    val1->2\n    val2->6\n\ntag2->\n    val2->1\n    val3->3\n*/\ntranspose(d)\n```\n\n<table id=\"table_yr2_jxb_d2c\"><thead><tr><th align=\"left\">\n\nkey\n\n</th><th align=\"left\">\n\nval1\n\n</th><th align=\"left\">\n\nval2\n\n</th></tr></thead><tbody><tr><td align=\"left\">\n\ntag1\n\n</td><td align=\"left\">\n\n2\n\n</td><td align=\"left\">\n\n6\n\n</td></tr><tr><td align=\"left\">\n\ntag2\n\n</td><td align=\"left\">\n\n</td><td align=\"left\">\n\n1\n\n</td></tr></tbody>\n</table>从结果可以看出，转置后的表的列包括 \"key\" 和第一个子字典的键（val1，val2），“key” 列的值对应字典 `d` 的键，val1 和 val2 列的值对应子字典中的相应值。由于 tag2 对应的子字典不包含键 val1，故表中对应的值为空值，且键 val3 对应的值会被丢弃。\n"
    },
    "treasuryConversionFactor": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/treasuryconversionfactor.html",
        "signatures": [
            {
                "full": "treasuryConversionFactor(contractCoupon, deliverableCoupon, monthsToNextCoupon, remainingPayments, frequency)",
                "name": "treasuryConversionFactor",
                "parameters": [
                    {
                        "full": "contractCoupon",
                        "name": "contractCoupon"
                    },
                    {
                        "full": "deliverableCoupon",
                        "name": "deliverableCoupon"
                    },
                    {
                        "full": "monthsToNextCoupon",
                        "name": "monthsToNextCoupon"
                    },
                    {
                        "full": "remainingPayments",
                        "name": "remainingPayments"
                    },
                    {
                        "full": "frequency",
                        "name": "frequency"
                    }
                ]
            }
        ],
        "markdown": "### [treasuryConversionFactor](https://docs.dolphindb.cn/zh/funcs/t/treasuryconversionfactor.html)\n\n\n\n#### 语法\n\ntreasuryConversionFactor(contractCoupon, deliverableCoupon, monthsToNextCoupon, remainingPayments, frequency)\n\n#### 详情\n\n本函数基于[中金所国债转换因子和应计利息计算公式](http://www.cffex.com.cn/5tf/)对转换因子进行估值计算。成功执行后将返回转换因子的估值。\n\n#### 参数\n\n**contractCoupon** 数值型类型标量或向量，非负数，表示国债合约票面利率。\n\n**deliverableCoupon** 数值型标量或向量，非负数，表示可交割国债的票面利率。\n\n**monthsToNextCoupon** 整数类型标量或向量，非负数，表示交割月到下一付息月的月份数。\n\n**remainingPayments** 整数类型标量或向量，非负数，表示剩余付息次数。\n\n**frequency** 表示可交割国债每年的付息频率，支持两种输入类型：\n\n* INT 类型标量或向量，正数，表示可交割国债每年的付息次数。例如，*frequency* = 1 表示每年付息 1 次，即按年支付；*frequency* = 2 表示每年付息 2 次，即按半年期支付。\n\n* DURATION 标量或向量：表示可交割国债每隔多久进行一次付息。例如，*frequency* = duration(\\`3M)，表示每隔 3 个月付息一次，即按季度支付。\n\n<table id=\"table_x5h_gyw_bdc\"><thead><tr><th align=\"left\">\n\n可选值\n\n</th><th align=\"left\">\n\n含义\n\n</th></tr></thead><tbody><tr><td>\n\n1 / 1y\n\n</td><td>\n\n表示每年付息1次\n\n</td></tr><tr><td>\n\n2 / 6M\n\n</td><td>\n\n表示每年付息2次 / 每6个月付息1次\n\n</td></tr><tr><td>\n\n3 / 4M\n\n</td><td>\n\n表示每年付息3次 / 每4个月付息1次\n\n</td></tr><tr><td>\n\n4 / 3M\n\n</td><td>\n\n表示每年付息4次 / 每3个月付息1次\n\n</td></tr><tr><td>\n\n6 / 2M\n\n</td><td>\n\n表示每年付息6次 / 每2个月付息1次\n\n</td></tr><tr><td>\n\n12 / 1M\n\n</td><td>\n\n表示每年付息12次 / 每月付息1次\n\n</td></tr><tr><td>\n\n13 / 4w\n\n</td><td>\n\n表示每年付息13次 / 每4周付息1次\n\n</td></tr><tr><td>\n\n26 / 2w\n\n</td><td>\n\n表示每年付息26次 / 每2周付息1次\n\n</td></tr><tr><td>\n\n52 / 1w\n\n</td><td>\n\n表示每年付息52次 / 每周付息1次\n\n</td></tr><tr><td>\n\n365 / 1d\n\n</td><td>\n\n表示每年付息365次 / 每天付息1次\n\n</td></tr></tbody>\n</table>注意：在调用此函数时，必须保证所有提供的向量参数长度相同。若参数向量长度不一致，函数将会报错。\n\n#### 返回值\n\nDOUBLE 类型标量或向量。\n\n#### 例子\n\n假设 5 年期国债合约票面利率为 3%，交割月到下一付息月的月份数为 2，剩余付息次数为 1，可交割国债的票面利率为 3.2%，付息频率为 4，该种情况下对转换因子进行估值计算。\n\n```\ntreasuryConversionFactor(contractCoupon=0.03, deliverableCoupon=0.032, monthsToNextCoupon=2, remainingPayments=1, frequency=4)\n// Output：1.000324624767048\n```\n"
    },
    "triggerCheckpointForIMOLTP": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/triggercheckpointforimoltp.html",
        "signatures": [
            {
                "full": "triggerCheckpointForIMOLTP([force=false], [sync=false])",
                "name": "triggerCheckpointForIMOLTP",
                "parameters": [
                    {
                        "full": "[force=false]",
                        "name": "force",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[sync=false]",
                        "name": "sync",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [triggerCheckpointForIMOLTP](https://docs.dolphindb.cn/zh/funcs/t/triggercheckpointforimoltp.html)\n\n#### 语法\n\ntriggerCheckpointForIMOLTP(\\[force=false], \\[sync=false])\n\n#### 详情\n\n用于手动向处于正常运行状态的 OLTP 发出创建检查点（checkpoint）的请求。\n\n#### 参数\n\n* **force**：布尔类型的可选参数，默认为 false。用于设定是否强制执行 checkpoint。设定为 true 后，OLTP 将在接收到该函数发出的指令后强制执行 checkpoint。\n\n* **sync**：布尔类型的可选参数，默认为 false。用于设定是否异步执行强制的 checkpoint。\n\n  * 设置为 false 时，该函数请求一次异步的 checkpoint，并不会等到请求完成再返回执行结果；\n\n  * 设置为 true时，该函数会等到请求受理后再返回执行结果。注意：此时的执行结果并不一定意味着 checkpoint 文件的创建完成。\n\n**Note:** 该函数的两个可选参数均设定为 true 后，手动创建 checkpoint 文件成功的前提是配置项 *enableIMOLTPEngine* 和 *enableIMOLTPCheckpoint* 均已启用且 OLTP 处于正常运行状态。\n\n#### 返回值\n\n无。\n\n"
    },
    "triggerNodeReport": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/triggerNodeReport.html",
        "signatures": [
            {
                "full": "triggerNodeReport(nodeAlias, [chunkId])",
                "name": "triggerNodeReport",
                "parameters": [
                    {
                        "full": "nodeAlias",
                        "name": "nodeAlias"
                    },
                    {
                        "full": "[chunkId]",
                        "name": "chunkId",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [triggerNodeReport](https://docs.dolphindb.cn/zh/funcs/t/triggerNodeReport.html)\n\n\n\n#### 语法\n\ntriggerNodeReport(nodeAlias, \\[chunkId])\n\n#### 详情\n\n强制触发别名为 *nodeAlias* 的节点向控制节点汇报信息，以更新控制节点维护的元数据信息。若指定了 *chunkId* 参数，则仅上报对应 chunk 信息。\n\n使用场景：该命令用于解决数据节点离线并再次上线后，出现不汇报某些 chunk 信息的问题。\n\n操作步骤如下：\n\n1. 通过命令 `getClusterPerf` 查看 state 字段，以确定各个节点的存活情况。\n\n2. 通过 [getClusterChunksStatus](https://docs.dolphindb.cn/zh/funcs/g/getClusterChunksStatus.html) 查看 replicas, replicaCount 字段，以确定 chunk 的副本信息。\n\n3. 若节点存活，但出现副本数不一致，在 controller 的日志中，搜索对应的 chunkId，并定位出未汇报的数据节点。在该数据节点上调用 `triggerNodeReport` 强制触发其汇报 chunk 信息。\n\n4. 若此方法失效，建议重启节点。\n\n#### 参数\n\n**nodeAlias** 字符串，表示节点的别名。\n\n**chunkId** 可选参数，一个字符串或者字符串向量。表示需要汇报的 chunks 的 ID 值。该参数仅对集群有效。\n\n#### 返回值\n\n无。\n"
    },
    "triggerPKEYCompaction": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/triggerPKEYCompaction.html",
        "signatures": [
            {
                "full": "triggerPKEYCompaction(chunkId, [async=true])",
                "name": "triggerPKEYCompaction",
                "parameters": [
                    {
                        "full": "chunkId",
                        "name": "chunkId"
                    },
                    {
                        "full": "[async=true]",
                        "name": "async",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [triggerPKEYCompaction](https://docs.dolphindb.cn/zh/funcs/t/triggerPKEYCompaction.html)\n\n\n\n#### 语法\n\ntriggerPKEYCompaction(chunkId, \\[async=true])\n\n#### 详情\n\n异步强制触发指定 chunk 进行 compaction，从而提升读取效率。\n\n#### 参数\n\n**chunkId** STRING 类型标量或向量，表示 chunk 对应的 ID。\n\n**async** BOOL 类型标量，表示是否异步触发：\n\n* 默认为 true，表示异步触发，即不等待 compaction 任务完成直接返回；\n* false 表示同步触发，即等待所有 compaction 任务完成后返回。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\ntriggerPKEYCompaction(chunkId=\"1486f935-6f87-479c-b341-34c6a303d4f9\", async=false)\n```\n"
    },
    "triggerTSDBCompaction": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/triggerTSDBCompaction.html",
        "signatures": [
            {
                "full": "triggerTSDBCompaction(chunkId, [level=0])",
                "name": "triggerTSDBCompaction",
                "parameters": [
                    {
                        "full": "chunkId",
                        "name": "chunkId"
                    },
                    {
                        "full": "[level=0]",
                        "name": "level",
                        "optional": true,
                        "default": "0"
                    }
                ]
            }
        ],
        "markdown": "### [triggerTSDBCompaction](https://docs.dolphindb.cn/zh/funcs/t/triggerTSDBCompaction.html)\n\n\n\n#### 语法\n\ntriggerTSDBCompaction(chunkId, \\[level=0])\n\n#### 详情\n\n在 TSDB 存储引擎中，强制触发指定 chunk 内指定层级所有 Level File 的合并操作，以提升读取效率。\n\n**注**：只有在配置参数 *allowTSDBLevel3Compaction* 设置为 true 且表中指定 *keepDuplicates*=FIRST/LAST 时，才会执行 Level 3 文件的合并。\n\n#### 参数\n\n**chunkId** 是字符串标量，表示 chunk 的 ID。\n\n**level**可选参数，表示需要合并的层级。可以是 \\[-1,3] 的整数。\n\n* 当 *level*为 \\[0,3] 区间内的整数时，触发对应层级的 Level File 合并。默认值为 0。\n* 当 *level* =-1 时，所有 Level File 会合并为一个 Level File。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n一个分区内包含两种文件类型，一种是记录数据库和数据表结构信息的文件（file chunk），另一种是数据文件（tablet chunk）。 因为只能对数据文件进行合并操作，在查询 chunk ID 时，需通过 type=1（代表数据文件）来进行过滤。\n\n```\nchunkIds = exec chunkId from getChunksMeta() where type=1\nfor (x in chunkIds) {\n    triggerTSDBCompaction(x)\n}\n```\n"
    },
    "tril": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tril.html",
        "signatures": [
            {
                "full": "tril(X, [k=0])",
                "name": "tril",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[k=0]",
                        "name": "k",
                        "optional": true,
                        "default": "0"
                    }
                ]
            }
        ],
        "markdown": "### [tril](https://docs.dolphindb.cn/zh/funcs/t/tril.html)\n\n\n\n#### 语法\n\ntril(X, \\[k=0])\n\n#### 详情\n\n* 若未指定 *k*： 返回矩阵 *X* 的下三角部分，其余元素设为0。\n\n* 若指定 *k*： 返回矩阵 *X* 的第 *k* 条对角线上以及该对角线下方的元素，其余元素设为0。矩阵的主对角线为其第0条对角线。\n\n#### 参数\n\n**X** 是一个矩阵。\n\n**k** 是一个整数。\n\n#### 返回值\n\n返回一个矩阵，其数据类型同 *X*。\n\n#### 例子\n\n```\nm=matrix(1 2 3, 4 5 6, 7 8 9);\nm;\n```\n\n| col1 | col2 | col3 |\n| ---- | ---- | ---- |\n| 1    | 4    | 7    |\n| 2    | 5    | 8    |\n| 3    | 6    | 9    |\n\n```\ntril(m);\n```\n\n| col1 | col2 | col3 |\n| ---- | ---- | ---- |\n| 1    | 0    | 0    |\n| 2    | 5    | 0    |\n| 3    | 6    | 9    |\n\n```\ntril(m,1);\n```\n\n| col1 | col2 | col3 |\n| ---- | ---- | ---- |\n| 1    | 4    | 0    |\n| 2    | 5    | 8    |\n| 3    | 6    | 9    |\n\n```\ntril(m,-1);\n```\n\n| col1 | col2 | col3 |\n| ---- | ---- | ---- |\n| 0    | 0    | 0    |\n| 2    | 0    | 0    |\n| 3    | 6    | 0    |\n\n相关函数：[triu](https://docs.dolphindb.cn/zh/funcs/t/triu.html)\n"
    },
    "trim": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/trim.html",
        "signatures": [
            {
                "full": "trim(X)",
                "name": "trim",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [trim](https://docs.dolphindb.cn/zh/funcs/t/trim.html)\n\n\n\n#### 语法\n\ntrim(X)\n\n#### 详情\n\n去掉每个字符串首尾的空格。\n\n#### 参数\n\n**X** 是一个字符串标量或向量。\n\n#### 返回值\n\nSTRING 类型标量或向量。\n\n#### 例子\n\n```\nx=[\"  t1\", \" t2 \"];\ntrim(x);\n// output\n[\"t1\",\"t2\"]\n```\n\n相关函数：[strip](https://docs.dolphindb.cn/zh/funcs/s/strip.html)\n"
    },
    "trima": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/trima.html",
        "signatures": [
            {
                "full": "trima(X, window)",
                "name": "trima",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    }
                ]
            }
        ],
        "markdown": "### [trima](https://docs.dolphindb.cn/zh/funcs/t/trima.html)\n\n\n\n#### 语法\n\ntrima(X, window)\n\nTA-lib 系列函数参数说明和窗口计算规则请参考：[TAlib](https://docs.dolphindb.cn/zh/funcs/themes/TAlib.html)\n\n#### 详情\n\n在给定长度（以元素个数衡量）的滑动窗口内，计算 *X* 的三角移动平均（Triangular Moving Average）。\n\n其计算公式为：![](https://docs.dolphindb.cn/zh/images/trima.png)\n\n其中 *w1 = (window + 1)/2* 向上取整；*w2 = (window + 1)/2* 向下取整。\n\n#### 返回值\n\nDOUBLE 类型向量/矩阵/表，数据形式同 *X*。\n\n#### 例子\n\n```\nx=12.1 12.2 12.6 12.8 11.9 11.6 11.2\ntrima(x,3);\n// output\n[,,12.274999999999998,18.625,18.662500000000001,15.225000000000001,11.59375]\n\nx=matrix(12.1 12.2 12.6 12.8 11.9 11.6 11.2, 14 15 18 19 21 12 10)\ntrima(x,3);\n```\n\n| col1    | col2    |\n| ------- | ------- |\n|         |         |\n|         |         |\n| 12.2749 | 15.5000 |\n| 12.5499 | 17.5000 |\n| 12.5249 | 19.2500 |\n| 12.0499 | 18.2500 |\n| 11.5750 | 13.7500 |\n\n相关函数：[sma](https://docs.dolphindb.cn/zh/funcs/s/sma.html), [wma](https://docs.dolphindb.cn/zh/funcs/w/wma.html), [trima](https://docs.dolphindb.cn/zh/funcs/t/trima.html)\n"
    },
    "triu": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/triu.html",
        "signatures": [
            {
                "full": "triu(X, [k=0])",
                "name": "triu",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[k=0]",
                        "name": "k",
                        "optional": true,
                        "default": "0"
                    }
                ]
            }
        ],
        "markdown": "### [triu](https://docs.dolphindb.cn/zh/funcs/t/triu.html)\n\n\n\n#### 语法\n\ntriu(X, \\[k=0])\n\n#### 详情\n\n* 若未指定 *k*： 返回矩阵 *X* 的上三角部分，其余元素设为0。\n\n* 若指定 *k*： 返回矩阵 *X* 的第 *k* 条对角线上以及该对角线上方的元素，其余元素设为0。矩阵的主对角线为其第0条对角线。\n\n与 Python 中 `numpy.triu` 的区别：`numpy.triu` 支持至少二维数组，并在高维数组中作用于最后两个轴；DolphinDB 的 `triu` 只接受矩阵。\n\n#### 参数\n\n**X** 是一个矩阵。\n\n**k** 是一个整数。\n\n#### 返回值\n\n返回一个矩阵，其数据类型同 *X*。\n\n#### 例子\n\n```\nm=matrix(1 2 3, 4 5 6, 7 8 9);\nm;\n```\n\n| col1 | col2 | col3 |\n| ---- | ---- | ---- |\n| 1    | 4    | 7    |\n| 2    | 5    | 8    |\n| 3    | 6    | 9    |\n\n```\ntriu(m);\n```\n\n| col1 | col2 | col3 |\n| ---- | ---- | ---- |\n| 1    | 4    | 7    |\n| 0    | 5    | 8    |\n| 0    | 0    | 9    |\n\n```\ntriu(m,1);\n```\n\n| col1 | col2 | col3 |\n| ---- | ---- | ---- |\n| 0    | 4    | 7    |\n| 0    | 0    | 8    |\n| 0    | 0    | 0    |\n\n```\ntriu(m,-1);\n```\n\n| col1 | col2 | col3 |\n| ---- | ---- | ---- |\n| 1    | 4    | 7    |\n| 2    | 5    | 8    |\n| 0    | 6    | 9    |\n\n相关函数： [tril](https://docs.dolphindb.cn/zh/funcs/t/tril.html)\n"
    },
    "trueRange": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/trueRange.html",
        "signatures": [
            {
                "full": "trueRange(high, low, close)",
                "name": "trueRange",
                "parameters": [
                    {
                        "full": "high",
                        "name": "high"
                    },
                    {
                        "full": "low",
                        "name": "low"
                    },
                    {
                        "full": "close",
                        "name": "close"
                    }
                ]
            }
        ],
        "markdown": "### [trueRange](https://docs.dolphindb.cn/zh/funcs/t/trueRange.html)\n\n\n\n#### 语法\n\ntrueRange(high, low, close)\n\n#### 详情\n\n计算真实波幅，即 | 最高价-最低价 | 和 | 最高价-昨收 | 和 | 昨收-最低价 | 的最大值。\n\n#### 参数\n\n**high**, **low** 和 **close** 是等长的数值型向量。\n\n#### 返回值\n\nDOUBLE 类型向量。\n\n#### 例子\n\n```\nsym=take(`A`B,10)\ndate=2020.01.01 2020.01.01 2020.01.02 2020.01.02 2020.01.03 2020.01.03 2020.01.04 2020.01.04 2020.01.05 2020.01.05\nhigh=[11.48,10.23,12.26,10.7,12.24,10.45,12.3,10.51,12.24,10.49]\nlow=[10.91,9.41,11.18,10,11.71,9.83,11.62,9.91,11.1,9.6]\nclose=[11.38,10.22,12.1,10.31,11.89,10.21,12.13,10.47,11.35,9.81]\nt=table(sym,date,high,low,close)\nselect sym,trueRange(high,low,close) as trange from t context by sym;\n```\n\n| sym | trange |\n| --- | ------ |\n| A   |        |\n| A   | 1.08   |\n| A   | 0.53   |\n| A   | 0.68   |\n| A   | 1.14   |\n| B   |        |\n| B   | 0.7    |\n| B   | 0.62   |\n| B   | 0.6    |\n| B   | 0.89   |\n"
    },
    "truncate": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/truncate.html",
        "signatures": [
            {
                "full": "truncate(dbUrl, tableName)",
                "name": "truncate",
                "parameters": [
                    {
                        "full": "dbUrl",
                        "name": "dbUrl"
                    },
                    {
                        "full": "tableName",
                        "name": "tableName"
                    }
                ]
            }
        ],
        "markdown": "### [truncate](https://docs.dolphindb.cn/zh/funcs/t/truncate.html)\n\n\n\n#### 语法\n\ntruncate(dbUrl, tableName)\n\n#### 详情\n\n删除分布式表的所有数据，但保留数据表结构。其性能较 [delete](https://docs.dolphindb.cn/zh/progr/sql/delete.html) 语句以及 [dropPartition](https://docs.dolphindb.cn/zh/funcs/d/dropPartition.html) 命令均有数倍提升。\n\n若仅需要删除表中所有的数据，但保留表结构，建议调用 `truncate` 实现。若无需保留表结构，建议调用 [dropTable](https://docs.dolphindb.cn/zh/funcs/d/dropTable.html) 命令。\n\n与 Python 中 `scipy.stats.truncate` 的区别：`scipy.stats.truncate` 是截断随机变量分布对象，DolphinDB 的 `truncate` 是数据库管理函数，用于清空 *dbUrl* 指定数据库中 *tableName* 对应的 DFS 表数据并保留表结构。\n\n#### 参数\n\n**dbUrl** 字符串，表示数据库的路径。\n\n**tableName** 字符串，表示数据表的表名。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\nn=1000000\nID=rand(150, n)\ndates=2017.08.07..2017.08.11\ndate=rand(dates, n)\nx=rand(10.0, n)\nt=table(ID, date, x)\ndbDate = database(, VALUE, 2017.08.07..2017.08.11)\ndbID = database(, RANGE, 0 50 100 150)\n\ndbName=\"dfs://compoDB\"\nif(existsDatabase(dbName)){\n\n      dropDatabase(dbName)\n}\ndb = database(dbName, COMPO, [dbDate, dbID])\npt = db.createPartitionedTable(t, `pt, `date`ID)\npt.append!(t);\n\ntruncate(dbName, `pt)\n```\n"
    },
    "tTest": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tTest.html",
        "signatures": [
            {
                "full": "tTest(X, [Y], [mu=0.0], [confLevel=0.95], [equalVar=false])",
                "name": "tTest",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[Y]",
                        "name": "Y",
                        "optional": true
                    },
                    {
                        "full": "[mu=0.0]",
                        "name": "mu",
                        "optional": true,
                        "default": "0.0"
                    },
                    {
                        "full": "[confLevel=0.95]",
                        "name": "confLevel",
                        "optional": true,
                        "default": "0.95"
                    },
                    {
                        "full": "[equalVar=false]",
                        "name": "equalVar",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [tTest](https://docs.dolphindb.cn/zh/funcs/t/tTest.html)\n\n\n\n#### 语法\n\ntTest(X, \\[Y], \\[mu=0.0], \\[confLevel=0.95], \\[equalVar=false])\n\n#### 详情\n\n对未知方差的数据进行t检验。\n\n如果没有指定 *Y*，对正态分布 *X* 进行单样本 t 检验；如果指定了 *Y*，对独立正态分布 *X* 和 *Y* 进行双样本 t 检验。\n\n#### 参数\n\n**X** 是一个数值向量，表示用于t检验的样本。\n\n**Y** 是一个数值向量，表示用于独立双样本t检验的另一个样本。它是可选参数。\n\n**mu** 是一个浮点数，默认值是0。如果没有指定 *Y* ，*mu* 表示 *X* 的均值的假设值；如果指定了 *Y*，*mu* 表示 *X*, *Y* 均值之差的假设值。\n\n**confLevel** 是0到1之间的浮点数，表示置信区间的置信水平。\n\n**equalVar** 是一个布尔值，表示 *X*, *Y* 的方差是否相等。\n\n#### 返回值\n\n一个字典，包含以下 key：\n\n* method：样本 t 检验方法。\n\n  * One sample t-test：单样本 t 检验\n  * Two sample t-test：独立同方差双样本 t 检验\n  * Welch two sample t-test：独立不同方差双样本 t 检验\n\n* stat：一张表，包含三种不同备择假设下的 p 值和置信区间\n\n* df：t 分布的自由度\n\n* confLevel：置信水平\n\n* tValue：t 统计量\n\n#### 例子\n\n单样本 t 检验：\n\n```\nx = norm(10.0, 1.0, 20)\ntTest(x, , 10.0);\n\n// output\nstat->\nalternativeHypothesis        pValue   lowerBound upperBound\n---------------------------- -------- ---------- ----------\ntrue mean is not equal to 10 0.499649 9.68582    10.621998\ntrue mean is less than 10    0.750176 -Infinity  10.540616\ntrue mean is greater than 10 0.249824 9.767202   Infinity\n\ndf->19\nconfLevel->0.95\nmethod->One sample t-test\ntValue->0.688192\n```\n\n独立同方差双样本 t 检验：\n\n```\nx = norm(10.0, 1.0, 20)\ny = norm(4.0, 1.0, 10)\ntTest(x, y, 6.0, , true);\n\n// output\nstat->\nalternativeHypothesis                pValue   lowerBound upperBound\n------------------------------------ -------- ---------- ----------\ndifference of mean is not equal to 6 0.438767 5.539812   7.03262\ndifference of mean is less than 6    0.780616 -Infinity  6.906078\ndifference of mean is greater than 6 0.219384 5.666354   Infinity\n\ndf->28\nconfLevel->0.95\nmethod->Two sample t-test\ntValue->0.785483\n```\n\n独立不同方差双样本 t 检验：\n\n```\nx = norm(10.0, 1.0, 20)\ny = norm(1.0, 2.0, 10)\ntTest(x, y, 9.0);\n\n// output\nstat->\nalternativeHypothesis          pValue   lowerBound upperBound\n------------------------------ ----------------- ---------- ----------\ntrue difference of mean is n...0.983376 7.752967   10.271656\ntrue difference of mean is l...0.508312 -Infinity  10.04285\ntrue difference of mean is g...0.491688 7.981773   Infinity\n\ndf->12.164434\nconfLevel->0.95\nmethod->Welch two sample t-test\ntValue->0.021269\n```\n"
    },
    "tupleSum": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/tupleSum.html",
        "signatures": [
            {
                "full": "tupleSum(X)",
                "name": "tupleSum",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [tupleSum](https://docs.dolphindb.cn/zh/funcs/t/tupleSum.html)\n\n\n\n#### 语法\n\ntupleSum(X)\n\n#### 详情\n\n`tupleSum` 用于从多个 `map` 调用中总结单个结果。如果每个 `map` 调用返回了一个包含 N 个非元组对象的元祖，那么 `tupleSum` 函数的输入将是一个包含 N 个元组对象的元组。每一个子元组包含 m 个拥有相同数据形式和数据类型的对象，m 是 `map` 函数调用的次数。如果有一个单独的 `map` 调用，`tupleSum` 以 `map` 调用的结果作为输入，将输入直接返回作为输出。\n\n`tupleSum` 的函数调用结果和 `map` 调用的结果总是有相同的格式。如果 `map` 调用返回一个包含至少 2 个非元组对象的元祖，`tupleSum` 将返回一个包含了具有相同个数的非元组对象的元组。\n\n#### 参数\n\n**X** 是一个元组。\n\n#### 返回值\n\n取决于 `map` 调用结果。\n\n#### 例子\n\n```\nx = [(1 2, 3 4, 5 6), (0.5, 0.6, 0.7)];\ntupleSum(x);\n// output\n([9,12],1.8)\n```\n\n如果 `map` 调用返回单个非元组的对象，`tupleSum` 也会返回单个非元组对象。\n\n```\nx = [(1 2, 3 4, 5 6)];\ntupleSum(x);\n// output\n[9,12]\n```\n"
    },
    "type": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/type.html",
        "signatures": [
            {
                "full": "type(X)",
                "name": "type",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [type](https://docs.dolphindb.cn/zh/funcs/t/type.html)\n\n\n\n#### 语法\n\ntype(X)\n\n#### 详情\n\n返回一个表明 *X* 的数据类型的整数。详细信息参见 [数据类型](https://docs.dolphindb.cn/zh/progr/data_types.html)。\n\n#### 参数\n\n**X** 可以是系统支持的任意数据类型。\n\n#### 返回值\n\nINT 类型标量。\n\n#### 例子\n\n```\nx=3;\nx;\n// output\n3\n\ntype(x);\n// output\n4\n// INT\n\ntype(1.2);\n// output\n16\n// DOUBLE\n\ntype(\"Hello\");\n// output\n18\n// STRING\n```\n"
    },
    "typestr": {
        "url": "https://docs.dolphindb.cn/zh/funcs/t/typestr.html",
        "signatures": [
            {
                "full": "typestr(X)",
                "name": "typestr",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [typestr](https://docs.dolphindb.cn/zh/funcs/t/typestr.html)\n\n\n\n#### 语法\n\ntypestr(X)\n\n#### 详情\n\n返回一个表明 *X* 的数据类型的字符串。详细信息参见 [数据类型](https://docs.dolphindb.cn/zh/progr/data_types.html)。\n\n#### 参数\n\n**X** 可以是系统支持的任意数据类型。\n\n#### 返回值\n\nSTRING 类型标量。\n"
    },
    "rad2deg": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rad2deg.html",
        "signatures": [
            {
                "full": "rad2deg(X)",
                "name": "rad2deg",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [rad2deg](https://docs.dolphindb.cn/zh/funcs/r/rad2deg.html)\n\n\n\n#### 语法\n\nrad2deg(X)\n\n#### 详情\n\n将 *X* 的角单位从弧度转换为度。\n\n#### 参数\n\n**X** 可以是标量、向量、矩阵或表。\n\n#### 返回值\n\n数据类型是 DOUBLE，数据形式与 *X* 相同。\n\n#### 例子\n\n```\nrad2deg(pi);\n// output\n180\n```\n\n相关函数：[deg2rad](https://docs.dolphindb.cn/zh/funcs/d/deg2rad.html)\n"
    },
    "rand": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rand.html",
        "signatures": [
            {
                "full": "rand(X, [count])",
                "name": "rand",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[count]",
                        "name": "count",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [rand](https://docs.dolphindb.cn/zh/funcs/r/rand.html)\n\n\n\n#### 语法\n\nrand(X, \\[count])\n\n#### 详情\n\n返回一个与 *X* 类型相同的随机标量/向量/矩阵。\n\n* 如果 *X* 是标量，*X* 必须为大于 0 且为数值类型，生成的随机数服从 \\[0, X) 下的均匀分布。\n* 如果 *X* 是向量，返回从 *X* 中随机选取的元素。\n\n#### 参数\n\n**X** 标量或向量。\n\n**count** 可选参数，INT 型标量或数据对。\n\n* 若不指定 *count*，返回一个标量。\n* 若为标量，表示输出向量的长度。\n* 若为数据对，表示输出矩阵的维度。\n\n#### 返回值\n\n返回一个与 *X* 类型相同的随机标量/向量/矩阵。\n\n#### 例子\n\n```\n// 不指定count，生成一个随机标量\nrand(2)\n// output: 0\nrand(1 2 5)\n// output: 1\n\n// 生成 20 个小于 10 的随机非负整数\nrand(10, 20);\n// output：[9,9,8,1,1,0,8,3,2,6,4,6,9,6,8,9,3,2,1,5]\n\n// 生成 10 个 小于 9.8 的随机非负浮点数\nrand(9.8, 10);\n// output：[3.653754,1.750518,0.055747,5.219222,2.473778,6.337576,7.797493,1.392241,0.149499,5.697612]\n\n// 生成 3 个随机从向量 x 中选取的值\nx=3 5 4 6 9;\nrand(x, 3);\n// output：[9,3,6]\n\n// 生成一个小于10的 2*2 的随机矩阵\nrand(10.0, 2:2)\n```\n\n| col1   | col2   |\n| ------ | ------ |\n| 0.8233 | 1.0052 |\n| 7.1127 | 9.7578 |\n\n```\n12:35:06 + rand(100, 10);\n//output：[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]\n\nx=`IBM`C`AAPL`BABA;\nrand(x, 10);\n// output：[\"IBM\",\"BABA\",\"C\",\"AAPL\",\"IBM\",\"C\",\"BABA\",\"AAPL\",\"BABA\",\"BABA\"]\n\nrand(x,2:3)\n```\n\n<table id=\"table_kxp_bz5_x1c\"><tbody><tr><td>\n\n\\#0\n\n</td><td>\n\n\\#1\n\n</td><td>\n\n\\#2\n\n</td></tr><tr><td>\n\nBABA\n\n</td><td>\n\nAAPL\n\n</td><td>\n\nBABA\n\n</td></tr><tr><td>\n\nC\n\n</td><td>\n\nAAPL\n\n</td><td>\n\nAAPL\n\n</td></tr></tbody>\n</table>\n"
    },
    "randBeta": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/randBeta.html",
        "signatures": [
            {
                "full": "randBeta(alpha, beta, count)",
                "name": "randBeta",
                "parameters": [
                    {
                        "full": "alpha",
                        "name": "alpha"
                    },
                    {
                        "full": "beta",
                        "name": "beta"
                    },
                    {
                        "full": "count",
                        "name": "count"
                    }
                ]
            }
        ],
        "markdown": "### [randBeta](https://docs.dolphindb.cn/zh/funcs/r/randBeta.html)\n\n\n\n#### 语法\n\nrandBeta(alpha, beta, count)\n\n#### 详情\n\n生成指定个数的 Beta 分布随机数。\n\n#### 参数\n\n形状参数 **alpha** 和 **beta** 都是正数。\n\n**count** 是正整数，表示生成随机数的个数。\n\n#### 返回值\n\n长度为 *count* 的 DOUBLE 类型向量。\n\n#### 例子\n\n```\nrandBeta(2.31, 0.627, 2);\n// output\n[0.781246, 0.951372]\n```\n"
    },
    "randBinomial": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/randBinomial.html",
        "signatures": [
            {
                "full": "randBinomial(trials, p, count)",
                "name": "randBinomial",
                "parameters": [
                    {
                        "full": "trials",
                        "name": "trials"
                    },
                    {
                        "full": "p",
                        "name": "p"
                    },
                    {
                        "full": "count",
                        "name": "count"
                    }
                ]
            }
        ],
        "markdown": "### [randBinomial](https://docs.dolphindb.cn/zh/funcs/r/randBinomial.html)\n\n\n\n#### 语法\n\nrandBinomial(trials, p, count)\n\n#### 详情\n\n生成指定个数的二项分布随机数。\n\n#### 参数\n\n**trials** 是正整数。\n\n**p** 是0到1之间的浮点数。\n\n**trials** 和 **p** 是形状参数。\n\n**count** 是正整数，表示生成的随机数个数。\n\n#### 返回值\n\n长度为 *count* 的 DOUBLE 类型向量。\n\n#### 例子\n\n```\nrandBinomial(2, 0.627, 2);\n// output\n[1, 1]\n```\n"
    },
    "randChiSquare": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/randChiSquare.html",
        "signatures": [
            {
                "full": "randChiSquare(df, count)",
                "name": "randChiSquare",
                "parameters": [
                    {
                        "full": "df",
                        "name": "df"
                    },
                    {
                        "full": "count",
                        "name": "count"
                    }
                ]
            }
        ],
        "markdown": "### [randChiSquare](https://docs.dolphindb.cn/zh/funcs/r/randChiSquare.html)\n\n\n\n#### 语法\n\nrandChiSquare(df, count)\n\n#### 详情\n\n生成指定个数的卡方分布随机数。\n\n#### 参数\n\n**df** 是正数，表示卡方分布的自由度。\n\n**count** 是正整数，表示生成的随机数个数。\n\n#### 返回值\n\n长度为 *count* 的 DOUBLE 类型向量。\n\n#### 例子\n\n```\nrandChiSquare(2.31, 2);\n// output\n[2.78303, 2.868523]\n```\n"
    },
    "randDiscrete": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/randDiscrete.html",
        "signatures": [
            {
                "full": "randDiscrete(v, p, count)",
                "name": "randDiscrete",
                "parameters": [
                    {
                        "full": "v",
                        "name": "v"
                    },
                    {
                        "full": "p",
                        "name": "p"
                    },
                    {
                        "full": "count",
                        "name": "count"
                    }
                ]
            }
        ],
        "markdown": "### [randDiscrete](https://docs.dolphindb.cn/zh/funcs/r/randDiscrete.html)\n\n\n\n#### 语法\n\nrandDiscrete(v, p, count)\n\n#### 详情\n\n根据给定的分布概率 *p*，生成向量 *v* 的随机样本。生成样本的长度由 *count* 指定。\n\n#### 参数\n\n**v** 向量或元组，表示样本数据。\n\n**p** 与 *v* 等长的浮点型向量，其每个元素必须是正数，对应 *v* 中采样元素的概率分布。系统会自动将 *p* 的元素归一化。\n\n**count** 正整数，表示输出的随机向量的长度。\n\n#### 返回值\n\n长度为 *count* 的 DOUBLE 类型向量。\n\n#### 例子\n\n```\nrandDiscrete(1..5, [0.1, 0.1, 0.2, 0.2, 0.4], 10)\n// output\n[2,3,5,2,5,5,2,1,1,2]\n\n// 若概率和不为1，系统会自动归一化\nrandDiscrete(1..5, [0.1, 0.2, 0.3, 0.4, 0.5], 5)\n// output\n[5,1,2,3,5]\n\nrandDiscrete(`A`B`C`E`F, [0.1, 0.2, 0.3, 0.4, 0.5], 5)\n// output\n[\"C\",\"E\",\"B\",\"C\",\"F\"]\n\n// 输入元组，对元组中的每个元素进行采样\nrandDiscrete([[1,2], [2,3,4], 'S', 'abc'], [0.3, 0.3, 0.2, 0.1], 10)\n// output\n('S',[2,3,4],[1,2],[2,3,4],[1,2],'S','S',[2,3,4],[2,3,4],[2,3,4])\n\n// 输入数组向量，对其中的每个向量进行采样\na = array\\(INT\\[\\], 0, 10\\).append!\\(\\[1 2 3, 4 5,6 7 8, 9 NULL\\]\\)\nrandDiscrete\\(a, \\[0.1, 0.2, 0.3, 0.4\\], 10\\)\n// output\n\\[\\[9,00i\\],\\[9,00i\\],\\[9,00i\\],\\[4,5\\],\\[9,00i\\],\\[1,2,3\\],\\[9,00i\\],\\[6,7,8\\],\\[9,00i\\],\\[9,00i\\]\\]\n```\n"
    },
    "randExp": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/randExp.html",
        "signatures": [
            {
                "full": "randExp(mean, count)",
                "name": "randExp",
                "parameters": [
                    {
                        "full": "mean",
                        "name": "mean"
                    },
                    {
                        "full": "count",
                        "name": "count"
                    }
                ]
            }
        ],
        "markdown": "### [randExp](https://docs.dolphindb.cn/zh/funcs/r/randExp.html)\n\n\n\n#### 语法\n\nrandExp(mean, count)\n\n#### 详情\n\n生成指定个数的指数分布随机数。\n\n#### 参数\n\n**mean** 是指数分布的均值。\n\n**count** 是正整数，表示生成的随机数个数。\n\n#### 返回值\n\n长度为 *count* 的 DOUBLE 类型向量。\n\n#### 例子\n\n```\nrandExp(2.31, 2);\n// output\n[0.732791, 0.732791]\n```\n"
    },
    "randF": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/randF.html",
        "signatures": [
            {
                "full": "randF(numeratorDF, denominatorDF, count)",
                "name": "randF",
                "parameters": [
                    {
                        "full": "numeratorDF",
                        "name": "numeratorDF"
                    },
                    {
                        "full": "denominatorDF",
                        "name": "denominatorDF"
                    },
                    {
                        "full": "count",
                        "name": "count"
                    }
                ]
            }
        ],
        "markdown": "### [randF](https://docs.dolphindb.cn/zh/funcs/r/randF.html)\n\n\n\n#### 语法\n\nrandF(numeratorDF, denominatorDF, count)\n\n#### 详情\n\n生成指定个数的 F 分布随机数。\n\n#### 参数\n\n**numeratorDF** 和 **denominatorDF** 都是正数，表示 F 分布的自由度。\n\n**count** 是正整数，表示生成的随机数个数。\n\n#### 返回值\n\n长度为 *count* 的 DOUBLE 类型向量。\n\n#### 例子\n\n```\nrandF(2.31, 0.671, 2);\n// output\n[0.41508, 0.642609]\n```\n"
    },
    "randGamma": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/randGamma.html",
        "signatures": [
            {
                "full": "randGamma(shape, scale, count)",
                "name": "randGamma",
                "parameters": [
                    {
                        "full": "shape",
                        "name": "shape"
                    },
                    {
                        "full": "scale",
                        "name": "scale"
                    },
                    {
                        "full": "count",
                        "name": "count"
                    }
                ]
            }
        ],
        "markdown": "### [randGamma](https://docs.dolphindb.cn/zh/funcs/r/randGamma.html)\n\n\n\n#### 语法\n\nrandGamma(shape, scale, count)\n\n#### 详情\n\n生成指定个数的 Gamma 分布随机数。\n\n#### 参数\n\n形状参数 **shape** 是正数。\n\n形状参数 **scale** 是正数。\n\n**count** 是正整数，表示生成的随机数个数。\n\n#### 返回值\n\n长度为 *count* 的 DOUBLE 类型向量。\n\n#### 例子\n\n```\nrandGamma(2.31, 0.671, 2);\n// output\n[0.784424, 0.716934]\n```\n"
    },
    "randLogistic": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/randLogistic.html",
        "signatures": [
            {
                "full": "randLogistic(mean, s, count)",
                "name": "randLogistic",
                "parameters": [
                    {
                        "full": "mean",
                        "name": "mean"
                    },
                    {
                        "full": "s",
                        "name": "s"
                    },
                    {
                        "full": "count",
                        "name": "count"
                    }
                ]
            }
        ],
        "markdown": "### [randLogistic](https://docs.dolphindb.cn/zh/funcs/r/randLogistic.html)\n\n\n\n#### 语法\n\nrandLogistic(mean, s, count)\n\n#### 详情\n\n生成指定个数的 Logistic 分布随机数。\n\n#### 参数\n\n**mean** Logistic 分布的均值。\n\n**s** 是Logistic 分布的尺度参数。\n\n**count** 是正整数，表示生成的随机数个数。\n\n#### 返回值\n\n长度为 *count* 的 DOUBLE 类型向量。\n\n#### 例子\n\n```\nrandLogistic(2.31, 0.671, 2);\n// output\n[2.465462, 2.577171]\n```\n"
    },
    "randMultivariateNormal": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/randMultivariateNormal.html",
        "signatures": [
            {
                "full": "randMultivariateNormal(mean, covar, count, [sampleAsRow=true])",
                "name": "randMultivariateNormal",
                "parameters": [
                    {
                        "full": "mean",
                        "name": "mean"
                    },
                    {
                        "full": "covar",
                        "name": "covar"
                    },
                    {
                        "full": "count",
                        "name": "count"
                    },
                    {
                        "full": "[sampleAsRow=true]",
                        "name": "sampleAsRow",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [randMultivariateNormal](https://docs.dolphindb.cn/zh/funcs/r/randMultivariateNormal.html)\n\n\n\n#### 语法\n\nrandMultivariateNormal(mean, covar, count, \\[sampleAsRow=true])\n\n别名：multivariateNormal\n\n#### 详情\n\n生成服从多元正态分布的随机数。\n\n#### 参数\n\n**mean** 是一个数组，表示多元正太分布的均值。\n\n**covar** 是一个正定矩阵，表示多元正太分布的协方差。\n\n**count** 是一个正整数，表示样本长度。\n\n**sampleAsRow** 是一个布尔值。默认值为 true，表示输出矩阵的一行是一个样本。如果 *sampleAsRow* 为 false，表示输出矩阵的一列是一个样本。\n\n#### 返回值\n\n返回一个矩阵。\n\n#### 例子\n\n```\nmultivariateNormal([2, 3], [1.0, 1.5, 1.5, 3.0]$2:2, 5);\n```\n\n输出返回：\n\n| #0        | #1        |\n| --------- | --------- |\n| -0.02395  | -0.844505 |\n| -0.630637 | 0.098955  |\n| 3.001908  | 4.831809  |\n| 0.791095  | 2.01402   |\n| 1.708191  | 2.41748   |\n\n```\nmultivariateNormal([2, 3], [1.0, 1.5, 1.5, 3.0]$2:2, 5, false);\n```\n\n输出返回：\n\n| #0       | #1       | #2        | #3        | #4       |\n| -------- | -------- | --------- | --------- | -------- |\n| 0.435419 | 0.138209 | -0.046187 | -1.201421 | 0.069719 |\n| 0.40163  | 0.034553 | -0.337324 | -1.008628 | 0.822161 |\n"
    },
    "randNormal": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/randNormal.html",
        "signatures": [
            {
                "full": "randNormal(mean, stdev, count)",
                "name": "randNormal",
                "parameters": [
                    {
                        "full": "mean",
                        "name": "mean"
                    },
                    {
                        "full": "stdev",
                        "name": "stdev"
                    },
                    {
                        "full": "count",
                        "name": "count"
                    }
                ]
            }
        ],
        "markdown": "### [randNormal](https://docs.dolphindb.cn/zh/funcs/r/randNormal.html)\n\n\n\n#### 语法\n\nrandNormal(mean, stdev, count)\n\n#### 详情\n\n生成指定个数的正态分布随机数。\n\n#### 参数\n\n**mean** 是正态分布的均值。\n\n**stdev** 是正态分布的标准差。\n\n**count** 是正整数，表示生成的随机数个数。\n\n#### 返回值\n\n长度为 *count* 的 DOUBLE 类型向量。\n\n#### 例子\n\n```\nrandNormal(2.31, 0.671, 2);\n// output\n[2.805524, 2.148019]\n```\n"
    },
    "randomForestClassifier": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/randomForestClassifier.html",
        "signatures": [
            {
                "full": "randomForestClassifier(ds, yColName, xColNames, numClasses, [maxFeatures=0], [numTrees=10], [numBins=32], [maxDepth=32], [minImpurityDecrease=0.0], [numJobs=-1], [randomSeed])",
                "name": "randomForestClassifier",
                "parameters": [
                    {
                        "full": "ds",
                        "name": "ds"
                    },
                    {
                        "full": "yColName",
                        "name": "yColName"
                    },
                    {
                        "full": "xColNames",
                        "name": "xColNames"
                    },
                    {
                        "full": "numClasses",
                        "name": "numClasses"
                    },
                    {
                        "full": "[maxFeatures=0]",
                        "name": "maxFeatures",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[numTrees=10]",
                        "name": "numTrees",
                        "optional": true,
                        "default": "10"
                    },
                    {
                        "full": "[numBins=32]",
                        "name": "numBins",
                        "optional": true,
                        "default": "32"
                    },
                    {
                        "full": "[maxDepth=32]",
                        "name": "maxDepth",
                        "optional": true,
                        "default": "32"
                    },
                    {
                        "full": "[minImpurityDecrease=0.0]",
                        "name": "minImpurityDecrease",
                        "optional": true,
                        "default": "0.0"
                    },
                    {
                        "full": "[numJobs=-1]",
                        "name": "numJobs",
                        "optional": true,
                        "default": "-1"
                    },
                    {
                        "full": "[randomSeed]",
                        "name": "randomSeed",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [randomForestClassifier](https://docs.dolphindb.cn/zh/funcs/r/randomForestClassifier.html)\n\n\n\n#### 语法\n\nrandomForestClassifier(ds, yColName, xColNames, numClasses, \\[maxFeatures=0], \\[numTrees=10], \\[numBins=32], \\[maxDepth=32], \\[minImpurityDecrease=0.0], \\[numJobs=-1], \\[randomSeed])\n\n#### 详情\n\n计算指定数据源中 *yColName* 和 *xColNames* 随机森林分类。\n\n生成的模型可以作为 `predict` 函数的输入\n\n#### 参数\n\n**ds** 是数据源，通常用sqlDS函数生成。\n\n**yColName** 是字符串，表示数据源中作为因变量（所属分类）的列名。\n\n**xColNames** 是字符串标量或向量，表示数据源中作为自变量的列名。\n\n**numClasses** 是正整数，表示分类数目。y 列的取值必须是\\[0, numClasses)之间的整数。\n\n**maxFeatures** 是一个整数或浮点数，表示一次分裂节点选取的特征个数或比例。默认值是0。\n\n* 如果 *maxFeatures* 为正整数，则在一次分裂时选取 *maxFeatures* 个特征。\n\n* 如果 *maxFeatures* =0，则在一次分裂时选取 sqrt(特征列数量) 个特征。\n\n* 如果 *maxFeatures* 是一个0和1之间的浮点数，则在一次分裂时选取 int(特征列数量\\**maxFeatures*) 个特征。\n\n**numTrees** 是正整数，表示森林中树的个数。默认值为10。\n\n**numBins** 是正整数，表示离散化连续特征时的桶数。默认值为32。增加 *numBins* 会使算法考虑更多的分裂结点的决策值，产生更好的分裂结果，但也会提高计算量和通讯量。\n\n**maxDepth** 是正整数，表示树的最大深度。默认值为32。\n\n**minImpurityDecrease** 是浮点数，如果分裂产生的基尼指数纯度减少值大于或等于这个值，结点会继续分裂。\n\n**numJobs** 是一个整数，表示训练时使用的任务数。它是可选参数，默认值为-1，表示训练时使用所有的线程。如果 *numJobs* 小于-1，假如设置的 localExecutor 参数为 n，产生的任务数为 (n+2+numJobs)。实际执行过程中，最多会产生 min(numTrees, n+1)个任务。如果 *ds* 中有数据源位于远程节点，该参数不起作用，只产生一个任务。\n\n**randomSeed** 是随机数生成器使用的种子。\n\n#### 返回值\n\n返回结果是字典，包含以下 key：numClasses, minImpurityDecrease, maxDepth, numBins, numTress, maxFeatures, model, modelName, xColNames。其中 model 是一个元组，保存了训练生成的树；modelName 为 “Random Forest Classifier”。\n\n#### 例子\n\n用模拟数据训练一个随机森林回归模型\n\n```\nt = table(100:0, `cls`x0`x1, [INT,DOUBLE,DOUBLE])\ncls = take(0, 50)\nx0 = norm(-1.0, 1.0, 50)\nx1 = norm(-1.0, 1.0, 50)\ninsert into t values (cls, x0, x1)\ncls = take(1, 50)\nx0 = norm(1.0, 1.0, 50)\nx1 = norm(1.0, 1.0, 50)\ninsert into t values (cls, x0, x1)\n\nmodel = randomForestClassifier(sqlDS(<select * from t>), `cls, `x0`x1, 2);\n```\n\n把模型用于预测\n\n```\npredict(model, t)\n```\n\n加载一个保存的模型\n\n```\nloadModel(\"C:/DolphinDB/data/classifierModel.bin\")\n```\n\n相关函数：[adaBoostRegressor](https://docs.dolphindb.cn/zh/funcs/a/adaBoostRegressor.html), [adaBoostClassifier](https://docs.dolphindb.cn/zh/funcs/a/adaBoostClassifier.html), [randomForestRegressor](https://docs.dolphindb.cn/zh/funcs/r/randomForestRegressor.html)\n"
    },
    "randomForestRegressor": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/randomForestRegressor.html",
        "signatures": [
            {
                "full": "randomForestRegressor(ds, yColName, xColNames, [maxFeatures=0], [numTrees=10], [numBins=32], [maxDepth=32], [minImpurityDecrease=0.0], [numJobs=-1], [randomSeed])",
                "name": "randomForestRegressor",
                "parameters": [
                    {
                        "full": "ds",
                        "name": "ds"
                    },
                    {
                        "full": "yColName",
                        "name": "yColName"
                    },
                    {
                        "full": "xColNames",
                        "name": "xColNames"
                    },
                    {
                        "full": "[maxFeatures=0]",
                        "name": "maxFeatures",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[numTrees=10]",
                        "name": "numTrees",
                        "optional": true,
                        "default": "10"
                    },
                    {
                        "full": "[numBins=32]",
                        "name": "numBins",
                        "optional": true,
                        "default": "32"
                    },
                    {
                        "full": "[maxDepth=32]",
                        "name": "maxDepth",
                        "optional": true,
                        "default": "32"
                    },
                    {
                        "full": "[minImpurityDecrease=0.0]",
                        "name": "minImpurityDecrease",
                        "optional": true,
                        "default": "0.0"
                    },
                    {
                        "full": "[numJobs=-1]",
                        "name": "numJobs",
                        "optional": true,
                        "default": "-1"
                    },
                    {
                        "full": "[randomSeed]",
                        "name": "randomSeed",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [randomForestRegressor](https://docs.dolphindb.cn/zh/funcs/r/randomForestRegressor.html)\n\n\n\n#### 语法\n\nrandomForestRegressor(ds, yColName, xColNames, \\[maxFeatures=0], \\[numTrees=10], \\[numBins=32], \\[maxDepth=32], \\[minImpurityDecrease=0.0], \\[numJobs=-1], \\[randomSeed])\n\n#### 详情\n\n计算指定数据源中 *yColName* 和 *xColNames* 随机森林回归。\n\n生成的模型可以作为 `predict` 函数的输入。\n\n#### 参数\n\n**ds** 是数据源，通常用 `sqlDS` 函数生成。\n\n**yColName** 是字符串，表示数据源中作为因变量的列名\n\n**xColNames** 是字符串标量或向量，表示数据源中作为自变量的列名。\n\n**maxFeatures** 是一个整数或浮点数，表示一次分裂节点选取的特征个数或比例。默认值是0。\n\n* 如果 *maxFeatures* 为正整数，则在一次分裂时选取 *maxFeatures* 个特征。\n\n* 如果 *maxFeatures* =0，则在一次分裂时选取 sqrt(特征列数量) 个特征。\n\n* 如果 *maxFeatures* 是一个0和1之间的浮点数，则在一次分裂时选取 int(特征列数量\\*maxFeatures) 个特征\n\n**numTrees** 是正整数，表示森林中树的个数。默认值为10。\n\n**numBins** 是正整数，表示离散化连续特征时的桶数。默认值为32。增加 *numBins* 会使算法考虑更多的分裂结点的决策值，产生更好的分裂结果，但也会提高计算量和通讯量。\n\n**maxDepth** 是正整数，表示树的最大深度。默认值为32。\n\n**minImpurityDecrease** 是浮点数，如果分裂产生的纯度减少值大于或等于这个值，结点会继续分裂。纯度用方差来计算。默认值是0。\n\n**numJobs** 是一个整数，表示训练时使用的任务数。它是可选参数，默认值为-1，表示训练时使用所有的线程。如果 *numJobs* 小于-1，假如设置的 localExecutor 参数为 n，产生的任务数为 (n+2+numJobs)。实际执行过程中，最多会产生 min(numTrees, n+1) 个任务。如果 *ds* 中有数据源位于远程节点，该参数不起作用，只产生一个任务。\n\n**randomSeed** 是随机数生成器使用的种子。\n\n#### 返回值\n\n返回结果是字典，包含以下 key：minImpurityDecrease, maxDepth, numBins, numTress, maxFeatures, model, modelName, xColNames。其中 model 是一个元组，保存了训练生成的树；modelName 为 “Random Forest Regressor”。\n\n#### 例子\n\n用模拟数据训练一个随机森林回归模型\n\n```\nx1 = rand(100.0, 100)\nx2 = rand(100.0, 100)\nb0 = 6\nb1 = 1\nb2 = -2\nerr = norm(0, 10, 100)\ny = b0 + b1 * x1 + b2 * x2 + err\nt = table(x1, x2, y)\nmodel = randomForestRegressor(sqlDS(<select * from t>), `y, `x1`x2)\nyhat=predict(model, t);\n\nplot(y, yhat, ,SCATTER);\n```\n\n保存模型到磁盘\n\n```\nsaveModel(model, \"C:/DolphinDB/Data/regressionModel.bin\")\n```\n\n加载一个保存的模型\n\n```\nloadModel(\"C:/DolphinDB/Data/regressionModel.bin\")\n```\n\n相关函数：[adaBoostClassifier](https://docs.dolphindb.cn/zh/funcs/a/adaBoostClassifier.html),[randomForestClassifier](https://docs.dolphindb.cn/zh/funcs/r/randomForestClassifier.html)\n"
    },
    "randPoisson": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/randPoisson.html",
        "signatures": [
            {
                "full": "randPoisson(mean, count)",
                "name": "randPoisson",
                "parameters": [
                    {
                        "full": "mean",
                        "name": "mean"
                    },
                    {
                        "full": "count",
                        "name": "count"
                    }
                ]
            }
        ],
        "markdown": "### [randPoisson](https://docs.dolphindb.cn/zh/funcs/r/randPoisson.html)\n\n\n\n#### 语法\n\nrandPoisson(mean, count)\n\n#### 详情\n\n生成指定个数的泊松分布随机数。\n\n#### 参数\n\n**mean** 是泊松分布的均值。\n\n**count** 是正整数，表示生成的随机数个数。\n\n#### 返回值\n\n长度为 *count* 的 DOUBLE 类型向量。\n\n#### 例子\n\n```\nrandPoisson(2.31, 2);\n// output\n[7, 2]\n```\n"
    },
    "randStudent": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/randStudent.html",
        "signatures": [
            {
                "full": "randStudent(df, count)",
                "name": "randStudent",
                "parameters": [
                    {
                        "full": "df",
                        "name": "df"
                    },
                    {
                        "full": "count",
                        "name": "count"
                    }
                ]
            }
        ],
        "markdown": "### [randStudent](https://docs.dolphindb.cn/zh/funcs/r/randStudent.html)\n\n\n\n#### 语法\n\nrandStudent(df, count)\n\n#### 详情\n\n生成指定个数的 t 分布随机数。\n\n#### 参数\n\n**df** 是正数，表示t分布的自由度。\n\n**count** 是正整数，表示生成的随机数个数。\n\n#### 返回值\n\n长度为 *count* 的 DOUBLE 类型向量。\n\n#### 例子\n\n```\nrandStudent(2.31, 2);\n\n// output\n[-0.543993, 0.375804]\n```\n"
    },
    "randUniform": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/randUniform.html",
        "signatures": [
            {
                "full": "randUniform(lower, upper, count)",
                "name": "randUniform",
                "parameters": [
                    {
                        "full": "lower",
                        "name": "lower"
                    },
                    {
                        "full": "upper",
                        "name": "upper"
                    },
                    {
                        "full": "count",
                        "name": "count"
                    }
                ]
            }
        ],
        "markdown": "### [randUniform](https://docs.dolphindb.cn/zh/funcs/r/randUniform.html)\n\n\n\n#### 语法\n\nrandUniform(lower, upper, count)\n\n#### 详情\n\n生成指定个数的均匀分布随机数。\n\n#### 参数\n\n**lower** 和 **upper** 是数值型标量，表示连续均匀分布的下限和上限。\n\n**count** 是正整数，表示生成的随机数个数。\n\n#### 返回值\n\n长度为 *count* 的 DOUBLE 类型向量。\n\n#### 例子\n\n```\nrandUniform(0.61, 2.31, 2);\n\n// output\n[2.064851, 2.263172]\n```\n"
    },
    "randWeibull": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/randWeibull.html",
        "signatures": [
            {
                "full": "randWeibull(alpha, beta, count)",
                "name": "randWeibull",
                "parameters": [
                    {
                        "full": "alpha",
                        "name": "alpha"
                    },
                    {
                        "full": "beta",
                        "name": "beta"
                    },
                    {
                        "full": "count",
                        "name": "count"
                    }
                ]
            }
        ],
        "markdown": "### [randWeibull](https://docs.dolphindb.cn/zh/funcs/r/randWeibull.html)\n\n\n\n#### 语法\n\nrandWeibull(alpha, beta, count)\n\n#### 详情\n\n生成指定个数的 Weibull 分布随机数。\n\n#### 参数\n\n形状参数 **alpha** 和 **beta** 都是正数。\n\n**count** 是正整数，表示生成的随机数个数。\n\n#### 返回值\n\n长度为 *count* 的 DOUBLE 类型向量。\n\n#### 例子\n\n```\nrandWeibull(2.31,0.61, 2);\n\n// output\n[0.524197, 0.51402]\n```\n"
    },
    "rank": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rank.html",
        "signatures": [
            {
                "full": "rank(X, [ascending=true], [groupNum], [ignoreNA=true], [tiesMethod='min'], [percent=false], [precision])",
                "name": "rank",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[groupNum]",
                        "name": "groupNum",
                        "optional": true
                    },
                    {
                        "full": "[ignoreNA=true]",
                        "name": "ignoreNA",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[tiesMethod='min']",
                        "name": "tiesMethod",
                        "optional": true,
                        "default": "'min'"
                    },
                    {
                        "full": "[percent=false]",
                        "name": "percent",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[precision]",
                        "name": "precision",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [rank](https://docs.dolphindb.cn/zh/funcs/r/rank.html)\n\n\n\n#### 语法\n\nrank(X, \\[ascending=true], \\[groupNum], \\[ignoreNA=true], \\[tiesMethod='min'], \\[percent=false], \\[precision])\n\n#### 详情\n\n基于 *ascending* 指定的排序顺序，返回 *X* 中每个元素的排名（从0开始排序）。\n\n* 若 *X* 是向量，返回一个与*X*等长的向量：\n  * 如果指定了 *groupNum*，则将排序后的 *X* 分成 *groupNum* 个组。返回 *X* 中每个元素对应的组编号（从0开始编号）。\n\n    **Note:**\n\n    * 若 *X*不能被均分，则前 mod(size(X), groupNum) 组将多存放一个元素。例如 *X* 的元素个数为6，*groupNum* = 4，排名后的第1和2个元素属于组0，第3和4个元素属于组1，第5个和第6个元素分别属于组2和组3。\n    * 若 *X* 中相同元素分别属于不同的组，则所有相同元素返回最小的组号。\n  * 如果 *ignoreNA* = true，则 NULL 值不参与排序，结果中 NULL 值的排名为空。\n\n* 若 *X* 是矩阵或表，在每列内进行上述计算，返回一个与 *X* 维度相同的矩阵或表。\n\n* 若 *X* 是字典，则按字典的值进行排序，并返回各元素的排名。\n\n#### 参数\n\n**X** 是一个向量、矩阵、表或字典。\n\n**ascending** 是一个布尔值，表示是否按升序排序。默认值是 true。\n\n**groupNum** 是一个正整数，指定该参数后，元素将分成指定数量的组，按组进行排序。\n\n**ignoreNA** 是一个布尔值，表示是否忽略 NULL 值，默认值为 true。false 表示 NULL 作为最小值参与排名。\n\n**tiesMethod** 是一个字符串，表示如何对具有相同值的元素进行排名。\n\n* 'min' 表示取最小排名。\n\n* 'max' 表示取最大排名。\n\n* 'average' 表示取排名的均值。\n\n* 'first' 表示按照原数据的顺序排名。\n\n**percent** 是一个布尔值，表示是否以百分比形式显示返回的排名。\n\n**precision** 是一个 \\[1, 15] 范围内的整数，用于设置参与排序的值的精度。若两个值之差的绝对值小于等于 10^(-precision) ，则认为两值相等。\n\n**Note:** 指定 *precision* 参数后，*X* 只能是数值型对象。且 *tiesMethod* 不能指定为 'first'。\n\n#### 返回值\n\nINT 类型的向量。\n\n#### 例子\n\n例 1. 基础排名（升序/降序）\n\n```\nrank(45 16 32 21);\n// output: [3,0,2,1]\n\nrank(45 16 32 21, false);\n// output: [0,3,1,2]\n\nrank(dict(`a`b`c, [4, 1, 2],true))\n// output: [2, 0, 1]\n```\n\n对于浮点数，可通过参数 *precision* 设置数值比较的精度。当两个值的差的绝对值小于等于 10^(-precision) 时，认为这两个值相等。下例中，设置 `precision=6` 后，1.0000001，1.0000002，1.0000003 被视为相等（都得到排名 0），2.0001 和 2.0002 不相等。\n\n```\nrank(1.0000001 1.0000002 1.0000003 2.0001 2.0002)\n// output: [0,1,2,3,4]  \nrank(1.0000001 1.0000002 1.0000003 2.0001 2.0002, precision=6);  \n// output: [0,0,0,3,4]\n```\n\n例 2. 通过 *tiesMethod* 参数处理重复值。\n\n```\n// 两个相同的元素有相同的排名\nrank(9 1 6 1 3 3);\n// output: [5,0,4,0,2,2]\n\nrank(X=1 2 2 3, tiesMethod='min');\n// output: [0,1,1,3]\n\nrank(X=1 2 2 3, tiesMethod='average');\n// output: [0,1.5,1.5,3]\n\nrank(X=1 2 2 3, tiesMethod='first');\n// output: [0,1,2,3]\n```\n\n例 3. 指定 *groupNum* 参数，进行分组排序。\n\n**说明**：将排序后的元素分成指定数量的组，返回每个元素所属的组编号（从0开始）。如果元素不能被均分，前面的组会多一个元素。相同元素会返回最小的组号。\n\n```\nrank(X=9 5 4 8 1 3 6 2 7, groupNum=3);\n// output: [2,1,1,2,0,0,1,0,2]\n\nrank(X=9 5 4 8 1 3 6 2 7, groupNum=6)\n// output: [5,2,1,4,0,1,2,0,3]\n\nrank(X=9 5 4 8 1 3 6 2 7, ascending=false, groupNum=3);\n// output: [0,1,1,0,2,2,1,2,0]\n```\n\n例 4. 指定 *ignoreNA* 参数，处理 NULL 值。\n\n```\nrank(1 NULL NULL 3);\n// output: [0,,,1]\n\nrank(X=1 NULL NULL 3, ignoreNA=false);\n// output: [2,0,0,3]\n```\n\n例 5. 指定参数 *percent*=true，以百分比的形式返回排名。\n\n```\nrank(45 16 32 21);  \n// output: [3,0,2,1]  \n  \nrank(45 16 32 21, percent=true);  \n// output: [1,0.25,0.75,0.5]\n```\n\n例 6. 在 SQL 查询中使用 `rank` 函数，配合 `context by` 子句对分组数据进行排名。\n\n```\nt=table(1 1 1 2 2 2 2 as id, 3 5 4 6 2 7 1 as x)\nt\n```\n\n| id | x |\n| -- | - |\n| 1  | 3 |\n| 1  | 5 |\n| 1  | 4 |\n| 2  | 6 |\n| 2  | 2 |\n| 2  | 7 |\n| 2  | 1 |\n\n```\nselect *, rank(x) from t context by id;\n```\n\n| id | x | rank\\_x |\n| -- | - | ------- |\n| 1  | 3 | 0       |\n| 1  | 5 | 2       |\n| 1  | 4 | 1       |\n| 2  | 6 | 2       |\n| 2  | 2 | 1       |\n| 2  | 7 | 3       |\n| 2  | 1 | 0       |\n"
    },
    "ratio": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/ratio.html",
        "signatures": [
            {
                "full": "ratio(X, Y)",
                "name": "ratio",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [ratio](https://docs.dolphindb.cn/zh/funcs/r/ratio.html)\n\n\n\n#### 语法\n\nratio(X, Y)\n\n或\n\nX\\Y\n\n#### 详情\n\n逐个元素地返回 *X* 和 *Y* 的比例。ratio函数总是返回浮点数。如果 *X* 和 *Y* 都是 integer/long 类型，`ratio` 把它们转换为浮点数，并执行除法。 这和除法运算符 [div](https://docs.dolphindb.cn/zh/funcs/d/div.html) (/)不同，除法运算符不把 integer/long 类型转换成浮点数。另一个不同点是，当 *X* 参数是整数时，该函数的 *Y* 参数可以是负整数。\n\n#### 参数\n\n**X** 和 **Y** 可以是标量、数据对、向量或矩阵。\n\n如果 *X* 或 *Y* 的其中一个是数据对、向量或矩阵，另一个必须是具有相同长度的数据对、向量或矩阵。\n\n#### 返回值\n\nDOUBLE 类型的标量、数据对、向量或矩阵。\n\n#### 例子\n\n```\n9\\2:5;\n// output\n4.5 : 1.8\n11:25\\3:4;\n// output\n3.666667 : 6.25\n\nx=1 2 3;\nx \\ 2;\n// output\n[0.5,1,1.5]\n2 \\ x;\n// output\n[2,1,0.666667]\n\ny=4 5 6;\n x \\ y;\n// output\n[0.25,0.4,0.5]\ny \\ x;\n// output\n[4,2.5,2]\n\nm1=1..6$2:3;\nm1\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1  | 3  | 5  |\n| 2  | 4  | 6  |\n\n```\n m1\\2;\n```\n\n| #0  | #1  | #2  |\n| --- | --- | --- |\n| 0.5 | 1.5 | 2.5 |\n| 1   | 2   | 3   |\n\n```\nm2=6..1$2:3;\nm2\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 6  | 4  | 2  |\n| 5  | 3  | 1  |\n\n```\nm1\\m2;\n```\n\n| #0       | #1       | #2  |\n| -------- | -------- | --- |\n| 0.166667 | 0.75     | 2.5 |\n| 0.4      | 1.333333 | 6   |\n\n```\n-7\\5;\n// output\n-1.4\nx=-1 2 3;\nx\\-5;\n// output\n[0.2,-0.4,-0.6]\n```\n"
    },
    "ratios": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/ratios.html",
        "signatures": [
            {
                "full": "ratios(X)",
                "name": "ratios",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [ratios](https://docs.dolphindb.cn/zh/funcs/r/ratios.html)\n\n\n\n#### 语法\n\nratios(X)\n\n#### 详情\n\n若 *X* 是向量，返回 X(n)\\X(n-1) 的值。返回结果的第一个元素是 NULL。\n\n若 *X* 是矩阵，在每列内进行上述计算，返回一个与 *X* 维度相同的矩阵。\n\n#### 参数\n\n**X** 是一个向量或矩阵。\n\n#### 返回值\n\n数据类型和形式与 *X* 相同。\n\n#### 例子\n\n```\nx=3 12 0 -5 32;\nratios x;\n// output\n[,4,0,,-6.4]\n\nx=2 3 6 NULL 28 7;\nratios x;\n// output\n[,1.5,2,,,0.25]\n\nm=matrix(100 105 109 112 108 116, 200 212 208 199 206 210);\nm;\n```\n\n| #0  | #1  |\n| --- | --- |\n| 100 | 200 |\n| 105 | 212 |\n| 109 | 208 |\n| 112 | 199 |\n| 108 | 206 |\n| 116 | 210 |\n\n```\nratios(m);\n```\n\n| #0                | #1                |\n| ----------------- | ----------------- |\n|                   |                   |\n| 1.05              | 1.06              |\n| 1.038095238095238 | 0.981132075471698 |\n| 1.027522935779817 | 0.956730769230769 |\n| 0.964285714285714 | 1.035175879396985 |\n| 1.074074074074074 | 1.019417475728155 |\n"
    },
    "rdp": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rdp.html",
        "signatures": [
            {
                "full": "rdp(pointList, epsilon)",
                "name": "rdp",
                "parameters": [
                    {
                        "full": "pointList",
                        "name": "pointList"
                    },
                    {
                        "full": "epsilon",
                        "name": "epsilon"
                    }
                ]
            }
        ],
        "markdown": "### [rdp](https://docs.dolphindb.cn/zh/funcs/r/rdp.html)\n\n\n\n#### 语法\n\nrdp(pointList, epsilon)\n\n#### 详情\n\n使用 RDP(Ramer-Douglas-Peucker) 矢量压缩算法对 POINT 类型向量进行压缩。\n\n#### 参数\n\n**pointList** 是一个 POINT 类型向量，且不能包含空元素。\n\n**epsilon** 是一个非负的 DOUBLE 类型的标量，表示压缩阈值。\n\n#### 返回值\n\nPOINT 类型向量。\n\n#### 例子\n\n```\npt = point(1 2 3 4, 1 2 3 4)\nrdp(pt, 0.1)\n// output\n[(1.0, 1.0), (4.0, 4.0)]\n​\npt = point(1 2 3 4, 1 3 3 4)\nrdp(pt, 0.1)\n// output\n[(1.0, 1.0), (2.0, 3.0), (3.0, 3.0), (4.0, 4.0)]\n\ntemp = array(POINT,0)\nn=90000\nx_data = rand(10.0,n)\ny_data = rand(10.0,n)\nindex=0\ndo{\ntemp.append!(point(x_data[index], y_data[index]))\nindex += 1\n}while(index<n)\ns=rdp(temp, 0.8)\nprint(s.size())\n// output\n82002\nprint(temp.size())\n// output\n90000\n```\n"
    },
    "readBytes": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/readBytes.html",
        "signatures": [
            {
                "full": "readBytes(fileHandle, sizeInByte)",
                "name": "readBytes",
                "parameters": [
                    {
                        "full": "fileHandle",
                        "name": "fileHandle"
                    },
                    {
                        "full": "sizeInByte",
                        "name": "sizeInByte"
                    }
                ]
            }
        ],
        "markdown": "### [readBytes](https://docs.dolphindb.cn/zh/funcs/r/readBytes.html)\n\n\n\n#### 语法\n\nreadBytes(fileHandle, sizeInByte)\n\n#### 详情\n\n从句柄中读取给定数目的字节。如果文件到达结尾，或发生了 IO 错误，将抛出一个 IOException；否则返回一个包含了给定数目字节的缓冲区。因此，必须在调用函数之前知道要读取的确切的字节数。\n\n#### 参数\n\n**fileHandle** 是文件句柄。\n\n**sizeInByte** 是整数，用于指定读取的字节数。\n\n#### 返回值\n\n返回一个包含了给定数目字节的缓冲区。\n\n#### 例子\n\n```\n// 定义一个文件复制函数\ndef fileCopy(source, target){\ns = file(source)\nlen = s.seek(0,TAIL)\ns.seek(0,HEAD)\nt = file(target,\"w\")\nif(len==0) return\ndo{\n  buf = s.readBytes(min(len,1024))\n  t.writeBytes(buf)\n  len -= buf.size()\n}while(len)\n};\nfileCopy(\"test.txt\",\"testcopy.txt\");\n```\n"
    },
    "readLine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/readLine.html",
        "signatures": [
            {
                "full": "readLine(handle)",
                "name": "readLine",
                "parameters": [
                    {
                        "full": "handle",
                        "name": "handle"
                    }
                ]
            }
        ],
        "markdown": "### [readLine](https://docs.dolphindb.cn/zh/funcs/r/readLine.html)\n\n\n\n#### 语法\n\nreadLine(handle)\n\n#### 详情\n\n从给定的文件中读取一行。\n\n#### 参数\n\n**handle** 是文件句柄。\n\n#### 返回值\n\n返回的行不包括换行符。如果文件结束，函数会返回一个 NULL 对象，可以用 [isVoid](https://docs.dolphindb.cn/zh/funcs/i/isVoid.html) 函数测试。\n\n#### 例子\n\n```\nx=`IBM`MSFT`GOOG`YHOO`ORCL;\neachRight(writeLine, file(\"test.txt\",\"w\"), x);\n\n// output\n[1,1,1,1,1]\n\nfin = file(\"test.txt\")\ndo{\nx=fin.readLine()\nif(x.isVoid()) break\nprint x\n}while(true);\n\n// output\nIBM\nMSFT\nGOOG\nYHOO\nORCL\n```\n"
    },
    "readLines": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/readLines.html",
        "signatures": [
            {
                "full": "readLines(handle, [length=1024])",
                "name": "readLines",
                "parameters": [
                    {
                        "full": "handle",
                        "name": "handle"
                    },
                    {
                        "full": "[length=1024]",
                        "name": "length",
                        "optional": true,
                        "default": "1024"
                    }
                ]
            }
        ],
        "markdown": "### [readLines](https://docs.dolphindb.cn/zh/funcs/r/readLines.html)\n\n\n\n#### 语法\n\nreadLines(handle, \\[length=1024])\n\n#### 详情\n\n从文件中读取指定行数。如果到达文件尾部或者已经读取指定行数后，函数将返回。\n\n#### 参数\n\n**handle** 是文件句柄。\n\n**length** 是从文件中读取的行数。默认的读取行数是1024。\n\n#### 返回值\n\nSTRING 类型向量。\n\n#### 例子\n\n```\n timer(10){\n x=rand(`IBM`MSFT`GOOG`YHOO`ORCL,10240)\n eachRight(writeLine, file(\"test.txt\",\"w\"),x)\n fin = file(\"test.txt\")\n do{\n    y=fin.readLine()\n } while(!y.isVoid())\n fin.close()\n };\n// output\nTime elapsed: 277.548 ms ms\n\n timer(10){\n x=rand(`IBM`MSFT`GOOG`YHOO`ORCL,10240)\n file(\"test.txt\",\"w\").writeLines(x)\n fin = file(\"test.txt\")\n do{\n    y=fin.readLines(1024)\n } while(y.size()==1024)\n  fin.close()\n };\n// output\nTime elapsed: 28.003 ms\n```\n"
    },
    "readLines!": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/readLines_.html",
        "signatures": [
            {
                "full": "readLines!(handle, holder, [offset=0], [length=1])",
                "name": "readLines!",
                "parameters": [
                    {
                        "full": "handle",
                        "name": "handle"
                    },
                    {
                        "full": "holder",
                        "name": "holder"
                    },
                    {
                        "full": "[offset=0]",
                        "name": "offset",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[length=1]",
                        "name": "length",
                        "optional": true,
                        "default": "1"
                    }
                ]
            }
        ],
        "markdown": "### [readLines!](https://docs.dolphindb.cn/zh/funcs/r/readLines_.html)\n\n\n\n#### 语法\n\nreadLines!(handle, holder, \\[offset=0], \\[length=1])\n\n#### 详情\n\n从句柄中读取给定数量的字符串，并从指定位置开始，把读取结果保存至 *holder* 表示的变量中。\n\n[readLines](https://docs.dolphindb.cn/zh/funcs/r/readLines.html) 函数的每次调用都创建了一个字符串向量并返回。创建字符串向量需要一定的时间开销，所以如果在重复执行函数调用时，能重用相同的向量作为缓冲区的话，可以节约时间。 `readLines!`函数接受已存在的缓冲区作为数据容器。\n\n下述的两个例子读取相同数量的数据 100 次，结果显示：`readLines!` 函数比 `readLines` 函数更快。\n\n#### 参数\n\n**handle** 是文件句柄。\n\n**holder** 是用于保存读取的数据的变量。\n\n**offset** 表示数据保存至holder的起始位置。\n\n**length** 是从文件中读取的行数。\n\n#### 返回值\n\n返回实际读取的行数。\n\n#### 例子\n\n```\n timer(100){\n fin = file(\"test.txt\")\n do{ y=fin.readLines(1024) } while(y.size()==1024)\n fin.close()\n };\n// output\nTime elapsed: 79.511 ms\n\n timer(100){\n fin = file(\"test.txt\")\n y=array(STRING,1024)\n do{ lines = fin.readLines!(y,0,1024) } while(lines==1024)\n fin.close()\n };\n\n// output\nTime elapsed: 56.034 ms\n```\n"
    },
    "readObject": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/readObject.html",
        "signatures": [
            {
                "full": "readObject(handle)",
                "name": "readObject",
                "parameters": [
                    {
                        "full": "handle",
                        "name": "handle"
                    }
                ]
            }
        ],
        "markdown": "### [readObject](https://docs.dolphindb.cn/zh/funcs/r/readObject.html)\n\n\n\n#### 语法\n\nreadObject(handle)\n\n#### 详情\n\n可以读取句柄中所有的数据类型，包括标量、向量、矩阵、集合、字典和表。该函数必须要用户登录后才能执行。\n\n#### 参数\n\n**handle** 是文件句柄。\n\n#### 返回值\n\n返回读取的内容。\n\n#### 例子\n\n```\na1=10.5\na2=1..10\na3=cross(*,1..5,1..10)\na4=set(`IBM`MSFT`GOOG`YHOO)\na5=dict(a4.keys(),125.6 53.2 702.3 39.7)\na6=table(1 2 3 as id, `Jenny`Tom`Jack as name)\na7=(1 2 3, \"hello world!\", 25.6)\n\nfout=file(\"test.bin\",\"w\")\nfout.writeObject(a1)\nfout.writeObject(a2)\nfout.writeObject(a3)\nfout.writeObject(a4)\nfout.writeObject(a5)\nfout.writeObject(a6)\nfout.writeObject(a7)\nfout.close();\n```\n\n上述的脚本把 7 个不同类型的对象写到一个文件中。下述的脚本将这 7 个对象从文件中读取出来，并为每个对象打印一个简短的描述。\n\n```\nfin = file(\"test.bin\")\nfor(i in 0:7) print typestr fin.readObject()\nfin.close();\n\n// output\nDOUBLE\nFAST INT VECTOR\nINT MATRIX\nSTRING SET\nSTRING->DOUBLE Dictionary\nTABLE\nANY VECTOR\n```\n"
    },
    "readRecord!": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/readRecord_.html",
        "signatures": [
            {
                "full": "readRecord!(handle, holder, [offset=0], [length])",
                "name": "readRecord!",
                "parameters": [
                    {
                        "full": "handle",
                        "name": "handle"
                    },
                    {
                        "full": "holder",
                        "name": "holder"
                    },
                    {
                        "full": "[offset=0]",
                        "name": "offset",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[length]",
                        "name": "length",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [readRecord!](https://docs.dolphindb.cn/zh/funcs/r/readRecord_.html)\n\n\n\n#### 语法\n\nreadRecord!(handle, holder, \\[offset=0], \\[length])\n\n#### 详情\n\n`readRecord!` 函数将二进制文件转换为 DolphinDB 数据对象。DolphinDB 也提供了 [writeRecord](https://docs.dolphindb.cn/zh/funcs/w/writeRecord.html) 函数，用于将 DolphinDB 数据对象转换为二进制文件，以供其它程序使用。 二进制文件基于行，且每行包含的记录有相同的数据类型和固定的长度。例如，如果一个二进制文件包含了 5 个数据域，分别具有下述数据类型（长度）：char(1), boolean(1), short(2), int(4), long(8), 和 double(8)， 那么 `readRecord!` 函数将把每行视为 24 个字节。类似地，`writeRecord` 函数把 DolphinDB 对象（例如表或元组）转换为具有上述格式的二进制文件。\n\n#### 参数\n\n**handle** 是文件句柄。\n\n**holder** 是用于保存读取的数据的变量。\n\n**offset** 表示数据保存至 *holder* 的起始位置。\n\n**length** 是从文件中读取的行数。\n\n#### 返回值\n\n返回读取的行数。\n\n#### 例子\n\n```\n// 创建一个文件句柄，用于读取记录。二进制文件 a.bin 包含了 1000 条记录。\nf=file(\"c:/DB/a.bin\")\nt=table(1000:0, `PERMNO`PRC`VOL`SHROUT, `int`double`int`double)\nf.readRecord!(t);\n// output\n1000\n\n// 类似地，我们可以将一个二进制文件读入一个 DolphinDB 元组对象\nf=file(\"c:/DB/a.bin\")\nt=loop(array, [int, double, int, double], 0, 500)\n// 创建具有 4 个数组元素的元组 t。每一个数组的长度是 500\n f.readRecord!(t, 0, 500);\n// 读取前 500 行\n// output\n500\n```\n"
    },
    "read!": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/read_.html",
        "signatures": [
            {
                "full": "read!(handle, holder, [offset=0], [length=1])",
                "name": "read!",
                "parameters": [
                    {
                        "full": "handle",
                        "name": "handle"
                    },
                    {
                        "full": "holder",
                        "name": "holder"
                    },
                    {
                        "full": "[offset=0]",
                        "name": "offset",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[length=1]",
                        "name": "length",
                        "optional": true,
                        "default": "1"
                    }
                ]
            }
        ],
        "markdown": "### [read!](https://docs.dolphindb.cn/zh/funcs/r/read_.html)\n\n\n\n#### 语法\n\nread!(handle, holder, \\[offset=0], \\[length=1])\n\n#### 详情\n\n从文件句柄中读取指定数目的数据点，并从指定位置开始，把读取结果保存至 *holder* 表示的变量中。读入的数据和 *holder* 具有相同的数据类型。\n\n[readBytes](https://docs.dolphindb.cn/zh/funcs/r/readBytes.html) 函数总是返回一个新的 CHAR 向量。创建一个新的向量缓冲区时会花费一定时间。为了提高性能，可以创建一个缓冲区，并重复利用。`read!`函数就是使用这样的方式提高速度。\n\n使用 `read!` 的另一个好处是，用户不需要知道确切的读取字节数。函数在文件到达结尾时返回，并给出读取的字节数。如果返回的字节数小于预期，表明文件已经到达结尾。\n\n#### 参数\n\n**handle** 是文件句柄。\n\n**holder** 是用于保存读取的数据的变量。\n\n**offset** 表示数据保存至 *holder* 的起始位置。\n\n**length** 是读取的数据点数量。\n\n#### 返回值\n\n返回实际读入的数据点的个数。\n\n#### 例子\n\n```\n// 用 read! 和 write 函数定义一个复制函数\n\ndef fileCopy(source, target){\ns = file(source)\nt = file(target,\"w\")\nbuf = array(CHAR,1024)\ndo{\n  numByte = s.read!(buf,0,1024)\n  t.write(buf,0, numByte)\n}while(numByte==1024)\n}\nfileCopy(\"test.txt\",\"testcopy.txt\");\n```\n"
    },
    "rebalanceChunksAmongDataNodes": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rebalanceChunksAmongDataNodes.html",
        "signatures": [
            {
                "full": "rebalanceChunksAmongDataNodes([exec = false], [updatedBeforeDays = 7.0])",
                "name": "rebalanceChunksAmongDataNodes",
                "parameters": [
                    {
                        "full": "[exec = false]",
                        "name": "[exec = false]"
                    },
                    {
                        "full": "[updatedBeforeDays = 7.0]",
                        "name": "[updatedBeforeDays = 7.0]"
                    }
                ]
            }
        ],
        "markdown": "### [rebalanceChunksAmongDataNodes](https://docs.dolphindb.cn/zh/funcs/r/rebalanceChunksAmongDataNodes.html)\n\n\n\n#### 语法\n\nrebalanceChunksAmongDataNodes(\\[exec = false], \\[updatedBeforeDays = 7.0])\n\n#### 详情\n\n在集群中的所有磁盘间平衡数据，以保证集群达到最佳性能。在集群中增加节点、磁盘后，或者在磁盘负载过高时，通常需要执行此操作。只能由管理员在控制节点上执行。\n\n调用该函数后，可以在控制节点上执行 [getRecoveryTaskStatus](https://docs.dolphindb.cn/zh/funcs/g/getRecoveryTaskStatus.html) 查看任务执行的状态。\n\n调用该函数后，系统会打印 INFO 级别的日志，输出每个磁盘的原始使用率以及平衡后的使用率。日志内容的格式如下：\n\n```\n[rebalance] Expected change of disk usage rate is 原本占有率->搬运后占有率\n[rebalance] Change of disk usage rate in 磁盘所在IP@磁盘fsid(1/磁盘数) is 原本占有率->搬运后占有率\n[rebalance] Change of disk usage rate in 磁盘所在IP@磁盘fsid(2/磁盘数) is 原本占有率->搬运后占有率\n...\n```\n\n#### 参数\n\n**exec** 布尔值，表示是否进行数据平衡。默认值为 false，表示输出数据平衡的执行计划，并不执行数据迁移。若设置为 true，则系统会执行数据迁移。\n\n**updatedBeforeDays** 非负浮点数，用于确定可以进行平衡的数据的时间范围，默认值是7，单位是天。表示数据块（chunk）的最后一次写入或更新（修改）时间发生在7天前时，才会进行平衡。\n\n#### 返回值\n\n返回一个表，包含以下列：\n\n| 列名         | 含义          |\n| ---------- | ----------- |\n| srcNode    | 源节点的别名      |\n| chunkId    | chunk 的唯一标识 |\n| destNode   | 目标节点的别名     |\n| destVolume | 目标磁盘卷的路径    |\n\n#### 例子\n\n```\nrebalanceChunksAmongDataNodes()\n```\n\n| srcNode | chunkId                              | destNode | destVolume              |\n| ------- | ------------------------------------ | -------- | ----------------------- |\n| node1   | 99279094-ca12-3b87-48b6-520cbb986f39 | node2    | /home/xxx/node2/storage |\n| node1   | 45f612b8-42f5-aebd-4cef-e522b6ae1fc8 | node2    | /home/xxx/node2/storage |\n"
    },
    "rebalanceChunksWithinDataNode": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rebalanceChunksWithinDataNode.html",
        "signatures": [
            {
                "full": "rebalanceChunksWithinDataNode(nodeAlias, [exec=false], [updatedBeforeDays = 7.0])",
                "name": "rebalanceChunksWithinDataNode",
                "parameters": [
                    {
                        "full": "nodeAlias",
                        "name": "nodeAlias"
                    },
                    {
                        "full": "[exec=false]",
                        "name": "exec",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[updatedBeforeDays = 7.0]",
                        "name": "[updatedBeforeDays = 7.0]"
                    }
                ]
            }
        ],
        "markdown": "### [rebalanceChunksWithinDataNode](https://docs.dolphindb.cn/zh/funcs/r/rebalanceChunksWithinDataNode.html)\n\n\n\n#### 语法\n\nrebalanceChunksWithinDataNode(nodeAlias, \\[exec=false], \\[updatedBeforeDays = 7.0])\n\n#### 详情\n\n一个节点内部增加磁盘卷后，需要调整现有磁盘卷上的数据量，使各个磁盘卷上的数据量达到平衡。该函数用于平衡一个数据节点内各磁盘卷间的数据，返回一个表，显示各磁盘卷间数据平衡计划。 若 *exec* 为 true，则进行数据平衡；若 *exec* 为 false，则不进行数据平衡。它只能在集群环境下由管理员在控制节点上执行。\n\n调用该函数进行数据平衡后，可以在控制节点上执行 [getRecoveryTaskStatus](https://docs.dolphindb.cn/zh/funcs/g/getRecoveryTaskStatus.html) 查看任务执行的状态。\n\n**Note:** 自 2.00.12 版本起，rebalanceChunksWithinDataNode 支持单节点模式。\n\n调用该函数后，系统会打印 INFO 级别的日志，输出每个磁盘的原始使用率以及平衡后的使用率。日志内容的格式如下：\n\n```\n[rebalance] Change of disk usage rate () expect: 原本占有率 -> 搬运后占有率\n[rebalance] Change of disk usage rate (1 / 磁盘数) 磁盘所在IP@磁盘fsid: 原本占有率 -> 搬运后占有率\n[rebalance] Change of disk usage rate (2 / 磁盘数) 磁盘所在IP@磁盘fsid: 原本占有率 -> 搬运后占有率\n...\n```\n\n#### 参数\n\n**nodeAlias** 字符串，表示数据节点的别名。\n\n**exec** 布尔值，表示是否在节点内进行数据平衡。默认值为 false，输出数据平衡的执行计划，并不执行数据迁移。若设置为 true，则系统会执行数据迁移。\n\n**updatedBeforeDays** 非负浮点数，用于确定可以进行平衡的数据的时间范围，默认值是7，单位是天。表示数据块（chunk）的最后一次写入或更新（修改）时间发生在7天前时，才会进行平衡。\n\n#### 返回值\n\n返回一个表，显示各磁盘卷间数据平衡计划，包含以下列：\n\n| 列名         | 含义          |\n| ---------- | ----------- |\n| chunkId    | chunk 的唯一标识 |\n| srcVolume  | 源磁盘卷        |\n| destVolume | 目标磁盘卷       |\n\n#### 例子\n\n```\nrebalanceChunksWithinDataNode(\"node1\")\n```\n\n| ChunkId                              | srcVolume         | destVolume        |\n| ------------------------------------ | ----------------- | ----------------- |\n| 82c6eb6c-36ee-b1b6-4a86-ca24d9faaa25 | /hdd/hdd1/volumes | /hdd/hdd2/volumes |\n"
    },
    "reciprocal": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/reciprocal.html",
        "signatures": [
            {
                "full": "reciprocal(X)",
                "name": "reciprocal",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [reciprocal](https://docs.dolphindb.cn/zh/funcs/r/reciprocal.html)\n\n\n\n#### 语法\n\nreciprocal(X)\n\n#### 详情\n\n返回 *X* 的倒数。\n\nDolphinDB 的 `reciprocal` 与 NumPy 的 `numpy.reciprocal` 在数学意义上相同，但对整数输入的处理不同。NumPy 会保持整数类型，因此 1/2 会得到 0；而 DolphinDB 会自动转换为浮点计算，返回 0.5。 例如，`reciprocal([1, 2, 4])` 的结果为 `[1,0.5,0.25]`，而 `np.reciprocal([1, 2, 4])` 的结果为 `[1,0,0]`。若 NumPy 使用浮点类型数据作为输入，则结果与 DolphinDB 相同。\n\n#### 参数\n\n**X** 可以是数值型标量、向量或矩阵。\n\n#### 返回值\n\n返回结果为 DOUBLE 类型。\n\n#### 例子\n\n```\nreciprocal(10);\n// output: 0.1\n\nreciprocal(1 2 4 8);\n// output: [1,0.5,0.25,0.125]\n\nreciprocal(1 2 4 8$2:2);\n```\n\n| #0  | #1    |\n| --- | ----- |\n| 1   | 0.25  |\n| 0.5 | 0.125 |\n"
    },
    "recursiveSplitText": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/recursiveSplitText.html",
        "signatures": [
            {
                "full": "recursiveSplitText(text, [maxLength=300], [chunkOverlap=20], [separators], [keepSeparator=true])",
                "name": "recursiveSplitText",
                "parameters": [
                    {
                        "full": "text",
                        "name": "text"
                    },
                    {
                        "full": "[maxLength=300]",
                        "name": "maxLength",
                        "optional": true,
                        "default": "300"
                    },
                    {
                        "full": "[chunkOverlap=20]",
                        "name": "chunkOverlap",
                        "optional": true,
                        "default": "20"
                    },
                    {
                        "full": "[separators]",
                        "name": "separators",
                        "optional": true
                    },
                    {
                        "full": "[keepSeparator=true]",
                        "name": "keepSeparator",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [recursiveSplitText](https://docs.dolphindb.cn/zh/funcs/r/recursiveSplitText.html)\n\n首发版本：3.00.4，3.00.3.1\n\n\n\n#### 语法\n\nrecursiveSplitText(text, \\[maxLength=300], \\[chunkOverlap=20], \\[separators], \\[keepSeparator=true])\n\n#### 详情\n\n根据分隔符对文本进行递归分段。\n\n#### 参数\n\n**text** LITERAL类型标量，表示需要分段处理的输入文本。\n\n**maxLength** 正整数，表示每个分段的最大长度，默认值为 300。\n\n**chunkOverlap** 不超过 *maxLength* 的非负整数，表示相邻分段允许重复的最大长度，默认值为 20。\n\n**separators** STRING 类型向量，表示自定义分隔符列表。默认值为 `[\"\\n\\n\", \"\\n\", \" \", \"\"]`。暂不支持正则表达式。\n\n**keepSeparator** 布尔值，表示是否保留分隔符：\n\n* true：默认值，保留分隔符，此时分隔符将保留在后半段文本开头。\n\n* false：不保留分隔符。\n\n#### 返回值\n\n字符串向量。\n\n#### 例子\n\n```\ntext = \"这是第一句文字。这是第二句，带有逗号。接着是第三句，它比前两句更长，需要被进一步分割。最后一句是结束语。\"\nseparators = [\"。\",\"，\"]\n\nchunks = recursiveSplitText(text, maxLength=15, chunkOverlap=5, separators=separators, keepSeparator=true)\n```\n"
    },
    "refCount": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/refCount.html",
        "signatures": [
            {
                "full": "refCount(varname)",
                "name": "refCount",
                "parameters": [
                    {
                        "full": "varname",
                        "name": "varname"
                    }
                ]
            }
        ],
        "markdown": "### [refCount](https://docs.dolphindb.cn/zh/funcs/r/refCount.html)\n\n\n\n#### 语法\n\nrefCount(varname)\n\n#### 详情\n\n计算某个对象被引用的数量。\n\n#### 参数\n\n**varname** 是一个字符串，表示变量名称。\n\n#### 返回值\n\nINT 类型标量。\n\n#### 例子\n\n```\ndb=database(\"\",VALUE,1 2 3)\nrefCount(`db);\n// output\n1\n\ndb1=db\ndb2=db\nrefCount(`db);\n// output\n3\n```\n"
    },
    "regexCount": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/regexCount.html",
        "signatures": [
            {
                "full": "regexCount(str, pattern, [offset=0])",
                "name": "regexCount",
                "parameters": [
                    {
                        "full": "str",
                        "name": "str"
                    },
                    {
                        "full": "pattern",
                        "name": "pattern"
                    },
                    {
                        "full": "[offset=0]",
                        "name": "offset",
                        "optional": true,
                        "default": "0"
                    }
                ]
            }
        ],
        "markdown": "### [regexCount](https://docs.dolphindb.cn/zh/funcs/r/regexCount.html)\n\n\n\n#### 语法\n\nregexCount(str, pattern, \\[offset=0])\n\n#### 详情\n\n从 *str* 的第 *offset* 个位置开始搜索，返回与 *pattern* 匹配的字符串在 *str* 中出现的次数。\n\n#### 参数\n\n**str** 是一个字符串或字符串向量。\n\n**pattern** 是一个字符串，表示搜索的模式字符串（[正则表达式](https://docs.dolphindb.cn/zh/progr/objs/expr.html)）。模式字符串可以包含字面量字符、元字符或两者的组合。\n\n**offset** 是一个非负整数，默认值为0。它是一个可选参数，表示从 *str* 的第 *offset* 个位置开始搜索。*str* 的第一个位置为0。\n\n#### 返回值\n\nINT 类型标量。\n\n#### 例子\n\n```\nregexCount(\"1231hsdU777_ DW#122ddd\", \"[0-9]+\");\n// output\n3\n\nregexCount(\"1231hsdU777_ DW#122ddd\", \"[0-9]+$\");\n// output\n0\n\nregexCount(\"1231hsdU777_ DW#122ddd\", \"^[0-9]+\");\n// output\n1\n\nregexCount(\"abc234 ff456\", \"[a-z]\", 3);\n// output\n2\n```\n"
    },
    "regexFind": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/regexFind.html",
        "signatures": [
            {
                "full": "regexFind(str, pattern, [offset])",
                "name": "regexFind",
                "parameters": [
                    {
                        "full": "str",
                        "name": "str"
                    },
                    {
                        "full": "pattern",
                        "name": "pattern"
                    },
                    {
                        "full": "[offset]",
                        "name": "offset",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [regexFind](https://docs.dolphindb.cn/zh/funcs/r/regexFind.html)\n\n\n\n#### 语法\n\nregexFind(str, pattern, \\[offset])\n\n#### 详情\n\n从 *str* 的第 *offset* 个位置开始搜索与 *pattern* 匹配的字符串，如果在 *str* 中找到匹配字符串，则返回 *str* 中第一个匹配字符串的位置；如果没有找到，则返回-1。\n\n#### 参数\n\n**str** 是一个字符串或字符串向量。\n\n**pattern** 是一个字符串，表示搜索的模式字符串（[正则表达式](https://docs.dolphindb.cn/zh/progr/objs/expr.html)）。模式字符串可以包含字面量字符、元字符或两者的组合。\n\n**offset** 是一个非负整数，默认值为0。它是一个可选参数，表示从 *str* 的第 *offset* 个位置开始搜索。*str* 的第一个位置为0。\n\n#### 返回值\n\nINT 类型标量。\n\n#### 例子\n\n```\nregexFind(\"1231hsdU777_ DW#122ddd\", \"[a-z]+\");\n// output\n4\n\nregexFind(\"1231hsdU777_ DW#122ddd\", \"[0-9]+\");\n// output\n0\n\nregexFind(\"1231hsdU777_ DW#122ddd\", \"[0-9]+\", 4);\n// output\n8\n```\n\n相关函数：[regexFindStr](https://docs.dolphindb.cn/zh/funcs/r/regexfindstr.html)\n"
    },
    "regexFindStr": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/regexfindstr.html",
        "signatures": [
            {
                "full": "regexFindStr(str, pattern, [onlyFirst=true], [offset])",
                "name": "regexFindStr",
                "parameters": [
                    {
                        "full": "str",
                        "name": "str"
                    },
                    {
                        "full": "pattern",
                        "name": "pattern"
                    },
                    {
                        "full": "[onlyFirst=true]",
                        "name": "onlyFirst",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[offset]",
                        "name": "offset",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [regexFindStr](https://docs.dolphindb.cn/zh/funcs/r/regexfindstr.html)\n\n\n\n#### 语法\n\nregexFindStr(str, pattern, \\[onlyFirst=true], \\[offset])\n\n#### 详情\n\n不同于 `regexFind` 返回满足条件的字符串位置，`regexFindStr` 从第 *offset* 个位置开始搜索，返回 *str* 中满足正则表达式 *pattern* 的字符串。\n\n**Note:** 该函数新增于 2.00.11.1版本。\n\n#### 参数\n\n**str** 字符串或字符串向量，表示待搜索的对象。\n\n**pattern** 字符串，表示搜索的模式字符串（正则表达式）。模式字符串可以包含字面量字符、元字符或两者的组合。\n\n**onlyFirst** 布尔标量，表示是否只返回与正则表达式匹配的第一个子字符串：\n\n* 默认值为 true，此时针对 str 中的每一个字符串，仅返回第一个满足正则表达式的子字符串；\n\n* 设置为 false 时，针对 str 中的每一个字符串，返回所有满足正则表达式的非重叠匹配的子字符串。\n\n**offset** 非负整数，表示从 *str* 的第 *offset* 个位置开始搜索。默认值为0，即 *str* 的第一个位置。\n\n#### 返回值\n\n* 当*str*为标量，且 *onlyFirst*为 true 时，若存在满足条件的子字符串，则返回一个字符串标量，否则返回一个空的字符串。\n\n* 当 *str*为标量，且 *onlyFirst*为 false 时，若存在满足条件的子字符串，则返回一个字符串向量，其元素为所有满足条件的子串。\n\n* 当 *str*为向量，且 *onlyFirst*为 true 时，返回一个字符串向量，其中每个元素都是 *str*中对应位置元素中第一个匹配正则表达式的子字符串。\n\n* 当 *str*为向量，且 *onlyFirst*为 false 时，返回一个元组，其中每个元素都是 *str*对应位置元素中所有匹配正则表达式的子字符串的向量。\n\n#### 例子\n\n*str* 为标量，且 *onlyFirst* 为 true 时：\n\n```\nregexFindStr('234AA(2)BBB S&P', '([A|B|C|+|-]*)', true)\n```\n\n返回：AA\n\n*str* 为标量，且 *onlyFirst* 为 *false* 时：\n\n```\nregexFindStr('234AA(2)BBB S&P', '([A|B|C|+|-]*)', false)\n```\n\n返回：\\[\"AA\",\"BBB\"]\n\n*str* 为向量，且 *onlyFirst* 为 true 时：\n\n```\nregexFindStr(['234AA(2)BBBS&P', '234AA(2)BBBS&P'], '([A|B|C|+|-]*)', true)\n```\n\n返回：\\[\"AA\",\"AA\"]\n\n*str* 为向量，且 *onlyFirst* 为 false 时：\n\n```\nregexFindStr(['234AA(2)BBBS&P', '234AA(2)BBBS&P'], '([A|B|C|+|-]*)', false)\n```\n\n返回：(\\[\"AA\",\"BBB\"],\\[\"AA\",\"BBB\"])\n\n**Related information**\n\n[regexFind](https://docs.dolphindb.cn/zh/funcs/r/regexFind.html)\n"
    },
    "regexReplace": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/regexReplace.html",
        "signatures": [
            {
                "full": "regexReplace(str, pattern, replacement, [offset])",
                "name": "regexReplace",
                "parameters": [
                    {
                        "full": "str",
                        "name": "str"
                    },
                    {
                        "full": "pattern",
                        "name": "pattern"
                    },
                    {
                        "full": "replacement",
                        "name": "replacement"
                    },
                    {
                        "full": "[offset]",
                        "name": "offset",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [regexReplace](https://docs.dolphindb.cn/zh/funcs/r/regexReplace.html)\n\n\n\n#### 语法\n\nregexReplace(str, pattern, replacement, \\[offset])\n\n#### 详情\n\n从 *str* 的第 *offset* 个位置开始搜索与 *pattern* 匹配的字符串，如果找到匹配字符串，则把匹配字符串替换成 *replacement*，然后返回替换后的字符串。\n\n#### 参数\n\n**str** 是一个字符串或字符串向量。\n\n**pattern** 是一个字符串，表示搜索的模式字符串（[正则表达式](https://docs.dolphindb.cn/zh/progr/objs/expr.html)）。模式字符串可以包含字面量字符、元字符或两者的组合。\n\n**replacement** 是字符串标量，表示替换的字符串。\n\n**offset** 是一个非负整数，默认值为0。它是一个可选参数，表示从 *str* 的第 *offset* 个位置开始搜索。*str* 的第一个位置为0。\n\n#### 返回值\n\nSTRING 类型标量或向量。\n\n#### 例子\n\n```\nregexReplace(\"abc234 ff456\", \"[a-z]\", \"z\");\n// output\nzzz234 zz456\n\nregexReplace(\"abc234 ff456\", \"[a-z]+\", \"zzz\");\n// output\nzzz234 zzz456\n\nregexReplace(\"abc234 ff456\", \"[0-9]+\", \"zzz\");\n// output\nabczzz ffzzz\n```\n"
    },
    "registerStreamingSQL": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/registerStreamingSQL.html",
        "signatures": [
            {
                "full": "registerStreamingSQL(query, [queryId], [logTableCacheSize])",
                "name": "registerStreamingSQL",
                "parameters": [
                    {
                        "full": "query",
                        "name": "query"
                    },
                    {
                        "full": "[queryId]",
                        "name": "queryId",
                        "optional": true
                    },
                    {
                        "full": "[logTableCacheSize]",
                        "name": "logTableCacheSize",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [registerStreamingSQL](https://docs.dolphindb.cn/zh/funcs/r/registerStreamingSQL.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\nregisterStreamingSQL(query, \\[queryId], \\[logTableCacheSize])\n\n#### 详情\n\n注册一条流式 SQL 查询，成功注册后返回一个唯一的 *queryId*。系统会基于该查询生成一个与 *queryId* 同名的共享流表，用于写入结果变更日志。\n\n\\*\\*注意：\\*\\*仅被声明的表才能通过 `registerStreamingSQL` 注册流式 SQL 查询。\n\n#### 参数\n\n**query** 字符串标量，表示要注册的流式 SQL 查询语句。\n\n**queryId** 可选参数，字符串标量，表示 *query* 对应的 ID 名称。格式要求与变量名相同，只能包含字母、数字及下划线，且必须以字母开头。\n\n* 若指定的 *queryId* 已存在，系统会自动在其后追加时间戳生成唯一 ID。\n* 若不指定，系统自动生成唯一 ID。\n\n**logTableCacheSize** 可选参数，正整数，表示结果变更日志在内存中的最大缓存条数，默认缓存全部。只要存在订阅，缓存中未发布的数据就会被保留，不会被清理。已发布数据清理规则如下：\n\n* 若单次插入的日志条数不超过 *logTableCacheSize*，当内存中数据总条数达到 *logTableCacheSize* \\* 2 时，开始清理旧数据。\n* 若单次插入的日志条数超过 *logTableCacheSize*，当内存中数据总条数达到插入行数与 *logTableCacheSize*之和的1.2倍，开始清理旧数据。\n\n#### 返回值\n\n字符串标量。\n\n#### 例子\n\n```\nt=table(1..10 as id,rand(100,10) as val)\nshare t as st\ndeclareStreamingSQLTable(st)\nregisterStreamingSQL(\"select avg(val) from st\",\"sql_avg\")\n\n// 查看流式 SQL 查询的状态\ngetStreamingSQLStatus(\"sql_avg\")\n```\n\n**相关函数：**[declareStreamingSQLTable](https://docs.dolphindb.cn/zh/funcs/d/declareStreamingSQLTable.html), [registerStreamingSQL](https://docs.dolphindb.cn/zh/funcs/r/registerStreamingSQL.html)\n"
    },
    "regroup": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/regroup.html",
        "signatures": [
            {
                "full": "regroup(X, label, func, [byRow=true])",
                "name": "regroup",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "label",
                        "name": "label"
                    },
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "[byRow=true]",
                        "name": "byRow",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [regroup](https://docs.dolphindb.cn/zh/funcs/r/regroup.html)\n\n\n\n#### 语法\n\nregroup(X, label, func, \\[byRow=true])\n\n#### 详情\n\n按给定的行/列标签对矩阵进行分组聚合的操作。\n\n数据表的分组聚合可以通过 SQL 的 group by 语句实现。而通过 `regroup` 函数，可以实现矩阵的分组聚合操作。\n\n注意：建议参数 *func* 优先指定为系统内置的聚合函数，因为系统内部对内置函数进行了优化处理。（参考下例 2）\n\n#### 参数\n\n**X** 矩阵。\n\n**label** 向量，表示用于分组计算的标签。当 *byRow* = true 时，*label* 的长度必须与矩阵行数相等，否则与矩阵列数相等。\n\n**func** 单目聚合函数，可以是用户自定义聚合函数，也可以是内置函数。对具有相同标签的分组应用该函数进行聚合。\n\n**byRow** 布尔值，默认值 true，表示按行聚合。若为 false，则表示按列聚合。\n\n#### 返回值\n\n一个矩阵。\n\n#### 例子\n\n例1：按行/列标签分组聚合\n\n```\nm = rand(20, 4:5)\nm;\n```\n\n| col1 | col2 | col3 | col4 | col5 |\n| ---- | ---- | ---- | ---- | ---- |\n| 11   | 6    | 6    | 10   | 4    |\n| 6    | 7    | 5    | 2    | 16   |\n| 2    | 16   | 14   | 19   | 9    |\n| 17   | 6    | 13   | 10   | 2    |\n\n```\n# 按照列标签重组\nlabel = `A`A`B`A`B\nregroup(X=m, label=label, func=firstNot, byRow=false)\n```\n\n| A  | B  |\n| -- | -- |\n| 11 | 6  |\n| 6  | 5  |\n| 2  | 14 |\n| 17 | 13 |\n\n```\n# 按照行标签重组\nlabel = 1 2 1 2\nregroup(X=m, label=label, func=firstNot, byRow=true)\n```\n\n| label | col1 | col2 | col3 | col4 | col5 |\n| ----- | ---- | ---- | ---- | ---- | ---- |\n| 1     | 11   | 6    | 6    | 10   | 4    |\n| 2     | 6    | 7    | 5    | 2    | 16   |\n\n例2：内置函数和用户自定函数的性能对比\n\n```\nm = rand(1000.0, 10000)$100:100\ndefg my_avg(v):avg(v)\n\ntimer(1000) regroup(m, take(1 2 3 4 5, 100), avg)\n// output\nTime elapsed: 176.175 ms\n\ntimer(1000) regroup(m, take(1 2 3 4 5, 100), my_avg)\n// output\nTime elapsed: 1062.553 ms\n```\n\n例3：对面板数据进行分钟聚合\n\n```\nn=1000\ntimestamp = 09:00:00 + rand(10000, n).sort!()\nid = take(`st1`st2`st3, n)\nvol = 100 + rand(10.0, n)\nvt = table(timestamp, id, vol)\nm = exec vol from vt pivot by timestamp, id\nregroup(m, minute(m.rowNames()), avg)\n```\n"
    },
    "remoteRun": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/remoteRun.html",
        "signatures": [
            {
                "full": "remoteRun(conn, script, args)",
                "name": "remoteRun",
                "parameters": [
                    {
                        "full": "conn",
                        "name": "conn"
                    },
                    {
                        "full": "script",
                        "name": "script"
                    },
                    {
                        "full": "args",
                        "name": "args"
                    }
                ]
            }
        ],
        "markdown": "### [remoteRun](https://docs.dolphindb.cn/zh/funcs/r/remoteRun.html)\n\n\n\n#### 语法\n\nremoteRun(conn, script, args)\n\n#### 详情\n\n将脚本或函数传输到远程数据库执行。\n\n#### 参数\n\n**conn** 是远程数据库的连接句柄。\n\n**script** 是要执行的脚本或函数名。\n\n**args** 可选的可变长度参数。如果 *script* 是函数名，*args* 是函数的参数。\n\n#### 返回值\n\n*script* 的执行结果。\n\n#### 例子\n\n第一种用法：在远程节点上执行脚本。\n\n```\nconn =  xdb(\"localhost\",81);\nremoteRun(conn, \"x=rand(1.0,10000000); y=x pow 2; avg y\");\n```\n\n输出返回：0.333254\n\n第二种用法：\n\n* 如果 functionName 加了单引号，双引号或者反引号，那么表示在远程节点上调用函数。函数是定义在远程节点上，但是参数由本地节点传过去。\n\n  ```\n  h=xdb(\"localhost\",80);\n  x=remoteRun(h, \"sum\",1..100);\n  x;\n  ```\n\n  输出返回：5050\n\n* 如果 functionName 没有加单引号，双引号或者反引号，那么表示调用的函数定义在本地节点上。参数也是由本地节点传过去。\n\n  假设在本地节点，我们有一个表 EarningsDates，该表有两列：股票代码和日期。表中3个股票中的每一个，都有2006年第三季度公布盈利的日期。在远程节点有一个表 USPrices，节点的名字为 localhost，端口号为8081。它包含所有美国股票的每日股票价格。我们希望从远程节点获得在宣布收益后的一周内所有 EarningsDates 表中股票的价格。 在远程节点，我们导入数据文件创建表 USPrices，然后将其共享为名叫 sharedUSPrices 的表。\n\n  ```\n  USPrices = loadText(\"c:/DolphinDB/Data/USPrices.csv\");\n  share USPrices as USPrices;\n  ```\n\n  当我们创建到远程节点的连接时，远程节点将为此连接创建一个新的会话。此新会话与远程节点上的其他会话完全隔离。这对于开发来说很方便，因为开发人员不必担心名称冲突。 然而，有时候我们也希望在同一节点上的多个会话之间共享数据。这时我们可以使用函数 [share](https://docs.dolphindb.cn/zh/progr/statements/share.html) 来共享对象。目前只能在 DolphinDB 中共享表。 在本地节点上，我们创建 EarningsDates 表，然后用脚本将其传输到远程节点。在执行完毕后，结果被返回到本地节点。\n\n  ```\n  EarningsDates=table(`XOM`AAPL`IBM as TICKER, 2006.10.26 2006.10.19 2006.10.17 as date)\n  def loadDailyPrice(data){\n      dateDict = dict(data.TICKER, data.date)\n      return select date, TICKER, PRC from objByName(\"sharedUSPrices\") where dateDict[TICKER]<date<=dateDict[TICKER]+7\n  }\n  conn = xdb(\"localhost\",8081)\n  prices = conn.remoteRun(loadDailyPrice, EarningsDates);\n  prices;\n  ```\n\n  输出返回：\n\n  | date       | TICKER | PRC   |\n  | ---------- | ------ | ----- |\n  | 2006.10.27 | XOM    | 71.46 |\n  | 2006.10.30 | XOM    | 70.84 |\n  | 2006.10.31 | XOM    | 71.42 |\n  | 2006.11.01 | XOM    | 71.06 |\n  | 2006.11.02 | XOM    | 71.19 |\n  | 2006.10.18 | IBM    | 89.82 |\n  | 2006.10.19 | IBM    | 89.86 |\n  | 2006.10.20 | IBM    | 90.48 |\n  | 2006.10.23 | IBM    | 91.56 |\n  | 2006.10.24 | IBM    | 91.49 |\n  | 2006.10.20 | AAPL   | 79.95 |\n  | 2006.10.23 | AAPL   | 81.46 |\n  | 2006.10.24 | AAPL   | 81.05 |\n  | 2006.10.25 | AAPL   | 81.68 |\n  | 2006.10.26 | AAPL   | 82.19 |\n\n相关函数：[remoteRunCompatible](https://docs.dolphindb.cn/zh/funcs/r/remoteruncompatible.html)\n"
    },
    "remoteRunCompatible": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/remoteruncompatible.html",
        "signatures": [
            {
                "full": "remoteRunCompatible(conn, script, args)",
                "name": "remoteRunCompatible",
                "parameters": [
                    {
                        "full": "conn",
                        "name": "conn"
                    },
                    {
                        "full": "script",
                        "name": "script"
                    },
                    {
                        "full": "args",
                        "name": "args"
                    }
                ]
            }
        ],
        "markdown": "### [remoteRunCompatible](https://docs.dolphindb.cn/zh/funcs/r/remoteruncompatible.html)\n\n\n\n#### 语法\n\nremoteRunCompatible(conn, script, args)\n\n#### 详情\n\n将脚本或函数传输到远程数据库执行。\n\nremoteRunCompatible 与 remoteRun 的区别在于：\n\n* remoteRunCompatible 对本地和远程数据库的版本没有限制。\n\n* remoteRun 在本地数据库为 3.00 版本时，不支持远程数据库的版本低于3.00。\n\n#### 参数\n\n**conn** 是远程数据库的连接句柄。\n\n**script** 是要执行的脚本或函数名。\n\n**args** 可选的可变长度参数。如果 *script* 是函数名，*args* 是函数的参数。\n\n#### 返回值\n\n*script* 的执行结果。\n\n#### 例子\n\n第一种用法：*script* 是脚本，则表示在远程节点上执行脚本。\n\n```\nconn =\n              xdb(host=\"localhost\",port=8848,userId=\"admin\",password=123456);\n            remoteRunCompatible(conn, \"avg(1..100)\");\n```\n\n结果为 50.5。\n\n第二种用法：*script* 是函数名\n\n* 如果 script 加了单引号，双引号或者反引号，那么表示在远程节点上调用函数。函数是定义在远程节点上，但是参数由本地节点传过去。\n\n在远程节点增加函数视图 myAvg\n\n`def myAvg(x){ return avg(x)+2 } addFunctionView(myAvg)`\n\n连接远程节点调用视图\n\n```\nconn =  xdb(\"localhost\",8848,`admin,`123456);\n            remoteRunCompatible(conn, \"myAvg\", 1..100);\n```\n\n结果为 52.5。\n\n* 如果 script 不加单引号，双引号或者反引号，那么表示调用的函数定义在本地节点上。参数也是由本地节点传过去。\n\n在本地节点定义同名函数 myAvg\n\n`def myAvg(x){ return avg(x)+1 }`\n\n在远程节点执行此函数\n\n```\nconn =  xdb(\"localhost\",8848,`admin,`123456);\n            remoteRunCompatible(conn, myAvg, 1..100);\n```\n\n结果为 51.5。\n\n相关函数：[remoteRun](https://docs.dolphindb.cn/zh/funcs/r/remoteRun.html)\n"
    },
    "remoteRunWithCompression": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/remoteRunWithCompression.html",
        "signatures": [
            {
                "full": "remoteRunWithCompression(conn, script, args)",
                "name": "remoteRunWithCompression",
                "parameters": [
                    {
                        "full": "conn",
                        "name": "conn"
                    },
                    {
                        "full": "script",
                        "name": "script"
                    },
                    {
                        "full": "args",
                        "name": "args"
                    }
                ]
            }
        ],
        "markdown": "### [remoteRunWithCompression](https://docs.dolphindb.cn/zh/funcs/r/remoteRunWithCompression.html)\n\n\n\n#### 语法\n\nremoteRunWithCompression(conn, script, args)\n\n#### 详情\n\n和 [remoteRun](https://docs.dolphindb.cn/zh/funcs/r/remoteRun.html) 功能和用法基本一致，唯一不同的是 `remoteRunWithCompression` 在传输时对脚本中大于 1024 行的表数据进行了压缩。\n\n#### 参数\n\n**conn** 是远程数据库的连接句柄。\n\n**script** 是要执行的脚本或函数名。\n\n**args** 可选参数，如果 *script* 是函数名，*args* 是函数的参数。\n\n#### 返回值\n\n*script* 的执行结果。\n"
    },
    "remove!": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/remove.html",
        "signatures": [
            {
                "full": "remove!(obj, index)",
                "name": "remove!",
                "parameters": [
                    {
                        "full": "obj",
                        "name": "obj"
                    },
                    {
                        "full": "index",
                        "name": "index"
                    }
                ]
            }
        ],
        "markdown": "### [remove!](https://docs.dolphindb.cn/zh/funcs/r/remove.html)\n\n首发版本：3.00.5\n\n\n\n#### 语法\n\nremove!(obj, index)\n\n#### 详情\n\n删除向量或元组指定位置的元素，并直接修改原对象。\n\n相较于 [drop](https://docs.dolphindb.cn/zh/funcs/d/drop.html), [pop!](https://docs.dolphindb.cn/zh/funcs/p/pop_.html), [removeHead!](https://docs.dolphindb.cn/zh/funcs/r/removeHead_.html), [removeTail!](https://docs.dolphindb.cn/zh/funcs/r/removeTail_.html) 等函数，`remove!` 更灵活，它支持删除任意位置的元素，而其他函数仅支持删除首部或尾部的元素。\n\n#### 参数\n\n**obj** 向量、数组向量、元组或列式元组。表示要删除元素的目标对象。\n\n**index** 整型标量或向量，表示要删除的元素索引（从0开始编号）。索引范围为 \\[0, obj.size())。如果为向量，索引值必须严格升序。\n\n#### 返回值\n\n返回删除指定元素后的对象，类型和形式同 *obj*。\n\n#### 例子\n\n删除常规向量的指定元素。\n\n```\nv = 1..10\nremove!(v, 2)  // v 变为 [1,2,4,5,6,7,8,9,10]\n\n// 基于上一步的结果继续执行\nremove!(v, [1,3,5])   // v 变为 [1,4,6,8,9,10]\n```\n\n删除数组向量的指定元素。\n\n```\nav = array(DOUBLE[], 0, 10).append!([[1.1,2.2], [3.3,4.4,5.5], [6.6], [7.7,8.8,9.9,10.0]])\nremove!(av, 1)   // av 变为 [[1.1,2.2], [6.6], [7.7,8.8,9.9,10.0]]\n\n// 基于上一步的结果继续执行\nremove!(av, [0,2])   // av 变为 [[6.6]]\n```\n\n删除常规元组的指定元素。\n\n```\ntp = (1, `AAPL, 3.14, 2023.01.01)\nremove!(tp, 2)  // tp 变为 (1, `AAPL, 2023.01.01)\n\n// 基于上一步的结果继续执行\nremove!(tp, [0,2]) // tp 变为 (`AAPL)\n```\n\n删除列式元组的指定元素。\n\n```\nctp = [[1,2,3], [4,5,6], [7,8], [9,2]].setColumnarTuple!()\nremove!(ctp, 1)\n// ctp 变为 [[1,2,3], [7,8], [9,2]]\n\n// 基于上一步的结果继续执行，删除多个元素\nremove!(ctp, [0,1])\n// ctp 变为 [[9,2]]\n```\n\n**相关函数：**[drop](https://docs.dolphindb.cn/zh/funcs/d/drop.html)、[pop!](https://docs.dolphindb.cn/zh/funcs/p/pop_.html)、[removeHead!](https://docs.dolphindb.cn/zh/funcs/r/removeHead_.html)、[removeTail!](https://docs.dolphindb.cn/zh/funcs/r/removeTail_.html)\n"
    },
    "removeCacheRulesForComputeGroup": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/removecacherulesforcomputegroup.html",
        "signatures": [
            {
                "full": "removeCacheRulesForComputeGroup(name, tableNames)",
                "name": "removeCacheRulesForComputeGroup",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "tableNames",
                        "name": "tableNames"
                    }
                ]
            }
        ],
        "markdown": "### [removeCacheRulesForComputeGroup](https://docs.dolphindb.cn/zh/funcs/r/removecacherulesforcomputegroup.html)\n\n首发版本：3.00.5\n\n\n\n#### 语法\n\nremoveCacheRulesForComputeGroup(name, tableNames)\n\n#### 详情\n\n移除计算组的缓存规则，指定需要取消计算组缓存的表。\n\n#### 参数\n\n**name** 字符串标量，指定需要移除缓存规则的计算组。\n\n**tableNames** 字符串标量或向量，指定需要取消计算组缓存的表，以库名/表名的形式拼接，例如\"dfs\\://compute\\_test/tb1\"。暂不支持通配符。\n\n#### 返回值\n\n无\n\n#### 例子\n\n```\nremoveCacheRulesForComputeGroup(\"cgroup1\", \"dfs://compute_test/tb1\")\n\nremoveCacheRulesForComputeGroup(\"cgroup1\", [\"dfs://compute_test/tb1\", \"dfs://compute_test/tb2\"])\n```\n\n**相关函数：**[addCacheRulesForComputeGroup](https://docs.dolphindb.cn/zh/funcs/a/addcacherulesforcomputegroup.html)、[getCacheRulesForComputeGroup](https://docs.dolphindb.cn/zh/funcs/g/getcacherulesforcomputegroup.html)\n"
    },
    "removeHead!": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/removeHead_.html",
        "signatures": [
            {
                "full": "removeHead!(obj, n)",
                "name": "removeHead!",
                "parameters": [
                    {
                        "full": "obj",
                        "name": "obj"
                    },
                    {
                        "full": "n",
                        "name": "n"
                    }
                ]
            }
        ],
        "markdown": "### [removeHead!](https://docs.dolphindb.cn/zh/funcs/r/removeHead_.html)\n\n\n\n#### 语法\n\nremoveHead!(obj, n)\n\n#### 详情\n\n删除向量 *obj* 的前 *n* 个元素。\n\n#### 参数\n\n**obj** 是一个向量。\n\n**n** 是一个正整数，表示要删除的位于向量头部的元素的个数。\n\n#### 返回值\n\n与 *obj* 同类型的向量。\n\n#### 例子\n\n```\nx=11..20;\nx.removeHead!(3);\n// output\n[14,15,16,17,18,19,20]\n```\n\n**相关函数：**[drop](https://docs.dolphindb.cn/zh/funcs/d/drop.html)、[pop!](https://docs.dolphindb.cn/zh/funcs/p/pop_.html)、[removeTail!](https://docs.dolphindb.cn/zh/funcs/r/removeTail_.html)、[remove!](https://docs.dolphindb.cn/zh/funcs/r/remove.html)\n"
    },
    "removeIPBlackList": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/removeipblacklist.html",
        "signatures": [
            {
                "full": "removeIPBlackList(ips)",
                "name": "removeIPBlackList",
                "parameters": [
                    {
                        "full": "ips",
                        "name": "ips"
                    }
                ]
            }
        ],
        "markdown": "### [removeIPBlackList](https://docs.dolphindb.cn/zh/funcs/r/removeipblacklist.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nremoveIPBlackList(ips)\n\n#### 详情\n\n从黑名单中移除 IP。当所有 IP 都从黑名单中移除后，即为关闭黑名单。\n\n此函数仅可由管理员执行，对整个集群生效。\n\n#### 参数\n\n**ips** 是 STRING 或 IPADDR 类型的标量或向量，表示一个或多个 IP 地址。\n\n#### 例子\n\n```\naddIPBlackList([\"1.1.1.1\", \"2.2.2.2\", \"3.3.3.3\"])\nremoveIPBlackList(\"2.2.2.2\")\ngetIPBlackList()\n// output: [\"1.1.1.1\", \"3.3.3.3\"]\n```\n\n相关函数：[addIPBlackList](https://docs.dolphindb.cn/zh/funcs/a/addipblacklist.html)、[getIPBlackList](https://docs.dolphindb.cn/zh/funcs/g/getipblacklist.html)\n"
    },
    "removeIPWhiteList": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/removeipwhitelist.html",
        "signatures": [
            {
                "full": "removeIPWhiteList(ips)",
                "name": "removeIPWhiteList",
                "parameters": [
                    {
                        "full": "ips",
                        "name": "ips"
                    }
                ]
            }
        ],
        "markdown": "### [removeIPWhiteList](https://docs.dolphindb.cn/zh/funcs/r/removeipwhitelist.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nremoveIPWhiteList(ips)\n\n#### 详情\n\n从白名单中移除 IP。当所有 IP 都从白名单中移除后，即为关闭白名单。\n\n此函数仅可由管理员执行，对整个集群生效。\n\n#### 参数\n\n**ips** 是 STRING 或 IPADDR 类型的标量或向量，表示一个或多个 IP 地址。\n\n#### 例子\n\n```\naddIPWhiteList([\"1.1.1.1\", \"2.2.2.2\", \"3.3.3.3\"])\nremoveIPWhiteList(\"2.2.2.2\")\ngetIPWhiteList()\n// output: [\"1.1.1.1\", \"3.3.3.3\"]\n```\n\n相关函数：[addIPWhiteList](https://docs.dolphindb.cn/zh/funcs/a/addipwhitelist.html)、[getIPWhiteList](https://docs.dolphindb.cn/zh/funcs/g/getipwhitelist.html)\n"
    },
    "removeNode": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/removenode.html",
        "signatures": [
            {
                "full": "removeNode(alias, [force=false])",
                "name": "removeNode",
                "parameters": [
                    {
                        "full": "alias",
                        "name": "alias"
                    },
                    {
                        "full": "[force=false]",
                        "name": "force",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [removeNode](https://docs.dolphindb.cn/zh/funcs/r/removenode.html)\n\n\n\n#### 语法\n\nremoveNode(alias, \\[force=false])\n\n#### 详情\n\n删除集群中名为 *alias* 的计算节点。仅限 admin 用户调用。\n\n此函数仅适用于 Linux 版本的 server。\n\n#### 参数\n\n**alias** STRING 类型的标量或向量，代表需要删除的计算节点的别名。\n\n**force** BOOL 类型的标量，表示是否强制删除节点：\n\n* 当值为 false（默认值）时 ，表示不强制删除，即仅当节点处于关闭状态时才会删除。\n\n* 当值为 true 时，表示强制删除，如果节点尚未关闭，则集群将会先关闭目标节点，然后再删除。此操作可能导致该节点正在进行的计算任务终止。\n\n#### 例子\n\n删除别名为 \"cnode1\" 的计算节点，删除前需要手动关闭该节点。\n\n```\nremoveNode(alias=\"cnode1\")\n```\n\n强制删除别名为 \"cnode2\", \"cnode3\" 的计算节点。\n\n```\nremoveNode(alias=`cnode2`cnode3, force=true)\n```\n"
    },
    "removeTail!": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/removeTail_.html",
        "signatures": [
            {
                "full": "removeTail!(obj, n)",
                "name": "removeTail!",
                "parameters": [
                    {
                        "full": "obj",
                        "name": "obj"
                    },
                    {
                        "full": "n",
                        "name": "n"
                    }
                ]
            }
        ],
        "markdown": "### [removeTail!](https://docs.dolphindb.cn/zh/funcs/r/removeTail_.html)\n\n\n\n#### 语法\n\nremoveTail!(obj, n)\n\n#### 详情\n\n删除向量 *obj* 的后 *n* 个元素。\n\n#### 参数\n\n**obj** 是一个向量。\n\n**n** 是一个正整数，表示要删除的位于向量尾部的元素的个数。\n\n#### 返回值\n\n与 *obj* 同类型的向量。\n\n#### 例子\n\n```\nx=11..20;\nx.removeTail!(3);\n// output\n[11,12,13,14,15,16,17]\n```\n\n**相关函数：**[drop](https://docs.dolphindb.cn/zh/funcs/d/drop.html)、[pop!](https://docs.dolphindb.cn/zh/funcs/p/pop_.html)、[removeHead!](https://docs.dolphindb.cn/zh/funcs/r/removeHead_.html)、[remove!](https://docs.dolphindb.cn/zh/funcs/r/remove.html)\n"
    },
    "removeTopicOffset": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/removeTopicOffset.html",
        "signatures": [
            {
                "full": "removeTopicOffset(topic)",
                "name": "removeTopicOffset",
                "parameters": [
                    {
                        "full": "topic",
                        "name": "topic"
                    }
                ]
            }
        ],
        "markdown": "### [removeTopicOffset](https://docs.dolphindb.cn/zh/funcs/r/removeTopicOffset.html)\n\n\n\n#### 语法\n\nremoveTopicOffset(topic)\n\n#### 详情\n\n删除给定订阅主题（topic）的持久化保存的最新一条已经处理订阅数据的偏移量（在 [subscribeTable](https://docs.dolphindb.cn/zh/funcs/s/subscribeTable.html) 函数中通过指定 *persistOffset* 参数为 true 获得）。\n\n#### 参数\n\n**topic** 是 [subscribeTable](https://docs.dolphindb.cn/zh/funcs/s/subscribeTable.html) 函数返回的订阅主题。\n"
    },
    "renameCatalog": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/renameCatalog.html",
        "signatures": [
            {
                "full": "renameCatalog(oldCatalog, newCatalog)",
                "name": "renameCatalog",
                "parameters": [
                    {
                        "full": "oldCatalog",
                        "name": "oldCatalog"
                    },
                    {
                        "full": "newCatalog",
                        "name": "newCatalog"
                    }
                ]
            }
        ],
        "markdown": "### [renameCatalog](https://docs.dolphindb.cn/zh/funcs/r/renameCatalog.html)\n\n\n\n#### 语法\n\nrenameCatalog(oldCatalog, newCatalog)\n\n#### 详情\n\n重命名 catalog。\n\n#### 参数\n\n**oldCatalog** 字符串标量，表示要修改的 catalog 的原名称。\n\n**newCatalog** 字符串标量，表示要修改的 catalog 的新名称。\n\n#### 例子\n\n```\nrenameCatalog(\"catalog1\", \"catalog2\")\n```\n"
    },
    "renameCatalogName": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/renameCatalogName.html",
        "signatures": [
            {
                "full": "renameCatalogName(catalog, schema, oldName, newName)",
                "name": "renameCatalogName",
                "parameters": [
                    {
                        "full": "catalog",
                        "name": "catalog"
                    },
                    {
                        "full": "schema",
                        "name": "schema"
                    },
                    {
                        "full": "oldName",
                        "name": "oldName"
                    },
                    {
                        "full": "newName",
                        "name": "newName"
                    }
                ]
            }
        ],
        "markdown": "### [renameCatalogName](https://docs.dolphindb.cn/zh/funcs/r/renameCatalogName.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\nrenameCatalogName(catalog, schema, oldName, newName)\n\n#### 详情\n\n修改全限定名 `<catalog>.<schema>.<name>` 中的 name。\n\n#### 参数\n\n**catalog** STRING 类型标量，表示 catalog 的名称。\n\n**schema** STRING 类型标量，表示 schema 名称，可以是 orca\\_graph, orca\\_table 或 orca\\_engine。\n\n**oldName**STRING 类型标量，表示修改前的 name。\n\n**newName**STRING 类型标量，表示修改后的 name。\n\n#### 例子\n\n```\nrenameCatalogName(catalog=\"demo1\", schema=\"orca_graph\", oldName=\"factor1\", newName=\"factor2\")\n\nrenameCatalogName(catalog=\"demo2\", schema=\"orca_engine\", oldName=\"engine1\", newName=\"engine2\")\n\nrenameCatalogName(catalog=\"demo3\", schema=\"orca_table\", oldName=\"trades1\", newName=\"trades2\")\n```\n"
    },
    "renameSchema": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/renameSchema.html",
        "signatures": [
            {
                "full": "renameSchema(catalog, oldSchema, newSchema)",
                "name": "renameSchema",
                "parameters": [
                    {
                        "full": "catalog",
                        "name": "catalog"
                    },
                    {
                        "full": "oldSchema",
                        "name": "oldSchema"
                    },
                    {
                        "full": "newSchema",
                        "name": "newSchema"
                    }
                ]
            }
        ],
        "markdown": "### [renameSchema](https://docs.dolphindb.cn/zh/funcs/r/renameSchema.html)\n\n\n\n#### 语法\n\nrenameSchema(catalog, oldSchema, newSchema)\n\n#### 详情\n\n重命名 schema。\n\n#### 参数\n\n**catalog** 字符串标量，表示 catalog 的名称。\n\n**oldSchema** 字符串标量，表示要修改的 schema 的原名称。\n\n**newSchema** 字符串标量，表示要修改的 schema 的新名称。\n\n#### 例子\n\n```\nrenameSchema(\"catalog1\", \"schema1\", \"schema2\")\n```\n"
    },
    "renameTable": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/renameTable.html",
        "signatures": [
            {
                "full": "renameTable(dbHandle, tableName, newTableName)",
                "name": "renameTable",
                "parameters": [
                    {
                        "full": "dbHandle",
                        "name": "dbHandle"
                    },
                    {
                        "full": "tableName",
                        "name": "tableName"
                    },
                    {
                        "full": "newTableName",
                        "name": "newTableName"
                    }
                ]
            }
        ],
        "markdown": "### [renameTable](https://docs.dolphindb.cn/zh/funcs/r/renameTable.html)\n\n\n\n#### 语法\n\nrenameTable(dbHandle, tableName, newTableName)\n\n#### 详情\n\n将给定分布式数据库内数据表改名。\n\n#### 参数\n\n**dbHandle** 是一个DFS数据库句柄。\n\n**tableName** 是一个字符串，表示要改名的数据表名称。该表既可为分布式表，亦可为维度表。\n\n**newTableName** 是一个字符串，表示要改名后的数据表名称。\n\n#### 返回值\n\n返回包含元数据的表对象。\n\n#### 例子\n\n```\nn=1000000\nID=rand(10, n)\nx=rand(1.0, n)\nt=table(ID, x)\ndb=database(\"dfs://hashdb101\", HASH,  [INT, 2]);\npt = db.createPartitionedTable(t, `pt, `ID)\npt.append!(t)\nrenameTable(db, `pt, `pt1)\nselect count(x) from loadTable(db, `pt1);\n```\n\n输出返回： 1000000\n"
    },
    "rename!": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rename_.html",
        "signatures": [
            {
                "full": "rename!(X, Y, [Z])",
                "name": "rename!",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "[Z]",
                        "name": "Z",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [rename!](https://docs.dolphindb.cn/zh/funcs/r/rename_.html)\n\n\n\n#### 语法\n\nrename!(X, Y, \\[Z])\n\n#### 详情\n\n* 对于向量，赋予其一个新标签。\n\n* 对于矩阵、索引矩阵，给列（和行）添加标签。\n\n* 对于表，替换表的列名。\n\n#### 参数\n\n**X** 可以是向量、矩阵、索引矩阵、非共享内存表或分布式表（仅支持 OLAP 引擎）。\n\n* 当 *X* 是向量时，*Y* 是表示标签的字符串。\n\n* 当 *X* 是矩阵、索引矩阵时，如果 *Z* 没有指定，则 *Y* 是列标签；如果 *Z* 指定了，*Y* 是行标签，而 *Z* 是列标签。列标签和行标签的长度分别需要等于 *X* 的列数和行数。*Y* 和 *Z* 可以是任意数据类型。\n\n* 当 *X* 是非共享内存表时，*Y* 和 *Z* 是字符串标量或向量。如果 *Z* 没有指定，则 *Y* 从左到右是新的列名，用户应该确保新的列名的数量小于或等于表中列的总数；如果 *Z* 指定了，则 *Y* 是旧的列名，*Z* 是对应的新的列名。\n\n* 当 *X* 是分布式表时，必须指定 *Y* 和 *Z* 且只能是字符串标量。其中 *Y* 表示指定的旧列名，*Z* 是对应的新列名。分布式表不支持批量修改列名。\n\n#### 返回值\n\n返回一个数据类型和形式与 *X* 相同的对象。\n\n#### 例子\n\n```\nk = 3 6 9;\nk.rename!(`rk);\n// output\n[3, 6, 9]\n\n// 用函数 stat 获取统计信息是一种查看名字的方法\nstat k;\n// output\nMedian->6\nAvg->6\nMin->3\nStdev->3\nCount->3\nSize->3\nName->rk        // k 的新标签\nMax->9\n```\n\n```\nm1 = 1..9$3:3;\nm1\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1  | 4  | 7  |\n| 2  | 5  | 8  |\n| 3  | 6  | 9  |\n\n```\nm1.rename!(`col1`col2`col3);\n```\n\n| col1 | col2 | col3 |\n| ---- | ---- | ---- |\n| 1    | 4    | 7    |\n| 2    | 5    | 8    |\n| 3    | 6    | 9    |\n\n```\nm1.rename!(1 2 3, `c1`c2`c3);\n```\n\n|   | c1 | c2 | c3 |\n| - | -- | -- | -- |\n| 1 | 1  | 4  | 7  |\n| 2 | 2  | 5  | 8  |\n| 3 | 3  | 6  | 9  |\n\n```\nm1 join k;\n// 注意新的矩阵使用 k 的标签作为它的列标签。\n```\n\n|   | c1 | c2 | c3 | rk |\n| - | -- | -- | -- | -- |\n| 1 | 1  | 4  | 7  | 3  |\n| 2 | 2  | 5  | 8  | 6  |\n| 3 | 3  | 6  | 9  | 9  |\n\n```\nt1=table(1..3 as x, 4..6 as y, 7..9 as z);\nt1\n```\n\n| x | y | z |\n| - | - | - |\n| 1 | 4 | 7 |\n| 2 | 5 | 8 |\n| 3 | 6 | 9 |\n\n```\nt1.rename!(`a`b);\n```\n\n**Note:** 若要重命名的列数超过原表的实际列数，则会报错。\n\n| a | b | z |\n| - | - | - |\n| 1 | 4 | 7 |\n| 2 | 5 | 8 |\n| 3 | 6 | 9 |\n\n```\nt1.rename!(`aa`bb`cc);\n```\n\n| aa | bb | cc |\n| -- | -- | -- |\n| 1  | 4  | 7  |\n| 2  | 5  | 8  |\n| 3  | 6  | 9  |\n\n```\nt1.rename!(`bb`cc, `y`z);\n```\n\n| aa | y | z |\n| -- | - | - |\n| 1  | 4 | 7 |\n| 2  | 5 | 8 |\n| 3  | 6 | 9 |\n\n```\nt1=table(1..3 as x, 4..6 as y, 7..9 as z, k);\nt1\n// 注意表使用了 k 的标签作为它的列名\n```\n\n| x | y | z | rk |\n| - | - | - | -- |\n| 1 | 4 | 7 | 3  |\n| 2 | 5 | 8 | 6  |\n| 3 | 6 | 9 | 9  |\n\n创建一个索引矩阵。\n\n```\nm = matrix(1..5, 11..15)\nm.rename!(2020.01.01..2020.01.05, `A`B)\nm1 = m.setIndexedMatrix!();\n```\n\n|            | A | B  |\n| ---------- | - | -- |\n| 2020.01.01 | 1 | 11 |\n| 2020.01.02 | 2 | 12 |\n| 2020.01.03 | 3 | 13 |\n| 2020.01.04 | 4 | 14 |\n| 2020.01.05 | 5 | 15 |\n\n修改其行、列标签。\n\n```\nm1.rename!( \"a\" + string(1..5), `A1`A2)\n```\n\n若向量不遵循严格递增或包含重复值，则会报错。\n\n```\nm1.rename!( \"a\" + string(4 6 2 1 3), `A1`A2)\nm1.rename!( \"a\"\"a\"\"a\"\"a\"\"a\", `A1`A2)\n//Error: The label of an indexed matrix or series must be in strict ascending order.\n```\n"
    },
    "reorderColumns!": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/reorderColumns_.html",
        "signatures": [
            {
                "full": "reorderColumns!(table, reorderedColNames)",
                "name": "reorderColumns!",
                "parameters": [
                    {
                        "full": "table",
                        "name": "table"
                    },
                    {
                        "full": "reorderedColNames",
                        "name": "reorderedColNames"
                    }
                ]
            }
        ],
        "markdown": "### [reorderColumns!](https://docs.dolphindb.cn/zh/funcs/r/reorderColumns_.html)\n\n\n\n#### 语法\n\nreorderColumns!(table, reorderedColNames)\n\n#### 详情\n\n调整表中各列的顺序。该命令直接在原有的表中修改，不会产生新的表。\n\n#### 参数\n\n**table** 是一个没有被共享的内存表。\n\n**reorderedColNames** 是一个字符串向量，表示调整顺序后的列名。此参数中只需写出表中发生顺序改变的列以及所有在其之前的列名。例如，将表中第3列于第6列的位置对换，则此参数只需写出前6列的列名。\n\n#### 返回值\n\n返回一个表。\n\n#### 例子\n\n```\nsym = `C`MS`MS`MS`IBM`IBM`C`C`C\nprice= 49.6 29.46 29.52 30.02 174.97 175.23 50.76 50.32 51.29\nqty = 2200 1900 2100 3200 6800 5400 1300 2500 8800\ntimestamp = [09:34:07,09:36:42,09:36:51,09:36:59,09:32:47,09:35:26,09:34:16,09:34:26,09:38:12]\nt = table(timestamp, sym, qty, price);\nt;\n```\n\n| timestamp | sym | qty  | price  |\n| --------- | --- | ---- | ------ |\n| 09:34:07  | C   | 2200 | 49.6   |\n| 09:36:42  | MS  | 1900 | 29.46  |\n| 09:36:51  | MS  | 2100 | 29.52  |\n| 09:36:59  | MS  | 3200 | 30.02  |\n| 09:32:47  | IBM | 6800 | 174.97 |\n| 09:35:26  | IBM | 5400 | 175.23 |\n| 09:34:16  | C   | 1300 | 50.76  |\n| 09:34:26  | C   | 2500 | 50.32  |\n| 09:38:12  | C   | 8800 | 51.29  |\n\n```\nreorderColumns!(t,`sym`timestamp`price`qty)\nt;\n```\n\n| sym | timestamp | price  | qty  |\n| --- | --------- | ------ | ---- |\n| C   | 09:34:07  | 49.6   | 2200 |\n| MS  | 09:36:42  | 29.46  | 1900 |\n| MS  | 09:36:51  | 29.52  | 2100 |\n| MS  | 09:36:59  | 30.02  | 3200 |\n| IBM | 09:32:47  | 174.97 | 6800 |\n| IBM | 09:35:26  | 175.23 | 5400 |\n| C   | 09:34:16  | 50.76  | 1300 |\n| C   | 09:34:26  | 50.32  | 2500 |\n| C   | 09:38:12  | 51.29  | 8800 |\n\n```\nreorderColumns!(t,`timestamp`sym);\nt;\n```\n\n| timestamp | sym | price  | qty  |\n| --------- | --- | ------ | ---- |\n| 09:34:07  | C   | 49.6   | 2200 |\n| 09:36:42  | MS  | 29.46  | 1900 |\n| 09:36:51  | MS  | 29.52  | 2100 |\n| 09:36:59  | MS  | 30.02  | 3200 |\n| 09:32:47  | IBM | 174.97 | 6800 |\n| 09:35:26  | IBM | 175.23 | 5400 |\n| 09:34:16  | C   | 50.76  | 1300 |\n| 09:34:26  | C   | 50.32  | 2500 |\n| 09:38:12  | C   | 51.29  | 8800 |\n"
    },
    "repartitionDS": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/repartitionDS.html",
        "signatures": [
            {
                "full": "repartitionDS(query, [column], [partitionType], [partitionScheme], [local=true])",
                "name": "repartitionDS",
                "parameters": [
                    {
                        "full": "query",
                        "name": "query"
                    },
                    {
                        "full": "[column]",
                        "name": "column",
                        "optional": true
                    },
                    {
                        "full": "[partitionType]",
                        "name": "partitionType",
                        "optional": true
                    },
                    {
                        "full": "[partitionScheme]",
                        "name": "partitionScheme",
                        "optional": true
                    },
                    {
                        "full": "[local=true]",
                        "name": "local",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [repartitionDS](https://docs.dolphindb.cn/zh/funcs/r/repartitionDS.html)\n\n\n\n#### 语法\n\nrepartitionDS(query, \\[column], \\[partitionType], \\[partitionScheme], \\[local=true])\n\n#### 详情\n\n使用新的分区类型和分区方案重新划分数据源。\n\n* 如果 *query* 是一个 SQL 查询的元代码，必须指定 *column* 参数。对于 COMPO 分区类型的表，可以不指定 *partitionType* 和 *partitionScheme* 参数，`repartitionDS` 函数会根据 *column* 列原始的分区类型和分区方案划分数据源。\n\n* 如果 *query* 是包含多个 SQL 查询元代码的元组，无需指定 *column*、*partitionType* 和 *partitionScheme* 参数，`repartitionDS` 函数会返回一个和 *query* 长度相同的元组，每个元素都是 *query* 中的元代码对应的数据源。\n\n* 当 *local* 设置为 true 时：将数据源获取到执行该函数的节点上。\n\n* 当 *local* 设置为 false 时：如果在指定了计算组的计算节点上执行该函数时，仅将数据源获取到同组内的所有计算节点上；否则将数据源获取到集群中所有数据节点、未指定计算组的计算节点上。\n\n#### 参数\n\n**query** 是一个 SQL 查询的元代码，或一个元组，其中每个元素都是 SQL 查询的元代码。\n\n**column** 是一个字符串，表示 *query* 中的一个列名。`repartitionDS` 函数会根据该列划分数据源。\n\n**partitionType** 表示分区类型，它的取值可以是 RANGE, VALUE 或 HASH。\n\n**partitionScheme** 是一个向量，表示分区方案。\n\n**local** 可选参数，布尔值，表示是否将数据源获取到当前节点进行计算。默认值为 true。\n\n#### 返回值\n\n该函数会返回一个元组，包含一组数据源。\n\n#### 例子\n\n创建分布式数据库和表：\n\n```\nn=1000000\nID=rand(100, n)\ndates=2017.08.07..2017.08.11\ndate=rand(dates, n)\nx=rand(10.0, n)\nt=table(ID, date, x)\n\ndbDate = database(, VALUE, 2017.08.07..2017.08.11)\ndbID = database(, RANGE, 0 50 100)\ndb = database(\"dfs://compoDB\", COMPO, [dbDate, dbID])\npt = db.createPartitionedTable(t, `pt, `date`ID)\npt.append!(t);\n```\n\n例1：*query*是一个 SQL 查询的元代码，指定了 *partitionType* 和 *partitionScheme*。\n\n```\nrepartitionDS(query=<select * from pt>,column=`date,partitionType=RANGE,partitionScheme=2017.08.07 2017.08.09 2017.08.11);\n\n// output: [DataSource< select [4] * from pt where date >= 2017.08.07,date < 2017.08.09 >,DataSource< select [4] * from pt where date >= 2017.08.09,date < 2017.08.11 >]\n```\n\n例2：*query*是一个 SQL 查询的元代码，没有指定 *partitionType*和 *partitionScheme*。\n\n```\nrepartitionDS(query=<select * from pt>,column=`ID)\n\n// output: [DataSource< select [4] * from pt [partition = */0_50] >,DataSource< select [4] * from pt [partition = */50_100] >]\n```\n\n例3：*query* 是包含多个 SQL 查询元代码的元组。\n\n```\nrepartitionDS(query=[<select * from pt where id between 0:50>,<select * from pt where id between 51:100>]);\n\n// output: [DataSource< select [4] * from pt where id between 0 : 50 >,DataSource< select [4] * from pt where id between 51 : 100 >]\n```\n"
    },
    "repeat": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/repeat.html",
        "signatures": [
            {
                "full": "repeat(X, n)",
                "name": "repeat",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "n",
                        "name": "n"
                    }
                ]
            }
        ],
        "markdown": "### [repeat](https://docs.dolphindb.cn/zh/funcs/r/repeat.html)\n\n\n\n#### 语法\n\nrepeat(X, n)\n\n#### 详情\n\n将 *X* 重复 *n* 次。\n\nDolphinDB 的 `repeat` 和 NumPy 的 `numpy.repeat` 存在以下区别：\n\n* 支持的数据类型不同：DolphinDB 的 `repeat` 仅支持字符串标量或字符串向量，而 `numpy.repeat` 可用于数值、布尔等多种 ndarray 数据类型。\n\n* 语义不同：\n  * DolphinDB 的 `repeat` 对每个字符串元素进行内容级重复，，是字符串级变换；而 NumPy 的 `numpy.repeat` 是“逐元素复制数组元素”，，是数组元素级展开。前者改变元素内容，后者改变元素数量。例如：DolphinDB `repeat([\"ab\", \"cd\"], 2)` 输出 `[\"abab\",\"cdcd\"]`；`np.repeat([\"ab\",\"cd\"], 2)` 输出 `['ab' 'ab' 'cd' 'cd']`。\n  * NumPy 支持按元素指定不同重复次数（vectorized repetition），例如：Numpy 支持 `np.repeat([\"a\",\"b\",\"c\"], [1,2,3])`；而 DolphinDB 不支持对应语义。\n\n* 返回值类型不同：DolphinDB 返回 STRING 标量或向量，而 NumPy 返回 ndarray。\n\n#### 参数\n\n**X** 是一个字符串或字符串向量。\n\n**n** 是一个非负整数，表示重复的次数。\n\n#### 返回值\n\n返回一个字符串或字符串向量。\n\n#### 例子\n\n```\nrepeat(`FB, 3);\n// output: FBFBFB\nrepeat(`AB`CD,2);\n// output: [\"ABAB\",\"CDCD\"]\n```\n"
    },
    "replace": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/replace.html",
        "signatures": [
            {
                "full": "replace(X, oldValue, newValue)",
                "name": "replace",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "oldValue",
                        "name": "oldValue"
                    },
                    {
                        "full": "newValue",
                        "name": "newValue"
                    }
                ]
            }
        ],
        "markdown": "### [replace](https://docs.dolphindb.cn/zh/funcs/r/replace.html)\n\n\n\n#### 语法\n\nreplace(X, oldValue, newValue)\n\n#### 详情\n\n返回将 *oldValue* 替换成 *newValue* 后的向量或矩阵。`replace!` 是 `replace` 的原地改变版本。\n\n#### 参数\n\n**X** 可以是向量、矩阵。\n\n**oldValue** 标量，与 *X/newValue* 具有相同数据类别，表示将被替换的值。\n\n**newValue** 标量，与 *X/oldValue* 具有相同数据类别，表示新的值。\n\n#### 返回值\n\n与 *X* 类型相同的向量或矩阵。\n\n#### 例子\n\n```\nx=1 1 3;\nx=x.replace(1,2);\nx\n// output\n[2,2,3];\n\nm=1..4$2:2;\nm\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 3  |\n| 2  | 4  |\n\n```\nm=m.replace(2,1);\nm\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 3  |\n| 1  | 4  |\n\n```\nm.replace!(1,6);\n```\n\n| #0 | #1 |\n| -- | -- |\n| 6  | 3  |\n| 6  | 4  |\n"
    },
    "replaceColumn!": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/replaceColumn_.html",
        "signatures": [
            {
                "full": "replaceColumn!(table, colName, newCol)",
                "name": "replaceColumn!",
                "parameters": [
                    {
                        "full": "table",
                        "name": "table"
                    },
                    {
                        "full": "colName",
                        "name": "colName"
                    },
                    {
                        "full": "newCol",
                        "name": "newCol"
                    }
                ]
            }
        ],
        "markdown": "### [replaceColumn!](https://docs.dolphindb.cn/zh/funcs/r/replaceColumn_.html)\n\n\n\n#### 语法\n\nreplaceColumn!(table, colName, newCol)\n\n#### 详情\n\n* 当 *table* 为内存表时：\n\n  * 使用向量替换 *table* 中指定列。替换后，指定列的数据类型与向量的数据类型一致。支持替换多列（请注意该操作目前不保证原子性，即在遇到一些系统错误时可能出现部分列替换失败的情况）。\n  * `replaceColumn!` 与 SQL 中的 [update](https://docs.dolphindb.cn/zh/progr/sql/update.html) 语句的区别在于，前者可以修改列的值或数据类型，而后者只能修改列的值。\n\n* 当 *table* 为 OLAP 分布式表时，`replaceColumn!` 仅修改列的数据类型，并遵循以下规则：\n  * SYMBOL 类型不支持转换，即不能将 SYMBOL 转换为其他类型，其他类型也不能转换为 SYMBOL。\n  * 除 SYMBOL 外，同类别的数据类型间支持相互转换。\n  * INTEGRAL 和 FLOATING 类型支持相互转换。\n  * INTEGRAL, FLOATING, LITERAL, TEMPORAL 类型支持转换为 STRING 类型。\n\n**Note:** 暂不支持替换 DECIMAL 类型列。\n\n#### 参数\n\n**table** 非共享内存表或 OLAP 引擎的分布式表。\n\n**colName** 字符串，表示要替换列的列名。当 *table* 是内存表时，*colName* 也可以是字符串向量，表示多列的列名。\n\n**newCol** 表示用于替换的列值。当 *table* 是内存表时，当 *colName*为标量时，*newCol*是一个长度与 *table* 行数相同的向量；当 *colName* 为向量时，*newCol* 是一个元组，其元素个数与 *colName* 一致，且每一个元素是一个长度与 *table* 行数相同的向量。当 *table* 是 OLAP 分布式表时，newCol 仅用于提供目标数据类型。\n\n#### 返回值\n\n返回替换后的表。\n\n#### 例子\n\n```\nsym = `C`MS`MS`MS`IBM`IBM`C`C`C\nprice= 49.6 29.46 29.52 30.02 174.97 175.23 50.76 50.32 51.29\nqty = 2200 1900 2100 3200 6800 5400 1300 2500 8800\ntimestamp = [09:34:07,09:36:42,09:36:51,09:36:59,09:32:47,09:35:26,09:34:16,09:34:26,09:38:12]\nt = table(timestamp, sym, qty, price)\nschema(t).colDefs;\n```\n\n输出返回：\n\n| name      | typeString | typeInt | extra | comment |\n| --------- | ---------- | ------- | ----- | ------- |\n| timestamp | SECOND     | 10      |       |         |\n| sym       | STRING     | 18      |       |         |\n| qty       | INT        | 4       |       |         |\n| price     | DOUBLE     | 16      |       |         |\n\n把 sym 列的数据类型修改为 SYMBOL 类型：\n\n```\nsyms=symbol(exec sym from t)\nreplaceColumn!(t,`sym,syms);\nschema(t).colDefs;\n```\n\n输出返回：\n\n| name      | typeString | typeInt | extra | comment |\n| --------- | ---------- | ------- | ----- | ------- |\n| timestamp | SECOND     | 10      |       |         |\n| sym       | SYMBOL     | 17      |       |         |\n| qty       | INT        | 4       |       |         |\n| price     | DOUBLE     | 16      |       |         |\n\n对 price 列和 timestamp 列进行替换：\n\n```\nnewPrice =round(t.qty)\nnewTimestamp = minute(t.timestamp)\nreplaceColumn!(t, `price`timestamp, (newPrice,newTimestamp))\nschema(t).colDefs;\n```\n\n输出返回：\n\n| name      | typeString | typeInt | extra | comment |\n| --------- | ---------- | ------- | ----- | ------- |\n| timestamp | MINUTE     | 9       |       |         |\n| sym       | SYMBOL     | 17      |       |         |\n| qty       | INT        | 4       |       |         |\n| price     | INT        | 4       |       |         |\n\n```\nlogin(\"admin\",\"123456\")\nif(existsDatabase(\"dfs://replaceColumn\")){\n  dropDatabase(\"dfs://replaceColumn\")\n}\nn=10\nmonth=take(2012.06.13..2012.06.13, n);\nx=rand(1.0, n);\nt=table(month, x);\ndb=database(\"dfs://replaceColumn\", VALUE, 2012.06.13..2012.06.23)\npt = db.createPartitionedTable(t, `pt, `month);\npt.append!(t);\nschema(pt).colDefs\n```\n\n输出返回：\n\n| name  | typeString | typeInt | extra | comment |\n| ----- | ---------- | ------- | ----- | ------- |\n| month | DATE       | 6       |       |         |\n| x     | DOUBLE     | 16      |       |         |\n\n```\nnewCols=array(INT,0)\nreplaceColumn!(loadTable(\"dfs://replaceColumn\",`pt), `x, newCols)\nschema(pt).colDefs\n```\n\n输出返回：\n\n| name  | typeString | typeInt | extra | comment |\n| ----- | ---------- | ------- | ----- | ------- |\n| month | DATE       | 6       |       |         |\n| x     | INT        | 4       |       |         |\n"
    },
    "replace!": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/replace_.html",
        "signatures": [
            {
                "full": "replace(X, oldValue, newValue)",
                "name": "replace",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "oldValue",
                        "name": "oldValue"
                    },
                    {
                        "full": "newValue",
                        "name": "newValue"
                    }
                ]
            }
        ],
        "markdown": "### [replace!](https://docs.dolphindb.cn/zh/funcs/r/replace_.html)\n\n是 [replace](https://docs.dolphindb.cn/zh/funcs/r/replace.html) 的别名。\n\n\n以下是 `replace` 函数的文档：\n### [replace](https://docs.dolphindb.cn/zh/funcs/r/replace.html)\n\n\n\n#### 语法\n\nreplace(X, oldValue, newValue)\n\n#### 详情\n\n返回将 *oldValue* 替换成 *newValue* 后的向量或矩阵。`replace!` 是 `replace` 的原地改变版本。\n\n#### 参数\n\n**X** 可以是向量、矩阵。\n\n**oldValue** 标量，与 *X/newValue* 具有相同数据类别，表示将被替换的值。\n\n**newValue** 标量，与 *X/oldValue* 具有相同数据类别，表示新的值。\n\n#### 返回值\n\n与 *X* 类型相同的向量或矩阵。\n\n#### 例子\n\n```\nx=1 1 3;\nx=x.replace(1,2);\nx\n// output\n[2,2,3];\n\nm=1..4$2:2;\nm\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 3  |\n| 2  | 4  |\n\n```\nm=m.replace(2,1);\nm\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 3  |\n| 1  | 4  |\n\n```\nm.replace!(1,6);\n```\n\n| #0 | #1 |\n| -- | -- |\n| 6  | 3  |\n| 6  | 4  |\n"
    },
    "replay": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/replay.html",
        "signatures": [
            {
                "full": "replay(inputTables, outputTables, [dateColumn], [timeColumn], [replayRate], [absoluteRate=true], [parallelLevel=1], [sortColumns], [preciseRate=false])",
                "name": "replay",
                "parameters": [
                    {
                        "full": "inputTables",
                        "name": "inputTables"
                    },
                    {
                        "full": "outputTables",
                        "name": "outputTables"
                    },
                    {
                        "full": "[dateColumn]",
                        "name": "dateColumn",
                        "optional": true
                    },
                    {
                        "full": "[timeColumn]",
                        "name": "timeColumn",
                        "optional": true
                    },
                    {
                        "full": "[replayRate]",
                        "name": "replayRate",
                        "optional": true
                    },
                    {
                        "full": "[absoluteRate=true]",
                        "name": "absoluteRate",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[parallelLevel=1]",
                        "name": "parallelLevel",
                        "optional": true,
                        "default": "1"
                    },
                    {
                        "full": "[sortColumns]",
                        "name": "sortColumns",
                        "optional": true
                    },
                    {
                        "full": "[preciseRate=false]",
                        "name": "preciseRate",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [replay](https://docs.dolphindb.cn/zh/funcs/r/replay.html)\n\n\n\n#### 语法\n\nreplay(inputTables, outputTables, \\[dateColumn], \\[timeColumn], \\[replayRate], \\[absoluteRate=true], \\[parallelLevel=1], \\[sortColumns], \\[preciseRate=false])\n\n#### 详情\n\n根据指定的回放模式，按时间顺序将一个或多个数据表或数据源列表（由 [replayDS](https://docs.dolphindb.cn/zh/funcs/r/replayDS.html) 函数的返回值）的数据回放到数据表，以模拟实时数据写入，通常用于高频策略回测场景。\n\n**Note:** 不支持乱序处理机制，用户需要自行保证输入的数据有序。\n\n##### 回放形式\n\n根据输入表到输出表的映射（mapping），`replay` 支持 1 对 1，N 对 N，N 对 1 三种回放形式。\n\n相比于N对N回放，N个1对1的各个回放相互独立。当 *inputTables* 指定为数据源列表时，N对N 回放形式可以确保所有回放的第一个数据源回放完，再开始回放第二个数据源。\n\n相比于N对N回放无法保证所有表的数据在全局上的时间顺序，N对1回放形式可以确保不同表的数据写入目标表的顺序与时间字段的先后顺序严格一致。\n\n##### 回放模式\n\n根据回放速度的不同设定，`replay` 提供以下四种回放模式：\n\n* 指定每秒回放记录数：如果 *replayRate* 为正整数，且 *absoluteRate* 为 true，则回放的速率基于记录数计算，系统按照每秒 *replayRate* 条记录进行回放。\n\n* 指定时间跨度回放加速倍数：如果 *replayRate* 为正整数，并且 *absoluteRate* 为 false，则根据输入表数据的时间跨度加速 *replayRate* 倍回放。注意，每秒回放的记录数是相同的。\n\n* 全速回放：如果 *replayRate* 未指定或者为负，无论 *absoluteRate* 为 false 还是 true，系统都将以最快的速率进行回放。\n\n* 精确速度回放：如果 *replayRate* 为正整数，且 *preciseRate*为 true，则数据完全按照事件时间进行倍速回放。系统根据两条相邻数据的时间间隔加速 *replayRate* 倍依次回放每条数据。例如，*replayRate*为 2 时，原本时间戳相差 t 毫秒 的相邻两条数据，会尽量以 t/2 毫秒的时间间隔依次回放。\n\n##### 回放过程\n\n1. 数据加载（仅当输入表是数据源列表时）。\n\n   从磁盘加载数据源到内存时，用户可以指定 *parallelLevel* 参数并行加载数据，以提升性能。数据加载和数据回放异步进行。\n\n2. 分批回放。\n\n   每批回放的记录数和回放耗时受回放模式和系统性能影响。\n\n   | 回放模式                           | 每批数据包含的记录数                                                                                                                              | 取数据的方式                                                | 回放耗时              |\n   | ------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------- | ----------------- |\n   | 按指定记录数回放（数据总数为 s）              | *replayRate* 条数据请注意：此模式下每秒回放一批数据。若输入表是数据源列表（即从磁盘加载）时，回放速度亦受磁盘IO性能制约。若一秒内加载的数据量小于 *replayRate*，则将已加载的数据作为一个批次进行回放。                       | 1 对 1：从单表取一批数据。N 对 1 / N 对 N：根据数据的时间戳顺序，从 N 张表中取一批数据。 | 约为 s/replayRate 秒 |\n   | 按时间跨度加速回放(数据时间跨度为 n 秒，数据总数为 s) | replayRate\\*s/n 条数据（若不足 1 条，则取 1 条）请注意：此模式下每秒回放一批数据。若输入表是数据源列表（即从磁盘加载）时，回放速度亦受磁盘IO性能制约。若一秒内加载的数据量小于 replayRate\\*s/n，则将已加载的数据作为一个批次进行回放。 | 1 对 1：从单表取一批数据。N 对 1 / N 对 N：根据数据的时间戳顺序，从 N 张表中取一批数据。 | 约为 n/replayRate 秒 |\n   | 全速回放                           | 每次回放时系统已加载的所有数据                                                                                                                         | 1 对 1：同上。N 对 1：同上。N 对 N：逐一回放各输入表，每次从单表取一批数据。          | 取决于系统性能           |\n\n   **Note:** 上表的回放耗时计算方法适用于评估同构回放的耗时，异构回放的耗时会略高于同构回放。\n\n   回放过程中，系统会先从内存按批取出数据并回放。`replay` 只保证同一批次数据的回放结果是有序的。因此，在调用 `replay` 函数前，请将输入表按照指定的时间列（由参数 *dateColumn* 和 *timeColumn* 决定）排序。\n\n3. 数据写入。\n\n   **Note:** 目前系统仅支持单线程写入输出表。\n\n4. 终止回放：可使用 [cancelJob](https://docs.dolphindb.cn/zh/funcs/c/cancelJob.html) 和 [cancelConsoleJob](https://docs.dolphindb.cn/zh/funcs/c/cancelConsoleJob.html) 命令。\n\n   **Note:**\n\n   * 2.00.5 版本前，N 对 1 回放要求输入表结构必须相同，称为同构回放。自 2.00.5 版本起，N 对 1 回放开始支持输入结构不同的表，称为异构回放。由于异构回放到输出表的记录均被序列化存储，无法直接读取，需要通过 [streamFilter](https://docs.dolphindb.cn/zh/funcs/s/streamFilter.html) 进行数据过滤和分发，详情请参考 [streamFilter](https://docs.dolphindb.cn/zh/funcs/s/streamFilter.html)。\n\n   * 2.00.9 版本后，若 N 对 1 回放的输入表为多个数据源列表，会自动按照时间戳排序后回放。在该版本前，系统每次仅加载多个列表相同索引位置的数据源排序后回放，不保证全局的有序性。\n\n#### 参数\n\n根据回放形式的不同， **inputTables** 的数据形式也有所不同：\n\n* 1 对 1 回放时，*inputTables* 是一个未分区的表或数据源列表。\n\n* N 对 1 同构回放或 N 对 N 回放时，*inputTables* 是多个未分区的表或数据源列表构成的元组。\n\n* N 对 1 异构回放时，*inputTables* 是一个字典。字典的 key 可以是任意数据类型，表示输入表或数据源列表的唯一标识，value 是一个表对象或数据源列表。\n\n根据回放形式的不同， **outputTables** 的数据形式也有所不同：\n\n**Note:** 支持指定 *outputTables* 为 Orca 流表名称，其格式为 \\<catalog>.orca\\_table.\\<name>。\n\n* 1 对 1 回放或 N 对 1 同构回放时，*outputTables*\\_是一个表对象（未分区的内存表/流数据表）或表示共享表名的字符串，必须与输入表的 schema 相同。\n\n* N 对 N 回放，*outputTables* 是多个表对象（未分区的内存表/流数据表）或表示共享表名的字符串构成的元组，且它的长度必须与 *inputTables* 相同。输出表和输入表一一对应，且 schema 必须相同。\n\n* N 对 1 异构回放时 *outputTables* 是 一个表对象（未分区的内存表/流数据表），至少包含三列：\n\n其中：\n\n* 第一列为 *dateColumn* 和 *timeColumn* 指定的回放时间的时间戳；\n\n* 第二列为 SYMBOL 或 STRING 类型，对应 *inputTables* 字典的 key；\n\n* 第三列为 BLOB 类型，用于存储被回放的每条记录序列化后的结果。\n\n此外，可输出各输入表的公共列（列名和类型一致的列）。\n\n**dateColumn** 和 **timeColumn** 为时间列的列名，至少指定其中一个参数。根据回放形式的不同，*dateColumn* 和 *timeColumn* 的取值有所区别：\n\n* 1 对 1 回放或 N 对 1 同构回放: 输入表与输出表的时间列列名必须相同，指定为字符串标量；\n\n* N 对 N 回放：输入表时间列的列名相同，指定为字符串标量；输入表时间列的列名不同，指定为字符串向量；\n\n* N 对 1 异构回放：输入表时间列的列名相同，指定为字符串标量；输入表时间列的列名不同，指定为字典，其中 key 为输入表的唯一标识符，value 是对应表时间列的列名。\n\n只指定 *dateColumn* 或 *timeColumn* 中的一个参数，或者 *dateColumn* 和 *timeColumn* 指定为同一列时，对指定的时间列的类型没有限制。\n\n若指定 *dateColumn* 和 *timeColumn* 为不同列，*dateColumn* 必须是 DATE 类型，*timeColumn* 只能是 SECOND, TIME 或 NANOTIME 类型。\n\n**replayRate** 整数，和参数 *absoluteRate* 共同决定了回放的速率。\n\n**absoluteRate** 布尔值。默认值为 true，表示系统每秒按 *replayRate* 指定的记录数回放。若为 false，表示依照数据的时间跨度加速 *replayRate* 倍回放。\n\n**parallelLevel** 正整数，表示从数据源加载数据到内存的工作线程数量，默认值为 1。如果 *inputTables* 不是数据源，无需指定该参数。\n\n**sortColumns** 字符串标量或者长度为2的向量。相同回放时间戳的数据将根据该参数指定的字段进行排序。\n\n**Note:** 该参数可以指定 *inputTables* 的非公共列。若某个输入表不存在指定的非公共列，则填充空值且将其前置。\n\n**preciseRate** 布尔值。默认值为 false，表示不开启精确速度回放。若指定为 true，则系统根据相邻记录的时间戳，以 *replayRate* 指定的倍数精确回放。\n\n#### 例子\n\n##### 一对一回放\n\n以下为按不同回放模式进行一对一回放的例子\n\n```\nn=1000\nsym = take(`IBM,n)\ntimestamp= take(temporalAdd(2012.12.06T09:30:12.000,1..500,'s'),n)\nvolume = rand(100,n)\ntrades=table(sym,timestamp,volume)\ntrades.sortBy!(`timestamp)\nshare streamTable(100:0,`sym`timestamp`volume,[SYMBOL,TIMESTAMP,INT]) as st\n```\n\n* 每秒回放100条数据：\n\n  ```\n  timer replay(inputTables=trades, outputTables=st, dateColumn=`timestamp, \n      timeColumn=`timestamp,replayRate=100, absoluteRate=true);\n   Time elapsed: 10001.195 ms\n  ```\n\n  表 trades 中一共有1000条数据，每秒回放100条耗时大约10秒。\n\n* 加速100倍时间回放：\n\n  ```\n  timer replay(inputTables=trades,outputTables=st,dateColumn=`timestamp,\n      timeColumn=`timestamp,replayRate=100,absoluteRate=false);\n    Time elapsed: 5001.909 ms\n  ```\n\n  表 trades 中的最大时间与最小时间相差500秒，加速 100 倍时间回放耗时大约5秒。\n\n* 以最快的速率回放：\n\n  ```\n  timer replay(inputTables=trades,outputTables=st,dateColumn=`timestamp,\n      timeColumn=`timestamp);\n    Time elapsed: 0.974 ms\n  ```\n\n* 精确速度回放：\n\n  ```\n  timer replay(inputTables=trades,outputTables=st,dateColumn=`timestamp,\n      timeColumn=`timestamp,replayRate=100,absoluteRate=false, preciseRate=true);\n    Time elapsed: 4991.177 ms\n  ```\n\n  表 trades 中，以相邻两条记录时间戳的 100 倍速度回放，回放时间大约 4.99 秒。\n\n##### N 对 N 回放\n\n以下为将多个数据源列表回放到多个输出表中的例子。\n\n以下脚本将两个数据源回放到连接引擎，进行 asof join 计算。\n\n```\nn=50000\nsym = rand(symbol(`IBM`APPL`MSFT`GOOG`GS),n)\ndate=take(2012.06.12..2012.06.16,n)\ntime=rand(13:00:00.000..16:59:59.999,n)\nvolume = rand(100,n)\nt1=table(sym,date,time,volume).sortBy!([`date, `time])\n\nsym = rand(symbol(`IBM`APPL`MSFT`GOOG`GS),n)\ndate=take(2012.06.12..2012.06.16,n)\ntime=rand(13:00:00.000..16:59:59.999,n)\nprice = 100 + rand(10.0,n)\nt2=table(sym,date,time,price).sortBy!([`date, `time])\n\nif(existsDatabase(\"dfs://test_stock\")){\ndropDatabase(\"dfs://test_stock\")\n}\ndb=database(\"dfs://test_stock\",VALUE,2012.06.12..2012.06.16)\npt1=db.createPartitionedTable(t1,`pt1,`date).append!(t1)\npt2=db.createPartitionedTable(t2,`pt2,`date).append!(t2)\n\nleft = table(100:0,`sym`dt`volume,[SYMBOL,TIMESTAMP,INT]) \nright = table(100:0,`sym`dt`price,[SYMBOL,TIMESTAMP,DOUBLE]) \n\nopt=table(100:0, `dt`sym`volume`price`total, [TIMESTAMP, SYMBOL, INT, DOUBLE, DOUBLE])\najEngine=createAsofJoinEngine(name=\"ajEngine\", leftTable=left, rightTable=right, \n    outputTable=opt, metrics=<[volume, price, volume*price]>, \n    matchingColumn=`sym, timeColumn=`dt, useSystemTime=false, delayedTime=1)\n\nds1=replayDS(sqlObj=<select sym, concatDateTime(date, time) as dt, volume from pt1>,\n    dateColumn=`date, timeColumn=`time,\n    timeRepartitionSchema=[13:00:00.000, 14:00:00.000, 15:00:00.000, 16:00:00.000, 17:00:00.000])\nds2=replayDS(sqlObj=<select sym, concatDateTime(date, time) as dt, price from pt2>,\n    dateColumn=`date, timeColumn=`time,\n    timeRepartitionSchema=[13:00:00.000, 14:00:00.000, 15:00:00.000, 16:00:00.000, 17:00:00.000])\n\nreplay(inputTables=[ds1,ds2], outputTables=[getLeftStream(ajEngine), \n    getRightStream(ajEngine)], dateColumn=`dt);   \n\nselect count(*) from opt\n```\n\n返回：50000\n\n##### 异构回放\n\n异构回放中，回放的输出表通常注入 streamFilter 引擎，进一步过滤分发处理。\n\n```\nn=1000\nsym = take(`IBM`GS,n)\nmyDate=take(2021.01.02..2021.01.06, n).sort!()\nmyTime=take(09:30:00..15:59:59,n)\nvol =  array(INT[], 0, 10)\nfor(i in 0:n){vol.append!([rand(100,3)])}\nt=table(sym,myDate,myTime,vol)\n\nsym = take(`IBM`GS,n)\ndate=take(2021.01.02..2021.01.06, n).sort!()\ntime=take(09:30:00..15:59:59,n)\nvol =  array(INT[], 0, 10)\nfor(i in 0:n){vol.append!([rand(100,3)])}\nprice =  array(DOUBLE[], 0, 10)\nfor(i in 0:n){price.append!([rand(10.0,3)])}\nt1=table(sym, date,time,vol,price)\n\n\nif(existsDatabase(\"dfs://test_stock1\")){\n  dropDatabase(\"dfs://test_stock1\")\n}\ndb1=database(\"\",RANGE, 2021.01.02..2021.01.07)\ndb2=database(\"\",VALUE,`IBM`GS)\ndb=database(\"dfs://test_stock1\",COMPO,[db1, db2], engine=\"TSDB\")\norders=db.createPartitionedTable(t,`orders,`myDate`sym, sortColumns=`sym`myDate`myTime)\norders.append!(t);\ntrades=db.createPartitionedTable(t1,`trades,`date`sym, sortColumns=`sym`date`time)\ntrades.append!(t1);\n// 获取数据源\nds = replayDS(sqlObj=<select * from loadTable(db, `orders)>, dateColumn=`myDate, timeColumn=`myTime)\nds.size();\nds1 = replayDS(sqlObj=<select * from loadTable(db, `trades)>, dateColumn=`date, timeColumn=`time)\nds1.size();\n\ninput_dict  = dict([\"msg1\", \"msg2\"], [ds, ds1])\ndate_dict = dict([\"msg1\", \"msg2\"], [`myDate, `date])\ntime_dict = dict([\"msg1\", \"msg2\"], [`myTime, `time])\n// replay 的输出表，被订阅输入 streamFilter\nshare streamTable(100:0,`timestamp`sym`blob`vol, [DATETIME,SYMBOL, BLOB, INT[]]) as opt\n\nfilterOrder=table(100:0, `sym`date`time`volume, [SYMBOL, DATE, SECOND, INT[]])\nfilterTrades=table(100:0, `sym`date`time`volume`price, [SYMBOL, DATE, SECOND, INT[], DOUBLE[]])\n// 定义 streamFilter 输入表\nshare streamTable(100:0,`timestamp`sym`blob`vol, [DATETIME,SYMBOL, BLOB, INT[]]) as streamFilter_input\n// streamFilter 对接收的数据进行处理，分别分发到表 filterOrder 和 filterTrades\nfilter1=dict(STRING,ANY)\nfilter1['condition']=`msg1\nfilter1['handler']=filterOrder\n\nfilter2=dict(STRING,ANY)\nfilter2['condition']=`msg2\nfilter2['handler']=filterTrades\nschema=dict([\"msg1\",\"msg2\"], [filterOrder, filterTrades])\nstEngine=streamFilter(name=`streamFilter, dummyTable=streamFilter_input, \n    filter=[filter1,filter2], msgSchema=schema)\nsubscribeTable(tableName=\"opt\", actionName=\"sub1\", offset=0, handler=stEngine, msgAsTable=true)\n\nreplay(inputTables=input_dict, outputTables=opt, dateColumn = date_dict, \n    timeColumn=time_dict,  replayRate=100, absoluteRate=false);\n\nselect count(*) from filterOrder\n```\n\n返回：1000\n\n```\nselect count(*) from filterTrades\n```\n\n返回：1000\n\n##### 自动记录回放数据的写入时间戳\n\n在数据回放前，对目标输出流表调用 [setStreamTableTimestamp](https://docs.dolphindb.cn/zh/funcs/s/setstreamtabletimestamp.html) 函数，可为输出表指定时间戳列。回放过程中，系统将自动把数据写入时的系统时间记录到该列。\n\n下例展示了通过 `setStreamTableTimestamp` 设置为输出表设置时间戳列，再执行数据回放操作。\n\n```\n// 输入表\nn=50000\nsym = rand(symbol(`IBM`APPL`MSFT`GOOG`GS),n)\ndate = take(2012.06.12..2012.06.16,n)\ntime = take(13:00:00.000..16:59:59.999,n)\nvolume = rand(100,n)\ninput1 = table(sym,date,time,volume).sortBy!([`date, `time])\nsym = rand(symbol(`IBM`APPL`MSFT`GOOG`GS),n)\ndate = take(2012.06.12..2012.06.16,n)\ntime = take(13:00:00.000..16:59:59.999,n)\nprice = 100 + rand(10.0,n)\ninput2 = table(sym,date,time,price).sortBy!([`date, `time])\n// 输出表\nshare streamTable(100:0,`sym`date`time`volume`replaytime,[SYMBOL,DATE,TIME,INT,TIMESTAMP]) as output1\nshare streamTable(100:0,`sym`date`time`price`replaytime,[SYMBOL,DATE,TIME,DOUBLE,TIMESTAMP]) as output2\nsetStreamTableTimestamp(output1, `replaytime)\nsetStreamTableTimestamp(output2, `replaytime)\n// 回放数据\nreplay(inputTables=[input1, input2], outputTables=[output1, output2], dateColumn=`date, timeColumn=`time)\n```\n\n输出表 output1：\n\n| sym  | date       | time         | volume | replaytime              |\n| ---- | ---------- | ------------ | ------ | ----------------------- |\n| GOOG | 2012.06.12 | 13:00:00.000 | 12     | 2025.08.05 10:14:55.475 |\n| GOOG | 2012.06.12 | 13:00:00.005 | 78     | 2025.08.05 10:14:55.475 |\n| GOOG | 2012.06.12 | 13:00:00.010 | 43     | 2025.08.05 10:14:55.475 |\n| GS   | 2012.06.12 | 13:00:00.015 | 19     | 2025.08.05 10:14:55.475 |\n| MSFT | 2012.06.12 | 13:00:00.020 | 99     | 2025.08.05 10:14:55.475 |\n| …    |            |              |        |                         |\n\n输出表 output2：\n\n| sym  | date       | time         | price              | replaytime              |\n| ---- | ---------- | ------------ | ------------------ | ----------------------- |\n| APPL | 2012.06.12 | 13:00:00.000 | 104.28991972325885 | 2025.08.05 10:14:55.476 |\n| MSFT | 2012.06.12 | 13:00:00.005 | 105.34384201248842 | 2025.08.05 10:14:55.476 |\n| APPL | 2012.06.12 | 13:00:00.010 | 102.77994729862654 | 2025.08.05 10:14:55.476 |\n| APPL | 2012.06.12 | 13:00:00.015 | 105.42814567712317 | 2025.08.05 10:14:55.476 |\n| APPL | 2012.06.12 | 13:00:00.020 | 108.74385016313717 | 2025.08.05 10:14:55.476 |\n\n**Related information**\n\n[replayDS](https://docs.dolphindb.cn/zh/funcs/r/replayDS.html)\n"
    },
    "replayDS": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/replayDS.html",
        "signatures": [
            {
                "full": "replayDS(sqlObj, [dateColumn], [timeColumn], [timeRepartitionSchema])",
                "name": "replayDS",
                "parameters": [
                    {
                        "full": "sqlObj",
                        "name": "sqlObj"
                    },
                    {
                        "full": "[dateColumn]",
                        "name": "dateColumn",
                        "optional": true
                    },
                    {
                        "full": "[timeColumn]",
                        "name": "timeColumn",
                        "optional": true
                    },
                    {
                        "full": "[timeRepartitionSchema]",
                        "name": "timeRepartitionSchema",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [replayDS](https://docs.dolphindb.cn/zh/funcs/r/replayDS.html)\n\n\n\n#### 语法\n\nreplayDS(sqlObj, \\[dateColumn], \\[timeColumn], \\[timeRepartitionSchema])\n\n#### 详情\n\n将一个 SQL 表达式，根据时间维度划分为多个数据源，作为 `replay` 函数的输入，逐一进行回放。时间维度既可以为 DFS 表的时间列的分区粒度，也可以是基于该分区粒度的进一步的划分（由参数 *timeColumn* 与 *timeRepartitionSchema* 决定）。\n\n若要回放 DFS 表中的数据，只能使用 `replayDS` 函数配合 `replay` 函数进行。\n\n#### 参数\n\n**sqlObj** 表示 SQL 查询的元代码。SQL 查询的表对象是 DFS 表，且至少有一个分区列为时间类型。\n\n**dateColumn** 列必须为 SQL 查询的表对象的时间类型列，一般为 DATE 类型，亦可为 MONTH 类型或其它时间类型。作为数据的排序依据。*dateColumn* 列必须为表的分区列之一，系统将根据 *dateColumn* 列的分区粒度划分数据源，如 dateColumn 列按天进行分区，则数据源也按天进行划分。\n\n**timeColumn** 列必须为 SQL 查询的表对象的时间列，作为数据的排序依据。若 *dateColumn* 为 DATE 类型时，可以指定 *timeColumn* 为 SECOND, TIME 或 NANOTIME 类型的列作为第二排序列。此外，配合 *timeRepartitionSchema* 参数，*timeColumn* 列也可以作为数据源划分依据。\n\n**Note:**\n\n* *dateColumn* 和 *timeColumn* 暂不支持 DATEHOUR 类型的时间列。\n* 如果没有指定 *dateColumn*，原数据表的第一列将会作为 *dateColumn*。\n\n**timeRepartitionSchema** 时间类型的向量。如果指定了 *timeColumn*，*timeRepartitionSchema* 可用于划分更小粒度的数据源。如果 *timeRepartitionSchema* 为 \\[t1, t2, t3]，均为 TIME 类型，则会将每天的数据进一步划分为 4 个数据源：\\[00:00:00.000,t1), \\[t1,t2), \\[t2,t3) 和 \\[t3,23:59:59.999)。\n\n#### 返回值\n\n返回一个数据源列表，类型为 ANY VECTOR。\n\n#### 例子\n\n在以下例子中：\n\n1. 创建变量 n。\n2. 创建一个包含 `IBM` 和 `GS` 的 join 表 sym，并重复该表内容。\n3. 创建一个包含 2021.01.04 到 2021.01.06 的日期序列 date，并对其排序，用于模拟交易日。\n4. 创建一个包含 09:30:00 到 15:59:59 的时间序列 time 用于模拟交易时间。\n5. 创建一个包含随机数（范围在 0 到 100 之间）的交易量序列 volume。\n6. 创建一个名为 t 的表，包含符号、日期、时间和交易量这四个字段。\n7. 如果名为 \"dfs\\://test\\_stock\" 的数据库存在，则删除该数据库。\n8. 创建两个不同类型的数据库 db1 和 db2，分别为 RANGE 类型和 VALUE 类型，并将它们组合到 \"dfs\\://test\\_stock\" 中。\n9. 在数据库中创建一个分区表 trades，按 date 和 sym 分区。\n10. 向 trades 表追加 t 表的内容。\n11. 创建一个 replayDS 对象，从 trades 表中加载数据，并按日期维度和时间维度划分这些数据形成数据源列表 ds。\n12. 输出 ds 的大小。\n\n```\nn=int(60*60*6.5)\nsym = take(take(`IBM,n).join(take(`GS,n)), n*2*3)\ndate=take(2021.01.04..2021.01.06, n*2*3).sort!()\ntime=take(09:30:00..15:59:59,n*2*3)\nvolume = rand(100, n*2*3)\nt=table(sym,date,time,volume)\nif(existsDatabase(\"dfs://test_stock\")){\ndropDatabase(\"dfs://test_stock\")\n}\ndb1=database(\"\",RANGE, 2021.01.04..2021.01.07)\ndb2=database(\"\",VALUE,`IBM`GS)\ndb=database(\"dfs://test_stock\",COMPO,[db1, db2])\ntrades=db.createPartitionedTable(t,`trades,`date`sym)\ntrades.append!(t);\nds = replayDS(sqlObj=<select * from loadTable(db, `trades)>, dateColumn=`date, timeColumn=`time)\nds.size();\n```\n\n返回：3。\n\n接着，从数据库中加载名为 trades 表的所有数据，指定 *timeRepartitionSchema* 为 `[11:30:00, 14:00:00]`，按照指定的时间范围对每日数据进行重分区，重新计算数据源列表的大小：\n\n```\nds = replayDS(sqlObj=<select * from loadTable(db, `trades)>, dateColumn=`date, timeColumn=`time, timeRepartitionSchema=[11:30:00, 14:00:00])\nds.size();\n```\n\n指定时间区间 `[11:30:00, 14:00:00]` 后，每天的数据被划分为三个更小的部分 \\[09:30:00, 11:30:00)、\\[11:30:00, 14:00:00] 和 \\[14:00, 15:59:59]。\n\n因此，返回：9。\n\n**Related information**\n\n[replay](https://docs.dolphindb.cn/zh/funcs/r/replay.html)\n"
    },
    "repmat": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/repmat.html",
        "signatures": [
            {
                "full": "repmat(X, rowRep, colRep)",
                "name": "repmat",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "rowRep",
                        "name": "rowRep"
                    },
                    {
                        "full": "colRep",
                        "name": "colRep"
                    }
                ]
            }
        ],
        "markdown": "### [repmat](https://docs.dolphindb.cn/zh/funcs/r/repmat.html)\n\n\n\n#### 语法\n\nrepmat(X, rowRep, colRep)\n\n#### 详情\n\n将矩阵 *X* 竖向重复 *rowRep* 次，横向重复 *colRep* 次，产生一个新的矩阵。\n\n#### 参数\n\n**X** 是一个矩阵。\n\n**rowRep** 与 **colRep** 均为正整数。\n\n#### 返回值\n\n一个矩阵。\n\n#### 例子\n\n```\nx=matrix(1 2 3, 4 5 6);\n```\n\n输出返回：\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 4  |\n| 2  | 5  |\n| 3  | 6  |\n\n```\nrepmat(x, 2, 3);\n```\n\n输出返回：\n\n| #0 | #1 | #2 | #3 | #4 | #5 |\n| -- | -- | -- | -- | -- | -- |\n| 1  | 4  | 1  | 4  | 1  | 4  |\n| 2  | 5  | 2  | 5  | 2  | 5  |\n| 3  | 6  | 3  | 6  | 3  | 6  |\n| 1  | 4  | 1  | 4  | 1  | 4  |\n| 2  | 5  | 2  | 5  | 2  | 5  |\n| 3  | 6  | 3  | 6  | 3  | 6  |\n"
    },
    "resample": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/resample.html",
        "signatures": [
            {
                "full": "resample(X, rule, func, [closed], [label], [origin='start_day'])",
                "name": "resample",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "rule",
                        "name": "rule"
                    },
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "[closed]",
                        "name": "closed",
                        "optional": true
                    },
                    {
                        "full": "[label]",
                        "name": "label",
                        "optional": true
                    },
                    {
                        "full": "[origin='start_day']",
                        "name": "origin",
                        "optional": true,
                        "default": "'start_day'"
                    }
                ]
            }
        ],
        "markdown": "### [resample](https://docs.dolphindb.cn/zh/funcs/r/resample.html)\n\n\n\n#### 语法\n\nresample(X, rule, func, \\[closed], \\[label], \\[origin='start\\_day'])\n\n#### 详情\n\n依照指定时间频率（或交易日历），对给定数据使用给定函数。注意，*rule* 指定为交易日历标识时，对于非交易日的数据，将并入上一个交易日计算。\n\nDolphinDB 的 `resample` 和 pandas 的 `resample` 都用于时间序列重采样与分桶聚合，但两者的接口设计和使用方式有所不同：\n\n* DolphinDB 的`resample` 采用函数式接口，直接将聚合函数作为参数传入。输入对象需为带递增时间行标签的矩阵或序列，并支持基于内置交易日历的重采样规则。\n\n* pandas 的 `resample` 则返回一个 `Resampler` 对象，通常以 `df.resample(\"3min\").sum()` 或 `.agg()` 的链式方式使用。输入可以是 DatetimeIndex、PeriodIndex 或 TimedeltaIndex，也可以通过 *on* 或 *level* 参数指定时间列。该接口更适合 DataFrame 工作流，并原生支持 `asfreq`、`ffill`、`bfill`、`interpolate` 等采样后补值操作。\n\n#### 参数\n\n**X** 是一个带有行标签的矩阵或序列（indexed series）。行标签要求为时间类型，不得含有空值，且必须保持递增。\n\n**rule** 是一个字符串，可取以下值：\n\n| rule 参数取值 | 对应 DolphinDB 函数      |\n| --------- | -------------------- |\n| \"B\"       | businessDay          |\n| \"W\"       | weekEnd              |\n| \"WOM\"     | weekOfMonth          |\n| \"LWOM\"    | lastWeekOfMonth      |\n| \"M\"       | monthEnd             |\n| \"MS\"      | monthBegin           |\n| \"BM\"      | businessMonthEnd     |\n| \"BMS\"     | businessMonthBegin   |\n| \"SM\"      | semiMonthEnd         |\n| \"SMS\"     | semiMonthBegin       |\n| \"Q\"       | quarterEnd           |\n| \"QS\"      | quarterBegin         |\n| \"BQ\"      | businessQuarterEnd   |\n| \"BQS\"     | businessQuarterBegin |\n| \"REQ\"     | fy5253Quarter        |\n| \"A\"       | yearEnd              |\n| \"AS\"      | yearBegin            |\n| \"BA\"      | businessYearEnd      |\n| \"BAS\"     | businessYearBegin    |\n| \"RE\"      | fy5253               |\n| \"D\"       | date                 |\n| \"H\"       | hourOfDay            |\n| \"U\"       | microsecond          |\n| \"L\"       | millisecond          |\n| \"min\"     | minuteOfHour         |\n| \"N\"       | nanosecond           |\n| \"S\"       | secondOfMinute       |\n| \"SA\"      | semiannualEnd        |\n| \"SAS\"     | semiannualBegin      |\n\n上述字符串亦可配合使用数字（必须为正整数），例如 \"2M\" 表示频率为每两个月月末。此外，*rule* 也可以是交易日历标识（国外交易所的 ISO Code、国内交易所简称或自定义交易日历名称），以便基于交易日历进行计算。交易日历也可以配合使用数字，表示多个交易日，此时只能指定由4个大写字母组成的交易日历标识。例如：“2XSHG”，表示上海证券交易所每两个交易日。\n\n**func** 一个聚合函数。\n\n**closed** 字符串，表示分组区间哪一个边界是闭合的。\n\n* *rule* 为 'M', 'A', 'Q', 'BM', 'BA', 'BQ' 和 'W' 时，*closed* 的默认取值为 'right' ，否则，*closed* 的默认取值为 'left'。\n\n* *origin* 取 'end' 或者 'end\\_day' 时，*closed* 的默认值为 'right'。\n\n**label** 字符串，表示将分组区间的哪一个边界作为 *label* 输出。\n\n* *rule* 为 'M', 'A', 'Q', 'BM', 'BA', 'BQ' 和 'W' 时，*label* 的默认取值为 'right' ，否则，*label* 的默认取值为 'left'。\n\n* *origin* 取 'end' 或者 'end\\_day' 时，*label* 的默认值为 'right'。\n\n**origin** 字符串或与 *X* 具有相同时间类型的标量，表示基于时间戳调整分组。*origin* 的取值为 'epoch', start', 'start\\_day', 'end', 'end\\_day' 或自定义的时间对象，默认值为 'start\\_day'。\n\n* 'epoch'：分组起始点为1970-01-01。\n\n* 'start'：分组起始点为时间序列的第一个值。\n\n* 'start\\_day'：分组起始点是时间序列的第一个值对应日期的午夜零点。\n\n* 'end'：分组起始点是时间序列的最后一个时间戳。\n\n* 'end\\_day'：分组起始点是时间序列的最后一个时间戳对应日期的午夜24点（即下一日的零点）。\n\n#### 返回值\n\n返回一个行标签的矩阵或序列。\n\n#### 例子\n\n```\nindex = [2000.01.01, 2000.01.31, 2000.02.15, 2000.02.20, 2000.03.12, 2000.04.16, 2000.05.06, 2000.08.30]\ns = indexedSeries(index, 1..8)\ns.resample(\"M\", sum);\n```\n\n|            | col1 |\n| ---------- | ---- |\n| 2000.01.31 | 3    |\n| 2000.02.29 | 7    |\n| 2000.03.31 | 5    |\n| 2000.04.30 | 6    |\n| 2000.05.31 | 7    |\n| 2000.06.30 |      |\n| 2000.07.31 |      |\n| 2000.08.31 | 8    |\n\n```\ns.resample(\"2M\", last);\n```\n\n|            | col1 |\n| ---------- | ---- |\n| 2000.01.31 | 2    |\n| 2000.03.31 | 5    |\n| 2000.05.31 | 7    |\n| 2000.07.31 |      |\n| 2000.09.30 | 8    |\n\n```\nindex = temporalAdd(2022.01.01 00:00:00,1..8,`m)\ns = indexedSeries(index, 1..8)\ns.resample(rule=`3min, func=sum);\n```\n\n| label               | col1 |\n| ------------------- | ---- |\n| 2022.01.01T00:00:00 | 3    |\n| 2022.01.01T00:03:00 | 12   |\n| 2022.01.01T00:06:00 | 21   |\n\n```\ns.resample(rule=`3min, func=sum, closed=`right);\n```\n\n| label               | col1 |\n| ------------------- | ---- |\n| 2022.01.01T00:00:00 | 6    |\n| 2022.01.01T00:03:00 | 15   |\n| 2022.01.01T00:06:00 | 15   |\n\n```\ns.resample(rule=`3min, func=sum, closed=`left,origin=`end);\n```\n\n| label               | col1 |\n| ------------------- | ---- |\n| 2022.01.01T00:02:00 | 1    |\n| 2022.01.01T00:05:00 | 9    |\n| 2022.01.01T00:08:00 | 18   |\n| 2022.01.01T00:11:00 | 8    |\n\n```\ns.resample(rule=`3min, func=sum,origin=2022.10.01 00:00:10)\n```\n\n| label               | col1 |\n| ------------------- | ---- |\n| 2022.01.01T00:00:10 | 6    |\n| 2022.01.01T00:03:10 | 15   |\n| 2022.01.01T00:06:10 | 15   |\n\n```\nm = matrix(1..5, 1..5)\nindex = temporalAdd(2000.01.01, [1, 1, 2, 2, 3], \"d\")\nm.rename!(index, `A`B);\nm.resample(rule=`D, func=sum);\n```\n\n| label      | A | B |\n| ---------- | - | - |\n| 2000.01.02 | 3 | 3 |\n| 2000.01.03 | 7 | 7 |\n| 2000.01.04 | 5 | 5 |\n\n**Related information**\n\n[spline](https://docs.dolphindb.cn/zh/funcs/s/spline.html)\n\n[neville](https://docs.dolphindb.cn/zh/funcs/n/neville.html)\n\n[dividedDifference](https://docs.dolphindb.cn/zh/funcs/d/dividedDifference.html)\n\n[loess](https://docs.dolphindb.cn/zh/funcs/l/loess.html)\n"
    },
    "resetDBDirMeta": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/resetDBDirMeta.html",
        "signatures": [
            {
                "full": "resetDBDirMeta(dbDir)",
                "name": "resetDBDirMeta",
                "parameters": [
                    {
                        "full": "dbDir",
                        "name": "dbDir"
                    }
                ]
            }
        ],
        "markdown": "### [resetDBDirMeta](https://docs.dolphindb.cn/zh/funcs/r/resetDBDirMeta.html)\n\n\n\n#### 语法\n\nresetDBDirMeta(dbDir)\n\n#### 详情\n\n跨磁盘卷转移元数据时, 由于元数据中包含了 DATABASE 存储路径相关的信息，所以转移元数据前，必须调用 `resetDBDirMeta` 修改元数据中 DATABASE 存储的路径为目的路径。该命令只能在数据节点上执行。\n\n请注意：\n\n1. 只能在同一个数据节点上进行跨磁盘卷转移元数据的操作。\n\n2. 进行该操作前，需要停止写入，保证所有事务都已完成，并将所有缓冲区的数据刷入磁盘。\n\n假设将 metalog 目录 从 volumeA 转移至 volumeB，完整过程如下：\n\n1. 执行命令 resetDBDirMeta('volumeB/DATABASE') 后关闭 server。\n\n2. 手动拷贝 volumeA 下的目录 CHUNK\\_METADATA, DATABASE, IOTRAN\\_TYPE 和 LOG 到 volumeB。\n\n3. 删除 volumeA 下的目录 CHUNK\\_METADATA，DATABASE，IOTRAN\\_TYPE 和 LOG。\n\n4. 修改配置 *chunkMetaDir* = volumeB/CHUNK\\_METADATA 后启动 server。\n\n**首发版本**：2.00.4\n\n#### 参数\n\n**dbDir** 是一个字符串，格式如：\"volumeB/DATABASE\"。表示 DATABASE 将要转移到的目的路径。\n"
    },
    "resetDfsRebalanceConcurrency": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/resetDfsRebalanceConcurrency.html",
        "signatures": [
            {
                "full": "resetDfsRebalanceConcurrency(newConcurrecyNum)",
                "name": "resetDfsRebalanceConcurrency",
                "parameters": [
                    {
                        "full": "newConcurrecyNum",
                        "name": "newConcurrecyNum"
                    }
                ]
            }
        ],
        "markdown": "### [resetDfsRebalanceConcurrency](https://docs.dolphindb.cn/zh/funcs/r/resetDfsRebalanceConcurrency.html)\n\n\n\n#### 语法\n\nresetDfsRebalanceConcurrency(newConcurrecyNum)\n\n#### 详情\n\n在线修改当前节点再平衡任务的最大并发数。此函数只能由管理员在控制节点调用。\n\n注意：此函数修改的配置值将在系统重启后失效。若需使配置值永久生效，请编辑配置文件中的 dfsRebalanceConcurrency 参数。默认情况下，该参数值为集群中控制节点、数据节点和计算节点的节点数之和的两倍。\n\n#### 参数\n\n**newConcurrecyNum** 正整数，代表再平衡任务的并发数上限。\n\n#### 例子\n\n```\nresetDfsRebalanceConcurrency(2)\n```\n\n相关函数：[getDfsRebalanceConcurrency](https://docs.dolphindb.cn/zh/funcs/g/getDfsRebalanceConcurrency.html)\n"
    },
    "resetDfsRecoveryConcurrency": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/resetDfsRecoveryConcurrency.html",
        "signatures": [
            {
                "full": "resetDfsRecoveryConcurrency(newConcurrecyNum)",
                "name": "resetDfsRecoveryConcurrency",
                "parameters": [
                    {
                        "full": "newConcurrecyNum",
                        "name": "newConcurrecyNum"
                    }
                ]
            }
        ],
        "markdown": "### [resetDfsRecoveryConcurrency](https://docs.dolphindb.cn/zh/funcs/r/resetDfsRecoveryConcurrency.html)\n\n\n\n#### 语法\n\nresetDfsRecoveryConcurrency(newConcurrecyNum)\n\n#### 详情\n\n在线修改当前节点分区恢复任务的最大并发数。此函数只能由管理员在控制节点调用。\n\n注意：此函数修改的配置值将在系统重启后失效。若需使配置值永久生效，请编辑配置文件中的 dfsRecoveryConcurrency参数。默认情况下，该参数值为集群中控制节点、数据节点和计算节点的节点数之和的两倍。\n\n#### 参数\n\n**newConcurrecyNum** 正整数，代表分区恢复任务的并发数上限。\n\n#### 例子\n\n```\nresetDfsRecoveryConcurrency(2)\n```\n\n相关函数：[getDfsRecoveryConcurrency](https://docs.dolphindb.cn/zh/funcs/g/getDfsRecoveryConcurrency.html)\n"
    },
    "resetPwd": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/resetPwd.html",
        "signatures": [
            {
                "full": "resetPwd(userId, newPwd)",
                "name": "resetPwd",
                "parameters": [
                    {
                        "full": "userId",
                        "name": "userId"
                    },
                    {
                        "full": "newPwd",
                        "name": "newPwd"
                    }
                ]
            }
        ],
        "markdown": "### [resetPwd](https://docs.dolphindb.cn/zh/funcs/r/resetPwd.html)\n\n\n\n#### 语法\n\nresetPwd(userId, newPwd)\n\n#### 详情\n\n重置用户的密码。\n\n**Note:** 该函数只能由管理员在控制节点、数据节点和计算节点运行。\n\n#### 参数\n\n**userId** 表示用户名的字符串。\n\n**newPwd** 表示用户新密码的字符串。它不能包含空格或控制字符。\n\n从 2.00.10.10 开始，用户可以通过配置项 *enhancedSecurityVerification* 控制是否对 *newPwd* 进行复杂性校验。若不设置 *enhancedSecurityVerification*，则不校验；若设置 *enhancedSecurityVerification*=true，则要求新密码必须满足以下条件：\n\n* 字符个数为8\\~20\n\n* 至少包含一个大写字母\n\n* 至少包含以下字符之一：!\"#$%&'()\\*+,-./:;<=>?@\\[]^\\_\\`{|}\\~。\n\n#### 例子\n\n```\nresetPwd(\"AlexEdwards\", \"T51pm363.\");\n```\n"
    },
    "resetRecoveryWorkerNum": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/resetRecoveryWorkerNum.html",
        "signatures": [
            {
                "full": "resetRecoveryWorkerNum(newWorkerNum)",
                "name": "resetRecoveryWorkerNum",
                "parameters": [
                    {
                        "full": "newWorkerNum",
                        "name": "newWorkerNum"
                    }
                ]
            }
        ],
        "markdown": "### [resetRecoveryWorkerNum](https://docs.dolphindb.cn/zh/funcs/r/resetRecoveryWorkerNum.html)\n\n\n\n#### 语法\n\nresetRecoveryWorkerNum(newWorkerNum)\n\n#### 详情\n\n在线修改当前节点用于 chunk 恢复的工作线程数。该命令只能由管理员在数据节点执行。\n\n请注意，此命令修改的配置值在系统重启后将失效。若需要配置值永久生效，请更改配置文件中的 *recoveryWorkers* （默认值是 1）。\n\n#### 参数\n\n**newWorkerNum** 正整数，指定用于 chunk 恢复的工作线程数。\n\n#### 例子\n\n```\nresetRecoveryWorkerNum(2)\n```\n\n相关函数：[getRecoveryWorkerNum](https://docs.dolphindb.cn/zh/funcs/g/getRecoveryWorkerNum.html)\n"
    },
    "reshape": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/reshape.html",
        "signatures": [
            {
                "full": "reshape(obj, [dim])",
                "name": "reshape",
                "parameters": [
                    {
                        "full": "obj",
                        "name": "obj"
                    },
                    {
                        "full": "[dim]",
                        "name": "dim",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [reshape](https://docs.dolphindb.cn/zh/funcs/r/reshape.html)\n\n\n\n#### 语法\n\nreshape(obj, \\[dim])\n\n#### 详情\n\n改变矩阵的形状。如果没有指定 *dim*，则将 *obj* 重组为一个向量。\n\nDolphinDB 的 `reshape(obj, dim)` 与 NumPy 的 `numpy.reshape(a, shape)` 都用于调整数据形状，但两者在行为上存在差异：\n\n* DolphinDB 仅支持向量和矩阵，目标维度通过数据对指定，并默认按列优先填充，行为更接近 NumPy 的 `order=\"F\"`。\n\n* NumPy 支持任意维度的 ndarray，默认按行优先（`order=\"C\"`）填充，同时支持自动推断维度，以及 *order*、*copy* 等参数。\n\n* 此外，DolphinDB 在省略 `dim` 时会将矩阵展平成向量；而 NumPy 必须显式指定目标形状，通常使用 `reshape(-1)` 实现展平操作。\n\n#### 参数\n\n**obj** 是一个向量或矩阵。\n\n**dim** 是一个数据对，表示返回结果的行数和列数。它是一个可选参数。\n\n#### 返回值\n\n返回一个改变形状后的矩阵。如果没有指定 *dim*，则返回一个向量。\n\n#### 例子\n\n```\nx=1..6;\nx=x.reshape(3:2);\nx\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 4  |\n| 2  | 5  |\n| 3  | 6  |\n\n```\nx=x.reshape(2:3);\nx\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1  | 3  | 5  |\n| 1  | 4  | 6  |\n\n```\nx=x.reshape(6:1)\nx\n```\n\n| #0 |\n| -- |\n| 1  |\n| 2  |\n| 3  |\n| 4  |\n| 5  |\n| 6  |\n\n```\nx.reshape()\n// output\n[1,2,3,4,5,6]    // 将 x 重组为一个向量\n```\n"
    },
    "residual": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/residual.html",
        "signatures": [
            {
                "full": "residual(Y,X,params,[intercept=true])",
                "name": "residual",
                "parameters": [
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "params",
                        "name": "params"
                    },
                    {
                        "full": "[intercept=true]",
                        "name": "intercept",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [residual](https://docs.dolphindb.cn/zh/funcs/r/residual.html)\n\n\n\n#### 语法\n\nresidual(Y,X,params,\\[intercept=true])\n\n#### 详情\n\n返回对 *X* 和 *Y* 计算最小二乘回归结果的残差。\n\n**Note:** 对于内存表，[ols](https://docs.dolphindb.cn/zh/funcs/o/ols.html) 和 [wls](https://docs.dolphindb.cn/zh/funcs/w/wls.html) 设置 *mode*=2，即可获得残差。对于分布式表，只能通过此函数计算残差。\n\n#### 参数\n\n**Y** 是因变量；**X** 是自变量。\n\n**Y** 是一个向量；**X** 是一个矩阵、表或元组。当 *X* 是矩阵时，如果行数等于 *Y* 的长度，*X* 的每一列都是一个因子；如果行数不等于 *Y* 的长度，并且如果列数等于 *Y* 的长度，*X* 的每一行都是一个因子。\n\n**params** 表示回归模型的系数。\n\n**intercept** 是一个布尔变量，表示是否包含回归中的截距。默认值是 true。当它为 true 时，系统自动给 *X* 添加一列 \"1\" 以生成截距。\n\n#### 返回值\n\n返回 DOUBLE 类型的向量。\n\n#### 例子\n\n例1\n\n```\nx1=1 3 5 7 11 16 23\nx2=2 8 11 34 56 54 100\ny=0.1 4.2 5.6 8.8 22.1 35.6 77.2\n\nparams=ols(y, x1);\nresidual(y,x1,params)\n// output\n[6.634188034188036,3.976923076923078,-1.380341880341881,-4.937606837606838,-5.152136752136756,-8.545299145299146,9.404273504273504]\n\nparams1=ols(y, (x1,x2),false);\nresidual(y,(x1,x2),params1,false)\n// output\n[-1.941530853763632,-2.556479729553295,-4.923597852949359,-11.809587658969416,-11.098921251860737,-4.0152525111045,13.183836820351686]\n\nx=matrix(1 4 8 2 3, 1 4 2 3 8, 1 5 1 1 5);\np1=ols(1..5, x);\nresidual(1..5, x,p1);\n// output\n[-0.474770642201834,0.268348623853214,-0.123853211009174,0.598623853211011,-0.268348623853205]\n```\n\n例2\n\n```\nx1 = 10 20 30 40 50\nx2 = 5 15 25 35 45\nx3 = 3 6 9 12 15\nfactor0 = 10.7 22.2 29.6 43.4 48.9\n\nt = table(x1, x2, x3, factor0)\n\nx = `x + string(1..3) \nresidual = makeCall(member, makeCall(ols, sqlCol(`factor0), makeUnifiedCall(matrix, sqlCol(x)), 1, 2), \"Residual\")\nsql(residual, t).eval()\n```\n\n| member |\n| ------ |\n| -0.74  |\n| 1      |\n| -1.36  |\n| 2.68   |\n| -1.58  |\n"
    },
    "restore": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/restore.html",
        "signatures": [
            {
                "full": "restore(backupDir, dbPath, tableName, partition, [force=false], [outputTable], [parallel=false], [snapshot=false], [keyPath])",
                "name": "restore",
                "parameters": [
                    {
                        "full": "backupDir",
                        "name": "backupDir"
                    },
                    {
                        "full": "dbPath",
                        "name": "dbPath"
                    },
                    {
                        "full": "tableName",
                        "name": "tableName"
                    },
                    {
                        "full": "partition",
                        "name": "partition"
                    },
                    {
                        "full": "[force=false]",
                        "name": "force",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[outputTable]",
                        "name": "outputTable",
                        "optional": true
                    },
                    {
                        "full": "[parallel=false]",
                        "name": "parallel",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[snapshot=false]",
                        "name": "snapshot",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[keyPath]",
                        "name": "keyPath",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [restore](https://docs.dolphindb.cn/zh/funcs/r/restore.html)\n\n\n\n#### 语法\n\nrestore(backupDir, dbPath, tableName, partition, \\[force=false], \\[outputTable], \\[parallel=false], \\[snapshot=false], \\[keyPath])\n\n#### 详情\n\n恢复指定分区的数据。该函数必须要用户登录后才能执行。\n\n#### 参数\n\n**backupDir** 字符串，表示存放备份数据的目录。\n\n**dbPath** 字符串，表示已备份的分布式数据库的路径。\n\n**tableName** 字符串，表示已备份的表的名称。\n\n**partition** 字符串，表示要恢复的分区的相对路径。分区路径可以包含通配符(\"%\"和\"?\"), \"?\"表示单个字符，\"%\"表示0，1或多个字符。\n\n* 若仅恢复某个分区，输入分区的相对路径或者\"%/\"+”分区名称”。举例：要恢复 \"dfs\\://compoDB\" 下的分区 ”20170810/50\\_100”，输入 \"/compoDB/20170807/0\\_50\" 或者 \"%/20170807/0\\_50\"。 请注意：若使用 2.00.4 \\~ 2.00.6 版本 server，对表级分区数据进行备份和恢复时，该参数必须指定路径到物理索引（可通过函数 [listTables](https://docs.dolphindb.cn/zh/funcs/l/listTables.html) 获取），例如分区 \"/compoDB/20170807/0\\_50\" 下表的物理索引为8，则 *partition* 需指定为 \"/compoDB/20170807/0\\_50/8\"。\n\n* 若需要恢复所有分区，直接输入\"%\"。但需注意，采用此方法可能会导致当前数据表的数据丢失。举例说明：若当前表有10个分区，备份只包含2个分区，若使用%恢复数据，则可能导致表中其他8个分区的数据丢失。\n\n**force** 布尔值，表示是否强制恢复。默认值为 false，表示只有元数据与备份数据元数据不一致的分区，才会恢复。\n\n**outputTable** 分布式表句柄，该表的结构必须与要恢复的表结构一致。如果没有指定 *outputTable*，恢复后的数据会存放到原表；如果指定了 *outputTable*，恢复后的数据会存放到该表中，而原数据表保持不变。\n\n**parallel** 布尔值，表示是否对一个数据表下不同分区进行并行恢复。默认值为 false。\n\n**snapshot** 仅在参数 *partition* = \"%\" 时有效。表示进行非首次恢复时，对于待恢复的数据库，若某些表或分区不在备份数据中，是否同步将数据库中对应的表/分区删除。 若设置为 true，则数据库将同步删除多余的表/分区；若设置为 false（默认值），则数据库不会删除多余的表/分区。\n\n请注意：若 server 版本号低于3.00.1，则 *snapshot* 的默认值是 true，用户需要根据需求合理设置 *snapshot* 参数。\n\n**keyPath** 字符串标量，指定恢复加密表备份的密钥路径。仅 Linux 系统支持该参数。恢复数据使用的密钥必须与备份时指定的密钥版本一致。注意恢复加密表时，备份表与目标表必须指定相同的加密方式（即建表时指定相同的 *encryptMode*参数）。\n\n#### 返回值\n\n返回一个字符串向量，包含恢复的分区的路径。该函数必须要用户登录后才能执行。\n\n#### 例子\n\n创建一个组合分区的数据库 dfs\\://compoDB：\n\n```\nn=1000000\nID=rand(100, n)\ndates=2017.08.07..2017.08.11\ndate=rand(dates, n)\nx=rand(10.0, n)\nt=table(ID, date, x);\n\ndbDate = database(, VALUE, 2017.08.07..2017.08.11)\ndbID=database(, RANGE, 0 50 100);\ndb = database(\"dfs://compoDB\", COMPO, [dbDate, dbID]);\npt = db.createPartitionedTable(t, `pt, `date`ID)\npt.append!(t);\n```\n\n备份表 pt 的所有数据：\n\n```\nbackup(\"/home/DolphinDB/backup\",<select * from loadTable(\"dfs://compoDB\",\"pt\")>,true);\n// output\n10\n```\n\n例1. 恢复所有数据到原表。\n\n```\nrestore(\"/home/DolphinDB/backup\",\"dfs://compoDB\",\"pt\",\"%\",true);\n// output\n[\"dfs://compoDB/20170807/0_50/6F\",\"dfs://compoDB/20170807/50_100/6F\",\"dfs://compoDB/20170808/0_50/6F\",\"dfs://compoDB/20170808/50_100/6F\",\"dfs://compoDB/20170809/0_50/6F\",\"dfs://compoDB/20170809/50_100/6F\",\"dfs://compoDB/20170810/0_50/6F\",\"dfs://compoDB/20170810/50_100/6F\",\"dfs://compoDB/20170811/0_50/6F\",\"dfs://compoDB/20170811/50_100/6F\"]\n```\n\n例2. 恢复日期为2017.08.10的数据。\n\n```\nrestore(\"/home/DolphinDB/backup\",\"dfs://compoDB\",\"pt\",\"%20170810%\",true)\n// output\n[\"dfs://compoDB/20170810/0_50/6F\",\"dfs://compoDB/20170810/50_100/6F\"]\n```\n\n例3. 在数据库 dfs\\://compoDB 中创建一个与表 pt 结构相同的表 temp，把 pt 的数据恢复到表 temp。请注意，采用此方法可能导致表中数据丢失。\n\n```\ntemp=db.createPartitionedTable(t, `pt, `date`ID);\n\nrestore(\"/home/DolphinDB/backup\",\"dfs://compoDB\",\"pt\",\"%\",true,temp);\n// output\n[\"dfs://compoDB/20170807/0_50/6F\",\"dfs://compoDB/20170807/50_100/6F\",\"dfs://compoDB/20170808/0_50/6F\",\"dfs://compoDB/20170808/50_100/6F\",\"dfs://compoDB/20170809/0_50/6F\",\"dfs://compoDB/20170809/50_100/6F\",\"dfs://compoDB/20170810/0_50/6F\",\"dfs://compoDB/20170810/50_100/6F\",\"dfs://compoDB/20170811/0_50/6F\",\"dfs://compoDB/20170811/50_100/6F\"]\n\nselect count(*) from temp;\n```\n\n| count   |\n| ------- |\n| 1000000 |\n\n相关函数：[restoreDB](https://docs.dolphindb.cn/zh/funcs/r/restoreDB.html), [restoreTable](https://docs.dolphindb.cn/zh/funcs/r/restoreTable.html), [migrate](https://docs.dolphindb.cn/zh/funcs/m/migrate.html), [backup](https://docs.dolphindb.cn/zh/funcs/b/backup.html)\n\n#### 注意事项\n\n* 恢复通过 SQL 元代码（即 [backup](https://docs.dolphindb.cn/zh/funcs/b/backup.html) 指定 *sqlObj* 参数）备份的文件时，不能指定 *snapshot*，否则会报错。\n\n* 指定 *outputTable* 时，恢复通过 SQL 元代码备份的文件，系统会在 *outputTable* 中直接追加（append）备份数据；而恢复通过拷贝方式（即 `backup` 指定 *dbPath* 参数）备份的文件时，系统只覆盖 *outputTable* 中数据不一致的分区。若不指定 *outputTable*，则数据恢复至原表，恢复方式相同。\n\n* 恢复时需要确保备份数据与待恢复数据库的引擎类型（engine）一致，且 *partitionScheme*（VALUE 除外）也保持一致。当采用 VALUE 分区时，若 newValuePartitionPolicy 不为 add，则须保证备份数据中的分区方案是待恢复数据库的分区方案的子集。例如：备份文件的分区方案是 database(\"dfs\\://xxx\", VALUE, 2017.08.07..2017.08.11)， 则待恢复数据库的 VALUE 分区范围必须不小于 2017.08.07..2017.08.11。\n"
    },
    "restoreDB": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/restoreDB.html",
        "signatures": [
            {
                "full": "restoreDB(backupDir, dbPath, [newDBPath], [keyPath])",
                "name": "restoreDB",
                "parameters": [
                    {
                        "full": "backupDir",
                        "name": "backupDir"
                    },
                    {
                        "full": "dbPath",
                        "name": "dbPath"
                    },
                    {
                        "full": "[newDBPath]",
                        "name": "newDBPath",
                        "optional": true
                    },
                    {
                        "full": "[keyPath]",
                        "name": "keyPath",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [restoreDB](https://docs.dolphindb.cn/zh/funcs/r/restoreDB.html)\n\n\n\n#### 语法\n\nrestoreDB(backupDir, dbPath, \\[newDBPath], \\[keyPath])\n\n#### 详情\n\n恢复备份的数据到数据库。\n\n该函数与 [migrate](https://docs.dolphindb.cn/zh/funcs/m/migrate.html) 类似，都可恢复整个数据库下的所有表，区别见表相关内容。\n\n**Note:**\n\n* 该函数仅支持恢复以拷贝文件方式（即 [backup](https://docs.dolphindb.cn/zh/funcs/b/backup.html) 时指定 *dbPath* 参数）进行的备份。\n* 恢复时需要确保备份数据与待恢复数据库的引擎类型（engine）一致，且 *partitionScheme*（VALUE 除外）也保持一致。 当采用 VALUE 分区时，须保证备份数据中的分区方案是待恢复数据库的分区方案的子集。例如：备份文件的分区方案是 database(\"dfs\\://xxx\", VALUE, 2017.08.07..2017.08.11)， 则待恢复数据库的 VALUE 分区范围必须不小于 2017.08.07..2017.08.11。\n\n#### 参数\n\n**backupDir** 字符串，表示存放备份数据的目录\n\n**dbPath** 字符串，表示已备份的分布式数据库的路径\n\n**newDBPath** 字符串，表示新数据库的名称。如果没有指定，默认值为 *dbPath*。\n\n**keyPath** 字符串标量，指定恢复加密表备份的密钥路径。仅 Linux 系统支持该参数。恢复数据使用的密钥必须与备份时指定的密钥版本一致。注意恢复加密表时，备份表与目标表必须指定相同的加密方式（即建表时指定相同的 *encryptMode*参数）。\n\n#### 返回值\n\n返回包含数据库名称和表名称的表，每一行为完成恢复的数据库及表名称。\n\n#### 例子\n\n```\ndbName = \"dfs://compoDB2\"\nn=1000\nID=rand(\"a\"+string(1..10), n)\ndates=2017.08.07..2017.08.11\ndate=rand(dates, n)\nx=rand(10, n)\nt=table(ID, date, x)\ndb1 = database(, VALUE, 2017.08.07..2017.08.11)\ndb2 = database(, HASH,[INT, 20])\nif(existsDatabase(dbName)){\n     dropDatabase(dbName)\n}\ndb = database(dbName, COMPO,[ db1,db2])\n\n// 创建2个表\npt1 = db.createPartitionedTable(t, `pt1, `date`x).append!(t)\npt2 = db.createPartitionedTable(t, `pt2, `date`x).append!(t)\n\nbackupDB(backupDir, dbName)\n\nrestoreDB(backupDir, dbName)\n```\n\n| dbName          | tableName |\n| --------------- | --------- |\n| dfs\\://compoDB2 | pt1       |\n| dfs\\://compoDB2 | pt2       |\n\n相关函数：[restore](https://docs.dolphindb.cn/zh/funcs/r/restore.html), [restoreTable](https://docs.dolphindb.cn/zh/funcs/r/restoreTable.html), [migrate](https://docs.dolphindb.cn/zh/funcs/m/migrate.html), [backup](https://docs.dolphindb.cn/zh/funcs/b/backup.html), [backupDB](https://docs.dolphindb.cn/zh/funcs/b/backupDB.html), [backupTable](https://docs.dolphindb.cn/zh/funcs/b/backupTable.html)\n"
    },
    "restoreDislocatedTablet": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/restoreDislocatedTablet.html",
        "signatures": [
            {
                "full": "restoreDislocatedTablet()",
                "name": "restoreDislocatedTablet",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [restoreDislocatedTablet](https://docs.dolphindb.cn/zh/funcs/r/restoreDislocatedTablet.html)\n\n\n\n#### 语法\n\nrestoreDislocatedTablet()\n\n#### 详情\n\n当配置分区粒度为表级分区时（详见 [StandaloneMode](https://docs.dolphindb.cn/zh/db_distr_comp/cfg/standalone.html) *enableChunkGranularityConfig* 参数），同一个分区的所有表将分布在相同的节点下。当调用函数 [rebalanceChunksAmongDataNodes](https://docs.dolphindb.cn/zh/funcs/r/rebalanceChunksAmongDataNodes.html) 进行数据平衡时，若出现节点宕机或离线，可能出现同一个分区里部分表的数据转移成功，部分表的数据转移失败的情况，即同一个分区下的不同表会分布在不同的节点。该函数可以修复此问题，将同一个分区里的表转移到同一个节点下。\n\n**Note:** 该函数必须在控制节点下运行。\n\n调用该函数后，可以在进行数据平衡的数据节点上执行 [getRecoveryTaskStatus](https://docs.dolphindb.cn/zh/funcs/g/getRecoveryTaskStatus.html) 查看任务执行的状态。\n\n#### 参数\n\n无\n\n#### 返回值\n\n返回一个表，包含以下列：\n\n| 列名       | 含义          |\n| -------- | ----------- |\n| chunkId  | chunk 的唯一标识 |\n| srcNode  | 源节点的别名      |\n| destNode | 目标节点的别名     |\n\n#### 例子\n\n```\nrestoreDislocatedTablet()\n```\n\n| chunkId                              | srcNode | destNode |\n| ------------------------------------ | ------- | -------- |\n| 99279094-ca12-3b87-48b6-520cbb986f39 | node1   | node2    |\n| 45f612b8-42f5-aebd-4cef-e522b6ae1fc8 | node1   | node2    |\n"
    },
    "restoreSettings": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/restoresettings.html",
        "signatures": [
            {
                "full": "restoreSettings(fileName, [overwrite=false])",
                "name": "restoreSettings",
                "parameters": [
                    {
                        "full": "fileName",
                        "name": "fileName"
                    },
                    {
                        "full": "[overwrite=false]",
                        "name": "overwrite",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [restoreSettings](https://docs.dolphindb.cn/zh/funcs/r/restoresettings.html)\n\n\n\n#### 语法\n\nrestoreSettings(fileName, \\[overwrite=false])\n\n#### 详情\n\n此函数只能由管理员在控制节点执行，将备份文件中保存的用户、用户权限和函数视图恢复到当前集群。\n\n备份文件由函数 [backupSettings](https://docs.dolphindb.cn/zh/funcs/b/backupsettings.html) 生成，与之搭配可以在数据库迁移时实现用户、用户权限及函数视图的迁移。\n\n#### 参数\n\n**fileName**STRING 类型标量，指定备份文件的路径，可以为绝对路径或相对于 \\<HomeDir> 的相对路径。\n\n**overwrite**BOOL 类型标量，表示是否将当前数据库系统的用户、用户权限和函数视图更新为与备份文件完全一致：\n\n* false：默认值，表示在恢复过程中仅添加备份文件中存在但当前系统中不存在的用户及其权限、函数视图。对于当前系统已存在的用户和函数视图，不会做任何修改。\n\n* true：表示将当前系统的用户、用户权限和函数视图设置为与备份文件完全一致，即删除当前系统中不存在于备份文件中的用户和函数视图，并添加备份文件中保存的用户及其权限、函数视图。\n\n#### 返回值\n\n函数返回一个向量，依次列出已成功恢复的用户名和函数视图名称。\n\n#### 例子\n\n下例以用户及权限为例，函数视图规则与之类似。\n\n当前集群有用户 A 和 B，备份文件中保存了用户 A，C 。\n\n```\n// 集群中A、B及其权限不变，增加用户C及其权限\nrestoreSettings(fileName=\"/home/ddb/backup/permission.back\", overwrite=false)\n// 集群中A的权限更新为与备份文件一致，删除用户B，增加用户C及其权限\nrestoreSettings(fileName=\"/home/ddb/backup/permission.back\", overwrite=true)\n```\n\n相关函数： [backupSettings](https://docs.dolphindb.cn/zh/funcs/b/backupsettings.html)\n"
    },
    "restoreTable": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/restoreTable.html",
        "signatures": [
            {
                "full": "restoreTable(backupDir, dbPath, tableName, [newDBPath], [newTableName], [keyPath])",
                "name": "restoreTable",
                "parameters": [
                    {
                        "full": "backupDir",
                        "name": "backupDir"
                    },
                    {
                        "full": "dbPath",
                        "name": "dbPath"
                    },
                    {
                        "full": "tableName",
                        "name": "tableName"
                    },
                    {
                        "full": "[newDBPath]",
                        "name": "newDBPath",
                        "optional": true
                    },
                    {
                        "full": "[newTableName]",
                        "name": "newTableName",
                        "optional": true
                    },
                    {
                        "full": "[keyPath]",
                        "name": "keyPath",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [restoreTable](https://docs.dolphindb.cn/zh/funcs/r/restoreTable.html)\n\n\n\n#### 语法\n\nrestoreTable(backupDir, dbPath, tableName, \\[newDBPath], \\[newTableName], \\[keyPath])\n\n#### 详情\n\n恢复备份的表到数据库。调用该函数可以简化代码，方便用户一次性恢复数据库的一张表。\n\n该函数与 [migrate](https://docs.dolphindb.cn/zh/funcs/m/migrate.html) 类似，都可恢复整个数据库下的整个表，区别见表相关内容。\n\n注意事项：\n\n该函数仅支持恢复以拷贝文件方式（即 [backup](https://docs.dolphindb.cn/zh/funcs/b/backup.html) 时指定 *dbPath* 参数）进行的备份。\n\n恢复时需要确保备份数据与待恢复数据库的引擎类型（engine）一致，且 *partitionScheme*（VALUE 除外）也保持一致。 当采用 VALUE 分区时，须保证备份数据中的分区方案是待恢复数据库的分区方案的子集。例如：备份文件的分区方案是 database(\"dfs\\://xxx\", VALUE, 2017.08.07..2017.08.11)， 则待恢复数据库的 VALUE 分区范围必须不小于 2017.08.07..2017.08.11。\n\n#### 参数\n\n**backupDir** 字符串，表示存放备份数据的目录。\n\n**dbPath** 字符串，表示已备份的分布式数据库的路径。\n\n**tableName** 字符串，表示表名。\n\n**newDBPath** 字符串，表示新数据库的名称。如果没有指定，默认值为 *dbPath*。\n\n**newTableName** 字符串，表示新表的名称。如果没有指定，默认值为 *tableName*。\n\n**keyPath** 字符串标量，指定恢复加密表备份的密钥路径。仅 Linux 系统支持该参数。恢复数据使用的密钥必须与备份时指定的密钥版本一致。注意恢复加密表时，备份表与目标表必须指定相同的加密方式（即建表时指定相同的 *encryptMode*参数）。\n\n#### 返回值\n\n返回一个表，包含数据库名称和表名称。\n\n#### 例子\n\n```\ndbName = \"dfs://compoDB2\"\nn=1000\nID=rand(\"a\"+string(1..10), n)\ndates=2017.08.07..2017.08.11\ndate=rand(dates, n)\nx=rand(10, n)\nt=table(ID, date, x)\ndb1 = database(, VALUE, 2017.08.07..2017.08.11)\ndb2 = database(, HASH,[INT, 20])\nif(existsDatabase(dbName)){\n     dropDatabase(dbName)\n}\ndb = database(dbName, COMPO,[ db1,db2])\n\n// 创建2个表\npt1 = db.createPartitionedTable(t, `pt1, `date`x).append!(t)\npt2 = db.createPartitionedTable(t, `pt2, `date`x).append!(t)\n\nbackupDB(backupDir, dbName)\n\nrestoreTable(backupDir,\"dfs://compoDB2\",`pt1)\n```\n\n输出返回：\n\n| dbName          | tableName |\n| --------------- | --------- |\n| dfs\\://compoDB2 | pt1       |\n\n相关函数：[restore](https://docs.dolphindb.cn/zh/funcs/r/restore.html), [restoreDB](https://docs.dolphindb.cn/zh/funcs/r/restoreDB.html), [migrate](https://docs.dolphindb.cn/zh/funcs/m/migrate.html), [backup](https://docs.dolphindb.cn/zh/funcs/b/backup.html), [backupDB](https://docs.dolphindb.cn/zh/funcs/b/backupDB.html), [backupTable](https://docs.dolphindb.cn/zh/funcs/b/backupTable.html)\n"
    },
    "resubmitStreamGraph": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/resubmitStreamGraph.html",
        "signatures": [
            {
                "full": "resubmitStreamGraph(name)",
                "name": "resubmitStreamGraph",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    }
                ]
            }
        ],
        "markdown": "### [resubmitStreamGraph](https://docs.dolphindb.cn/zh/funcs/r/resubmitStreamGraph.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nresubmitStreamGraph(name)\n\n#### 详情\n\n重新提交处于失败（failed）、销毁中（destroying）或已销毁（destroyed）状态的流图。\n\n#### 参数\n\n**name** 字符串标量，表示流图的名字。可以传入完整的流图全限定名（如 \"catalog\\_name.orca\\_graph.graph\\_name\"），也可以仅提供流图名（如 \"factors\"）；系统会根据当前的 catalog 设置自动补全为对应的全限定名。\n\n#### 例子\n\n假设有已通过 [dropStreamGraph](https://docs.dolphindb.cn/zh/funcs/d/dropStreamGraph.html) 销毁的流图 demo.orca\\_graph.indicators：\n\n```\nresubmitStreamGraph(\"demo.orca_graph.indicators\")\ngetStreamGraphMeta(\"demo.orca_graph.indicators\")[\"status\"]\n// Output: [\"running\"]\n```\n"
    },
    "resumeRecovery": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/resumeRecovery.html",
        "signatures": [
            {
                "full": "resumeRecovery()",
                "name": "resumeRecovery",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [resumeRecovery](https://docs.dolphindb.cn/zh/funcs/r/resumeRecovery.html)\n\n\n\n#### 语法\n\nresumeRecovery()\n\n#### 详情\n\n用于重启节点恢复的进程。调用该命令后，会继续恢复 \"Waiting\" 状态的数据。该函数只能由管理员在控制节点上调用。\n\n**Note:**\n\n启用高可用集群时，需要在 raft 组内每个节点执行该命令。\n\n相关命令： [suspendRecovery](https://docs.dolphindb.cn/zh/funcs/s/suspendRecovery.html)\n\n#### 参数\n\n无\n"
    },
    "resumeTimerEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/resumeTimerEngine.html",
        "signatures": [
            {
                "full": "resumeTimerEngine(engine)",
                "name": "resumeTimerEngine",
                "parameters": [
                    {
                        "full": "engine",
                        "name": "engine"
                    }
                ]
            }
        ],
        "markdown": "### [resumeTimerEngine](https://docs.dolphindb.cn/zh/funcs/r/resumeTimerEngine.html)\n\n\n\n#### 语法\n\nresumeTimerEngine(engine)\n\n#### 详情\n\n该函数只能通过 `useOrcaStreamEngine` 调用，恢复执行由 `DStream::timerEngine` 提交的任务。\n\n#### 参数\n\n**engine**表示引擎名称。字符串标量，可以传入完整的全限定名（如 \"catalog\\_name.orca\\_engine.engine\\_name\"）；或引擎名（如 \"engine\\_name\"），系统会根据当前的 catalog 设置自动补全为对应的全限定名。\n\n#### 例子\n\n提交任务\n\n```\nif (!existsCatalog(\"test\")) {\n\tcreateCatalog(\"test\")\t\n}\ngo\nuse catalog test\n\n// 定义任务\ndef myFunc(x,y,z){\n    writeLog(x,y,z)\n}\n\n// 定义参数\na = \"aaa\"\nb = \"bbb\"\nc = \"ccc\"\n\n// 提交流图\ng = createStreamGraph(\"timerEngineDemo\")\ng.source(\"trade\", `id`price, [INT, DOUBLE])\n .timerEngine(3, myFunc, a, b, c)\n .setEngineName(\"myJob\")\n .sink(\"result\")\ng.submit()\n```\n\n暂停任务执行\n\n```\nuseOrcaStreamEngine(\"myJob\", stopTimerEngine)\n```\n\n继续执行任务\n\n```\nuseOrcaStreamEngine(\"myJob\", resumeTimerEngine)\n```\n\n**相关函数：**[DStream::timerEngine](https://docs.dolphindb.cn/zh/funcs/d/DStream_timerEngine.html), [stopTimerEngine](https://docs.dolphindb.cn/zh/funcs/s/stopTimerEngine.html)\n"
    },
    "reverse": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/reverse.html",
        "signatures": [
            {
                "full": "reverse(X)",
                "name": "reverse",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [reverse](https://docs.dolphindb.cn/zh/funcs/r/reverse.html)\n\n\n\n#### 语法\n\nreverse(X)\n\n#### 详情\n\n将 X 中的元素反序排列。\n\n#### 参数\n\n**X** 可以是向量、矩阵、内存表、有序字典。\n\n#### 返回值\n\n* 若 *X* 为向量或矩阵，返回一个新的向量或矩阵，它和原有向量或矩阵的元素顺序相反。\n\n* 若 *X* 为内存表，返回一个内存表，其行序与原表相反。\n\n* 若 *X* 为有序字典，返回一个有序字典，其键值对顺序与原字典​​相反​。\n\n#### 例子\n\n```\nreverse `hello `world;\n// output\n[world,hello]\n\n(1..6).reverse();\n// output\n[6,5,4,3,2,1]\nx=1..6$2:3;\nx\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1  | 3  | 5  |\n| 2  | 4  | 6  |\n\n```\nreverse(x);\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 6  | 4  | 2  |\n| 5  | 3  | 1  |\n\n```\nt = table(1 2 3 as a, `x`y`z as b)\nreverse(t)\n```\n\n| a | b |\n| - | - |\n| 3 | z |\n| 2 | y |\n| 1 | x |\n\n```\nd = dict(1 2 3, `x`y`z, true)\nreverse(d)\n\n/*\noutput:\n3->z\n2->y\n1->x\n*/\n```\n"
    },
    "revoke": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/revoke.html",
        "signatures": [
            {
                "full": "revoke(userId|groupId, accessType, [objs])",
                "name": "revoke",
                "parameters": [
                    {
                        "full": "userId|groupId",
                        "name": "userId|groupId"
                    },
                    {
                        "full": "accessType",
                        "name": "accessType"
                    },
                    {
                        "full": "[objs]",
                        "name": "objs",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [revoke](https://docs.dolphindb.cn/zh/funcs/r/revoke.html)\n\n\n\n#### 语法\n\nrevoke(userId|groupId, accessType, \\[objs])\n\n#### 详情\n\n`revoke` 函数执行以下操作：\n\n（1）撤销某个用户或某个组的之前被赋予或禁止的权限。\n\n（2）撤销 `grant` 给某个用户的内存约束，包含：查询返回结果的内存上限（指定 *accessType* = QUERY\\_RESULT\\_MEM\\_LIMIT）和发送的批量子查询占用的内存上限（指定 *accessType* = TASK\\_GROUP\\_MEM\\_LIMIT）。撤销后，将恢复为系统的默认值。\n\n管理员可以通过该命令撤销用户所有权限（*accessType*），但普通用户在拥有相关的 OWNER 权限后，只能通过该命令撤销以下权限：TABLE\\_READ, TABLE\\_WRITE, TABLE\\_INSERT, TABLE\\_UPDATE, TABLE\\_DELETE, DB\\_READ, DB\\_WRITE, DB\\_INSERT, DB\\_UPDATE, DB\\_DELETE, DBOBJ\\_DELETE, DBOBJ\\_CREATE 和 VIEW\\_EXEC。\n\n可被撤销的权限类型，参见 [grant](https://docs.dolphindb.cn/zh/funcs/g/grant.html)。Orca 流图和流表相关权限：详见 [Orca 实时计算平台 6.3 节](https://docs.dolphindb.cn/zh/stream/orca.md#)。\n\n**Note:** 该函数只能由管理员在控制节点、数据节点和计算节点运行。\n\n#### 参数\n\n**userId** | **groupId** 是表示用户名或组名的字符串。\n\n**accessType** 权限类型/内存限制。\n\n**objs** 标量或向量，表示权限类型的应用对象/约束规则。也可以指定为 \\*，表示全局。当 *accessType* 指定为 COMPUTE\\_GROUP\\_EXEC 时，*objs* 必须为对应的计算组名。\n\n**Note:**\n\n* 管理共享内存表、流数据表或流计算引擎的权限时，*objs* 必须为 \"tableName\\@nodeAlias\" 或\"nodeAlias:tableName\"。\n* 管理 IMOLTP 引擎库表权限时，*objs* 必须为 \"oltp\\://database/table\\@nodeAlias\" 或 \"oltp\\://database\\@nodeAlias\"。\n\n*accessType* 和 *objs* 的取值请参照 [用户权限管理](https://docs.dolphindb.cn/zh/tutorials/ACL_and_Security.html) 权限类型表。\n\n#### 例子\n\n撤销组 \"production\" 的所有成员读取所有数据库表的权限：\n\n```\nrevoke(`production, TABLE_READ, \"*\")\n```\n\n撤销组 \"research\" 的所有成员读写表 dfs\\://db1/t1 的权限：\n\n```\nrevoke(`research, TABLE_WRITE, \"dfs://db1/t1\")\n```\n\n撤销组 \"research\" 的所有成员在数据库 dfs\\://db1 和 dfs\\://db2 创建表的权限：\n\n```\nrevoke(\"research\", DBOBJ_CREATE, [\"dfs://db1\",\"dfs://db2\"])\n```\n\n撤销用户 \"AlexSmith\" 创建和删除数据库的权限：\n\n```\nrevoke(\"AlexSmith\", DB_MANAGE)\n```\n\n撤销用户 \"AlexSmith\" 执行脚本的权限：\n\n```\nrevoke(\"AlexSmith\", SCRIPT_EXEC)\n```\n\n撤销用户 \"AlexSmith\" 测试脚本的权限：\n\n```\nrevoke(\"AlexSmith\", TEST_EXEC)\n```\n"
    },
    "revokeStreamingSQL": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/revokeStreamingSQL.html",
        "signatures": [
            {
                "full": "revokeStreamingSQL(queryId)",
                "name": "revokeStreamingSQL",
                "parameters": [
                    {
                        "full": "queryId",
                        "name": "queryId"
                    }
                ]
            }
        ],
        "markdown": "### [revokeStreamingSQL](https://docs.dolphindb.cn/zh/funcs/r/revokeStreamingSQL.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\nrevokeStreamingSQL(queryId)\n\n#### 详情\n\n注销一个通过 `registerStreamingSQL` 注册的流式 SQL 查询。只能注销当前用户自己注册的查询。\n\n#### 参数\n\n**queryId** 字符串标量，表示已注册的流式 SQL 查询的 ID。\n\n#### 例子\n\n```\nt=table(1..10 as id,rand(100,10) as val)\nshare t as st\ndeclareStreamingSQLTable(st)\nregisterStreamingSQL(\"select avg(val) from st\",\"sql_avg\") \n\n// 查看流式 SQL 查询的状态\ngetStreamingSQLStatus(\"sql_avg\")\n\n// 注销流式 SQL 查询\nrevokeStreamingSQL(\"sql_avg\")\n```\n\n**相关函数：**[declareStreamingSQLTable](https://docs.dolphindb.cn/zh/funcs/d/declareStreamingSQLTable.html), [getStreamingSQLStatus](https://docs.dolphindb.cn/zh/funcs/g/getStreamingSQLStatus.html), [registerStreamingSQL](https://docs.dolphindb.cn/zh/funcs/r/registerStreamingSQL.html)\n"
    },
    "revokeStreamingSQLTable": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/revokeStreamingSQLTable.html",
        "signatures": [
            {
                "full": "revokeStreamingSQLTable(tableName)",
                "name": "revokeStreamingSQLTable",
                "parameters": [
                    {
                        "full": "tableName",
                        "name": "tableName"
                    }
                ]
            }
        ],
        "markdown": "### [revokeStreamingSQLTable](https://docs.dolphindb.cn/zh/funcs/r/revokeStreamingSQLTable.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\nrevokeStreamingSQLTable(tableName)\n\n#### 详情\n\n注销一个通过 `declareStreamingSQLTable` 声明的流式 SQL 表。\n\n* 只能取消当前用户自己声明的表。\n* 注销前，必须先取消在该表上已注册的所有流式 SQL 查询。\n* 注销操作仅移除表的流式 SQL 功能，不会删除表本身或表中的数据。\n\n#### 参数\n\n**tableName** 字符串标量，表示已声明的流式 SQL 表的名称。\n\n#### 例子\n\n```\nt=table(1..10 as id,rand(100,10) as val)\nshare t as st\ndeclareStreamingSQLTable(st)\nregisterStreamingSQL(\"select avg(val) from st\",\"sql_avg\")\n\n// 取消已注册的流式 SQL 查询\nrevokeStreamingSQL(\"sql_avg\")\n\n// 注销流式 SQL 表\nrevokeStreamingSQLTable(`st)\n```\n\n**相关函数：**[declareStreamingSQLTable](https://docs.dolphindb.cn/zh/funcs/d/declareStreamingSQLTable.html), [listStreamingSQLTables](https://docs.dolphindb.cn/zh/funcs/l/listStreamingSQLTables.html), [registerStreamingSQL](https://docs.dolphindb.cn/zh/funcs/r/registerStreamingSQL.html), [revokeStreamingSQL](https://docs.dolphindb.cn/zh/funcs/r/revokeStreamingSQL.html)\n"
    },
    "ridge": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/ridge.html",
        "signatures": [
            {
                "full": "ridge(ds, yColName, xColNames, [alpha=1.0], [intercept=true], [normalize=false], [maxIter=1000], [tolerance=0.0001], [solver='svd'], [swColName])",
                "name": "ridge",
                "parameters": [
                    {
                        "full": "ds",
                        "name": "ds"
                    },
                    {
                        "full": "yColName",
                        "name": "yColName"
                    },
                    {
                        "full": "xColNames",
                        "name": "xColNames"
                    },
                    {
                        "full": "[alpha=1.0]",
                        "name": "alpha",
                        "optional": true,
                        "default": "1.0"
                    },
                    {
                        "full": "[intercept=true]",
                        "name": "intercept",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[normalize=false]",
                        "name": "normalize",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[maxIter=1000]",
                        "name": "maxIter",
                        "optional": true,
                        "default": "1000"
                    },
                    {
                        "full": "[tolerance=0.0001]",
                        "name": "tolerance",
                        "optional": true,
                        "default": "0.0001"
                    },
                    {
                        "full": "[solver='svd']",
                        "name": "solver",
                        "optional": true,
                        "default": "'svd'"
                    },
                    {
                        "full": "[swColName]",
                        "name": "swColName",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [ridge](https://docs.dolphindb.cn/zh/funcs/r/ridge.html)\n\n\n\n#### 语法\n\nridge(ds, yColName, xColNames, \\[alpha=1.0], \\[intercept=true], \\[normalize=false], \\[maxIter=1000], \\[tolerance=0.0001], \\[solver='svd'], \\[swColName])\n\n#### 详情\n\n进行 ridge 回归估计。\n\n最小化以下目标函数：\n\n![](https://docs.dolphindb.cn/zh/images/ridge.png)\n\n#### 参数\n\n**ds** 是一个内存表或通常用 [sqlDS](https://docs.dolphindb.cn/zh/funcs/s/sqlDS.html) 函数生成的数据源。\n\n**yColName** 是字符串，表示数据源中因变量的列名。\n\n**xColNames** 是字符串标量或向量，表示数据源中自变量的列名。\n\n**alpha** 是浮点数，表示乘以 L1 范数惩罚项的系数。默认值是1.0。\n\n**intercept** 是布尔值，表示是否回归模型包含截距。默认值为true。\n\n**normalize** 是布尔值。默认值为 false。若设为 true，则所有自变量均会进行如下标准化：减去平均值，然后除以 L2 范数。若 *intercept* 为 false，该参数会被忽略。\n\n**maxIter** 是正整数，表示最大迭代次数。默认值是1000。\n\n**tolerance** 是浮点数，表示迭代中止的边界差值。默认值是0.0001。\n\n**solver** 是字符串，表示回归算法模型。可取值 'svd' 或 'cholesky'。若ds为多个数据源，则 *solver* 必须为 'cholesky'。\n\n**swColName** 字符串，表示列名，必须为 *ds* 中存在的列名。如果未指定该参数，则所有样本的权重都默认为1；如果指定该参数，则将指定的列作为样本的权重。\n\n#### 返回值\n\n返回一个字典，包含以下键值：modelName，coefficients，intercept，xColNames，predict。\n\n#### 例子\n\n```\ny = [225.720746,-76.195841,63.089878,139.44561,-65.548346,2.037451,22.403987,-0.678415,37.884102,37.308288]\nx0 = [2.240893,-0.854096,0.400157,1.454274,-0.977278,-0.205158,0.121675,-0.151357,0.333674,0.410599]\nx1 = [0.978738,0.313068,1.764052,0.144044,1.867558,1.494079,0.761038,0.950088,0.443863,-0.103219]\nt = table(y, x0, x1);\n\nridge(t, `y, `x0`x1);\n```\n\n如果 t 是一个 DFS 表，则应使用数据源作为输入：\n\n```\nridge(sqlDS(<select * from t>), `y, `x0`x1);\n```\n"
    },
    "ridgeBasic": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/ridgeBasic.html",
        "signatures": [
            {
                "full": "ridgeBasic(Y, X, [mode=0], [alpha=1.0], [intercept=true], [normalize=false], [maxIter=1000], [tolerance=0.0001], [solver='svd'], [swColName])",
                "name": "ridgeBasic",
                "parameters": [
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[mode=0]",
                        "name": "mode",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[alpha=1.0]",
                        "name": "alpha",
                        "optional": true,
                        "default": "1.0"
                    },
                    {
                        "full": "[intercept=true]",
                        "name": "intercept",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[normalize=false]",
                        "name": "normalize",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[maxIter=1000]",
                        "name": "maxIter",
                        "optional": true,
                        "default": "1000"
                    },
                    {
                        "full": "[tolerance=0.0001]",
                        "name": "tolerance",
                        "optional": true,
                        "default": "0.0001"
                    },
                    {
                        "full": "[solver='svd']",
                        "name": "solver",
                        "optional": true,
                        "default": "'svd'"
                    },
                    {
                        "full": "[swColName]",
                        "name": "swColName",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [ridgeBasic](https://docs.dolphindb.cn/zh/funcs/r/ridgeBasic.html)\n\n\n\n#### 语法\n\nridgeBasic(Y, X, \\[mode=0], \\[alpha=1.0], \\[intercept=true], \\[normalize=false], \\[maxIter=1000], \\[tolerance=0.0001], \\[solver='svd'], \\[swColName])\n\n#### 详情\n\n进行 ridge 回归估计。\n\n最小化以下目标函数：\n\n![](https://docs.dolphindb.cn/zh/images/ridge.png)\n\n#### 参数\n\n`Y` 数值类型的向量，表示因变量。\n\n`X` 数值类型的向量/元组/矩阵/表，表示自变量。\n\n* 当 *X* 是向量/元组时，其长度必须等于 Y 的长度。\n\n* 当 *X* 是矩阵/表时，其行数必须等于 Y 的长度。\n\n`mode` 一个整数，可取以下 3 个值\n\n* 0（默认值）: 输出一个系数估计向量\n\n* 1: 输出一个具有系数估计，标准差，t 统计量和 p 值的表\n\n* 2: 输出一个具有 ANOVA(方差分析)、RegressionStat(回归统计)、Cofficient(系数) 和 Residual(残差) 的字典，具体含义见下表：\n\n键 ANOVA 对应值：\n\n<table id=\"table_txw_vpc_zzb\"><thead><tr><th>\n\nSource of Variance\n\n</th><th>\n\n自由度(Degree of freedom)\n\n</th><th>\n\n平方和(Sum of Square)\n\n</th><th>\n\n均方差(Mean of square)\n\n</th><th>\n\nF统计量\n\n</th><th>\n\nSignificance\n\n</th></tr></thead><tbody><tr><td>\n\nRegression(回归)\n\n</td><td>\n\n变量个数(p)\n\n</td><td>\n\n回归平方和(SSR)\n\n</td><td>\n\n回归均方差(MSR=SSR/R)\n\n</td><td>\n\nMSR对MSE的比值\n\n</td><td>\n\n显著性，即统计出的P值\n\n</td></tr><tr><td>\n\nResidual(残差)\n\n</td><td>\n\n残差自由度(n-p-1)\n\n</td><td>\n\n残差平方和(SSE)\n\n</td><td>\n\n残差均方差(MSE=MSE/E)\n\n</td><td>\n\n</td><td>\n\n</td></tr><tr><td>\n\nTotal\n\n</td><td>\n\n样本自由度， 不包括常数项(n-1)\n\n</td><td>\n\n总离差平方和(SST)\n\n</td><td>\n\n</td><td>\n\n</td><td>\n\n</td></tr></tbody>\n</table>键 RegressionStat 对应值：\n\n<table id=\"table_hcq_xpc_zzb\"><thead><tr><th>\n\nitem\n\n</th><th>\n\n统计值\n\n</th></tr></thead><tbody><tr><td>\n\nR2\n\n</td><td>\n\nR决定系数，描述回归曲线对真实数据点拟合程度的统计量。范围在 \\[0,1]之间，越接近1 ，说明对y的解释能力越强，拟合越好。\n\n</td></tr><tr><td>\n\nAdjustedR2\n\n</td><td>\n\n经自由度修正后的决定系数，通过样本数量与模型数量对 R-squared 进行修正。\n\n</td></tr><tr><td>\n\nStdError\n\n</td><td>\n\n回归残差标准误差，残差经自由度修正后的标准差。\n\n</td></tr><tr><td>\n\nObservations\n\n</td><td>\n\n观察样本个数。\n\n</td></tr></tbody>\n</table>键 Coefficient 对应值：\n\n<table id=\"table_cvz_ypc_zzb\"><thead><tr><th>\n\n元素\n\n</th><th>\n\n说明\n\n</th></tr></thead><tbody><tr><td>\n\nfactor\n\n</td><td>\n\n自变量名称\n\n</td></tr><tr><td>\n\nbeta\n\n</td><td>\n\n回归系数估计值\n\n</td></tr><tr><td>\n\nstdError\n\n</td><td>\n\n回归系数标准误差。\n\n</td></tr><tr><td>\n\ntstat\n\n</td><td>\n\nT统计值，衡量系数的统计显著性。\n\n</td></tr></tbody>\n</table>键 Residual 对应每一个预测值和实际值之间的残差。\n\n`alpha` 一个浮点数，表示乘以L1范数惩罚项的系数。默认值是1.0。\n\n`intercept` 布尔值，表示是否包含回归中的截距。默认值为 true，此时系统自动给 *X* 添加一列 “1” 以生成截距。\n\n`normalize` 布尔值，默认值为 false。若设为 true，则所有自变量均会进行如下标准化：减去平均值，然后除以L2范数。若 intercept 为 false，该参数会被忽略。\n\n`maxIter` 一个正整数，表示最大迭代次数。默认值是1000。\n\n`tolerance` 一个浮点数，表示迭代中止的边界差值。默认值是0.0001。\n\n`solve` 字符串，表示回归算法模型。可取值 ‘svd’ 或 ‘cholesky’。若 ds 为多个数据源，则 solver 必须为 ’cholesky’。\n\n`swColName` 字符串，表示列名，必须为 X 中存在的列名。如果未指定该参数，则所有样本的权重都默认为1；如果指定该参数，则将指定的列作为自变量的权重。\n\n#### 返回值\n\n返回一个向量、表或字典，取决于参数 *mode*。\n\n#### 例子\n\n例1：设置 *mode*=0，输出一个系数估计向量。\n\n```\nY = [225.72, -76.20, 63.09, 139.45, -65.55]\nX0 = [2.24, -0.85, 0.40, 1.45, -0.98]\nX1 = [0.98, 0.31, 1.76, 0.14, 1.87]\n\ncoefficients = ridgeBasic(Y, [X0, X1], mode=0, alpha=0.5, intercept=true)\ncoefficients\n\n// 输出：[7.940468476954727, 88.20426761349431, 9.380634942436586]\n```\n\n例2：设置 mode=1，输出包含 ANOVA（方差分析）、RegressionStat（回归统计）、Cofficient（系数）和 Residual（残差）的字典。\n\n```\nY = [1.5, 2.3, 4.7, 3.2, 5.1]\nX = matrix([1.1, 2.2, 3.1, 2.8, 4.0], [0.5, 0.8, 1.2, 1.0, 1.5])\n\nresult = ridgeBasic(Y, X, mode=2, alpha=0.8, solver='svd')\n```\n\n查看方差分析。\n\n```\nresult[`ANOVA]\n```\n\n| Breakdown  | DF | SS                 | MS                 | F                  | Significance       |\n| ---------- | -- | ------------------ | ------------------ | ------------------ | ------------------ |\n| Regression | 2  | 6.439542296188023  | 3.2197711480940114 | 6.3847474657971865 | 0.1354142446483848 |\n| Residual   | 2  | 1.0085821452899069 | 0.5042910726449534 |                    |                    |\n| Total      | 4  | 9.432000000000016  |                    |                    |                    |\n\n查看回归统计。\n\n```\nresult[`RegressionStat]\n```\n\n| item         | statistics         |\n| ------------ | ------------------ |\n| R2           | 0.6827334919622574 |\n| AdjustedR2   | 0.3654669839245148 |\n| StdError     | 0.7101345454524469 |\n| Observations | 5                  |\n\n查看回归系数。\n\n```\nresult[`Coefficient]\n```\n\n| factor    | beta                | stdError          | tstat               | pvalue             |\n| --------- | ------------------- | ----------------- | ------------------- | ------------------ |\n| intercept | 0.22075506589464267 | 1.084447930898624 | 0.20356446778566378 | 0.8575265882132079 |\n| beta0     | 1.0193512860448009  | 2.662502504483437 | 0.3828545829828503  | 0.7386872800445148 |\n| beta1     | 0.44815753894708277 | 7.540425982186433 | 0.05943398158218302 | 0.9580108927931805 |\n\n查看残差。\n\n```\nresult[`Residual]\n// 输出：[-0.06612025001746513, -0.5218539263508712, 0.7814669006299755, -0.32309620576716735, 0.12960348150553003]\n```\n"
    },
    "ridgeCV": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/ridgeCV.html",
        "signatures": [
            {
                "full": "ridgeCV(ds, yColName, xColNames, [alphas=[0.01,0.1,1.0]], [intercept=true], [normalize=false], [maxIter=1000], [tolerance=0.0001], [solver='svd'], [swColName])",
                "name": "ridgeCV",
                "parameters": [
                    {
                        "full": "ds",
                        "name": "ds"
                    },
                    {
                        "full": "yColName",
                        "name": "yColName"
                    },
                    {
                        "full": "xColNames",
                        "name": "xColNames"
                    },
                    {
                        "full": "[alphas=[0.01",
                        "name": "[alphas=[0.01"
                    },
                    {
                        "full": "0.1",
                        "name": "0.1"
                    },
                    {
                        "full": "1.0]]",
                        "name": "1.0]]"
                    },
                    {
                        "full": "[intercept=true]",
                        "name": "intercept",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[normalize=false]",
                        "name": "normalize",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[maxIter=1000]",
                        "name": "maxIter",
                        "optional": true,
                        "default": "1000"
                    },
                    {
                        "full": "[tolerance=0.0001]",
                        "name": "tolerance",
                        "optional": true,
                        "default": "0.0001"
                    },
                    {
                        "full": "[solver='svd']",
                        "name": "solver",
                        "optional": true,
                        "default": "'svd'"
                    },
                    {
                        "full": "[swColName]",
                        "name": "swColName",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [ridgeCV](https://docs.dolphindb.cn/zh/funcs/r/ridgeCV.html)\n\n\n\n#### 语法\n\nridgeCV(ds, yColName, xColNames, \\[alphas=\\[0.01,0.1,1.0]], \\[intercept=true], \\[normalize=false], \\[maxIter=1000], \\[tolerance=0.0001], \\[solver='svd'], \\[swColName])\n\n#### 详情\n\n使用五折交叉验证法进行岭回归（ridge）估计，输出最优参数对应的岭回归模型。\n\n![](https://docs.dolphindb.cn/zh/images/ridge.png)\n\n#### 参数\n\n**alphas** 是浮点型标量或向量，表示乘以L1范数惩罚项的系数。默认值是 \\[0.01, 0.1, 1.0]。\n\n**Note:** 除 *alphas* 参数外，其它参数都和 ridge 的参数相同，参数描述可参考 [ridge](https://docs.dolphindb.cn/zh/funcs/r/ridge.html)。这里仅说明 *alphas* 参数。\n\n#### 返回值\n\n结果为一个字典，包含以下 key：\n\n* modelName：模型名称，ridgeCV 方法对应的模型名为 \"ridgeCV\"。\n\n* coefficients：模型的回归系数。\n\n* intercept：截距。\n\n* xColNames：数据源中自变量的列名。\n\n* predict：用于预测的函数。\n\n* alpha：交叉验证选择的惩罚量。\n\n#### 例子\n\n```\ny = [225.720746,-76.195841,63.089878,139.44561,-65.548346,2.037451,22.403987,-0.678415,37.884102,37.308288]\nx0 = [2.240893,-0.854096,0.400157,1.454274,-0.977278,-0.205158,0.121675,-0.151357,0.333674,0.410599]\nx1 = [0.978738,0.313068,1.764052,0.144044,1.867558,1.494079,0.761038,0.950088,0.443863,-0.103219]\nt = table(y, x0, x1);\n\nridgeCV(t, `y, `x0`x1);\n```\n\n返回如下：\n\n```\ncoefficients->[94.3410,14.2523]\npredict->coordinateDescentPredict\nmodelName->ridgeCV\nxColNames->[x0,x1]\nintercept->0.1063\nalpha->0.0100\n```\n"
    },
    "right": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/right.html",
        "signatures": [
            {
                "full": "right(X, n)",
                "name": "right",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "n",
                        "name": "n"
                    }
                ]
            }
        ],
        "markdown": "### [right](https://docs.dolphindb.cn/zh/funcs/r/right.html)\n\n\n\n#### 语法\n\nright(X, n)\n\n#### 详情\n\n返回 *X* 右边 *n* 个字符。\n\n#### 参数\n\n**X** 是一个字符串或字符串向量。\n\n**n** 必须是一个非负整数。\n\n#### 返回值\n\n返回一个字符串或字符串向量。\n\n#### 例子\n\n```\nright(\"I love this game!\", 6);\n```\n\n输出返回：game!\n"
    },
    "rm": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rm.html",
        "signatures": [
            {
                "full": "rm(filename)",
                "name": "rm",
                "parameters": [
                    {
                        "full": "filename",
                        "name": "filename"
                    }
                ]
            }
        ],
        "markdown": "### [rm](https://docs.dolphindb.cn/zh/funcs/r/rm.html)\n\n\n\n#### 语法\n\nrm(filename)\n\n#### 详情\n\n删除一个文件。该命令必须要用户登录后才能执行。\n\n#### 参数\n\n**filename** 是要删除的文件的名称。\n\n#### 例子\n\n```\nfiles(\"/home/test\");\n```\n\n| filename | isDir | fileSize | lastAccessed            | lastModified            |\n| -------- | ----- | -------- | ----------------------- | ----------------------- |\n| abc.txt  | 0     | 15       | 2017.06.05 08:09:47.443 | 2017.06.05 07:24:19.999 |\n| dir1     | 1     | 0        | 2017.06.05 08:06:44.836 | 2017.06.05 08:06:44.836 |\n| dir2     | 1     | 0        | 2017.06.05 08:06:42.210 | 2017.06.05 08:06:42.210 |\n| dir3     | 1     | 0        | 2017.06.05 08:06:39.597 | 2017.06.05 08:06:39.597 |\n\n```\nrm(\"/home/test/abc.txt\");       // delete file abc.txt\n\nfiles(\"/home/test\");\n```\n\n| filename | isDir | fileSize | lastAccessed            | lastModified            |\n| -------- | ----- | -------- | ----------------------- | ----------------------- |\n| dir1     | 1     | 0        | 2017.06.05 08:06:44.836 | 2017.06.05 08:06:44.836 |\n| dir2     | 1     | 0        | 2017.06.05 08:06:42.210 | 2017.06.05 08:06:42.210 |\n| dir3     | 1     | 0        | 2017.06.05 08:06:39.597 | 2017.06.05 08:06:39.597 |\n"
    },
    "rmdir": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rmdir.html",
        "signatures": [
            {
                "full": "rmdir(directory, [recursive=false], [keepRootDir=false])",
                "name": "rmdir",
                "parameters": [
                    {
                        "full": "directory",
                        "name": "directory"
                    },
                    {
                        "full": "[recursive=false]",
                        "name": "recursive",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[keepRootDir=false]",
                        "name": "keepRootDir",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [rmdir](https://docs.dolphindb.cn/zh/funcs/r/rmdir.html)\n\n\n\n#### 语法\n\nrmdir(directory, \\[recursive=false], \\[keepRootDir=false])\n\n#### 详情\n\n删除目录。默认情况下，要删除的目录必须为空。如果目录不为空仍然要删除它时，请设置 *recursive* 的值为true。\n\n**Note:** 该命令在用户登录后才能执行。\n\n#### 参数\n\n**directory** 必备参数，用于指定要删除的文件夹名称。如果该目录不为空，则通过设定 *recursive* 的值为 true 可以删除所有子目录和文件\n\n**recursive** 布尔值，可选参数，用于是否删除所有指定文件夹所有子目录及其中文件。默认值为 false。\n\n**keepRootDir** 布尔值，可选参数，用于指定是否保留根目录。默认值为 false。当设置为 true 时，仅删除子目录和文件，而不会删除根目录。\n\n**Note:** 若设置 *keepRootDir*=true，则必须设置 *recursive*=true。\n\n#### 例子\n\n```\nfiles(\"/home/test\");\n```\n\n| filename | isDir | fileSize | lastAccessed            | lastModified            |\n| -------- | ----- | -------- | ----------------------- | ----------------------- |\n| dir1     | 1     | 0        | 2024.04.03 01:31:48.367 | 2024.04.03 01:31:48.367 |\n| dir2     | 1     | 0        | 2024.04.03 01:36:43.982 | 2024.04.03 01:36:43.982 |\n| dir3     | 1     | 0        | 2024.04.03 01:37:45.618 | 2024.04.03 01:37:45.618 |\n\n```\n// delete a directory. dir1 is empty, dir2 is not empty.\nrmdir(\"/home/test/dir1\");\nrmdir(\"/home/test/dir2\");\n// output\nFailed to remove directory [/home/test/dir2] with error code 145\n\n// Delete a directory recursively\nrmdir(\"/home/test/dir2\", true);\n\nfiles(\"/home/test\");\n```\n\n| filename | isDir | fileSize | lastAccessed            | lastModified            |\n| -------- | ----- | -------- | ----------------------- | ----------------------- |\n| dir3     | 1     | 0        | 2024.04.03 01:37:45.618 | 2024.04.03 01:37:45.618 |\n"
    },
    "rms": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rms.html",
        "signatures": [
            {
                "full": "rms(X)",
                "name": "rms",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [rms](https://docs.dolphindb.cn/zh/funcs/r/rms.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nrms(X)\n\n#### 详情\n\n求 *X* 的均方根。公式如下：\n\n![](https://docs.dolphindb.cn/zh/funcs/images/rms1.png)\n\n#### 参数\n\n**X** 可以是数值标量、数据对、向量、矩阵或表。\n\n#### 返回值\n\n* 若 *X* 为标量、数据对或向量，返回一个标量值。\n* 若 *X* 为矩阵，返回每列的均方根，结果是一个向量。\n* 若 *X* 为表，返回每列的均方根，结果是一个单行的表。\n\n#### 例子\n\n例 1：*X* 为向量时，\n\n```\nX=[1,2,3,4,5]\nrms(X)\n// output: 3.317\n```\n\n例 2：*X* 为矩阵时，\n\n```\nX=matrix(1 2 3, 4 5 6)\nrms(X)\n// output: [2.160,5.066]\n```\n\n例 3：*X* 为表时，\n\n```\nX=1 2 3 4 5 6\nY=7 8 9 10 11 12\nt=table(X as val1, Y as val2)\nrms(t)\n```\n\n返回：\n\n| **val1** | **val2** |\n| -------- | -------- |\n| 3.894    | 9.652    |\n"
    },
    "rollingPanel": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rollingPanel.html",
        "signatures": [
            {
                "full": "rollingPanel(X, window, [groupingCol])",
                "name": "rollingPanel",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    },
                    {
                        "full": "[groupingCol]",
                        "name": "groupingCol",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [rollingPanel](https://docs.dolphindb.cn/zh/funcs/r/rollingPanel.html)\n\n\n\n#### 语法\n\nrollingPanel(X, window, \\[groupingCol])\n\n#### 详情\n\n滚动截取数据表 *X* 中固定数量的行，产生一个新的数据表。若 *groupingCol* 指定，分组进行上述操作。\n\n结果中 panelNumber 列为每次截取的数据的编号，从0开始。\n\n#### 参数\n\n**X** 是一个数据表。\n\n**window** 是一个正整数，表示窗口长度。\n\n**groupingCol** 是一个字符串标量或向量，表示数据表 *X* 中的某个或某些列。\n\n#### 返回值\n\n返回一个表。\n\n#### 例子\n\n```\nt=table(1 1 1 1 1 2 2 2 2 2 as id, 1..10 as x);\nrollingPanel(t, 3, `id);\n```\n\n| id | x  | panelNumber |\n| -- | -- | ----------- |\n| 1  | 1  | 0           |\n| 1  | 2  | 0           |\n| 1  | 3  | 0           |\n| 1  | 2  | 1           |\n| 1  | 3  | 1           |\n| 1  | 4  | 1           |\n| 1  | 3  | 2           |\n| 1  | 4  | 2           |\n| 1  | 5  | 2           |\n| 2  | 6  | 3           |\n| 2  | 7  | 3           |\n| 2  | 8  | 3           |\n| 2  | 7  | 4           |\n| 2  | 8  | 4           |\n| 2  | 9  | 4           |\n| 2  | 8  | 5           |\n| 2  | 9  | 5           |\n| 2  | 10 | 5           |\n"
    },
    "rotateTDEKey": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rotatetdekey.html",
        "signatures": [
            {
                "full": "rotateTDEKey(masterKeyPath)",
                "name": "rotateTDEKey",
                "parameters": [
                    {
                        "full": "masterKeyPath",
                        "name": "masterKeyPath"
                    }
                ]
            }
        ],
        "markdown": "### [rotateTDEKey](https://docs.dolphindb.cn/zh/funcs/r/rotatetdekey.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nrotateTDEKey(masterKeyPath)\n\n#### 详情\n\n启用静态数据加密密钥轮转以更新 TDE 密钥。该函数必须由管理员在控制节点执行。仅 Linux 系统支持该功能。\n\n系统会使用新的 TDE 密钥对所有加密表的表密钥重新加密，并更新表头文件。如函数报错，请检查密钥路径是否正确，以及文件是否符合密钥格式要求。\n\n#### 参数\n\n**masterKeyPath** 字符串标量，指定 TDE 密钥文件的路径。\n\n#### 返回值\n\n如果设置成功，函数返回 true。\n\n#### 例子\n\n```\nenableTDEKey(path/to/newKey)\n```\n"
    },
    "round": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/round.html",
        "signatures": [
            {
                "full": "round(X, [precision])",
                "name": "round",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[precision]",
                        "name": "precision",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [round](https://docs.dolphindb.cn/zh/funcs/r/round.html)\n\n\n\n#### 语法\n\nround(X, \\[precision])\n\n#### 详情\n\n`round` 函数按照指定小数位数对 *X* 进行四舍五入运算。\n\n[floor](https://docs.dolphindb.cn/zh/funcs/f/floor.html) 和 [ceil](https://docs.dolphindb.cn/zh/funcs/c/ceil.html) 函数分别将一个实数映射到不大于 *X* 的最大整数和不小于 *X* 的最小整数。\n\nDolphinDB 的 `round` 按“四舍五入”处理；Python 内置 `round` 和 `numpy.round` 采用 half-to-even 规则。另外，DolphinDB 中 `round` 的参数 *precision* 范围是 0..10；Python 内置 `round` 的参数 *ndigits* 和 `numpy.round` 的参数 *decimals* 支持负数。\n\n#### 参数\n\n**X** 可以是标量、向量或矩阵。\n\n**precision** 是 0 到 10 的整数，表示保留小数点后几位。默认值是 0。\n\n#### 返回值\n\n* *precision* 未指定或设置为0时，返回值数据类型为 LONG，数据形式同 *X*。\n* *precision* 指定为大于0小于等于10的值时，返回值数据类型为 DOUBLE，数据形式同 *X*。\n\n#### 例子\n\n```\nround 2.1;\n//output: 2\n\nround 2.9;\n//output: 3\n\nround -2.1;\n//output: -2\n\nround(2.154,2);\n//output: 2.15\n\nround(2.156,2);\n//output: 2.16\n\nceil 2.1;\n//output: 3\n\nceil 2.9;\n//output: 3\n\nceil -2.1;\n//output: -2\n\nfloor 2.1;\n//output: 2\n\nfloor 2.9;\n//output: 2\n\nfloor -2.1;\n//output: -3\n\nm = 1.1 2.2 3.3 4.4 5.5 6.6 7.7 8.8 9.9 10$2:5;\nm;\n```\n\n返回：\n\n| #0  | #1  | #2  | #3  | #4  |\n| --- | --- | --- | --- | --- |\n| 1.1 | 3.3 | 5.5 | 7.7 | 9.9 |\n| 2.2 | 4.4 | 6.6 | 8.8 | 10  |\n\n```\nround m;\n```\n\n返回：\n\n| #0 | #1 | #2 | #3 | #4 |\n| -- | -- | -- | -- | -- |\n| 1  | 3  | 6  | 8  | 10 |\n| 2  | 4  | 7  | 9  | 10 |\n"
    },
    "routeEvent": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/routeEvent.html",
        "signatures": [
            {
                "full": "routeEvent(event)",
                "name": "routeEvent",
                "parameters": [
                    {
                        "full": "event",
                        "name": "event"
                    }
                ]
            }
        ],
        "markdown": "### [routeEvent](https://docs.dolphindb.cn/zh/funcs/r/routeEvent.html)\n\n\n\n#### 语法\n\nrouteEvent(event)\n\n#### 详情\n\nrouteEvent 是 CEP monitor 内部的事件控制接口，用于将一个事件插入到当前子引擎的事件输入队列的队首。\n\n#### 参数\n\n**event** 事件实例。\n\n#### 例子\n\n定义事件：\n\n```\nclass UpdateFactor{\n    sym :: STRING\n    factor :: DOUBLE\n    def UpdateFactor(code, val){\n        sym = code\n        factor = val\n    }\n}\n\nclass MarketData{\n    market :: STRING\n    code :: STRING\n    price :: DOUBLE\n    qty :: INT\n    def MarketData(m,c,p,q){\n        market = m\n        code = c\n        price = p\n        qty = q\n    }\n}\n```\n\n定义 monitor：\n\n```\n\nclass MainMonitor : CEPMonitor{\n    maxPrice :: DOUBLE\n\n    def MainMonitor(){ maxPrice = 0.0 }\n    \n    def updateMarketData(event)\n\n    // Monitor 启动时注册事件监听器\n    def onload(){\n        addEventListener(handler=updateMarketData, eventType='MarketData', times='all')\n    }\n\n    // 核心事件处理函数\n    def updateMarketData(event){\n        print(\"处理 MarketData: \"+event.code+\" 价格=\"+string(event.price))\n\n        if(event.price > maxPrice){\n            maxPrice = event.price\n\n            // emitEvent：输出到流表\n            emitEvent(UpdateFactor(\"maxPrice\", maxPrice))\n\n            // routeEvent：队首插入一个警告事件，优先处理\n            routeEvent(UpdateFactor(\"alert\", maxPrice))\n\n            // sendEvent：队尾插入一个信息事件，顺序处理\n            sendEvent(UpdateFactor(\"info\", maxPrice))\n        }\n    }\n}\n```\n\n创建流表接收输出事件：\n\n```\nshare streamTable(array(STRING,0) as eventType, array(BLOB,0) as blobs) as simulateResult\n\nserializer = streamEventSerializer(\n    name=`simulate,\n    eventSchema=[UpdateFactor],\n    outputTable=simulateResult\n)\n\ndummy = table(array(STRING,0) as eventType, array(BLOB,0) as blobs)\n```\n\n创建 CEP 引擎：\n\n```\nengine = createCEPEngine(\n    name='cep1',\n    monitors=<MainMonitor()>,\n    dummyTable=dummy,\n    eventSchema=[MarketData],\n    outputTable=serializer\n)\n```\n\n**相关函数**：[addEventListener](https://docs.dolphindb.cn/zh/funcs/a/addEventListener.html), [createCEPEngine](https://docs.dolphindb.cn/zh/funcs/c/createCEPEngine.html), [appendEvent](https://docs.dolphindb.cn/zh/funcs/a/appendEvent.html), [emitEvent](https://docs.dolphindb.cn/zh/funcs/e/emitEvent.html), [sendEvent](https://docs.dolphindb.cn/zh/funcs/s/sendEvent.html)\n"
    },
    "row": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/row.html",
        "signatures": [
            {
                "full": "row(obj,index)",
                "name": "row",
                "parameters": [
                    {
                        "full": "obj",
                        "name": "obj"
                    },
                    {
                        "full": "index",
                        "name": "index"
                    }
                ]
            }
        ],
        "markdown": "### [row](https://docs.dolphindb.cn/zh/funcs/r/row.html)\n\n\n\n#### 语法\n\nrow(obj,index)\n\n#### 详情\n\n获取向量、矩阵或表的一行或多行。参见相关函数：[col](https://docs.dolphindb.cn/zh/funcs/c/col.html)。\n\n#### 参数\n\n**obj** 可以是向量、矩阵或表\n\n**index** 是一个整数标量或数据对。\n\n#### 返回值\n\n返回向量、矩阵或表的一行或多行。\n\n#### 例子\n\n```\nx=matrix(1 2 3, 4 5 6);\nx;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 4  |\n| 2  | 5  |\n| 3  | 6  |\n\n```\nrow(x,1);\n// output\n[2,5]\n\nrow(x,0);\n// output\n[1,4]\n\nx.row(2);\n// output\n[3,6]\n\na=table(1..3 as x,`IBM`C`AAPL as y);\na\n```\n\n| x | y    |\n| - | ---- |\n| 1 | IBM  |\n| 2 | C    |\n| 3 | AAPL |\n\n```\nrow(a,1);\n// output\ny->C\nx->2\n\nrow(a,1:3)\n```\n\n| x | y    |\n| - | ---- |\n| 2 | C    |\n| 3 | AAPL |\n"
    },
    "rowAlign": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rowAlign.html",
        "signatures": [
            {
                "full": "rowAlign(left, right, how)",
                "name": "rowAlign",
                "parameters": [
                    {
                        "full": "left",
                        "name": "left"
                    },
                    {
                        "full": "right",
                        "name": "right"
                    },
                    {
                        "full": "how",
                        "name": "how"
                    }
                ]
            }
        ],
        "markdown": "### [rowAlign](https://docs.dolphindb.cn/zh/funcs/r/rowAlign.html)\n\n\n\n#### 语法\n\nrowAlign(left, right, how)\n\n#### 详情\n\n对 *left* 和 *right* 中的每一行向量，根据其元素值进行对齐。\n\n该函数主要应用于金融场景下对多档买卖报价进行价格对齐，*left* 是某个时刻的买价/卖价，而 *right* 则是上一时刻的买价/卖价。通常结合 `rowAt` 函数，按行取出索引对应的元素。\n\n注意：若 *left/right* 是列式元组，则返回的元组内的元素也是列式元组。\n\n下图演示某行的 *left* 和 *right* 对齐的过程。图中标注出对齐方式为 “bid“ 和 “allBid“ ，”ask” 和 “allAsk“ 时的区别（ 蓝色背景是以 “bid“ 或 “ask“ 对齐时，超出有效档位的数据）。\n\n通过 `rowAt` 函数可以按行取出对应索引的元素。\n\n* *how* = \"bid\" 或 \"allBid\" 时，bid 中某行数据的对齐过程如下图所示：\n\n  ![rowAlign1](https://docs.dolphindb.cn/zh/images/rowAlign_1.png)\n\n* *how* = \"ask\" 或 \"allAsk\" 时，ask 中某行数据的对齐过程如下图所示：\n\n  ![rowAlign2](https://docs.dolphindb.cn/zh/images/rowAlign_2.png)\n\n#### 参数\n\n**left/right**是数组向量或列式元组。\n\n**Note:**\n\n* *left* 和 *right* 的长度和类型必须相同，但它们对应的每行向量的个数可以相同或不同。例如：*left* 的长度是3，其第一行向量的长度是5，则 *right* 的长度必须是3，其每一行向量的长度可以是5或者其它值。\n\n* 必须保证 *left*/*right* 中每行向量的数据严格有序排列。\n\n**how** 字符串，用于指定数据对齐的方式。设置值不同，会影响 *left* 和 *right* 对齐的数据范围。可选值为：\n\n| how(不区分大小写) | 含义                                                            | 对齐后的最大值                    | 对齐后的最小值                    |\n| ----------- | ------------------------------------------------------------- | -------------------------- | -------------------------- |\n| \"bid\"       | 表示 left/right 为多档买方报价数据，其数据严格降序排列。此时，仅将有效档位内的数据进行对齐。          | max(max(left), max(right)) | max(min(left), min(right)) |\n| \"allBid\"    | 表示 left/right 为多档买方报价数据，其数据严格降序排列。此时，将 left 和 right 所有数据进行对齐。 | max(max(left), max(right)) | min(min(left), min(right)  |\n| \"ask\"       | 表示 left/right 为多档卖方报价数据，其数据严格升序排列。此时，仅将有效档位内的数据进行对齐。          | min(max(left), max(right)) | min(min(left), min(right)) |\n| ”allAsk“    | 表示 left/right 为多档卖方报价数据，其数据严格升序排列。此时，将 left 和 right 所有数据进行对齐。 | max(max(left), max(right)) | min(min(left), min(right)  |\n\n#### 返回值\n\n返回一个长度为 2 的元组，分别表示对齐后的数据在原向量中的索引。若 *left/right* 中不存在数据与 *right/left* 的元素值相等，则返回 -1。\n\n#### 例子\n\n```\nleft = array(DOUBLE[], 0, 5).append!([9.01 9.00 8.99 8.98 8.97, 9.00 8.98 8.97 8.96 8.95, 8.99 8.97 8.95 8.93 8.91])\nright = array(DOUBLE[], 0, 5).append!([9.02 9.01 9.00 8.99 8.98, 9.01 9.00 8.99 8.98 8.97, 9.00 8.98 8.97 8.96 8.95])\nleftIndex, rightIndex = rowAlign(left, right, \"bid\")\nleftIndex\n//output:[[-1,0,1,2,3],[-1,0,-1,1,2],[-1,0,-1,1,-1,2]]\nleft.rowAt(leftIndex)\n//output:[[,9.01,9.00,8.99,8.98],[,9,,8.98,8.97],[,8.99,,8.97,,8.95]]\n\nrightIndex\n//output:[[0,1,2,3,4],[0,1,2,3,4],[0,-1,1,2,3,4]]\nright.rowAt(rightIndex)\n//output:[[9.02,9.01,9.00,8.99,8.98],[9.01,9.00,8.99,8.98,8.97],[9.00,,8.98,8.97,8.96,8.95]]\n\n// 输出 left 与 right 数据对齐后的买方报价\nleft.rowAt(leftIndex).nullFill(right.rowAt(rightIndex))\n//output:[[9.02,9.01,9,8.99,8.98],[9.01,9.00,8.99,8.98,8.97],[9.00,8.99,8.98,8.97,8.96,8.95]]\n\n// 假定 bid 对应的 qty 如下\n leftBidQty = array(INT[], 0, 5).append!([10 5 15 20 13, 12 15 20 21 18, 7 8 9 9 10])\n rightBidQty = array(INT[], 0, 5).append!([8 12 10 12 8, 10 5 15 18 13, 12 15 20 21 19])\n\n// 计算 left 和 right 五档报价对应委托量的变化\nleftBidQty.rowAt(leftIndex).nullFill(0) - rightBidQty.rowAt(rightIndex).nullFill(0)\n//output:[[-8,-2,-5,3,12],[-10,7,-15,-3,7],[-12,7,-15,-12,-21,-10]]\n\nleftIndex, rightIndex = rowAlign(left, right, \"allBid\")\nleftIndex\n//output:[[-1,0,1,2],[-1,-1,0,1,2],[-1,0,-1,1,2]]\n\nrightIndex\n//output:[[0,1,2,-1],[0,1,2,-1,-1],[0,-1,1,2,-1]]\n\nleft = array(DOUBLE[], 0, 3).append!([8.99 9.00 9.01, 8.97 8.99 9.00, 8.95 8.97 8.99])\nright = array(DOUBLE[], 0, 3).append!([9.00 9.01 9.02, 8.99 9.00 9.01, 8.97 8.98 9.00])\nleftIndex, rightIndex = rowAlign(left, right, \"ask\")\nleftIndex\n//output:[[0,1,2],[0,1,2],[0,1,-1,2]]\n\nrightIndex\n//output:[[-1,0,1],[-1,0,1],[-1,0,1,-1]]\n\nleftIndex, rightIndex = rowAlign(left, right, \"allAsk\")\nleftIndex\n//output:[[0,1,2,-1],[0,1,2,-1],[0,1,-1,2,-1]]\n\nrightIndex\n//output:[[-1,0,1,2],[-1,0,1,2],[-1,0,1,-1,2]]\n\nsym = `st1`st2`st3\nleft = [[3.1,2.5,2.8], [3.1,3.3], [3.2,2.9,3.3]]\nleft.setColumnarTuple!()\nright = [[3.1,2.5,2.8], [3.1,3.3], [3.2,2.9,3.3]]\nright.setColumnarTuple!()\nrowAlign(left, right, \"bid\")\n//output:[([0,1,2],[0,1],[0,1,2]), ([0,1,2],[0,1],[0,1,2])]\n```\n"
    },
    "rowAnd": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rowAnd.html",
        "signatures": [
            {
                "full": "rowAnd(args...)",
                "name": "rowAnd",
                "parameters": [
                    {
                        "full": "args...",
                        "name": "args..."
                    }
                ]
            }
        ],
        "markdown": "### [rowAnd](https://docs.dolphindb.cn/zh/funcs/r/rowAnd.html)\n\n\n\n#### 语法\n\nrowAnd(args...)\n\nrow 系列函数通用参数说明和计算规则请参考：[rowFunctions](https://docs.dolphindb.cn/zh/funcs/themes/rowFunctions.html)\n\n#### 详情\n\n逐行进行逻辑与操作\n\n#### 返回值\n\n返回一个长度与输入参数行数相同的向量。\n\n#### 例子\n\n```\nm=matrix([true false false, true true true, true true true])\nrowAnd(m);\n// output\n[1,0,0]\n\nt1=table(false true true true false as x, false true false true true as y)\nrowAnd(t1);\n// output\n[0,1,0,1,0]\n\nt=table(`AAPL`MS`IBM`IBM`C as sym, 49.6 29.46 29.52 30.02 174.97 as price1, 175.23 50.76 50.32 51.29 26.23 as price2)\n// output\n\nselect *  from t where rowAnd(price1>30, price2>50);\n```\n\n| sym  | price1 | price2 |\n| ---- | ------ | ------ |\n| AAPL | 49.6   | 175.23 |\n| IBM  | 30.02  | 51.29  |\n\n相关函数：[and](https://docs.dolphindb.cn/zh/funcs/a/and.html)\n"
    },
    "rowAt": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rowAt.html",
        "signatures": [
            {
                "full": "rowAt(X, [Y])",
                "name": "rowAt",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[Y]",
                        "name": "Y",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [rowAt](https://docs.dolphindb.cn/zh/funcs/r/rowAt.html)\n\n\n\n#### 语法\n\nrowAt(X, \\[Y])\n\nrow 系列函数通用参数说明和计算规则请参考：[rowFunctions](https://docs.dolphindb.cn/zh/funcs/themes/rowFunctions.html)\n\n#### 详情\n\n逐行取出 *X* 中对应索引的元素。\n\n* 若 *Y* 是整型向量，*Y* 的每个元素表示 *X* 每行的列索引，逐行取出 *X* 中对应索引的元素，返回一个与 *Y* 长度相同的向量。若索引无对应元素或索引超出 *X* 的有效索引范围，则返回空值。\n\n* 若 *Y* 是布尔类型的矩阵或数组向量（或列式元组），则取出 *X* 对应于 *Y* 中 true 值的元素，返回一个与 *Y* 行数相同的数组向量。若 *Y* 中某一行的所有元素值都是 false，则该行返回空值。其中，当 Y 是布尔类型矩阵时，X 只能是矩阵。\n\n* 若 *Y* 是整型数组向量（或列式元组），*Y* 的每个元素表示 *X* 每行的列索引，逐行取出 *X* 中对应索引的元素，返回一个与 *Y* 维度相同的数组向量（或列式元组）。若索引无对应元素或索引超出 *X* 的有效索引范围，则返回空值。\n\n* 若 *Y* 不指定，*X* 必须是布尔类型的矩阵或数组向量（或列式元组）。该函数逐行取出 *X* 中元素值是 true 的索引。返回一个整型数组向量（或列式元组），其行数和 *X* 的行数相同。若 *X* 中某一行的所有元素值都是空值或 false，则该行返回空值。\n\n#### 参数\n\n**X** 矩阵、数组向量或列式元组。\n\n**Y** 整型向量、布尔型矩阵、整型或布尔型数组向量或列式元组。\n\n#### 返回值\n\n返回一个与 *Y* 长度相同的向量。若索引无对应元素或索引超出 *X* 的有效索引范围，则返回空值。\n\n#### 例子\n\n```\nm = matrix(3.1 4.5 2.2, 4.2 4.3 5.1, 6.2 7.1 2.2, 1.8 6.1 5.3, 7.1 8.4 3.5)\nindex = 4 0 2\nrowAt(m, index)\n// output\n[7.1,4.5,2.2]\n\ntrades = table(10:0,`time`sym`p1`p2`p3`p4`p5`vol1`vol2`vol3`vol4`vol5,[TIMESTAMP,SYMBOL,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,INT,INT,INT,INT,INT])\ninsert into trades values(2022.01.01T09:00:00, `A, 33.2, 33.8, 33.6, 33.3, 33.1, 200, 180, 180, 220, 200)\ninsert into trades values(2022.01.01T09:00:00, `A, 33.1, 32.8, 33.2, 34.3, 32.3, 150, 280, 190, 100, 220)\ninsert into trades values(2022.01.01T09:00:00, `A, 31.2, 32.6, 33.6, 35.3, 34.5, 220, 160, 130, 100, 110)\ninsert into trades values(2022.01.01T09:00:00, `A, 30.2, 32.5, 33.6, 35.3, 34.1, 200, 180, 150, 140, 120)\ninsert into trades values(2022.01.01T09:00:00, `A, 33.2, 33.8, 33.6, 33.3, 33.1, 180, 160, 160, 180, 200)\nselect rowAt(matrix(p1, p2, p3, p4, p5), rowImin(vol1, vol2, vol3, vol4, vol5)) as price1, rowAt(matrix(p1, p2, p3, p4, p5), rowImax(vol1, vol2, vol3, vol4, vol5)) as price2 from trades\n```\n\n| price1 | price2 |\n| :----- | :----- |\n| 33.8   | 33.3   |\n| 34.3   | 32.8   |\n| 35.3   | 31.2   |\n| 34.1   | 30.2   |\n| 33.8   | 33.1   |\n\n```\nindex = array\\(INT\\[\\], 0, 10\\).append!\\(\\[0 1, 2 4, 3 4 5\\]\\)\nrowAt\\(m, index\\)\n// output\n\\[\\[3.1,4.2\\],\\[7.1,8.4\\],\\[5.3,3.5,\\]\\]\n\nx = array\\(DOUBLE\\[\\], 0, 10\\).append!\\(\\[3.3 3.6 3.8, 3.7 3.4 3.5, 3.4 3.4 3.5\\]\\)\nindex = array\\(INT\\[\\], 0, 10\\).append!\\(\\[0 1, 2, 0 2\\]\\)\nrowAt\\(x, index\\)\n// output\n\\[\\[3.3,3.6\\],\\[3.5\\],\\[3.4,3.5\\]\\]\n```\n\n2.00.10.2 及以上版本，当 *X* 是布尔类型矩阵或数组向量时，*Y* 可以不指定，此时 `rowAt` 返回每行中 true 元素的索引。\n\n```\nm = matrix(true false false, false true false, true true false)\nR=rowAt(m)\nR\n// output\n[[0,2],[1,2],]\ntypestr(R)\n// output\nFAST INT[] VECTOR\n\nm = matrix(3.1 4.5 2.2, 2.2 4.3 5.1, 1.2 7.1 2.2, 1.8 6.1 5.3, 1 4 3)\nrowAt(m, m>4)\n// output\n[,[4.5,4.3,7.1,6.1],[5.1,5.3]]\n\nx = array(DOUBLE[], 0, 10).append!([3.3 3.6 3.8, 3.7 3.4 3.5, 3.4 3.4 3.5])\nrowAt(x, x>3.5)\n// output\n[[3.6,3.8],[3.7],]\n```\n\n对列式元组与数组向量应用 `rowAt`：\n\n```\nx = ([1, 2, 3], [4, 5, 6]).setColumnarTuple!()\ny = fixedLengthArrayVector([1, 4], [2, 5], [3, 6])\n\nrowAt(x, x > 1)\n// output\n([2,3],[4,5,6])\n\nrowAt(y, y>1)\n// output\n[[2,3],[4,5,6]]\n```\n\n**Related information**\n\n[at](https://docs.dolphindb.cn/zh/funcs/a/at.html)\n"
    },
    "rowAvg": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rowAvg.html",
        "signatures": [
            {
                "full": "rowAvg(args...)",
                "name": "rowAvg",
                "parameters": [
                    {
                        "full": "args...",
                        "name": "args..."
                    }
                ]
            }
        ],
        "markdown": "### [rowAvg](https://docs.dolphindb.cn/zh/funcs/r/rowAvg.html)\n\n\n\n#### 语法\n\nrowAvg(args...)\n\nrow 系列函数通用参数说明和计算规则请参考：[rowFunctions](https://docs.dolphindb.cn/zh/funcs/themes/rowFunctions.html)\n\n#### 详情\n\n逐行进行元素求平均操作。\n\n#### 返回值\n\n返回一个长度与输入参数行数相同的向量。\n\n#### 例子\n\n```\nm=matrix([4.5 2.6 1.5, 1.5 4.8 5.9, 4.9 2.0 NULL])\nrowAvg(m);\n// output\n[3.633333,3.133333,3.7]\n\nt1=table(1..5 as x, 6..10 as y)\nt2=table(5..1 as a, 10..6 as b);\nrowAvg(t1);\n// output\n[3.5,4.5,5.5,6.5,7.5]\n\nrowAvg(t1[`x], t2, take(1, 5));\n// output\n[4.25,4,3.75,3.5,3.25]\n\nt=table(`AAPL`MS`IBM`IBM`C as sym, 49.6 29.46 29.52 30.02 174.97 as price1, 175.23 50.76 50.32 51.29 26.23 as price2)\nselect sym,rowAvg(price1,price2) as avg from t;\n```\n\n| sym  | price1  |\n| ---- | ------- |\n| AAPL | 112.415 |\n| MS   | 40.11   |\n| IBM  | 39.92   |\n| IBM  | 40.655  |\n| C    | 100.6   |\n\n相关函数：[avg](https://docs.dolphindb.cn/zh/funcs/a/avg.html)\n"
    },
    "rowBeta": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rowBeta.html",
        "signatures": [
            {
                "full": "rowBeta(Y, X)",
                "name": "rowBeta",
                "parameters": [
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [rowBeta](https://docs.dolphindb.cn/zh/funcs/r/rowBeta.html)\n\n\n\n#### 语法\n\nrowBeta(Y, X)\n\nrow 系列函数通用参数说明和计算规则请参考：[rowFunctions](https://docs.dolphindb.cn/zh/funcs/themes/rowFunctions.html)\n\n#### 详情\n\n逐行计算 *Y* 在 *X* 上的回归系数的最小二乘估计\n\n#### 返回值\n\n返回一个长度与输入参数行数相同的向量。\n\n#### 例子\n\n```\nm1=matrix([4.5 2.6 1.5, 1.5 4.8 5.9, 4.9 2.0 NULL])\nm2=matrix(49.6 NULL 29.52, 50.32 51.29 26.23, NULL 74.97 23.75)\nrowBeta(m1, m2)\n// output\n[-4.1667,-0.1182, -1.3374]\n\nm3=matrix(8 NULL 10, 8 NULL 4, 14 NULL NULL)\nrowBeta(m3, m2)\n// output\n[0, , 1.8237]\n\na= 110 112.3 44 98\nb= 57.9 39 75 90\nc= 55 64 37 78\nx=array\\(DOUBLE\\[\\],0, 10\\).append!\\(\\[a, b, c\\]\\)\ny=array\\(DOUBLE\\[\\],0, 10\\).append!\\(\\[b, a, c\\]\\)\nrowBeta\\(x, y\\)\n// output\n\\[0.6783, 1 , -0.3202, 1\\]\n```\n\n相关函数：[beta](https://docs.dolphindb.cn/zh/funcs/b/beta.html)\n"
    },
    "rowCorr": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rowCorr.html",
        "signatures": [
            {
                "full": "rowCorr(X, Y)",
                "name": "rowCorr",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [rowCorr](https://docs.dolphindb.cn/zh/funcs/r/rowCorr.html)\n\n\n\n#### 语法\n\nrowCorr(X, Y)\n\nrow 系列函数通用参数说明和计算规则请参考：[rowFunctions](https://docs.dolphindb.cn/zh/funcs/themes/rowFunctions.html)\n\n#### 详情\n\n逐行计算 *X* 和 *Y* 之间的相关性。\n\n#### 返回值\n\n返回一个长度与输入参数行数相同的向量。\n\n#### 例子\n\n```\nm1=matrix(2 -1 4, 8 3 2, 9 0 1)\nm2=matrix(8 11 10, 8 17 4, 14 6 4)\nrowCorr(m1, m2)\n// output\n[0.61, 0.7559, 0.9449]\n\nm3=matrix(8 NULL 10, 8 NULL 4, 14 NULL NULL)\nrowCorr(m1, m3)\n// output\n[0.61, , 1]\n\na=array\\(DOUBLE\\[\\], 0, 10\\).append!\\(\\[1 2 3, 4 NULL 5, 6 7 8, NULL 3 10\\]\\);\nb=array\\(DOUBLE\\[\\], 0, 10\\).append!\\(\\[\\[1.3,1.2, 4\\], \\[1.0,1.4, 2\\], \\[1.1, 1.4, 3\\],\\[1, 4, 7\\]\\]\\);\n\nrowBeta\\(a, b\\)\n// output\n\\[0.535, 1 , 0.9105, 2.3333\\]\n```\n\n相关函数：[corr](https://docs.dolphindb.cn/zh/funcs/c/corr.html)\n"
    },
    "rowCount": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rowCount.html",
        "signatures": [
            {
                "full": "rowCount(args...)",
                "name": "rowCount",
                "parameters": [
                    {
                        "full": "args...",
                        "name": "args..."
                    }
                ]
            }
        ],
        "markdown": "### [rowCount](https://docs.dolphindb.cn/zh/funcs/r/rowCount.html)\n\n\n\n#### 语法\n\nrowCount(args...)\n\nrow 系列函数通用参数说明和计算规则请参考：[rowFunctions](https://docs.dolphindb.cn/zh/funcs/themes/rowFunctions.html)\n\n#### 详情\n\n逐行进行非空值的统计操作\n\n#### 返回值\n\n返回一个长度与输入参数行数相同的向量。\n\n#### 例子\n\n```\nm=matrix([4.5 2.6 1.5, 1.5 4.8 5.9, 4.9 2.0 NULL]);\nrowCount(m);\n// output\n[3,3,2]\n\nt1=table(1 NULL 3 NULL 5 as x, 6..10 as y);\nt2=table(5 NULL 3 NULL 1 as a, 10..6 as b);\nrowCount(t1);\n// output\n[2,1,2,1,2]\n\nrowCount(t1[`x], t2, 1 NULL 2 NULL NULL);\n// output\n[4,1,4,1,3]\n\nt=table(`AAPL`MS`IBM`IBM`C as sym, [49.6, NULL, 29.52, NULL, 174.97] as price1, [175.23, NULL, 50.32, 51.29, 26.23] as price2);\nselect sym,rowCount(price1,price2) as count from t;\n```\n\n| sym  | count |\n| ---- | ----- |\n| AAPL | 2     |\n| MS   | 0     |\n| IBM  | 2     |\n| IBM  | 1     |\n| C    | 2     |\n\n相关函数：[rowSize](https://docs.dolphindb.cn/zh/funcs/r/rowSize.html), [count](https://docs.dolphindb.cn/zh/funcs/c/count.html)\n"
    },
    "rowCovar": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rowCovar.html",
        "signatures": [
            {
                "full": "rowCovar(X, Y)",
                "name": "rowCovar",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [rowCovar](https://docs.dolphindb.cn/zh/funcs/r/rowCovar.html)\n\n\n\n#### 语法\n\nrowCovar(X, Y)\n\nrow 系列函数通用参数说明和计算规则请参考：[rowFunctions](https://docs.dolphindb.cn/zh/funcs/themes/rowFunctions.html)\n\n#### 详情\n\n逐行计算 *X* 和 *Y* 之间的协方差\n\n#### 返回值\n\n返回一个长度与输入参数行数相同的向量。\n\n#### 例子\n\n```\nm1=matrix(2 8 9 12, 9 14 11 8,-3 NULL NULL 9)\nm2=matrix(11.2 3 5 9, 7 -10 8 5,17 12 18 9)\nrowCovar(m1, m2)\n// output\n[-29.7333, -39, 3, 3.3333]\n\na= 110 112.3 44 98\nb= 57.9 39 75 90\nc= 55 64 37 78\nx=array\\(DOUBLE\\[\\],0, 10\\).append!\\(\\[a, b, c\\]\\)\ny=array\\(DOUBLE\\[\\],0, 10\\).append!\\(\\[b, a, c\\]\\)\n\nrowCovar\\(x, y\\)\n// output\n\\[-327.9475, -327.9475, 295\\]\n```\n\n```\n// 定义一个随机数据集x\n\nx = rand(1.0, 1000000)\n\n// 自定义了一个聚合函数，窗口长度为5，滑动计算窗口内 x 和它排序后数据的协方差\ntimer moving(defg(x):covar(x, sort(x)), x, 5)\n// output\n1928.888 ms\n\n// movingWindowIndex 滑动选取 x 的5个元素的索引，movingTopNIndex 滑动选取 x 的5个元素排序后的索引。通过 rowCovar 函数计算\ntimer rowCovar(x[movingWindowIndex(x, 5)], x[movingTopNIndex(x, 5, 5)])\n// output\n232.407 ms\n```\n\n相关函数：[covar](https://docs.dolphindb.cn/zh/funcs/c/covar.html)\n"
    },
    "rowCovarp": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rowCovarp.html",
        "signatures": [
            {
                "full": "rowCovarp(X, Y)",
                "name": "rowCovarp",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [rowCovarp](https://docs.dolphindb.cn/zh/funcs/r/rowCovarp.html)\n\n首发版本：3.00.5\n\n\n\n#### 语法\n\nrowCovarp(X, Y)\n\nrow 系列函数通用参数说明和计算规则请参考：[rowFunctions](https://docs.dolphindb.cn/zh/funcs/themes/rowFunctions.html)\n\n#### 详情\n\n逐行计算 *X* 和 *Y* 之间的总体协方差。\n\n#### 返回值\n\n返回一个长度与输入参数行数相同的向量。\n\n#### 例子\n\n```\nm1=matrix(2 8 9 12, 9 14 11 8,-3 NULL NULL 9)\nm2=matrix(11.2 3 5 9, 7 -10 8 5,17 12 18 9)\nrowCovarp(m1, m2)\n// output: [-19.82,-19.5,1.5,2.22]\n\na= 110 112.3 44 98\nb= 57.9 39 75 90\nc= 55 64 37 78\nx=array(DOUBLE[],0, 10).append!([a, b, c])\ny=array(DOUBLE[],0, 10).append!([b, a, c])\n\nrowCovarp(x, y)\n// output: [-245.96,-245.96,221.25]\n```\n\n相关函数：[covarp](https://docs.dolphindb.cn/zh/funcs/c/covarp.html)\n"
    },
    "rowCummax": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rowCummax.html",
        "signatures": [
            {
                "full": "rowCummax(X)",
                "name": "rowCummax",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [rowCummax](https://docs.dolphindb.cn/zh/funcs/r/rowCummax.html)\n\n\n\n#### 语法\n\nrowCummax(X)\n\nrow 系列函数通用参数说明和计算规则请参考：[rowFunctions](https://docs.dolphindb.cn/zh/funcs/themes/rowFunctions.html)\n\n#### 详情\n\n逐行计算 *X* 元素的累积最大值。\n\n#### 返回值\n\n返回一个数据类型与 *X* 相同的对象。\n\n#### 例子\n\n```\nm=matrix([4.5 2.6 1.5, 1.5 4.8 5.9, 4.9 2.0 NULL])\nrowCummax(m)\n```\n\n| col1 | col2 | col3 |\n| ---- | ---- | ---- |\n| 4.5  | 4.5  | 4.9  |\n| 2.6  | 4.8  | 4.8  |\n| 1.5  | 5.9  | 5.9  |\n\n```\na=array(INT[], 0, 10).append!([1 2 3, 4 5, 6 7 8]);\nrowCummax(a)\n// output\n[[1,2,3],[4,5],[6,7,8]]\n\ntp = [[1.3,2.5,2.3], [4.1,5.3,6.2]]\ntp.setColumnarTuple!()\nrowCummax(tp)\n// output\n[[1.3,2.5,2.5],[4.1,5.3,6.2]]\n```\n"
    },
    "rowCummin": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rowCummin.html",
        "signatures": [
            {
                "full": "rowCummin(X)",
                "name": "rowCummin",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [rowCummin](https://docs.dolphindb.cn/zh/funcs/r/rowCummin.html)\n\n\n\n#### 语法\n\nrowCummin(X)\n\nrow 系列函数通用参数说明和计算规则请参考：[rowFunctions](https://docs.dolphindb.cn/zh/funcs/themes/rowFunctions.html)\n\n#### 详情\n\n逐行计算 *X* 元素的累积最小值。\n\n#### 返回值\n\n返回一个数据类型与 *X* 相同的对象。\n\n#### 例子\n\n```\nm=matrix([4.5 2.6 1.5, 1.5 4.8 5.9, 4.9 2.0 NULL])\nrowCummin(m)\n```\n\n| col1 | col2 | col3 |\n| ---- | ---- | ---- |\n| 4.5  | 1.5  | 1.5  |\n| 2.6  | 2.6  | 2    |\n| 1.5  | 1.5  | 1.5  |\n\n```\na=array(INT[], 0, 10).append!([1 2 3, 4 5, 6 7 8]);\nrowCummin(a)\n// output\n[[1,1,1],[4,4],[6,6,6]]\n\ntp = [[1.3,2.5,2.3], [4.1,5.3,6.2]]\ntp.setColumnarTuple!()\nrowCummin(tp)\n// output\n[[1.3,1.3,1.3],[4.1,4.1,4.1]]\n```\n"
    },
    "rowCumprod": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rowCumprod.html",
        "signatures": [
            {
                "full": "rowCumprod(X)",
                "name": "rowCumprod",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [rowCumprod](https://docs.dolphindb.cn/zh/funcs/r/rowCumprod.html)\n\n\n\n#### 语法\n\nrowCumprod(X)\n\nrow 系列函数通用参数说明和计算规则请参考：[rowFunctions](https://docs.dolphindb.cn/zh/funcs/themes/rowFunctions.html)\n\n#### 详情\n\n逐行计算 *X* 元素的累积乘积。\n\n#### 返回值\n\n返回一个数据类型与 *X* 相同的对象。\n\n#### 例子\n\n```\nm=matrix([4.5 2.6 1.5, 1.5 4.8 5.9, 4.9 2.0 NULL])\nrowCumprod(m)\n```\n\n| col1 | col2  | col3   |\n| ---- | ----- | ------ |\n| 4.5  | 6.75  | 33.075 |\n| 2.6  | 12.48 | 24.96  |\n| 1.5  | 8.85  | 8.85   |\n\n```\na=array(INT[], 0, 10).append!([1 2 3, 4 5, 6 7 8]);\nrowCumprod(a)\n// output\n[[1,3,6],[4,9],[6,13,21]]\n\ntp = [[1.3,2.5,2.3], [4.1,5.3,6.2]]\ntp.setColumnarTuple!()\nrowCumprod(tp)\n// output\n[[1.3,3.25,7.475],[4.1,21.73,134.726]]\n```\n"
    },
    "rowCumsum": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rowCumsum.html",
        "signatures": [
            {
                "full": "rowCumsum(X)",
                "name": "rowCumsum",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [rowCumsum](https://docs.dolphindb.cn/zh/funcs/r/rowCumsum.html)\n\n\n\n#### 语法\n\nrowCumsum(X)\n\nrow 系列函数通用参数说明和计算规则请参考：[rowFunctions](https://docs.dolphindb.cn/zh/funcs/themes/rowFunctions.html)\n\n#### 详情\n\n逐行计算 *X* 中元素的累计和。\n\n#### 返回值\n\n返回一个数据类型与 *X* 相同的对象。\n\n#### 例子\n\n```\nm=matrix([4.5 2.6 1.5, 1.5 4.8 5.9, 4.9 2.0 NULL])\nrowCumsum(m)\n```\n\n| col1 | col2 | col3 |\n| ---- | ---- | ---- |\n| 4.5  | 6    | 10.9 |\n| 2.6  | 7.4  | 9.4  |\n| 1.5  | 7.4  | 7.4  |\n\n```\na=array(INT[], 0, 10).append!([1 2 3, 4 5, 6 7 8]);\nrowCumsum(a)\n// output\n[[1,3,6],[4,9],[6,13,21]]\n\ntp = [[1.3,2.5,2.3], [4.1,5.3,6.2]]\ntp.setColumnarTuple!()\nrowCumsum(tp)\n// output\n[[1.3,3.8,6.1],[4.1,9.4,15.6]]\n```\n"
    },
    "rowCumwsum": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rowCumwsum.html",
        "signatures": [
            {
                "full": "rowCumwsum(X, Y)",
                "name": "rowCumwsum",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [rowCumwsum](https://docs.dolphindb.cn/zh/funcs/r/rowCumwsum.html)\n\n\n\n#### 语法\n\nrowCumwsum(X, Y)\n\nrow 系列函数通用参数说明和计算规则请参考：[rowFunctions](https://docs.dolphindb.cn/zh/funcs/themes/rowFunctions.html)\n\n#### 详情\n\n逐行计算 *X* 和 *Y* 的累积内积。\n\n#### 返回值\n\n返回一个数据类型与 *X* 相同的对象。\n\n#### 例子\n\n```\nm1=matrix(2 -1 4, 8 3 2, 9 0 1)\nm2=matrix(8 11 10, 8 17 4, 14 6 4)\nrowCumwsum(m1, m2)\n```\n\n| col1 | col2 | col3 |\n| ---- | ---- | ---- |\n| 16   | 80   | 206  |\n| -11  | 40   | 40   |\n| 40   | 48   | 52   |\n\n```\na= -10 12.3 4 -8\nb= 17.9 9 7.5 -4\nc= 5.5 6.4 -7 8\nx=array(DOUBLE[],0, 10).append!([a, b, c])\ny=array(DOUBLE[],0, 10).append!([b, a, c])\nrowCumwsum(x, y)\n// output\n[[-179,-68.30,-38.30,-6.29],[-179,-68.30,-38.30,-6.29],[30.25,71.21,120.21,184.21]]\n\ntp1 = [[3,4,5],[4,5,6]]\ntp1.setColumnarTuple!()\n\ntp2 = [[13,41,25],[21,30,10]]\ntp2.setColumnarTuple!()\nrowCumwsum(tp1, tp2)\n// output\n[[39,203,328],[84,234,294]]\n```\n"
    },
    "rowDenseRank": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rowDenseRank.html",
        "signatures": [
            {
                "full": "rowDenseRank(X, [ascending=true], [ignoreNA=true], [percent=false])",
                "name": "rowDenseRank",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[ignoreNA=true]",
                        "name": "ignoreNA",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[percent=false]",
                        "name": "percent",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [rowDenseRank](https://docs.dolphindb.cn/zh/funcs/r/rowDenseRank.html)\n\n\n\n#### 语法\n\nrowDenseRank(X, \\[ascending=true], \\[ignoreNA=true], \\[percent=false])\n\n#### 详情\n\n逐行计算 *X* 的元素连续排名，排名方式请参照 [denseRank](https://docs.dolphindb.cn/zh/funcs/d/denseRank.html)。\n\n#### 参数\n\nrow 系列函数通用参数说明和计算规则请参考：[rowFunctions](https://docs.dolphindb.cn/zh/funcs/themes/rowFunctions.html)。\n\n**ascending** 是一个布尔值，表示排序方向。true 表示升序，false 表示降序。默认值为 true。它是一个可选参数。\n\n**ignoreNA** 是一个布尔值，表示是否忽略 NULL 值。true 表示忽略 NULL 值，false 表示 NULL 值参与排名。默认值为 true。它是一个可选参数。NULL 值参与排序时，NULL 值为最小值。\n\n**percent** 是一个布尔值，表示是否以百分比形式显示返回的排名。\n\n#### 返回值\n\n返回一个和 *X* 维度相同的矩阵。\n\n#### 例子\n\n```\nm = matrix(1 5 8 5 9, 2 8 2 5 2, 6 5 3 3 4)\nrowDenseRank(m)\n```\n\n返回：\n\n| col1 | col2 | col3 |\n| ---- | ---- | ---- |\n| 0    | 1    | 2    |\n| 0    | 1    | 0    |\n| 2    | 0    | 1    |\n| 1    | 1    | 0    |\n| 2    | 0    | 1    |\n\n返回：\n\n```\ny=matrix(1 3 3, 6 5 6, NULL 0 9)\nrowDenseRank(y)\n```\n\n返回：\n\n| col1 | col2 | col3 |\n| ---- | ---- | ---- |\n| 0    |      | 1    |\n| 1    | 2    | 0    |\n| 0    | 1    | 2    |\n\n```\nrowDenseRank(y, ignoreNA=false)\n```\n\n返回：\n\n| col1 | col2 | col3 |\n| ---- | ---- | ---- |\n| 1    | 2    | 0    |\n| 1    | 2    | 0    |\n| 0    | 1    | 2    |\n\n**Related information**\n\n[denseRank](https://docs.dolphindb.cn/zh/funcs/d/denseRank.html)\n\n[rowRank](https://docs.dolphindb.cn/zh/funcs/r/rowRank.html)\n"
    },
    "rowDot": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rowDot.html",
        "signatures": [
            {
                "full": "rowDot(X, Y)",
                "name": "rowDot",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [rowDot](https://docs.dolphindb.cn/zh/funcs/r/rowDot.html)\n\n\n\n#### 语法\n\nrowDot(X, Y)\n\n#### 详情\n\n若 *X* 和 *Y* 同时为向量/矩阵，按行计算 *X* 和 *Y* 的内积。若 *X* 和 *Y* 同时为索引矩阵，会对齐标签，对标签相同的行进行计算，标签不同的行直接返回 NULL。\n\n若 *X* 和 *Y* 一个为向量，一个为矩阵，则向量的长度必须与矩阵的列数相同，计算向量与矩阵每一行的内积。\n\n若 *X* 和 *Y* 是数组向量，计算 *X* 和 *Y* 对应位置的向量的内积，即 dot(X.row(i),Y.row(i))。\n\n若 *X* 和 *Y* 一个为向量，一个为数组向量，计算向量与数组向量内每个向量的内积。两个向量的长度相同时返回计算结果，长度不相同时返回 NULL。\n\n与所有其它聚合函数一致，计算时忽略 NULL 值。\n\n#### 参数\n\n**X** 和 **Y** 是长度相同的数值型向量或数组向量，或维度相同的矩阵。若 *X* 和 *Y* 为数组向量，它们对应位置的向量必须具有相同长度。\n\n#### 返回值\n\n一个向量。\n\n#### 例子\n\n```\nrowDot(13.5 15.2 6.3, 18.6 14.8 15.5)\n// output\n[251.1,224.96,97.65]\n\ns1=indexedSeries(2020.01.01..2020.01.03, 10.4 11.2 9)\ns2=indexedSeries(2020.01.01 2020.01.03 2020.01.04, 23.5 31.2 26)\nrowDot(s1,s2)\n// output\n[244.4,349.44,234]\n\nm=matrix(23 56 47, 112 94 59)\nm1=matrix(11 15 89, 52 41 63)\nrowDot(m,m1)\n// output\n[6077,4694,7900]\n\nm.rename!(2020.01.01..2020.01.03, `A`B)\nm.setIndexedMatrix!()\nm1.rename!(2020.01.01 2020.01.03 2020.01.04, `A`B)\nm1.setIndexedMatrix!()\nrowDot(m,m1)\n// output\n[6077,NULL,3124,NULL]\n\na=array(DOUBLE[],0,10)\na.append!([[10.5, 11.8, 9],[15, NULL], [2.5, 2.2, 1.3, 1.5]])\nb=array(DOUBLE[],0,10)\nb.append!([[1.1, 1.8, 6],[5, 6.9], [3.5, 2, 3, 2.8]])\nrowDot(a,b)\n// output\n[86.79,75,21.25]\n```\n\n相关函数：[dot](https://docs.dolphindb.cn/zh/funcs/d/dot.html)\n"
    },
    "rowEuclidean": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rowEuclidean.html",
        "signatures": [
            {
                "full": "rowEuclidean(X, Y)",
                "name": "rowEuclidean",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [rowEuclidean](https://docs.dolphindb.cn/zh/funcs/r/rowEuclidean.html)\n\n\n\n#### 语法\n\nrowEuclidean(X, Y)\n\n#### 详情\n\n若 *X* 和 *Y* 同时为向量/矩阵，按行计算 *X* 和 *Y* 之间的欧式距离。若 *X* 和 *Y* 同时为索引矩阵，会对齐标签，对标签相同的行进行计算，标签不同的行直接返回 NULL。\n\n若 *X* 和 *Y* 一个为向量，一个为矩阵，则向量的长度必须与矩阵的列数相同，计算向量与矩阵每一行的欧式距离。\n\n若 *X* 和 *Y* 是数组向量，计算 *X* 和 *Y* 对应位置的向量之间的欧式距离，即 euclidean(X.row(i),Y.row(i))。\n\n若 *X* 和 *Y* 一个为向量，一个为数组向量，计算向量与数组向量内每个向量的欧式距离。两个向量的长度相同时返回计算结果，长度不相同时返回 NULL。\n\n与所有其它聚合函数一致，计算时忽略 NULL 值。\n\n#### 参数\n\n**X** 和 **Y** 是长度相同的数值型向量或数组向量，或维度相同的矩阵。若 *X* 和 *Y* 为数组向量，它们对应位置的向量必须具有相同长度。\n\n#### 返回值\n\n一个向量。\n\n#### 例子\n\n```\nrowEuclidean(3.6 5.2 6.3, 8.6 4.8 5.5)\n// output\n[5,0.4,0.8]\n\nm=matrix(23 56 47, 112 94 59)\nm1=matrix(11 15 89, 52 41 63)\nrowEuclidean(m,m1)\n// output\n[61.1882,67.0075,42.19]\n\nm.rename!(2020.01.01..2020.01.03, `A`B)\nm.setIndexedMatrix!()\nm1.rename!(2020.01.01 2020.01.03 2020.01.04, `A`B)\nm1.setIndexedMatrix!()\nrowEuclidean(m,m1)\n// output\n[61.1882,NULL,36.7151,NULL]\n\na=array(INT[],0,10)\na.append!([[1, 8, 9],[15, NULL], [25, 22, 13, 15]])\nb=array(INT[],0,10)\nb.append!([[11, 18, 6],[5, 9], [5, 2, 3, 1]])\nrowEuclidean(a,b)\n// output\n[14.4568,10,33.1059]\n```\n\n相关函数：[euclidean](https://docs.dolphindb.cn/zh/funcs/e/euclidean.html)\n"
    },
    "rowFilterAndSort": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rowfilterandsort.html",
        "signatures": [
            {
                "full": "rowFilterAndSort(sortVec, filterVec, orderedFilters, args...)",
                "name": "rowFilterAndSort",
                "parameters": [
                    {
                        "full": "sortVec",
                        "name": "sortVec"
                    },
                    {
                        "full": "filterVec",
                        "name": "filterVec"
                    },
                    {
                        "full": "orderedFilters",
                        "name": "orderedFilters"
                    },
                    {
                        "full": "args...",
                        "name": "args..."
                    }
                ]
            }
        ],
        "markdown": "### [rowFilterAndSort](https://docs.dolphindb.cn/zh/funcs/r/rowfilterandsort.html)\n\n首发版本：3.00.5\n\n\n\n#### 语法\n\nrowFilterAndSort(sortVec, filterVec, orderedFilters, args...)\n\n#### 详情\n\n对数组向量或列式元组中的元素进行过滤和排序。\n\n*sortVec* 、 *filterVec* 和 *args...* 的元素按位置一一对应。该函数先基于 *filterVec* 进行过滤，再基于 *sortVec* 和 *filterVec* 进行排序，过滤和排序标准由 *orderedFilters* 指定：\n\n* **过滤** ：对 *filterVec* 遵照 *orderedFilters* 进行过滤，仅保留 *orderedFilters* 中指定的值。\n\n* **排序** ：过滤后，对 sortVec 中的等值数据，根据对应 *filterVec* 的值遵照 *orderedFilters* 指定顺序进行排序。\n\n#### 参数\n\n**sortVec** 数值类型或时间类型的数组向量或列式元组，表示排序列。或是一个元组，包含最多 3 个数组向量或列式元组。每一行中的元素必须为有序。\n\n**filterVec** STRING 类型的列式元组，表示过滤并用于排序的键列。或是一个元组，包含最多 3 个 STRING 类型的列式元组。\n\n**orderedFilters** STRING 向量或元组，表示过滤与排序的标准。过滤后 *filterVec* 中仅在 *orderedFilters* 中指定的元素将被保留。当 *filterVec* 是元组时， *orderedFilters* 也必须是元组，且元组中元素个数与 *filterVec* 相等。\n\n**args** 可选参数，可以是数组向量或列式元组，其数据形式必须与 *sortVec* 一致，表示同步过滤与重排的附加数据列。\n\n#### 返回值\n\n返回一个元组，元素依次为过滤排序并展开的 *sortVec* 、 *filterVec* 和 *args* 。\n\n**Note:**\n\n展开指当 *sortVec，filterVec* 和 *args* 是元组时，其每个元素独立作为返回结果元组的一个元素。例如， *sortVec，filterVec* 都是包含两个元素的元组， *args* 包含三个元素，返回结果为包含 7 （=2+2+3）个元素的元组。\n\n#### 例子\n\n例1. 对列式元组进行过滤排序：askPrices 中各档报价来自不同的渠道 srcs。现过滤出来自 SRC3 或 SRC1 的报价，相同报价按照 SRC3, SRC1 的顺序排列。相应的多档委托量 askVols 也一并过滤和排序。\n\n```\norderedFilters = `SRC3`SRC1\nsrcs = [`SRC1`SRC2`SRC3`SRC1`SRC3, `SRC1`SRC3`SRC1`SRC2`SRC3`SRC1`SRC2].setColumnarTuple!(true)\naskPrices = [900 900 900 901 901, 800 800 802 802 802 803 803].setColumnarTuple!(true)\naskVols = [10 15 20 15 20, 20 15 30 40 20 15 30].setColumnarTuple!(true)\nrowFilterAndSort(askPrices, srcs, orderedFilters, askVols)\n/*\noutput: \n(([900,900,901,901],[800,800,802,802,803]),\n([\"SRC3\",\"SRC1\",\"SRC3\",\"SRC1\"],[\"SRC3\",\"SRC1\",\"SRC3\",\"SRC1\",\"SRC1\"]),\n([20,10,20,15],[15,20,20,30,15]))\n*/\n```\n\n例2. 对数组向量的元组：askPrices 中各档报价对应不同时间，来自不同的渠道 srcs，各渠道有不同的清算速度。现过滤出来自 SRC1 或 SRC3，且清算速度为 T0，T1 或 T2 的报价，结果将按照价格优先、时间优先，渠道按照 SRC1、SRC3，清算速度按照 T0，T1，T2 的顺序排列。相应的多档委托量 askVols 也一并过滤和排序。\n\n```\norderedFilters = [`SRC1`SRC3, `T0`T1`T2]\nsrcs = [`SRC1`SRC1`SRC3`SRC3`SRC3, `SRC3`SRC3`SRC1`SRC2`SRC3`SRC1`SRC2].setColumnarTuple!(true)\nspeeds = [`T1`T2`T0`T2`T4, `T2`T0`T1`T0`T0`T0`T1].setColumnarTuple!(true)\naskPrices = array(INT[], 0, 10).append!([900 900 900 901 901, 800 800 802 802 802 803 803])\nquoteTimes = array(SECOND[], 0, 10).append!([09:30:00 09:30:00 09:30:00 09:30:01 09:30:02, \n\t09:30:00 09:30:00 09:30:00 09:30:00 09:30:00 09:30:00 09:30:00])\naskVols = array(INT[], 0, 10).append!([10 15 20 15 20, 20 15 30 40 20 15 30])\nrowFilterAndSort([askPrices,quoteTimes], [srcs,speeds], orderedFilters, askVols)\n/*\noutput: \n([[900,900,900,901],[800,800,802,802,803]],\n[[09:30:00,09:30:00,09:30:00,09:30:01],[09:30:00,09:30:00,09:30:00,09:30:00,09:30:00]],\n([\"SRC1\",\"SRC1\",\"SRC3\",\"SRC3\"],[\"SRC3\",\"SRC3\",\"SRC1\",\"SRC2\",\"SRC3\"]),\n([\"T1\",\"T2\",\"T0\",\"T2\"],[\"T0\",\"T2\",\"T1\",\"T0\",\"T0\"]),\n[[10,15,20,15],[15,20,30,20,15]])\n*/\n```\n\n**相关函数：[rowMergeAndSort](https://docs.dolphindb.cn/zh/funcs/r/rowmergeandsort.html)**\n"
    },
    "rowGmd5": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rowgmd5.html",
        "signatures": [
            {
                "full": "rowGmd5(args...)",
                "name": "rowGmd5",
                "parameters": [
                    {
                        "full": "args...",
                        "name": "args..."
                    }
                ]
            }
        ],
        "markdown": "### [rowGmd5](https://docs.dolphindb.cn/zh/funcs/r/rowgmd5.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nrowGmd5(args...)\n\n#### 详情\n\n逐行计算 gmd5。\n\n#### 参数\n\n**args** 是数组向量或列式元组。\n\n#### 返回值\n\n一个长度与 *args* 行数相同的 INT128 向量。\n\n#### 例子\n\n```\nxs = array(INT[], 0, 10).append!([1 2 3, 4 5, 6 7 8, 9 10])\nrowGmd5(xs)\n// output: [2a1dd1e1e59d0a384c26951e316cd7e6,678157bbe4fd35371e047b4cadf9c46a,ff93cd8c0033f2ab93726d48661d1221,10986ac9310ecb2f10c3a5524eb38999]\n// 输出四行，每个元素对应array vector中的每行，如1 2 3对应2a1dd1e1e59d0a384c26951e316cd7e6\n\ngmd5(1 2 3)\n// output: 2a1dd1e1e59d0a384c26951e316cd7e6\n\nrowGmd5(xs, xs)\n// output: [50420aa84aa547ebc24dfa3ef8fffa57,de90d6c74c0b99f5656b95563a9a35b7,376579b27ec7c2f6eed7347ef0e5a15b,78bf6752e93cbca5fd1dcc3519fc6c55]\n \nys = [1 2 3, 4 5, 6 7 8, 9 10]\nys.setColumnarTuple!(true)\nrowGmd5(xs, ys)\n// output: [50420aa84aa547ebc24dfa3ef8fffa57,de90d6c74c0b99f5656b95563a9a35b7,376579b27ec7c2f6eed7347ef0e5a15b,78bf6752e93cbca5fd1dcc3519fc6c55]\n```\n\n相关函数：[gmd5](https://docs.dolphindb.cn/zh/funcs/g/gmd5.html)\n"
    },
    "rowImax": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rowImax.html",
        "signatures": [
            {
                "full": "rowImax(args...)",
                "name": "rowImax",
                "parameters": [
                    {
                        "full": "args...",
                        "name": "args..."
                    }
                ]
            }
        ],
        "markdown": "### [rowImax](https://docs.dolphindb.cn/zh/funcs/r/rowImax.html)\n\n\n\n#### 语法\n\nrowImax(args...)\n\nrow 系列函数通用参数说明和计算规则请参考：[rowFunctions](https://docs.dolphindb.cn/zh/funcs/themes/rowFunctions.html)\n\n#### 详情\n\n返回每行元素中最大元素的索引。如果有多个相同的最大值，返回左起第一个最大值的索引。\n\n#### 返回值\n\n结果为一个长度与输入参数行数相同的向量。\n\n#### 例子\n\n```\nm=matrix([4.5 2.6 1.5 3.2, 1.5 4.8 5.9 1.7, 4.9 2.0 NULL 5.5])\nprint rowImax(m)\n```\n\n返回：\\[2,1,1,2]\n\n```\ntrades = table(10:0,`time`sym`p1`p2`p3`p4`p5`vol1`vol2`vol3`vol4`vol5,[TIMESTAMP,SYMBOL,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,INT,INT,INT,INT,INT])\ninsert into trades values(2022.01.01T09:00:00, `A, 33.2, 33.8, 33.6, 33.3, 33.1, 200, 180, 180, 220, 200)\ninsert into trades values(2022.01.01T09:00:00, `A, 33.1, 32.8, 33.2, 34.3, 32.3, 150, 280, 190, 100, 220)\ninsert into trades values(2022.01.01T09:00:00, `A, 31.2, 32.6, 33.6, 35.3, 34.5, 220, 160, 130, 100, 110)\ninsert into trades values(2022.01.01T09:00:00, `A, 30.2, 32.5, 33.6, 35.3, 34.1, 200, 180, 150, 140, 120)\ninsert into trades values(2022.01.01T09:00:00, `A, 33.2, 33.8, 33.6, 33.3, 33.1, 180, 160, 160, 180, 200)\nselect rowAt(matrix(p1, p2, p3, p4, p5), rowImax(vol1, vol2, vol3, vol4, vol5)) as price from trades\n```\n\n返回：\n\n| price |\n| ----- |\n| 33.3  |\n| 32.8  |\n| 31.2  |\n| 30.2  |\n| 33.1  |\n\n当 args 是数组向量时，返回每行元素中的最大元素的索引，结果为一个向量：\n\n```\na = 1 8 3 8 1\nb = 5 8 1 3 6\nc =  9 5 4 7 6\nx = fixedLengthArrayVector(a, b, c)\nrowImax(x)\n```\n\n返回：\\[2,0,2,0,1]\n\n**Related information**\n\n[imax](https://docs.dolphindb.cn/zh/funcs/i/imax.html)\n\n[rowImaxLast](https://docs.dolphindb.cn/zh/funcs/r/rowimaxlast.html)\n\n[rowFunctions](https://docs.dolphindb.cn/zh/funcs/themes/rowFunctions.html)\n"
    },
    "rowImaxLast": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rowimaxlast.html",
        "signatures": [
            {
                "full": "rowImaxLast(args…)",
                "name": "rowImaxLast",
                "parameters": [
                    {
                        "full": "args…",
                        "name": "args…"
                    }
                ]
            }
        ],
        "markdown": "### [rowImaxLast](https://docs.dolphindb.cn/zh/funcs/r/rowimaxlast.html)\n\n\n\n#### 语法\n\nrowImaxLast(args…)\n\n#### 详情\n\n返回每行元素中最大元素的索引。如果有多个相同的最大值，返回右起第一个最大值的索引。\n\n#### 参数\n\nrow 系列函数通用参数说明和计算规则请参考：[行计算系列（row 系列）](https://docs.dolphindb.cn/zh/funcs/themes/rowFunctions.html)\n\n#### 返回值\n\n结果为一个长度与输入参数行数相同的向量。\n\n#### 例子\n\n```\nm=matrix([4.5 2.6 1.5 3.2, 1.5 4.8 5.9 1.7, 4.9 2.0 NULL 5.5])\nrowImaxLast(m)\n// output\n[2,1,1,2]\n\ntrades = table(10:0,`time`sym`p1`p2`p3`p4`p5`vol1`vol2`vol3`vol4`vol5,[TIMESTAMP,SYMBOL,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,INT,INT,INT,INT,INT])\ninsert into trades values(2022.01.01T09:00:00, `A, 33.2, 33.8, 33.6, 33.3, 33.1, 200, 180, 180, 220, 200)\ninsert into trades values(2022.01.01T09:00:00, `A, 33.1, 32.8, 33.2, 34.3, 32.3, 150, 280, 190, 100, 220)\ninsert into trades values(2022.01.01T09:00:00, `A, 31.2, 32.6, 33.6, 35.3, 34.5, 220, 160, 130, 100, 110)\ninsert into trades values(2022.01.01T09:00:00, `A, 30.2, 32.5, 33.6, 35.3, 34.1, 200, 180, 150, 140, 120)\ninsert into trades values(2022.01.01T09:00:00, `A, 33.2, 33.8, 33.6, 33.3, 33.1, 180, 160, 160, 180, 200)\n\nselect rowAt(matrix(p1, p2, p3, p4, p5), rowImaxLast(vol1, vol2, vol3, vol4, vol5)) as price from trades\n// output\nprice\n33.3\n32.8\n31.2\n30.2\n33.1\n\n```\n\n相关函数：[rowImax](https://docs.dolphindb.cn/zh/funcs/r/rowImax.html)\n"
    },
    "rowImin": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rowImin.html",
        "signatures": [
            {
                "full": "rowImin(args...)",
                "name": "rowImin",
                "parameters": [
                    {
                        "full": "args...",
                        "name": "args..."
                    }
                ]
            }
        ],
        "markdown": "### [rowImin](https://docs.dolphindb.cn/zh/funcs/r/rowImin.html)\n\n\n\n#### 语法\n\nrowImin(args...)\n\nrow 系列函数通用参数说明和计算规则请参考：[rowFunctions](https://docs.dolphindb.cn/zh/funcs/themes/rowFunctions.html)\n\n#### 详情\n\n返回每行元素中最小元素的索引。如果有多个相同的最小值，返回左起第一个最小值的索引。\n\n#### 返回值\n\n结果为一个长度与输入参数行数相同的向量。\n\n#### 例子\n\n```\nm=matrix([4.5 2.6 1.5 3.2, 1.5 4.8 5.9 1.7, 4.9 2.0 NULL 5.5])\nrowImin(m)\n```\n\n返回：\\[1,2,0,1]\n\n```\ntrades = table(10:0,`time`sym`p1`p2`p3`p4`p5`vol1`vol2`vol3`vol4`vol5,[TIMESTAMP,SYMBOL,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,INT,INT,INT,INT,INT])\ninsert into trades values(2022.01.01T09:00:00, `A, 33.2, 33.8, 33.6, 33.3, 33.1, 200, 180, 180, 220, 200)\ninsert into trades values(2022.01.01T09:00:00, `A, 33.1, 32.8, 33.2, 34.3, 32.3, 150, 280, 190, 100, 220)\ninsert into trades values(2022.01.01T09:00:00, `A, 31.2, 32.6, 33.6, 35.3, 34.5, 220, 160, 130, 100, 110)\ninsert into trades values(2022.01.01T09:00:00, `A, 30.2, 32.5, 33.6, 35.3, 34.1, 200, 180, 150, 140, 120)\ninsert into trades values(2022.01.01T09:00:00, `A, 33.2, 33.8, 33.6, 33.3, 33.1, 180, 160, 160, 180, 200)\n\nselect rowAt(matrix(p1, p2, p3, p4, p5), rowImin(vol1, vol2, vol3, vol4, vol5)) as price from trades\n```\n\n返回：\n\n| price |\n| ----- |\n| 33.8  |\n| 34.3  |\n| 35.3  |\n| 34.1  |\n| 33.8  |\n\n当 args 是数组向量时，返回每行元素中的最小元素的索引，结果为一个向量：\n\n```\na = 1 8 3 8 1\nb = 5 7 1 3 9\nc =  5 5 4 3 6\nx = fixedLengthArrayVector(a, b, c)\nrowImin(x)\n```\n\n返回：\\[0,2,1,1,0]\n\n**Related information**\n\n[imin](https://docs.dolphindb.cn/zh/funcs/i/imin.html)\n\n[rowIminLast](https://docs.dolphindb.cn/zh/funcs/r/rowiminlast.html)\n\n[rowFunctions](https://docs.dolphindb.cn/zh/funcs/themes/rowFunctions.html)\n"
    },
    "rowIminLast": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rowiminlast.html",
        "signatures": [
            {
                "full": "rowIminLast(args…)",
                "name": "rowIminLast",
                "parameters": [
                    {
                        "full": "args…",
                        "name": "args…"
                    }
                ]
            }
        ],
        "markdown": "### [rowIminLast](https://docs.dolphindb.cn/zh/funcs/r/rowiminlast.html)\n\n\n\n#### 语法\n\nrowIminLast(args…)\n\n#### 详情\n\n返回每行元素中最小元素的索引。如果有多个相同的最小值，返回右起第一个最小值的索引。\n\n#### 参数\n\nrow 系列函数通用参数说明和计算规则请参考：[行计算系列（row 系列）](https://docs.dolphindb.cn/zh/funcs/themes/rowFunctions.html)\n\n#### 返回值\n\n结果为一个长度与输入参数行数相同的向量。\n\n#### 例子\n\n```\nm=matrix([4.5 2.6 1.5 3.2, 1.5 4.8 5.9 1.7, 4.9 2.0 NULL 5.5])\nrowIminLast(m)\n// output\n[1,2,0,1]\n\ntrades = table(10:0,`time`sym`p1`p2`p3`p4`p5`vol1`vol2`vol3`vol4`vol5,[TIMESTAMP,SYMBOL,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,INT,INT,INT,INT,INT])\ninsert into trades values(2022.01.01T09:00:00, `A, 33.2, 33.8, 33.6, 33.3, 33.1, 200, 180, 180, 220, 200)\ninsert into trades values(2022.01.01T09:00:00, `A, 33.1, 32.8, 33.2, 34.3, 32.3, 150, 280, 190, 100, 220)\ninsert into trades values(2022.01.01T09:00:00, `A, 31.2, 32.6, 33.6, 35.3, 34.5, 220, 160, 130, 100, 110)\ninsert into trades values(2022.01.01T09:00:00, `A, 30.2, 32.5, 33.6, 35.3, 34.1, 200, 180, 150, 140, 120)\ninsert into trades values(2022.01.01T09:00:00, `A, 33.2, 33.8, 33.6, 33.3, 33.1, 180, 160, 160, 180, 200)\n\nselect rowAt(matrix(p1, p2, p3, p4, p5), rowIminLast(vol1, vol2, vol3, vol4, vol5)) as price from trades\n// output\nprice\n33.6\n34.3\n35.3\n34.1\n33.6\n\n```\n\n相关函数：[rowImin](https://docs.dolphindb.cn/zh/funcs/r/rowImin.html)\n"
    },
    "rowKurtosis": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rowKurtosis.html",
        "signatures": [
            {
                "full": "rowKurtosis(X, [biased=true])",
                "name": "rowKurtosis",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[biased=true]",
                        "name": "biased",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [rowKurtosis](https://docs.dolphindb.cn/zh/funcs/r/rowKurtosis.html)\n\n\n\n#### 语法\n\nrowKurtosis(X, \\[biased=true])\n\nrow 系列函数通用参数说明和计算规则请参考：[rowFunctions](https://docs.dolphindb.cn/zh/funcs/themes/rowFunctions.html)\n\n#### 详情\n\n逐行计算 *X* 的峰度。\n\nDolphinDB 使用以下公式计算峰度（当 *biased*=true 时）：\n\n![kurtosisx](https://docs.dolphindb.cn/zh/images/kurtosisx.png)\n\n#### 参数\n\n**biased** 是一个布尔值，表示是否为有偏估计。默认值为 true，表示为有偏估计。\n\n#### 返回值\n\n一个向量。\n\n#### 例子\n\n```\nm = [4.5 2.6 1.5 1.5 4.8, 5.9 4.9 2.0 4.0 6.3, 2 2 2 2 2, 2.1 3.4 4.2 5.5 2.3]\nrowKurtosis(m);\n// output\n[1.336589711715856,1.839333299961742,2.248755164221374,1.437834622248661,1.341044189891083]\n\nm=matrix([4.5 2.6 1.5, 1.5 4.8 5.9, 4.9 2.0 NULL, 4.3 NULL 3.5]);\nrowKurtosis(m);\n// output\n[2.270290894661423,1.499999999999941,1.499999999999972]\n\nt1=table(1..5 as x, 10..6 as y, 15..19 as z, take(3,5) as t);\nrowKurtosis(t1);\n// output\n[1.417974225003112,1.676864,1.951167883478534,2.158698670898631,2.262015004030008]\n```\n\n相关函数：[kurtosis](https://docs.dolphindb.cn/zh/funcs/k/kurtosis.html)\n"
    },
    "rowMax": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rowMax.html",
        "signatures": [
            {
                "full": "rowMax(args...)",
                "name": "rowMax",
                "parameters": [
                    {
                        "full": "args...",
                        "name": "args..."
                    }
                ]
            }
        ],
        "markdown": "### [rowMax](https://docs.dolphindb.cn/zh/funcs/r/rowMax.html)\n\n\n\n#### 语法\n\nrowMax(args...)\n\nrow 系列函数通用参数说明和计算规则请参考：[rowFunctions](https://docs.dolphindb.cn/zh/funcs/themes/rowFunctions.html)\n\n#### 详情\n\n逐行进行取最大值的操作。\n\n#### 返回值\n\n返回一个长度与输入参数行数相同的向量。\n\n#### 例子\n\n```\nm=matrix([4.5 2.6 1.5, 1.5 4.8 5.9, 4.9 2.0 NULL])\nrowMax(m);\n```\n\n返回：\\[4.9,4.8,5.9]\n\n```\nt1=table(1..5 as x, 6..10 as y)\nt2=table(5..1 as a, 10..6 as b);\n\nrowMax(t1);\n```\n\n返回：\\[6,7,8,9,10]\n\n```\nrowMax(t1[`y], t2, take(8, 5));\n```\n\n返回：\\[10,9,8,9,10]\n\n```\nt=table(`AAPL`MS`IBM`IBM`C as sym, 49.6 29.46 29.52 30.02 174.97 as price1, 175.23 50.76 50.32 51.29 26.23 as price2);\nselect sym,rowMax(price1,price2) as max from t;\n```\n\n返回：\n\n| sym  | max    |\n| ---- | ------ |\n| AAPL | 175.23 |\n| MS   | 50.76  |\n| IBM  | 50.32  |\n| IBM  | 51.29  |\n| C    | 174.97 |\n\n**Related information**\n\n[max](https://docs.dolphindb.cn/zh/funcs/m/max.html)\n"
    },
    "rowMergeAndSort": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rowmergeandsort.html",
        "signatures": [
            {
                "full": "rowMergeAndSort(sortVec, asc, args...)",
                "name": "rowMergeAndSort",
                "parameters": [
                    {
                        "full": "sortVec",
                        "name": "sortVec"
                    },
                    {
                        "full": "asc",
                        "name": "asc"
                    },
                    {
                        "full": "args...",
                        "name": "args..."
                    }
                ]
            }
        ],
        "markdown": "### [rowMergeAndSort](https://docs.dolphindb.cn/zh/funcs/r/rowmergeandsort.html)\n\n首发版本：3.00.5\n\n\n\n#### 语法\n\nrowMergeAndSort(sortVec, asc, args...)\n\n#### 详情\n\n将数组向量或列式元组的多行合并为一行，并对合并结果进行排序。\n\n*sortVec* 和 *args* 的元素按位置一一对应， *args* 的元素跟随 sortVec 同步合并和排序。\n\n#### 参数\n\n**sortVec** 可以是数组向量或列式元组，表示合并后的排序列。 *sortVec* 也可以是一个元组，包含最多 2 个数组向量或列式元组。\n\n**asc** 是一个布尔值或布尔向量，表示合并后的 *sortVec* 是否按升序排列，true 代表升序。当 *sortVec* 为元组时， *asc* 可以为向量，长度与 *sortVec* 元素个数相等，分别指示 sortVec 的每一个元素在合并后的排序规则。\n\n**args** 可选参数，可以是数组向量或列式元组，表示需要随 *sortVec* 同步合并并按相同排序重排的附加列。\n\n#### 返回值\n\n* 指定 args 时，返回一个元组，元素数量为 args 长度加一，每个元素均为向量。\n\n* 未指定 args 时，返回一个向量。\n\n#### 例子\n\n例1. 合并数组向量，并按照升序排序。返回一个向量\n\n```\naskPrices = array(INT[], 0, 10).append!([900 900 900 901 901, 800 800 802 802 802 803 803])\nrowMergeAndSort(askPrices, true)\n//output: ([800,800,802,802,802,803,803,900,900,900,901,901])\n```\n\n例2. 合并列式元组，多个排序列按照不同顺序排列：askPrices 中各档报价对应不同时间 、不同委托量，来自不同的渠道 srcs。现将数据合并，并按照 askPrices 降序，quoteTimes 升序的顺序排列。返回一个元组。\n\n```\nsrcs = [`SRC1`SRC1`SRC3`SRC3`SRC3, `SRC3`SRC3`SRC1`SRC2`SRC3`SRC1`SRC2].setColumnarTuple!(true)\naskPrices = array(INT[], 0, 10).append!([900 900 900 901 901, 800 800 802 802 802 803 803])\nquoteTimes = array(SECOND[], 0, 10).append!([09:30:00 09:30:00 09:30:00 09:30:01 09:30:02, \n\t09:30:00 09:30:00 09:30:00 09:30:00 09:30:00 09:30:00 09:30:00])\naskVols = array(INT[], 0, 10).append!([10 15 20 15 20, 20 15 30 40 20 15 30])\nrowMergeAndSort([askPrices,quoteTimes], false true, srcs, askVols)\n/*\noutput: \n([901,901,900,900,900,803,803,802,802,802,800,800],\n[09:30:01,09:30:02,09:30:00,09:30:00,09:30:00,09:30:00,09:30:00,09:30:00,09:30:00,09:30:00,09:30:00,09:30:00],\n[\"SRC3\",\"SRC3\",\"SRC1\",\"SRC1\",\"SRC3\",\"SRC1\",\"SRC2\",\"SRC1\",\"SRC2\",\"SRC3\",\"SRC3\",\"SRC3\"],\n[15,20,10,15,20,15,30,30,40,20,20,15])\n*/\n```\n\n**相关函数：[rowFilterAndSort](https://docs.dolphindb.cn/zh/funcs/r/rowfilterandsort.html)**\n"
    },
    "rowMin": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rowMin.html",
        "signatures": [
            {
                "full": "rowMin(args...)",
                "name": "rowMin",
                "parameters": [
                    {
                        "full": "args...",
                        "name": "args..."
                    }
                ]
            }
        ],
        "markdown": "### [rowMin](https://docs.dolphindb.cn/zh/funcs/r/rowMin.html)\n\n\n\n#### 语法\n\nrowMin(args...)\n\nrow 系列函数通用参数说明和计算规则请参考：[rowFunctions](https://docs.dolphindb.cn/zh/funcs/themes/rowFunctions.html)\n\n#### 详情\n\n逐行进行取最小值的操作。\n\n#### 返回值\n\n返回一个长度与输入参数行数相同的向量。\n\n#### 例子\n\n```\nm=matrix([4.5 2.6 1.5, 1.5 4.8 5.9, 4.9 2.0 NULL])\nrowMin(m);\n// output\n[1.5,2,1.5]\n\nt1=table(1..5 as x, 6..10 as y)\nt2=table(5..1 as a, 10..6 as b);\n\nrowMin(t1);\n// output\n[1,2,3,4,5]\n\nrowMin(t1[`x], t2, take(2, 5));\n// output\n[1,2,2,2,1]\n\nt=table(`AAPL`MS`IBM`IBM`C as sym, 49.6 29.46 29.52 30.02 174.97 as price1, 175.23 50.76 50.32 51.29 26.23 as price2);\nselect sym,rowMin(price1,price2) as min from t;\n```\n\n| sym  | min   |\n| ---- | ----- |\n| AAPL | 49.6  |\n| MS   | 29.46 |\n| IBM  | 29.52 |\n| IBM  | 30.02 |\n| C    | 26.23 |\n\n相关函数：[min](https://docs.dolphindb.cn/zh/funcs/m/min.html)\n"
    },
    "rowMove": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rowMove.html",
        "signatures": [
            {
                "full": "rowMove(X, steps)",
                "name": "rowMove",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "steps",
                        "name": "steps"
                    }
                ]
            }
        ],
        "markdown": "### [rowMove](https://docs.dolphindb.cn/zh/funcs/r/rowMove.html)\n\n\n\n#### 语法\n\nrowMove(X, steps)\n\n#### 详情\n\n根据 *steps* 的设置，逐行移动元素。\n\n#### 参数\n\nrow 系列函数通用参数说明和计算规则请参考：[rowFunctions](https://docs.dolphindb.cn/zh/funcs/themes/rowFunctions.html)。\n\n**steps** 是一个整数，表示移动多少位置。\n\n* 如果 *steps* 为正数，*X* 向右移动 *steps* 个位置；\n\n* 如果 *steps* 为负数，*X* 向左移动 *steps* 个位置；\n\n* 如果 *steps* 为 0，不改变 *X* 的位置。\n\n#### 返回值\n\n返回一个数据类型和形式与 *X* 相同的对象。\n\n#### 例子\n\n```\nm=matrix([4.5 2.6 1.5, 1.5 4.8 5.9, 4.9 2.0 NULL])\nrowMove(m, 2)\n```\n\n返回：\n\n| col1 | col2 | col3 |\n| ---- | ---- | ---- |\n|      |      | 4.5  |\n|      |      | 2.6  |\n|      |      | 1.5  |\n\n```\nrowMove(m, -2)\n```\n\n返回：\n\n| col1 | col2 | col3 |\n| ---- | ---- | ---- |\n| 4.9  |      |      |\n| 2    |      |      |\n|      |      |      |\n\n```\na=array(INT[], 0, 10).append!([1 2 3, 4 5, 6 7 8]);\nrowMove(a, 2)\n\n//output: [[00i,00i,1],[00i,00i],[00i,00i,6]]\n\ntp = [[1.3,2.5,2.3], [4.1,5.3,6.2]]\ntp.setColumnarTuple!()\nrowMove(tp, -2)\n\n//output: [[2.3,00F,00F],[6.200000000000001,00F,00F]]\n```\n"
    },
    "rowNames": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rowNames.html",
        "signatures": [
            {
                "full": "rowNames(X)",
                "name": "rowNames",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [rowNames](https://docs.dolphindb.cn/zh/funcs/r/rowNames.html)\n\n\n\n#### 语法\n\nrowNames(X)\n\n#### 详情\n\n返回矩阵 *X* 的行名。参见相关函数： [columnNames](https://docs.dolphindb.cn/zh/funcs/c/columnNames.html)\n\n#### 参数\n\n**X** 是一个矩阵\n\n#### 返回值\n\n返回一个向量。\n\n#### 例子\n\n```\nx=1..6$2:3;\nx\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1  | 3  | 5  |\n| 2  | 4  | 6  |\n\n```\nx.rename!(1 2, `a`b`c);\n```\n\n|   | a | b | c |\n| - | - | - | - |\n| 1 | 1 | 3 | 5 |\n| 2 | 2 | 4 | 6 |\n\n```\nrowNames x;\n// output\n[1,2]\n```\n"
    },
    "rowNext": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rowNext.html",
        "signatures": [
            {
                "full": "rowNext(X)",
                "name": "rowNext",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [rowNext](https://docs.dolphindb.cn/zh/funcs/r/rowNext.html)\n\n\n\n#### 语法\n\nrowNext(X)\n\n#### 详情\n\n逐行将 *X* 向左移动一个位置。\n\n#### 参数\n\nrow 系列函数通用参数说明和计算规则请参考：[rowFunctions](https://docs.dolphindb.cn/zh/funcs/themes/rowFunctions.html)。\n\n#### 返回值\n\n返回一个数据类型和形式与 *X* 相同的对象。\n\n#### 例子\n\n```\nm=matrix([4.5 2.6 1.5, 1.5 4.8 5.9, 4.9 2.0 NULL])\nrowNext(m)\n```\n\n返回：\n\n| col1 | col2 | col3 |\n| ---- | ---- | ---- |\n| 1.5  | 4.9  |      |\n| 4.8  | 2    |      |\n| 5.9  |      |      |\n\n```\na=array(INT[], 0, 10).append!([1 2 3, 4 5, 6 7 8]);\nrowNext(a)\n\n//output: [[2,3,00i],[5,00i],[7,8,00i]]\n\ntp = [[1.3,2.5,2.3], [4.1,5.3,6.2]]\ntp.setColumnarTuple!()\nrowNext(tp)\n\n//output: [[2.5,2.3,00F],[5.3,6.2,00F]]\n```\n"
    },
    "rowNo": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rowNo.html",
        "signatures": [
            {
                "full": "rowNo(X)",
                "name": "rowNo",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [rowNo](https://docs.dolphindb.cn/zh/funcs/r/rowNo.html)\n\n\n\n#### 语法\n\nrowNo(X)\n\n#### 详情\n\n*rowNo* 通常用于在表中产生行号。行号从 0 开始。\n\n#### 参数\n\n**X** 是向量。\n\n#### 返回值\n\n返回一个向量。\n\n#### 例子\n\n```\nteam=1 1 1 1 1 2 2 2 2 2\nid=1..5 join 2..6\nx=11..20\\2\nt=table(team, id, x)\nt;\n```\n\n| team | id | x   |\n| ---- | -- | --- |\n| 1    | 1  | 5.5 |\n| 1    | 2  | 6   |\n| 1    | 3  | 6.5 |\n| 1    | 4  | 7   |\n| 1    | 5  | 7.5 |\n| 2    | 2  | 8   |\n| 2    | 3  | 8.5 |\n| 2    | 4  | 9   |\n| 2    | 5  | 9.5 |\n| 2    | 6  | 10  |\n\n```\nselect * from t where rowNo(id)%3=0;\n```\n\n| team | id | x   |\n| ---- | -- | --- |\n| 1    | 1  | 5.5 |\n| 1    | 4  | 7   |\n| 2    | 3  | 8.5 |\n| 2    | 6  | 10  |\n\n```\nupdate t set teamFirst=(rowNo(id)==0) context by team;\nt;\n```\n\n| team | id | x   | teamFirst |\n| ---- | -- | --- | --------- |\n| 1    | 1  | 5.5 | 1         |\n| 1    | 2  | 6   | 0         |\n| 1    | 3  | 6.5 | 0         |\n| 1    | 4  | 7   | 0         |\n| 1    | 5  | 7.5 | 0         |\n| 2    | 2  | 8   | 1         |\n| 2    | 3  | 8.5 | 0         |\n| 2    | 4  | 9   | 0         |\n| 2    | 5  | 9.5 | 0         |\n| 2    | 6  | 10  | 0         |\n"
    },
    "rowOr": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rowOr.html",
        "signatures": [
            {
                "full": "rowOr(args...)",
                "name": "rowOr",
                "parameters": [
                    {
                        "full": "args...",
                        "name": "args..."
                    }
                ]
            }
        ],
        "markdown": "### [rowOr](https://docs.dolphindb.cn/zh/funcs/r/rowOr.html)\n\n\n\n#### 语法\n\nrowOr(args...)\n\nrow 系列函数通用参数说明和计算规则请参考：[rowFunctions](https://docs.dolphindb.cn/zh/funcs/themes/rowFunctions.html)\n\n#### 详情\n\n逐行进行逻辑或操作。\n\n#### 返回值\n\n返回一个长度与输入参数行数相同的向量。\n\n#### 例子\n\n```\nm=matrix([true false false, true true true, true true true])\nrowOr(m);\n// output\n[1,1,1]\n\nt1=table(false true true true false as x, false true false true true as y)\nrowOr(t1);\n\n0,1,1,1,1]]\n\nt=table(`AAPL`MS`IBM`IBM`C as sym, 49.6 29.46 29.52 30.02 174.97 as price1, 175.23 50.76 50.32 51.29 26.23 as price2)\nselect *  from t where rowOr(price1>30, price2>100);\n```\n\n| sym  | price1 | price2 |\n| ---- | ------ | ------ |\n| AAPL | 49.6   | 175.23 |\n| IBM  | 30.02  | 51.29  |\n| C    | 174.97 | 26.23  |\n\n相关函数：[or](https://docs.dolphindb.cn/zh/funcs/o/or.html)\n"
    },
    "rowPrev": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rowPrev.html",
        "signatures": [
            {
                "full": "rowPrev(X)",
                "name": "rowPrev",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [rowPrev](https://docs.dolphindb.cn/zh/funcs/r/rowPrev.html)\n\n\n\n#### 语法\n\nrowPrev(X)\n\n#### 详情\n\n逐行将 *X* 向右移动一个位置。\n\n#### 参数\n\nrow 系列函数通用参数说明和计算规则请参考：[rowFunctions](https://docs.dolphindb.cn/zh/funcs/themes/rowFunctions.html)。\n\n#### 返回值\n\n返回一个数据类型和形式与 *X* 相同的对象。\n\n#### 例子\n\n```\nm=matrix([4.5 2.6 1.5, 1.5 4.8 5.9, 4.9 2.0 NULL])\nrowPrev(m)\n```\n\n返回：\n\n| col1 | col2 | col3 |\n| ---- | ---- | ---- |\n|      | 4.5  | 1.5  |\n|      | 2.6  | 4.8  |\n|      | 1.5  | 5.9  |\n\n```\na=array(INT[], 0, 10).append!([1 2 3, 4 5, 6 7 8]);\nrowPrev(a)\n\n//output: [[00i,1,2],[00i,4],[00i,6,7]]\n\ntp = [[1.3,2.5,2.3], [4.1,5.3,6.2]]\ntp.setColumnarTuple!()\nrowPrev(tp)\n\n//output: [[00F,1.3,2.5],[00F,4.1,5.3]]\n```\n"
    },
    "rowProd": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rowProd.html",
        "signatures": [
            {
                "full": "rowProd(args...)",
                "name": "rowProd",
                "parameters": [
                    {
                        "full": "args...",
                        "name": "args..."
                    }
                ]
            }
        ],
        "markdown": "### [rowProd](https://docs.dolphindb.cn/zh/funcs/r/rowProd.html)\n\n\n\n#### 语法\n\nrowProd(args...)\n\nrow 系列函数通用参数说明和计算规则请参考：[rowFunctions](https://docs.dolphindb.cn/zh/funcs/themes/rowFunctions.html)\n\n#### 详情\n\n逐行进行元素求乘积操作。\n\n#### 返回值\n\n返回一个长度与输入参数行数相同的向量。\n\n#### 例子\n\n```\nm=matrix([4.5 2.6 1.5, 1.5 4.8 5.9, 4.9 2.0 NULL])\nrowProd(m);\n// output\n[33.075,24.96,8.85]\n\nv1=1 0 2 -2 5\nv2=-8 1 2 4 2\nrowProd(v1, v2);\n// output\n[-8,0,4,-8,10]\n\nt=table(`AAPL`MS`IBM`IBM`C as sym, 49.6 29.46 29.52 30.02 174.97 as price1, 175.23 50.76 50.32 51.29 26.23 as price2)\nselect * from t where rowOr(price1>50, price2>50);\n```\n\n| sym  | price     |\n| ---- | --------- |\n| AAPL | 8691.408  |\n| MS   | 1495.3896 |\n| IBM  | 1485.4464 |\n| IBM  | 1539.7258 |\n| C    | 4589.4631 |\n\n相关函数：[prod](https://docs.dolphindb.cn/zh/funcs/p/prod.html)\n"
    },
    "rowRank": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rowRank.html",
        "signatures": [
            {
                "full": "rowRank(X, [ascending=true], [groupNum], [ignoreNA=true], [tiesMethod='min'], [percent=false], [precision])",
                "name": "rowRank",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[ascending=true]",
                        "name": "ascending",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[groupNum]",
                        "name": "groupNum",
                        "optional": true
                    },
                    {
                        "full": "[ignoreNA=true]",
                        "name": "ignoreNA",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[tiesMethod='min']",
                        "name": "tiesMethod",
                        "optional": true,
                        "default": "'min'"
                    },
                    {
                        "full": "[percent=false]",
                        "name": "percent",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[precision]",
                        "name": "precision",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [rowRank](https://docs.dolphindb.cn/zh/funcs/r/rowRank.html)\n\n\n\n#### 语法\n\nrowRank(X, \\[ascending=true], \\[groupNum], \\[ignoreNA=true], \\[tiesMethod='min'], \\[percent=false], \\[precision])\n\n#### 详情\n\n逐行计算 *X* 的元素排名或组排名，排名方式请参照 [rank](https://docs.dolphindb.cn/zh/funcs/r/rank.html)。\n\n#### 参数\n\nrow 系列函数通用参数说明和计算规则请参考：[rowFunctions](https://docs.dolphindb.cn/zh/funcs/themes/rowFunctions.html)。\n\n**ascending** 是一个布尔值，表示排序方向。true 表示升序，false 表示降序。默认值为 true。它是一个可选参数。\n\n**groupNum** 是一个正整数，表示排序形成的组的数量。它是一个可选参数。\n\n**ignoreNA** 是一个布尔值，表示是否忽略 NULL 值。true 表示忽略 NULL 值，false 表示 NULL 值参与排名。默认值为 true。它是一个可选参数。NULL 值参与排序时，NULL 值为最小值。\n\n**tiesMethod** 是一个字符串，表示如何对具有相同值的元素进行排名。\n\n* 'min'表示取最小排名。\n\n* 'max'表示取最大排名。\n\n* 'average'表示取排名的均值。\n\n* 'first' 表示按照原数据的顺序排名。\n\n**percent** 是一个布尔值，表示是否以百分比形式显示返回的排名。\n\n**precision** 是一个 \\[1, 15] 范围内的整数，用于设置参与排序的值的精度。若两个值之差的绝对值小于等于 10^(-precision) ，则认为两值相等。\n\n**Note:** 指定 *precision* 参数后，*X* 只能是数值型对象。且 *tiesMethod* 不能指定为 'first'。\n\n#### 返回值\n\n返回一个和 *X* 维度相同的矩阵。\n\n#### 例子\n\n```\nm=matrix(3 1 2 4 7 6 9 8 5, 9 NULL 2 3 5 6 3 2 8).transpose();\nm\n```\n\n返回：\n\n| #0 | #1 | #2 | #3 | #4 | #5 | #6 | #7 | #8 |\n| -- | -- | -- | -- | -- | -- | -- | -- | -- |\n| 3  | 1  | 2  | 4  | 7  | 6  | 9  | 8  | 5  |\n| 9  |    | 2  | 3  | 5  | 6  | 3  | 2  | 8  |\n\n```\nm.rowRank();\n```\n\n返回：\n\n| #0 | #1 | #2 | #3 | #4 | #5 | #6 | #7 | #8 |\n| -- | -- | -- | -- | -- | -- | -- | -- | -- |\n| 2  | 0  | 1  | 3  | 6  | 5  | 8  | 7  | 4  |\n| 7  |    | 0  | 2  | 4  | 5  | 2  | 0  | 6  |\n\n```\nm.rowRank(ascending=false);\n```\n\n返回：\n\n| #0 | #1 | #2 | #3 | #4 | #5 | #6 | #7 | #8 |\n| -- | -- | -- | -- | -- | -- | -- | -- | -- |\n| 6  | 8  | 7  | 5  | 2  | 3  | 0  | 1  | 4  |\n| 0  |    | 6  | 4  | 3  | 2  | 4  | 6  | 1  |\n\n指定 `percent=true`，以分数形式返回排名。\n\n```\nm.rowRank(percent=true);\n```\n\n| 0    | 1    | 2     | 3     | 4     | 5    | 6     | 7     | 8     |\n| ---- | ---- | ----- | ----- | ----- | ---- | ----- | ----- | ----- |\n| 0.33 | 0.11 | 0.22  | 0.44  | 0.77  | 0.67 | 1     | 0.89  | 0.56  |\n| 1    |      | 0.125 | 0.375 | 0.625 | 0.75 | 0.375 | 0.125 | 0.875 |\n\n```\nm.rowRank(groupNum=3);\n```\n\n返回：\n\n| #0 | #1 | #2 | #3 | #4 | #5 | #6 | #7 | #8 |\n| -- | -- | -- | -- | -- | -- | -- | -- | -- |\n| 0  | 0  | 0  | 1  | 2  | 1  | 2  | 2  | 1  |\n| 2  |    | 0  | 0  | 1  | 1  | 0  | 0  | 2  |\n\n```\nm.rowRank(ignoreNA=false);\n```\n\n返回：\n\n| #0 | #1 | #2 | #3 | #4 | #5 | #6 | #7 | #8 |\n| -- | -- | -- | -- | -- | -- | -- | -- | -- |\n| 2  | 0  | 1  | 3  | 6  | 5  | 8  | 7  | 4  |\n| 8  | 0  | 1  | 3  | 5  | 6  | 3  | 1  | 7  |\n\n```\nm.rowRank(ignoreNA=false, tiesMethod='max');\n```\n\n返回：\n\n| #0 | #1 | #2 | #3 | #4 | #5 | #6 | #7 | #8 |\n| -- | -- | -- | -- | -- | -- | -- | -- | -- |\n| 2  | 0  | 1  | 3  | 6  | 5  | 8  | 7  | 4  |\n| 8  | 0  | 2  | 4  | 5  | 6  | 4  | 2  | 7  |\n\n```\nm.rowRank(ignoreNA=false, tiesMethod='first');\n```\n\n返回：\n\n| col1 | col2 | col3 | col4 | col5 | col6 | col7 | col8 | col9 |\n| ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- |\n| 2    | 0    | 1    | 3    | 6    | 5    | 8    | 7    | 4    |\n| 8    | 0    | 1    | 3    | 5    | 6    | 4    | 2    | 7    |\n\n对于浮点数，可通过参数 *precision* 设置数值比较的精度。当两个值的差的绝对值小于等于 10^(-precision) 时，认为这两个值相等。下例中不设置 *precision* 参数，默认将1.000003，1.000004视为不相等。\n\n```\nm = matrix(1.000001 1.000002 1.000003,   \n           2.000001 2.000002 2.000003,  \n           1.000001 1.000002 1.000004) \nrowRank(m);\n```\n\n| col1 | col2 | col3 |\n| ---- | ---- | ---- |\n| 0    | 2    | 0    |\n| 0    | 2    | 0    |\n| 0    | 2    | 1    |\n\n设置 `precision=4` 后，1.000003，1.000004 被视为相等（都得到排名 0）。\n\n```\nrowRank(m, precision=4)\n```\n\n| col1 | col2 | col3 |\n| ---- | ---- | ---- |\n| 0    | 2    | 0    |\n| 0    | 2    | 0    |\n| 0    | 2    | 0    |\n\n**Related information**\n\n[rowDenseRank](https://docs.dolphindb.cn/zh/funcs/r/rowDenseRank.html)\n\n[rank](https://docs.dolphindb.cn/zh/funcs/r/rank.html)\n"
    },
    "rows": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rows.html",
        "signatures": [
            {
                "full": "rows(X)",
                "name": "rows",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [rows](https://docs.dolphindb.cn/zh/funcs/r/rows.html)\n\n\n\n#### 语法\n\nrows(X)\n\n#### 详情\n\n返回 *X* 中的行数。参见相关函数： [cols](https://docs.dolphindb.cn/zh/funcs/c/cols.html)。\n\n#### 参数\n\n**X** 可以是任意数据形式的对象。\n\n#### 返回值\n\n一个 INT 标量。\n\n#### 例子\n\n```\ny=1 2 3;\nrows(y);\n// output\n3\n// 一个向量可以被视为一个 n* 1 的矩阵\n\nx=1..6$2:3;\nX\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1  | 3  | 5  |\n| 2  | 4  | 6  |\n\n```\nrows X\n// output\n2\n\na=table(1..3 as x,`IBM`C`AAPL as y);\na\n```\n\n| x | y    |\n| - | ---- |\n| 1 | IBM  |\n| 2 | C    |\n| 3 | AAPL |\n\n```\nrows a;\n// output\n3\n```\n"
    },
    "rowSize": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rowSize.html",
        "signatures": [
            {
                "full": "rowSize(args...)",
                "name": "rowSize",
                "parameters": [
                    {
                        "full": "args...",
                        "name": "args..."
                    }
                ]
            }
        ],
        "markdown": "### [rowSize](https://docs.dolphindb.cn/zh/funcs/r/rowSize.html)\n\n\n\n#### 语法\n\nrowSize(args...)\n\nrow 系列函数通用参数说明和计算规则请参考：[rowFunctions](https://docs.dolphindb.cn/zh/funcs/themes/rowFunctions.html)\n\n#### 详情\n\n逐行进行元素统计（包含空值）操作。\n\n#### 返回值\n\n返回一个长度与输入参数行数相同的向量。\n\n#### 例子\n\n```\nm=matrix([4.5 2.6 1.5, 1.5 4.8 5.9, 4.9 2.0 NULL]);\nrowSize(m);\n// output\n[3,3,3]\n\nt1=table(1 NULL 3 NULL 5 as x, 6..10 as y);\nt2=table(5 NULL 3 NULL 1 as a, 10..6 as b);\nrowSize(t1);\n// output\n[2,2,2,2,2]\n\nrowCount(t1[`x], t2, 1 NULL 2 NULL NULL);\n// output\n[4,1,4,1,3]\nrowSize(t1[`x], t2, 1 NULL 2 NULL NULL);\n// output\n[4,4,4,4,4]\n\nt=table(`AAPL`MS`IBM`IBM`C as sym, [49.6, NULL, 29.52, NULL, 174.97] as price1, [175.23, NULL, 50.32, 51.29, 26.23] as price2);\nselect sym,rowSize(price1,price2) as size from t;\n```\n\n输出返回：\n\n| sym  | size |\n| ---- | ---- |\n| AAPL | 2    |\n| MS   | 2    |\n| IBM  | 2    |\n| IBM  | 2    |\n| C    | 2    |\n\n相关函数：[rowCount](https://docs.dolphindb.cn/zh/funcs/r/rowCount.html), [size](https://docs.dolphindb.cn/zh/funcs/s/size.html)\n"
    },
    "rowSkew": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rowSkew.html",
        "signatures": [
            {
                "full": "rowSkew(X, [biased=true])",
                "name": "rowSkew",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[biased=true]",
                        "name": "biased",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [rowSkew](https://docs.dolphindb.cn/zh/funcs/r/rowSkew.html)\n\n\n\n#### 语法\n\nrowSkew(X, \\[biased=true])\n\nrow 系列函数通用参数说明和计算规则请参考：[rowFunctions](https://docs.dolphindb.cn/zh/funcs/themes/rowFunctions.html)\n\n#### 详情\n\n逐行计算 *X* 的斜度。\n\nDolphinDB 使用以下公式计算倾斜度（当 *biased*=true 时）：\n\n![skewx](https://docs.dolphindb.cn/zh/images/rowskewx.png)\n\n#### 参数\n\n**biased** 是一个布尔值，表示是否为有偏估计。默认值为 true，表示为有偏估计。\n\n#### 返回值\n\n返回一个 DOUBLE 类型的向量。\n\n#### 例子\n\n```\nm = [4.5 2.6 1.5 1.5 4.8, 5.9 4.9 2.0 4.0 6.3, 2 2 2 2 2]\nrowSkew(m);\n// output\n[-0.329206341655613,0.586870565935934,-0.707106781186563,0.595170064139497,-0.350377619697706]\n\nm=matrix([4.5 2.6 1.5, 1.5 4.8 5.9, 4.9 2.0 NULL, 4.3 NULL 3.5]);\nrowSkew(m);\n// output\n[-1.064430070205901,0.577633692366209,0.110780117654846]\n\nt1=table(1..5 as x, 10..6 as y, take(3, 5) as z);\nrowSkew(t1);\n// output\n[0.567316577993729,0.652012117044047,0.707106781186548,0.528004979218188,-0.381801774160629]\n```\n\n相关函数：[skew](https://docs.dolphindb.cn/zh/funcs/s/skew.html)\n"
    },
    "rowStd": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rowStd.html",
        "signatures": [
            {
                "full": "rowStd(args...)",
                "name": "rowStd",
                "parameters": [
                    {
                        "full": "args...",
                        "name": "args..."
                    }
                ]
            }
        ],
        "markdown": "### [rowStd](https://docs.dolphindb.cn/zh/funcs/r/rowStd.html)\n\n\n\n#### 语法\n\nrowStd(args...)\n\nrow 系列函数通用参数说明和计算规则请参考：[rowFunctions](https://docs.dolphindb.cn/zh/funcs/themes/rowFunctions.html)\n\n#### 详情\n\n逐行进行元素求样本标准差操作。\n\n#### 返回值\n\n返回一个长度与输入参数行数相同的向量。\n\n#### 例子\n\n```\nm=matrix([4.5 2.6 1.5, 1.5 4.8 5.9, 4.9 2.0 NULL])\nrowStd(m);\n// output\n[1.858315,1.474223,3.11127]\n\nt1=table(1..5 as x, 10..6 as y, take(3, 5) as z)\nt2=table(5..1 as a, 6..10 as b, take(8, 5) as c);\n\nrowStd(t1);\n// output\n[4.725816,3.785939,2.886751,2.081666,1.527525]\n\nrowStd(t1[`x], t2, 1 1 2 2 2);\n// output\n[3.114482,3.04959,2.949576,3.316625,3.834058]\n\n\nt=table(`AAPL`MS`IBM`IBM`C as sym, 49.6 29.46 29.52 30.02 174.97 as price1, 175.23 50.76 50.32 51.29 26.23 as price2)\nselect sym,rowStd(price1,price2) as std from t;\n```\n\n| sym  | std        |\n| ---- | ---------- |\n| AAPL | 88.833825  |\n| MS   | 15.061374  |\n| IBM  | 14.707821  |\n| IBM  | 15.040161  |\n| C    | 105.175063 |\n\n相关函数：[rowStdp](https://docs.dolphindb.cn/zh/funcs/r/rowStdp.html), [std](https://docs.dolphindb.cn/zh/funcs/s/std.html)\n"
    },
    "rowStdp": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rowStdp.html",
        "signatures": [
            {
                "full": "rowStdp(args...)",
                "name": "rowStdp",
                "parameters": [
                    {
                        "full": "args...",
                        "name": "args..."
                    }
                ]
            }
        ],
        "markdown": "### [rowStdp](https://docs.dolphindb.cn/zh/funcs/r/rowStdp.html)\n\n\n\n#### 语法\n\nrowStdp(args...)\n\nrow 系列函数通用参数说明和计算规则请参考：[rowFunctions](https://docs.dolphindb.cn/zh/funcs/themes/rowFunctions.html)\n\n#### 详情\n\n逐行进行元素求总体标准差操作。\n\n#### 返回值\n\n返回一个长度与输入参数行数相同的向量。\n\n#### 例子\n\n```\nm=matrix([4.5 2.6 1.5, 1.5 4.8 5.9, 4.9 2.0 NULL])\nrowStdp(m);\n// output\n[1.517307556898806,1.203698005684518,2.2]\n\nt1=table(1..5 as x, 10..6 as y, take(3, 5) as z)\nt2=table(5..1 as a, 6..10 as b, take(8, 5) as c);\nrowStdp(t1);\n// output\n[3.858612300930075,3.091206165165235,2.357022603955159,1.699673171197595,1.247219128924648]\n\nrowStdp(t1[`x], t2, 1 1 2 2 2);\n// output\n[2.785677655436824,2.727636339397171,2.638181191654584,2.966479394838265,3.42928563989645]\n\n\nt=table(`AAPL`MS`IBM`IBM`C as sym, 49.6 29.46 29.52 30.02 174.97 as price1, 175.23 50.76 50.32 51.29 26.23 as price2)\nselect sym,rowStdp(price1,price2) as stdp from t;\n```\n\n| sym  | stdp   |\n| ---- | ------ |\n| AAPL | 62.815 |\n| MS   | 10.65  |\n| IBM  | 10.4   |\n| IBM  | 10.635 |\n| C    | 74.37  |\n\n相关函数：[rowStd](https://docs.dolphindb.cn/zh/funcs/r/rowStd.html), [std](https://docs.dolphindb.cn/zh/funcs/s/std.html)\n"
    },
    "rowSum": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rowSum.html",
        "signatures": [
            {
                "full": "rowSum(args...)",
                "name": "rowSum",
                "parameters": [
                    {
                        "full": "args...",
                        "name": "args..."
                    }
                ]
            }
        ],
        "markdown": "### [rowSum](https://docs.dolphindb.cn/zh/funcs/r/rowSum.html)\n\n\n\n#### 语法\n\nrowSum(args...)\n\nrow 系列函数通用参数说明和计算规则请参考：[rowFunctions](https://docs.dolphindb.cn/zh/funcs/themes/rowFunctions.html)\n\n#### 详情\n\n逐行进行元素求和操作。\n\n#### 返回值\n\n返回一个长度与输入参数行数相同的向量。\n\n#### 例子\n\n```\nm=matrix([4.5 2.6 1.5, 1.5 4.8 5.9, 4.9 2.0 NULL])\nrowSum(m);\n// output\n[10.9,9.4,7.4]\n\nt1=table(1..5 as x, 6..10 as y)\nt2=table(5..1 as a, 10..6 as b);\n\nrowSum(t1);\n// output\n[7,9,11,13,15]\n\nrowSum(t1[`x], t2, 1 1 2 2 2);\n// output\n[17,16,16,15,14]\n\nt=table(`AAPL`MS`IBM`IBM`C as sym, 49.6 29.46 29.52 30.02 174.97 as price1, 175.23 50.76 50.32 51.29 26.23 as price2)\nselect sym,rowSum(price1,price2) as priceSum from t;\n```\n\n| sym  | priceSum |\n| ---- | -------- |\n| AAPL | 224.83   |\n| MS   | 80.22    |\n| IBM  | 79.84    |\n| IBM  | 81.31    |\n| C    | 201.2    |\n\n相关函数：[sum](https://docs.dolphindb.cn/zh/funcs/s/sum.html)\n"
    },
    "rowSum2": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rowSum2.html",
        "signatures": [
            {
                "full": "rowSum2(args...)",
                "name": "rowSum2",
                "parameters": [
                    {
                        "full": "args...",
                        "name": "args..."
                    }
                ]
            }
        ],
        "markdown": "### [rowSum2](https://docs.dolphindb.cn/zh/funcs/r/rowSum2.html)\n\n\n\n#### 语法\n\nrowSum2(args...)\n\nrow 系列函数通用参数说明和计算规则请参考：[rowFunctions](https://docs.dolphindb.cn/zh/funcs/themes/rowFunctions.html)\n\n#### 详情\n\n逐行进行元素求平方和操作。\n\n#### 返回值\n\n返回一个长度与输入参数行数相同的向量。\n\n#### 例子\n\n```\nm=matrix([4.5 2.6 1.5, 1.5 4.8 5.9, 4.9 2.0 NULL]);\nrowSum2(m);\n// output\n[46.51,33.8,37.06]\n\nt1=table(1..5 as x, 6..10 as y);\nt2=table(5..1 as a, 10..6 as b);\n\nrowSum2(t1);\n// output\n[37,53,73,97,125]\n\nrowSum2(t1[`x], t2, 1 1 2 2 2);\n// output\n[127,102,86,73,66]\n\nt=table(`AAPL`MS`IBM`IBM`C as sym, 49.6 29.46 29.52 30.02 174.97 as price1, 175.23 50.76 50.32 51.29 26.23 as price2);\nselect sym,rowSum2(price1,price2) as price2Sum from t;\n```\n\n| sym  | priceSum |\n| ---- | -------- |\n| AAPL | 224.83   |\n| MS   | 80.22    |\n| IBM  | 79.84    |\n| IBM  | 81.31    |\n| C    | 201.2    |\n\n相关函数：[sum2](https://docs.dolphindb.cn/zh/funcs/s/sum2.html)\n"
    },
    "rowTanimoto": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rowTanimoto.html",
        "signatures": [
            {
                "full": "rowTanimoto(X, Y)",
                "name": "rowTanimoto",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [rowTanimoto](https://docs.dolphindb.cn/zh/funcs/r/rowTanimoto.html)\n\n\n\n#### 语法\n\nrowTanimoto(X, Y)\n\n#### 详情\n\n若 *X* 和 *Y* 同时为向量/矩阵，按行计算 *X* 和 *Y* 之间的谷本距离。若 *X* 和 *Y* 同时为索引矩阵，会对齐标签，对标签相同的行进行计算，标签不同的行直接返回 NULL。\n\n若 *X* 和 *Y* 一个为向量，一个为矩阵，则向量的长度必须与矩阵的列数相同，计算向量与矩阵每一行的谷本距离。\n\n若 *X* 和 *Y* 是数组向量，计算 *X* 和 *Y* 对应位置的向量之间的谷本距离，即 tanimoto(X.row(i),Y.row(i))。\n\n若 *X* 和 *Y* 一个为向量，一个为数组向量，计算向量与数组向量内每个向量的谷本距离。两个向量的长度相同时返回计算结果，长度不相同时返回 NULL。\n\n与所有其它聚合函数一致，计算时忽略 NULL 值。\n\n#### 参数\n\n**X** 和 **Y** 是长度相同的数值型向量或数组向量，或维度相同的矩阵。若 *X* 和 *Y* 为数组向量，它们对应位置的向量必须具有相同长度。\n\n#### 返回值\n\n返回一个向量。\n\n#### 例子\n\n```\nrowTanimoto(3.6 5.2 6.3, 8.6 4.8 5.5)\n// output\n[0.4467,0.0064,0.0181]\n\na=array(INT[],0,10)\na.append!([[1, 8, 9],[15, NULL], [25, 22, 13, 15]])\nb=array(INT[],0,10)\nb.append!([[11, 18, 6],[5, 9], [5, 2, 3, 1]])\nrowTanimoto(a,b)\n// output\n[0.5,0.5714,0.8309]\n\ns1=indexedSeries(2020.01.01..2020.01.03, 10.4 11.2 9)\ns2=indexedSeries(2020.01.01 2020.01.03 2020.01.04, 23.5 31.2 26)\nrowTanimoto(s1,s2)\n// output\n[0.4125,0.5337,0.5526]\n\nm=matrix(23 56 47, 112 94 59)\nm1=matrix(11 15 89, 52 41 63)\nrowTanimoto(m,m1)\n// output\n[0.3812,0.4889,0.1839]\n\nm.rename!(2020.01.01..2020.01.03, `A`B)\nm.setIndexedMatrix!()\nm1.rename!(2020.01.01 2020.01.03 2020.01.04, `A`B)\nm1.setIndexedMatrix!()\nrowTanimoto(m,m1)\n// output\n[0.3812,NULL,0.3014,NULL]\n```\n\n相关函数：[tanimoto](https://docs.dolphindb.cn/zh/funcs/t/tanimoto.html)\n"
    },
    "rowVar": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rowVar.html",
        "signatures": [
            {
                "full": "rowVar(args...)",
                "name": "rowVar",
                "parameters": [
                    {
                        "full": "args...",
                        "name": "args..."
                    }
                ]
            }
        ],
        "markdown": "### [rowVar](https://docs.dolphindb.cn/zh/funcs/r/rowVar.html)\n\n\n\n#### 语法\n\nrowVar(args...)\n\nrow 系列函数通用参数说明和计算规则请参考：[rowFunctions](https://docs.dolphindb.cn/zh/funcs/themes/rowFunctions.html)\n\n#### 详情\n\n逐行进行元素求样本方差操作。\n\n#### 返回值\n\n返回一个长度与输入参数行数相同的向量。\n\n#### 例子\n\n```\nm=matrix([4.5 2.6 1.5, 1.5 4.8 5.9, 4.9 2.0 NULL]);\nrowVar(m);\n// output\n[3.453333,2.173333,9.68]\n\nt1=table(1..5 as x, 10..6 as y, take(3, 5) as z);\nt2=table(5..1 as a, 6..10 as b, take(8, 5) as c);\n\nrowVar(t1);\n// output\n[22.333333,14.333333,8.333333,4.333333,2.333333]\n\nrowVar(t1[`x], t2, 1 1 2 2 2);\n// output\n[9.7,9.3,8.7,11,14.7]\n\nt=table(`AAPL`MS`IBM`IBM`C as sym, 49.6 29.46 29.52 30.02 174.97 as price1, 175.23 50.76 50.32 51.29 26.23 as price2);\nselect sym,rowVar(price1,price2) as var from t;\n```\n\n| sym  | var        |\n| ---- | ---------- |\n| AAPL | 7891.44845 |\n| MS   | 226.845    |\n| IBM  | 216.32     |\n| IBM  | 226.20645  |\n| C    | 11061.7938 |\n\n相关函数：[rowVarp](https://docs.dolphindb.cn/zh/funcs/r/rowVarp.html), [varp](https://docs.dolphindb.cn/zh/funcs/v/varp.html)\n"
    },
    "rowVarp": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rowVarp.html",
        "signatures": [
            {
                "full": "rowVarp(args...)",
                "name": "rowVarp",
                "parameters": [
                    {
                        "full": "args...",
                        "name": "args..."
                    }
                ]
            }
        ],
        "markdown": "### [rowVarp](https://docs.dolphindb.cn/zh/funcs/r/rowVarp.html)\n\n\n\n#### 语法\n\nrowVarp(args...)\n\nrow 系列函数通用参数说明和计算规则请参考：[rowFunctions](https://docs.dolphindb.cn/zh/funcs/themes/rowFunctions.html)\n\n#### 详情\n\n逐行进行元素求总体方差操作。\n\n#### 返回值\n\n返回一个长度与输入参数行数相同的向量。\n\n#### 例子\n\n```\nm=matrix([4.5 2.6 1.5, 1.5 4.8 5.9, 4.9 2.0 NULL]);\nrowVarp(m);\n// output\n[2.302222222222225,1.448888888888887,4.84]\n\nt1=table(1..5 as x, 10..6 as y, take(3, 5) as z);\nt2=table(5..1 as a, 6..10 as b, take(8, 5) as c);\nrowVarp(t1);\n// output\n[14.888888888888891,9.555555555555557,5.555555555555558,2.888888888888891,1.555555555555557]\n\nrowVarp(t1[`x], t2, 1 1 2 2 2);\n// output\n[7.76,7.440000000000001,6.96,8.8,11.760000000000001]\n\nt=table(`AAPL`MS`IBM`IBM`C as sym, 49.6 29.46 29.52 30.02 174.97 as price1, 175.23 50.76 50.32 51.29 26.23 as price2);\nselect sym,rowVarp(price1,price2) as varp from t;\n```\n\n| sym  | varp      |\n| ---- | --------- |\n| AAPL | 3945.7242 |\n| MS   | 113.4225  |\n| IBM  | 108.16    |\n| IBM  | 113.1032  |\n| C    | 5530.8969 |\n\n相关函数：[rowVar](https://docs.dolphindb.cn/zh/funcs/r/rowVar.html), [varp](https://docs.dolphindb.cn/zh/funcs/v/varp.html)\n"
    },
    "rowWavg": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rowWavg.html",
        "signatures": [
            {
                "full": "rowWavg(X, Y)",
                "name": "rowWavg",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [rowWavg](https://docs.dolphindb.cn/zh/funcs/r/rowWavg.html)\n\n\n\n#### 语法\n\nrowWavg(X, Y)\n\nrow 系列函数通用参数说明和计算规则请参考：[rowFunctions](https://docs.dolphindb.cn/zh/funcs/themes/rowFunctions.html)\n\n#### 详情\n\n逐行计算 *X* 以 *Y* 为权重的加权平均。\n\n#### 返回值\n\n返回一个长度与输入参数行数相同的向量。\n\n#### 例子\n\n```\nm1=matrix(2 -1 4, 8 3 2, 9 0 1)\nm2=matrix(8 11 10, 8 17 4, 14 6 4)\nrowWavg(m1, m2)\n// output\n[6.8667, 1.1765, 2.8889]\n\nm3=matrix(2 NULL 4, 8 NULL 2, 9 NULL NULL)\nrowWavg(m3, m2)\n// output\n[6.8667, , 3.4286]\n\na= -10 12.3 -10 -8\nb= 17.9 9 7.5 -4\nc= 5.5 5.5 -7 8\n\nrowWavg(matrix(a, b, c), matrix(b, a, c))\n// output\n[-24.459, 9.3899, 10.6316, -32]\n\nx=array\\(DOUBLE\\[\\],0, 10\\).append!\\(\\[a, b, c\\]\\)\ny=array\\(DOUBLE\\[\\],0, 10\\).append!\\(\\[b, a, c\\]\\)\nrowWavg\\(x, y\\)\n// output\n\\[-3.6612, 7.0892, 14.4583\\]\n```\n\n相关函数：[wavg](https://docs.dolphindb.cn/zh/funcs/w/wavg.html)\n"
    },
    "rowWsum": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rowWsum.html",
        "signatures": [
            {
                "full": "rowWsum(X, Y)",
                "name": "rowWsum",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [rowWsum](https://docs.dolphindb.cn/zh/funcs/r/rowWsum.html)\n\n\n\n#### 语法\n\nrowWsum(X, Y)\n\nrow 系列函数通用参数说明和计算规则请参考：[rowFunctions](https://docs.dolphindb.cn/zh/funcs/themes/rowFunctions.html)\n\n#### 详情\n\n逐行计算 *X* 和 *Y* 的内积。\n\n#### 返回值\n\n返回一个长度与输入参数行数相同的向量。\n\n#### 例子\n\n```\nm1=matrix(2 -1 4, 8 3 2, 9 0 1)\nm2=matrix(8 11 10, 8 17 4, 14 6 4)\nrowWsum(m1, m2)\n// output\n[206, 40, 52]\n\nm3=matrix(8 NULL 10, 8 NULL 4, 14 NULL NULL)\nrowWsum(m1, m3)\n// output\n[206, , 48]\n\na= -10 12.3 4 -8\nb= 17.9 9 7.5 -4\nc= 5.5 6.4 -7 8\nx=array\\(DOUBLE\\[\\],0, 10\\).append!\\(\\[a, b, c\\]\\)\ny=array\\(DOUBLE\\[\\],0, 10\\).append!\\(\\[b, a, c\\]\\)\n\nrowWsum\\(x, y\\)\n// output\n\\[0.63, -6.3 , 184.21\\]\n```\n\n相关函数：[wsum](https://docs.dolphindb.cn/zh/funcs/w/wsum.html)\n"
    },
    "rowXor": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rowXor.html",
        "signatures": [
            {
                "full": "rowXor(args...)",
                "name": "rowXor",
                "parameters": [
                    {
                        "full": "args...",
                        "name": "args..."
                    }
                ]
            }
        ],
        "markdown": "### [rowXor](https://docs.dolphindb.cn/zh/funcs/r/rowXor.html)\n\n\n\n#### 语法\n\nrowXor(args...)\n\nrow 系列函数通用参数说明和计算规则请参考：[rowFunctions](https://docs.dolphindb.cn/zh/funcs/themes/rowFunctions.html)\n\n#### 详情\n\n逐行进行逻辑异或操作。\n\n#### 返回值\n\n返回一个长度与输入参数行数相同的向量。\n\n#### 例子\n\n```\nm=matrix([true false false, true true true, true true true]);\nrowXor(m);\n// output\n[1,0,0]\n\nt=table(true false false true false true as x, false true false true false true as y, false false true true false false as z);\nt;\n```\n\n| x  | y  | z  |\n| :- | :- | :- |\n| 1  | 0  | 0  |\n| 0  | 1  | 0  |\n| 0  | 0  | 1  |\n| 1  | 1  | 1  |\n| 0  | 0  | 0  |\n| 1  | 1  | 0  |\n\n```\nrowXor(t);\n// output\n[1,1,1,1,0,0]\n\nt=table(`AAPL`MS`IBM`IBM`C as sym, 49.6 29.46 29.52 30.02 174.97 as price1, 175.23 50.76 50.32 51.29 26.23 as price2);\nselect * from t where rowXor(price1$ 30, price2$ 50);\n```\n\n| sym | price1 | price2 |\n| --- | ------ | ------ |\n| MS  | 29.46  | 50.76  |\n| IBM | 29.52  | 50.32  |\n| C   | 174.97 | 26.23  |\n\n相关函数：[xor](https://docs.dolphindb.cn/zh/funcs/x/xor.html)\n"
    },
    "rpad": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rpad.html",
        "signatures": [
            {
                "full": "rpad(str, length, [pattern])",
                "name": "rpad",
                "parameters": [
                    {
                        "full": "str",
                        "name": "str"
                    },
                    {
                        "full": "length",
                        "name": "length"
                    },
                    {
                        "full": "[pattern]",
                        "name": "pattern",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [rpad](https://docs.dolphindb.cn/zh/funcs/r/rpad.html)\n\n\n\n#### 语法\n\nrpad(str, length, \\[pattern])\n\n#### 详情\n\n在字符串的右边填充特定字符串。\n\n#### 参数\n\n**str** 是一个字符串或字符串向量。它表示目标字符串。\n\n**length** 是一个不超过 65536 的非负整数。它表示返回字符串的长度。如果 *length* 小于 *str* 的长度，`rpad` 会把 *str* 截断成长度为 *length* 的字符串。如果 *length* 大于 65536，则系统会自动调整为 65536。\n\n**pattern** 是一个填充字符串。它是一个可选参数。如果没有指定，则在 *str* 的右边填充空格。\n\n#### 返回值\n\n一个字符串或字符串向量。\n\n#### 例子\n\n```\nrpad(\"Hello\",2);\n// output\nHe\n\nrpad(`Hello, 10);\n// output\nHello\n\nrpad(`Hello, 12, `0);\n// output\nHello0000000\n```\n"
    },
    "rpc": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rpc.html",
        "signatures": [
            {
                "full": "rpc(nodeAlias, func, args, ...)",
                "name": "rpc",
                "parameters": [
                    {
                        "full": "nodeAlias",
                        "name": "nodeAlias"
                    },
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "args",
                        "name": "args"
                    },
                    {
                        "full": "...",
                        "name": "..."
                    }
                ]
            }
        ],
        "markdown": "### [rpc](https://docs.dolphindb.cn/zh/funcs/r/rpc.html)\n\n\n\n#### 语法\n\nrpc(nodeAlias, func, args, ...)\n\n#### 详情\n\n在指定的远程节点上调用本地函数，并把结果返回到本地节点。这个函数可以是内置函数或调用节点上的用户自定义函数。函数的参数暂不支持值为函数定义的字典。\n\n调用节点和远程节点必须在同一集群。否则，我们需要使用 [remoteRun](https://docs.dolphindb.cn/zh/funcs/r/remoteRun.html) 函数。详情请参考 [BatchJobManagement](https://docs.dolphindb.cn/zh/sys_man/BatchJobManagement.html)。\n\n#### 参数\n\n**nodeAlias** 是远程节点的别名。\n\n**func** 是函数，它不能被引用。这个函数可以是内置函数或调用节点上的用户自定义函数。\n\n**args** 是函数的参数。\n\n#### 返回值\n\n*func* 执行的结果。\n\n#### 例子\n\n* 远程调用用户定义函数\n\n  ```\n  rpc(\"nodeA\", def(x,y):x+y, 10, 15)\n  ```\n\n* 远程调用部分应用\n\n  ```\n  rpc(\"nodeA\", getRecentJobs{10})\n  ```\n\n* 远程调用引用了用户定义函数的内置函数\n\n  ```\n  def jobDemo(n){\n      s = 0\n      for (x in 1 : n) {\n         s += sum(sin rand(1.0, 100000000)-0.5)\n             print(\"iteration \" + x + \" \" + s)\n      }\n      return s\n  };\n  // the node \"DFS_NODE2\" is located in the same cluster as the local node.\n  rpc(\"DFS_NODE2\", submitJob, \"jobDemo3\", \"job demo\", jobDemo, 10);\n  // output: \n  jobDemo3\n\n  rpc(\"DFS_NODE2\", getJobReturn, \"jobDemo3\")\n  // output: \n  -3426.577521\n  ```\n"
    },
    "rshift": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rshift.html",
        "signatures": [
            {
                "full": "rshift(X, a)",
                "name": "rshift",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "a",
                        "name": "a"
                    }
                ]
            }
        ],
        "markdown": "### [rshift](https://docs.dolphindb.cn/zh/funcs/r/rshift.html)\n\n\n\n#### 语法\n\nrshift(X, a) 或 X>>a\n\n#### 详情\n\n`rshift` 将参数按位右移。\n\n#### 参数\n\n**X** 可以是标量、数据对、向量或矩阵\n\n**a** 是移动的位数。\n\n#### 返回值\n\n数据形式和类型与 X 相同的对象。\n\n#### 例子\n\n```\nrshift(2048, 2);\n// output\n512\n\n 1..10 >> 1;\n// output\n[0,1,1,2,2,3,3,4,4,5]\n\n1:10>>1;\n// output\n0 : 5\n```\n\n相关函数：[lshift](https://docs.dolphindb.cn/zh/funcs/l/lshift.html)\n"
    },
    "rtrim": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/rtrim.html",
        "signatures": [
            {
                "full": "rtrim(X)",
                "name": "rtrim",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [rtrim](https://docs.dolphindb.cn/zh/funcs/r/rtrim.html)\n\n\n\n#### 语法\n\nrtrim(X)\n\n#### 详情\n\n删除字符串或字符串向量的每个元素右边的空格。\n\n#### 参数\n\n**X** 是一个字符串或字符串向量。\n\n#### 返回值\n\n一个字符串或字符串向量。\n\n#### 例子\n\n```\nrtrim(\"I love      \")+\" \"+ltrim(\"    this game!\");\n// output\nI love this game!\n```\n"
    },
    "run": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/run.html",
        "signatures": [
            {
                "full": "run(scriptFile, [newSession=false], [clean=true])",
                "name": "run",
                "parameters": [
                    {
                        "full": "scriptFile",
                        "name": "scriptFile"
                    },
                    {
                        "full": "[newSession=false]",
                        "name": "newSession",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[clean=true]",
                        "name": "clean",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [run](https://docs.dolphindb.cn/zh/funcs/r/run.html)\n\n\n\n#### 语法\n\nrun(scriptFile, \\[newSession=false], \\[clean=true])\n\n#### 详情\n\n执行一个已经保存的程序文件。\n\n如果设置 *newSession* = false，程序文件在当前 session 中运行。如果设置 *newSession* = true，程序文件在新开的 session 中运行。运行结束，关闭该 session。\n\n**注意**：该命令必须要用户登录后才能执行。非管理员用户执行该命令须满足以下条件：（1）获得 [SCRIPT\\_EXEC 权限](https://docs.dolphindb.cn/zh/funcs/g/grant.html)；（2）配置项 [*strictPermissionMode*](https://docs.dolphindb.cn/zh/db_distr_comp/cfg/function_configuration.html) 为 false（即默认值）。\n\n#### 参数\n\n**scriptFile** 是服务器端的脚本所在路径。\n\n**newSession** 是否新开一个 session 运行脚本。\n\n**clean** 是否清理当前 session 中的变量。默认为 true，即 `run` 运行后会清除变量。\n\n#### 例子\n\n```\nrun \"/home/DolphinDB/test.dos\";\n\nd = dict(STRING, ANY)\nd[\"TradePrice\"] = 1..1000\n// clean 参数设置为 false，当前 session 中定义的变量 d 不会被清除。\nrun(\"/home/DolphinDB/test.dos\", clean=false)\nparseExpr(\"avg(TradePrice)\",d).eval()\n// output\n500.5\n```\n"
    },
    "runExternalQuery": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/runexternalquery.html",
        "signatures": [
            {
                "full": "runExternalQuery(config, query, [preExecuteQueries])",
                "name": "runExternalQuery",
                "parameters": [
                    {
                        "full": "config",
                        "name": "config"
                    },
                    {
                        "full": "query",
                        "name": "query"
                    },
                    {
                        "full": "[preExecuteQueries]",
                        "name": "preExecuteQueries",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [runExternalQuery](https://docs.dolphindb.cn/zh/funcs/r/runexternalquery.html)\n\n首发版本：3.00.5\n\n\n\n#### 语法\n\nrunExternalQuery(config, query, \\[preExecuteQueries])\n\n#### 详情\n\n将指定的 SQL 语句发送到远程数据库，在远程数据库执行该语句并返回执行结果。\n\n**Note:**\n\n* 调用函数前必须安装和加载 [ODBC 插件](https://docs.dolphindb.cn/zh/plugins/odbc/odbc.html)。\n* 支持的远程数据库包括 MySQL、PostgreSQL、SQLServer、ClickHouse、SQLite、Oracle、Hive 和 GaussDB。此外，建议将数据库安装于 CentOS 7。\n\n#### 参数\n\n**config** 字典，设置连接远程数据库的参数。字典键为 \"connectionString\"，字典值为 [ODBC 连接字符串](https://docs.dolphindb.cn/zh/plugins/odbc/odbc.html#connect)。示例：`config = dict([\"connectionString\"], [\"Dsn=MyOracleDB\"])`。\n\n**query** 字符串标量，指定需要执行的 SQL 语句。该语句需要符合远程数据库的 SQL 语法规则。\n\n**preExecuteQueries** 可选参数，字符串向量。如果在执行 *query* 参数指定的 SQL 语句前，需要预执行某些 SQL 语句，可以设置该参数。系统会按照向量中的顺序依次执行 SQL 语句，但预执行的 SQL 语句不会返回执行结果。\n\n#### 返回值\n\n一个内存表。\n\n#### 例子\n\n```\noracle_cfg = dict([\"connectionString\"], [\"Dsn=MyOracleDB\"])\n\nt1 = createExternalTable(\"t1\", \"oracle\", oracle_cfg)\n\nt2 = runExternalQuery(oracle_cfg, \"select * from t1 inner join t2 on t1.id = t2.id;\")\n\nt3 = select * from t1, t2, runExternalQuery(oracle_cfg, \"select * from t3;\") as t3;\n```\n\n**相关函数**：[createExternalTable](https://docs.dolphindb.cn/zh/progr/sql/createExternalTable.html)\n"
    },
    "runScript": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/runScript.html",
        "signatures": [
            {
                "full": "runScript(script)",
                "name": "runScript",
                "parameters": [
                    {
                        "full": "script",
                        "name": "script"
                    }
                ]
            }
        ],
        "markdown": "### [runScript](https://docs.dolphindb.cn/zh/funcs/r/runScript.html)\n\n\n\n#### 语法\n\nrunScript(script)\n\n#### 详情\n\n本地执行一段脚本。该命令必须要用户登录后才能执行。\n\n#### 参数\n\n**script** 是字符串，表示需要执行的脚本。\n\n#### 例子\n\n```\nt = table(1..100 as id,201..300 as val1)\nscript1 = 'dn = \"dfs://test\";if(existsDatabase(dn)){dropDatabase(dn)};db = database(dn,VALUE,1..10);pt = db.createPartitionedTable(t,`pt,`id).append!(t)'\nscript2 = 'select * from loadTable(\"dfs://test\",`pt)'\nrunScript(script1)\nrunScript(script2)\n```\n"
    },
    "runSQL": {
        "url": "https://docs.dolphindb.cn/zh/funcs/r/runsql.html",
        "signatures": [
            {
                "full": "runSQL(X, [sqlStd='ddb'], [variables])",
                "name": "runSQL",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[sqlStd='ddb']",
                        "name": "sqlStd",
                        "optional": true,
                        "default": "'ddb'"
                    },
                    {
                        "full": "[variables]",
                        "name": "variables",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [runSQL](https://docs.dolphindb.cn/zh/funcs/r/runsql.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nrunSQL(X, \\[sqlStd='ddb'], \\[variables])\n\n#### 详情\n\n`runSQL` 函数根据指定的语法环境解析并执行脚本。同时，支持通过用户输入的变量作为参数动态传递给 SQL 语句，从而避免手动拼接 SQL 字符串，降低注入风险，确保代码安全性和易维护性。\n\n**注意**：`runSQL` 在自定义函数内调用时，无法读取到完整的上下文，不建议在自定义函数中使用 `runSQL` 函数。\n\n目前仅支持 Oracle 和 MySQL 的部分功能和函数，见下表：\n\n<table id=\"table_skr_245_c2c\"><thead><tr id=\"row_pdg_4g2_myb\"><th id=\"entry_qdg_4g2_myb\">\n\nSQL 方言\n\n</th><th id=\"entry_rdg_4g2_myb\">\n\n支持功能\n\n</th><th id=\"entry_sdg_4g2_myb\">\n\n支持函数（无分大小写）\n\n</th></tr></thead><tbody><tr id=\"row_tdg_4g2_myb\"><td id=\"entry_udg_4g2_myb\">\n\nOracle\n\n</td><td id=\"entry_vdg_4g2_myb\">\n\n* 注释符：--、/\\*\\*/\n* 字符串拼接符：||\n\n</td><td id=\"entry_ydg_4g2_myb\">\n\nasciistr, concat, decode, instr, length, listagg, nvl, nvl2, rank, regexp\\_like, replace, to\\_char, to\\_date, to\\_number, trunc, wm\\_concat**Note:** to\\_char 只接收数值类型和 DATE, DATEHOUR, DATETIME 类型的参数。有关 Oracle SQL 函数的语法参考，请访问：[SQL Language Reference](https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/Functions.html#GUID-D079EFD3-C683-441F-977E-2C9503089982)\n\n</td></tr><tr id=\"row_zdg_4g2_myb\"><td id=\"entry_a2g_4g2_myb\">\n\nMySQL\n\n</td><td id=\"entry_b2g_4g2_myb\">\n\n \n\n</td><td id=\"entry_c2g_4g2_myb\">\n\nsysdate**Note:** 有关 MySQL 函数的语法参考，请访问：[MySQL :: MySQL 8.0 Reference Manual :: 12 Functions and Operators](https://dev.mysql.com/doc/refman/8.0/en/functions.html)\n\n</td></tr></tbody>\n</table>**注：**在 Oracle 或 MySQL 模式下，同样支持解析使用 DolphinDB 语言编写的脚本。\n\n#### 参数\n\n**X** 字符串，表示需要执行的脚本。*X* 不支持 SQL DDL 操作；此外，当*sqlStd*指定为 'oracle' 和 'mysql' 时，*X* 也不支持DML 操作。\n\n**sqlStd** 可选参数。字符串，用于指定脚本的解析方言。可选值包括：'ddb'（默认值），'oracle'，'mysql'。\n\n**variables** 可选参数。用于动态传递参数的字典。字典的键为字符串，表示变量名称（可以包含字母，数字和下划线，但必须以字母开头）；值为对应的对象。\n\n#### 返回值\n\n*X* 查询的结果。\n\n#### 例子\n\n例 1：使用 DolphinDB 语法进行解析，并指定 *variables*用于动态传递参数。\n\n假设有以下订单表 t。\n\n```\nn=10\ncustomerId=\"DB00\"+string(1..5)\norderDate=2025.01.01..2025.01.10\nt=table(take(orderDate, n) as orderDate, 1..10 as orderId, take(customerId,n) as customerId, rand(1000,n) as volume)\nt\n```\n\n| **orderDate** | **orderId** | **customerId** | **volume** |\n| ------------- | ----------- | -------------- | ---------- |\n| 2025.01.01    | 1           | DB001          | 435        |\n| 2025.01.02    | 2           | DB002          | 134        |\n| 2025.01.03    | 3           | DB003          | 483        |\n| 2025.01.04    | 4           | DB004          | 867        |\n| 2025.01.05    | 5           | DB005          | 708        |\n| 2025.01.06    | 6           | DB001          | 291        |\n| 2025.01.07    | 7           | DB002          | 663        |\n| 2025.01.08    | 8           | DB003          | 254        |\n| 2025.01.09    | 9           | DB004          | 386        |\n| 2025.01.10    | 10          | DB005          | 653        |\n\n我们需要查询某个客户 （DB001）最近 10 天内的订单（假设查询当天为 2025.01.14）。\n\n```\nsql_script =\"SELECT orderId,customerId, orderDate, volume FROM t WHERE customerId==customer AND orderDate>=(date(now())- days)\"\nvariables={\"customer\":`DB001,\"days\": 10}\nre=runSQL(sql_script, , variables)\nprint(re)\n```\n\n返回：\n\n| **orderId** | **customerId** | **orderDate** | **volume** |\n| ----------- | -------------- | ------------- | ---------- |\n| 6           | DB001          | 2025.01.06    | 291        |\n\n例 2：使用 Oracle 语法进行解析\n\n```\nrunSQL(\"concat(CONCAT(`14`mysql, `22`oracle),`11`33)\", 'oracle')\n// output: [\"142211\",\"mysqloracle33\"]\n\nrunSQL(\"string(1 2 3) || string(4 5 6)\", 'oracle')\n// output: [\"14\",\"25\",\"36\"]\n\nrunSQL(\"TO_DATE('2023-05-18', 'YYYY-MM-DD')\", 'oracle')\n// output: 2023.05.18\n```\n\n例 3：使用 MySQL 语法进行解析\n\n```\nrunSQL(\"SYSDATE() + 1\", 'mysql')\n// output: 2025.01.15\n```\n"
    },
    "undef": {
        "url": "https://docs.dolphindb.cn/zh/funcs/u/undef.html",
        "signatures": [
            {
                "full": "undef(obj, [objType=VAR])",
                "name": "undef",
                "parameters": [
                    {
                        "full": "obj",
                        "name": "obj"
                    },
                    {
                        "full": "[objType=VAR]",
                        "name": "objType",
                        "optional": true,
                        "default": "VAR"
                    }
                ]
            }
        ],
        "markdown": "### [undef](https://docs.dolphindb.cn/zh/funcs/u/undef.html)\n\n\n\n#### 语法\n\nundef(obj, \\[objType=VAR])\n\n或\n\nundef all\n\n#### 详情\n\n从内存中释放变量和函数定义。VAR（本地变量）亦可通过 \"= NULL\" 释放变量。\n\n#### 参数\n\n**obj** 需要取消定义的对象。如果想要取消所有变量、所有全局变量或所有用户自定义函数的定义，*obj* 可以使用 \"all\"。\n\n**objType** 需要取消定义的对象的类型。可以是以下取值之一：VAR（本地变量）,SHARED（共享变量） 或 DEF（函数定义）。默认值是 VAR。\n\n使用 `undef all` 删除系统中所有用户自定义的对象。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\nundef all;\nx=1\nundef(`x);\nx=1\ny=2\nundef(`x`y);\nshare table(1..3 as x, 4..6 as y) as t\nundef(`t, SHARED);\n```\n\n```\ndef f(a){return a+1}\nundef(`f, DEF);\na=1\nb=2\nundef all, VAR;\n// 取消所有变量的定义，但不包括函数定义。\n```\n"
    },
    "ungroup": {
        "url": "https://docs.dolphindb.cn/zh/funcs/u/ungroup.html",
        "signatures": [
            {
                "full": "ungroup(X)",
                "name": "ungroup",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [ungroup](https://docs.dolphindb.cn/zh/funcs/u/ungroup.html)\n\n\n\n#### 语法\n\nungroup(X)\n\n#### 详情\n\n若表 *X* 的某列中包含数组向量或列式元组，则将其展开后整体做为一列；同时保留原同行中其余列的数据，按照对应数组向量或列式元组的元素数量进行复制填充；\n\n若 *X* 的行数为0或不包含数组向量或列式元组，则直接返回 *X*。\n\n#### 参数\n\n**X** 必须是一个表对象。\n\n#### 返回值\n\n一个表。\n\n#### 例子\n\n```\nx = array(INT[], 0).append!([1 2 3, 4 5, 6 7 8, 9 10])\nt = table(1 2 3 4 as id, x as vol)\nungroup(t)\n// output\nid vol\n-- -------\n1  1      \n1  2      \n1  3      \n2  4      \n2  5      \n3  6      \n3  7      \n3  8      \n4  9      \n4  10     \n\n//创建一个表，其中 price 列为列式元组。\nsym = `st1`st2`st3\nprice = [[3.1,2.5,2.8], [3.1,3.3], [3.2,2.9,3.3]]\nprice.setColumnarTuple!()\nt = table(sym, price)\nungroup(t)\n```\n\n| sym | price                   |\n| --- | ----------------------- |\n| st1 | \\[3.1000,2.5000,2.8000] |\n| st2 | \\[3.1000,3.3000]        |\n| st3 | \\[3.2000,2.9000,3.3000] |\n\n```\nungroup(t)\n```\n\n| sym | price |\n| --- | ----- |\n| st1 | 3.1   |\n| st1 | 2.5   |\n| st1 | 2.8   |\n| st2 | 3.1   |\n| st2 | 3.3   |\n| st3 | 3.2   |\n| st3 | 2.9   |\n| st3 | 3.3   |\n\n```\n\nsym = `st1`st2`st2`st1`st3`st1`st3`st2`st3\nvolume = 106 115 121 90 130 150 145 123 155;\nt = table(sym, volume);\nt;\n\nt1 = select toArray(volume) as volume_all from t group by sym;\nt1;\n```\n\n| sym | volume\\_all    |\n| --- | -------------- |\n| st1 | \\[106,90,150]  |\n| st2 | \\[115,121,123] |\n| st3 | \\[130,145,155] |\n\n```\n\nungroup(t1)\n```\n\n| sym | volume\\_all |\n| --- | ----------- |\n| st1 | 106         |\n| st1 | 90          |\n| st1 | 150         |\n| st2 | 115         |\n| st2 | 121         |\n| st2 | 123         |\n| st3 | 130         |\n| st3 | 145         |\n| st3 | 155         |\n"
    },
    "unifiedExpr": {
        "url": "https://docs.dolphindb.cn/zh/funcs/u/unifiedExpr.html",
        "signatures": [
            {
                "full": "unifiedExpr(objs, optrs)",
                "name": "unifiedExpr",
                "parameters": [
                    {
                        "full": "objs",
                        "name": "objs"
                    },
                    {
                        "full": "optrs",
                        "name": "optrs"
                    }
                ]
            }
        ],
        "markdown": "### [unifiedExpr](https://docs.dolphindb.cn/zh/funcs/u/unifiedExpr.html)\n\n\n\n#### 语法\n\nunifiedExpr(objs, optrs)\n\n#### 详情\n\n使用 *optrs* 中的二元运算符，将 *objs* 中元素连接，生成一个多元运算表达式的元代码。使用 [eval](https://docs.dolphindb.cn/zh/funcs/e/eval.html) 函数可以执行 `unifiedExpr` 函数生成的元代码。\n\n#### 参数\n\n**objs** 是长度在2到1024之间的元组。\n\n**optrs** 是由二元运算符组成的向量，其数量为 size(*objs*)-1。\n\n#### 返回值\n\nCODE 类型元代码。\n\n#### 例子\n\n```\nunifiedExpr((1, 2), add)\n// output: <1 + 2>\n\nt=table(1..3 as price1, 4..6 as price2, 5..7 as price3)\na=sqlColAlias(unifiedExpr((sqlCol(\"price1\"), sqlCol(\"price2\"), sqlCol(\"price3\")), take(add, 2)))\nsql(select=(sqlCol(`price1),sqlCol(`price2),sqlCol(`price3),a), from=t).eval()\n```\n\n| price1 | price2 | price3 | price1\\_add |\n| ------ | ------ | ------ | ----------- |\n| 1      | 4      | 5      | 10          |\n| 2      | 5      | 6      | 13          |\n| 3      | 6      | 7      | 16          |\n\n相关函数： [binaryExpr](https://docs.dolphindb.cn/zh/funcs/b/binaryExpr.html)\n"
    },
    "union": {
        "url": "https://docs.dolphindb.cn/zh/funcs/u/union.html",
        "signatures": [
            {
                "full": "union(X, Y)",
                "name": "union",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [union](https://docs.dolphindb.cn/zh/funcs/u/union.html)\n\n\n\n#### 语法\n\nunion(X, Y) 或 X|Y\n\n#### 详情\n\n返回两个集合的并集。\n\n#### 参数\n\n**X** 和 **Y** 是集合\n\n#### 返回值\n\n一个集合。\n\n#### 例子\n\n```\nx=set([5,5,3,4]);\ny=set(8 9 9 4 6);\nx | y;\n// output: set(8,9,6,4,3,5)\n```\n"
    },
    "unionAll": {
        "url": "https://docs.dolphindb.cn/zh/funcs/u/unionAll.html",
        "signatures": [
            {
                "full": "unionAll(tableA, tableB, [byColName=false])",
                "name": "unionAll",
                "parameters": [
                    {
                        "full": "tableA",
                        "name": "tableA"
                    },
                    {
                        "full": "tableB",
                        "name": "tableB"
                    },
                    {
                        "full": "[byColName=false]",
                        "name": "byColName",
                        "optional": true,
                        "default": "false"
                    }
                ]
            },
            {
                "full": "unionAll(tables, [partition=true], [byColName=false])",
                "name": "unionAll",
                "parameters": [
                    {
                        "full": "tables",
                        "name": "tables"
                    },
                    {
                        "full": "[partition=true]",
                        "name": "partition",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[byColName=false]",
                        "name": "byColName",
                        "optional": true,
                        "default": "false"
                    }
                ]
            },
            {
                "full": "unionAll(tables, tableB)",
                "name": "unionAll",
                "parameters": [
                    {
                        "full": "tables",
                        "name": "tables"
                    },
                    {
                        "full": "tableB",
                        "name": "tableB"
                    }
                ]
            }
        ],
        "markdown": "### [unionAll](https://docs.dolphindb.cn/zh/funcs/u/unionAll.html)\n\n\n\n#### 语法\n\nunionAll(tableA, tableB, \\[byColName=false])\n\n或\n\nunionAll(tables, \\[partition=true], \\[byColName=false])\n\n或\n\nunionAll(tables, tableB)\n\n#### 详情\n\n第一种用法只能将两个表合并成一个表，返回的结果是未分区的内存表。\n\n第二种用法可以多个表合并成一个表。如果 *partition* 为 false，返回的结果是未分区的内存表；如果 *partition* 为 true，返回的结果是一个顺序分区的内存表。默认值为 true。\n\n当 *byColName* =true 时，各表可有不同数量的列。若某列在某些表中不存在，结果中会以空值填充。\n\n当 *byColName* =false 时，各表必须有相同数量的列。\n\n第三种用法是将多个表追加到指定的表，并返回该表。常用于 `mr` 函数的 finalFunc。\n\n#### 参数\n\n* 用法一：\n\n  * **tableA** 和 **tableB** 是列数相同的内存表。\n\n* 用法二：\n\n  * **tables** 是一个元组，其中每个元素都是一个表，并且它们具有相同的列数。\n\n  * **partition** 是布尔值，表示是否进行顺序分区（SEQ），默认值是 true。\n\n  * **byColName** 是一个布尔值。若设为 true，表示表合并时，依照列名进行，各表中相同列名的列进行合并，缺失的列用空值填充。若设为 false，表示表合并时仅基于列顺序，不管列名是否一致。\n\n* 用法三：\n\n  * **tables** 是一个元组，其中每个元素都是一个内存表，并且它们具有相同的列数。**tableB** 是一个和 *tables* 中表列数相同的内存表。\n\n**Note:**\n\n*tableA*, *tableB*, *tables* 支持以下内存表：table, keyedTable, indexedTable, latestKeyedTable, latestIndexedTable。此外，用法三的 *tableB* 还可以是一个分区内存表。\n\n#### 返回值\n\n一个表。\n\n#### 例子\n\n用法一：合并两个内存表\n\n```\nt1=table(1 2 3 as id, 11 12 13 as x)\nt2=table(4 5 6 as id, 14 15 16 as x)\nre=unionAll(t1,t2)\nre;\n```\n\n| id | x  |\n| -- | -- |\n| 1  | 11 |\n| 2  | 12 |\n| 3  | 13 |\n| 4  | 14 |\n| 5  | 15 |\n| 6  | 16 |\n\n```\ntypestr(re);\n// output\nIN-MEMORY TABLE\n```\n\n用法二：合并多个内存表\n\n```\nt1=table(1 2 3 as id, 11 12 13 as x)\nt2=table(4 5 6 as id, 14 15 16 as x)\nt3=table(7 8 as id, 17 18 as x)\nre=unionAll([t1,t2,t3])\nselect * from re;\n```\n\n| id | x  |\n| -- | -- |\n| 1  | 11 |\n| 2  | 12 |\n| 3  | 13 |\n| 4  | 14 |\n| 5  | 15 |\n| 6  | 16 |\n| 7  | 17 |\n| 8  | 18 |\n\n```\ntypestr(re);\n// output\nSEGMENTED IN-MEMORY TABLE\n```\n\n指定 byColName：\n\n```\nt1=table(1 2 3 as id, 11 12 13 as x)\nt2=table(14 15 16 as x, 4 5 6 as id)\nunionAll(t1,t2,true);\n```\n\n| id | x  |\n| -- | -- |\n| 1  | 11 |\n| 2  | 12 |\n| 3  | 13 |\n| 4  | 14 |\n| 5  | 15 |\n| 6  | 16 |\n\n```\nt1=table(1 2 3 as id, 11 12 13 as x)\nt2=table(14 15 16 as x, 4 5 6 as id)\nunionAll(t1,t2);\n```\n\n| id | x  |\n| -- | -- |\n| 1  | 11 |\n| 2  | 12 |\n| 3  | 13 |\n| 14 | 4  |\n| 15 | 5  |\n| 16 | 6  |\n\n上例中可见，若不指定 *byColName* （即 *byColName* =false），请务必确认各表中列名顺序一致，否则会产生错误结果。\n\n```\nt1=table(1 2 3 as id, 11 12 13 as x, 21 22 23 as y)\nt2=table(4 5 6 as id, 14 15 16 as x)\nunionAll(t1,t2,true);\n```\n\n| id | x  | y  |\n| -- | -- | -- |\n| 1  | 11 | 21 |\n| 2  | 12 | 22 |\n| 3  | 13 | 23 |\n| 4  | 14 |    |\n| 5  | 15 |    |\n| 6  | 16 |    |\n\n```\nt1=table(1 2 3 as id, 11 12 13 as x, 21 22 23 as y)\nt2=table(4 5 6 as id, 14 15 16 as x)\nunionAll(t1, t2) => The number of columns of the table to insert must be the same as that of the original table.\n```\n\n上例中可见，若各表中列数不一致，必须将 *byColName* 设为 true。\n\n用法三：将多个内存表合并到分区内存表\n\n```\ndef testFunc(data, off){\n    return select *, price * (1-off) as `discountPrice from data\n}\nn = 100\ndates = 2021.01.01..2021.12.31\nt = table(take(dates, 365 * n).sort() as `date, `sym + take(1..n, 365 * n).sort()$STRING as `sym, round(10 + norm(0, 2, 365 * n), 2) as `price)\n\ndb = database(\"\", VALUE, 2021.01.01..2021.12.31)\ntrade = db.createPartitionedTable(table=t, tableName=\"trade\", partitionColumns=`date).append!(t)\ndb = database(\"\", RANGE, date(month(dates.first()) .. (month(dates.last()) + 1)))\noutputT=table(1:0, `date`sym`price`discountPrice, [DATE,SYMBOL,DOUBLE,DOUBLE])\nports = db.createPartitionedTable(outputT, \"ports\", `date)\n//map reduce\nmr(sqlDS(<select * from trade>), testFunc{,0.3},,unionAll{,ports})\n\nselect * from ports\n```\n"
    },
    "unloadVocab": {
        "url": "https://docs.dolphindb.cn/zh/funcs/u/unloadVocab.html",
        "signatures": [
            {
                "full": "unloadVocab([vocabName])",
                "name": "unloadVocab",
                "parameters": [
                    {
                        "full": "[vocabName]",
                        "name": "vocabName",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [unloadVocab](https://docs.dolphindb.cn/zh/funcs/u/unloadVocab.html)\n\n首发版本：3.00.4，3.00.3.1\n\n\n\n#### 语法\n\nunloadVocab(\\[vocabName])\n\n#### 详情\n\n从内存中删除已加载的词库。\n\n#### 参数\n\n**vocabName** 可选参数，字符串标量，指定要删除的词库名称。若不指定，则删除所有词库。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\nunloadVocab(\"vocab1\")\n```\n\n相关函数：[loadVocab](https://docs.dolphindb.cn/zh/funcs/l/loadVocab.html), [tokenizeBert](https://docs.dolphindb.cn/zh/funcs/t/tokenizeBert.html)\n"
    },
    "unlockUser": {
        "url": "https://docs.dolphindb.cn/zh/funcs/u/unlockUser.html",
        "signatures": [
            {
                "full": "unlockUser(userId)",
                "name": "unlockUser",
                "parameters": [
                    {
                        "full": "userId",
                        "name": "userId"
                    }
                ]
            }
        ],
        "markdown": "### [unlockUser](https://docs.dolphindb.cn/zh/funcs/u/unlockUser.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nunlockUser(userId)\n\n#### 详情\n\n解锁用户 *userId*。该函数仅限管理员用户调用，调用时须开启配置项 *enhancedSecurityVerification*。\n\n#### 参数\n\n**userId** 是表示用户名的字符串。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\nunlockUser(\"user1\")\n```\n\n相关函数：[lockUser](https://docs.dolphindb.cn/zh/funcs/l/lockUser.html)\n"
    },
    "unpack": {
        "url": "https://docs.dolphindb.cn/zh/funcs/u/unpack.html",
        "signatures": [
            {
                "full": "unpack(format, buf)",
                "name": "unpack",
                "parameters": [
                    {
                        "full": "format",
                        "name": "format"
                    },
                    {
                        "full": "buf",
                        "name": "buf"
                    }
                ]
            }
        ],
        "markdown": "### [unpack](https://docs.dolphindb.cn/zh/funcs/u/unpack.html)\n\n\n\n#### 语法\n\nunpack(format, buf)\n\n#### 详情\n\n根据 *format* 指定的格式，将 *buf* 解包成 DolphinDB 中的数据。返回一个元组，其元素为解包后的数据。\n\n#### 参数\n\n**format** 格式字符串，用于指定数据格式。指定方式参见附录。关于格式字符串的说明：\n\n* 格式字符之前可以带有整数表示重复计数。 例如，格式字符串 '4h' 的含义与 'hhhh' 完全相同。\n\n* 格式之间的空白字符会被忽略；但是计数及其格式字符中不可有空白字符。\n\n* 对于 's' 格式字符，计数会被解析为字节的长度，而不是像其他格式字符那样的重复计数；例如，'10s' 表示一个 10 字节的字节串，而 '10c' 表示 10 个字符。 若未给出计数，则默认值为1。返回结果的字节对象长度必须恰好等于指定的字节数量。 作为特殊情况，'0c' 表示 0 个字符。\n\n**buf** 二进制字节流，可以是 STRING 或 BLOB 类型。*buf* 中各元素的字节大小和类型必须匹配 *format* 所要求的大小和类型。\n\n#### 返回值\n\n一个元组，其元素为解包后的数据。\n\n#### 例子\n\n```\nres = pack(\"N\",1);\nres1 = unpack(\"N\", res);\nprint(res1)\n// output: (1)\n\n\nres = pack(\"3s i\", `123, 3)\nres1 = unpack(\"3s i\",  res);\nprint(res1)\n// output: (\"123\",3)\n```\n\n相关函数：[pack](https://docs.dolphindb.cn/zh/funcs/p/pack.html)\n\n#### 附录\n\n##### 格式字符与类型\n\n| 格式 | C 类型               | Python 类型 | DolphinDB 类型 | 范围                       |\n| -- | ------------------ | --------- | ------------ | ------------------------ |\n| x  | 填充字节               | 无         | VOID         |                          |\n| c  | char               | 长度为1的字节串  | CHAR         | -27 +1 \\~ 27 -1          |\n| b  | signed char        | integer   | LONG         | -27 \\~ 27 -1             |\n| B  | unsigned char      | integer   | LONG         | 0 \\~ 28 -1               |\n| ?  | \\_Bool             | bool      | LONG         | -263 \\~ 263 -1           |\n| h  | short              | integer   | LONG         | -215 \\~ 215 -1           |\n| H  | unsigned short     | integer   | LONG         | 0 \\~ 216 -1              |\n| i  | int                | integer   | LONG         | -231 \\~ 231 -1           |\n| I  | unsigned int       | integer   | LONG         | 0 \\~ 232 -1              |\n| l  | long               | integer   | LONG         | -231 \\~ 231 -1           |\n| L  | unsigned long      | integer   | LONG         | 0 \\~ 232 -1              |\n| q  | long long          | integer   | LONG         | -263 \\~ 263 -1           |\n| Q  | unsigned long long | integer   | LONG         | 0 \\~ 263 -1              |\n| n  | ssize\\_t           | integer   | LONG         | -263 \\~ 263 -1           |\n| N  | size\\_t            | integer   | LONG         | 0 \\~ 263 -1              |\n| f  | float              | float     | LONG         | -3.40E+38 \\~ +3.40E+38   |\n| d  | double             | float     | LONG         | -1.79E+308 \\~ +1.79E+308 |\n| s  | char\\[]            | bytes     | STRING       |                          |\n| p  | char\\[]            | bytes     | STRING       |                          |\n| P  | void\\*             | integer   | LONG         | -263 \\~ 263 -1           |\n\n##### 首字符字节顺序，大小和对齐方式\n\n| 字符 | 字节顺序    | 大小   | 对齐方式 |\n| -- | ------- | ---- | ---- |\n| >  | 大端      | 标准   | 无    |\n| =  | 按原字节    | 标准   | 无    |\n| <  | 小端      | 标准   | 无    |\n| @  | 按原字节    | 按原字节 | 按原字节 |\n| !  | 网络（=大端） | 标准   | 无    |\n\n默认情况下，C 类型以本机格式和字节顺序表示，在必要时通过跳过填充字节进行正确对齐（根据 C 编译器使用的规则）。\n\n格式字符串的第一个字符可用于指示打包数据的字节顺序，大小和对齐方式，见首字符字节顺序，大小和对齐方式部分内容。 如果第一个字符不是其中之一，则按 '@' 处理。\n"
    },
    "unpivot": {
        "url": "https://docs.dolphindb.cn/zh/funcs/u/unpivot.html",
        "signatures": [
            {
                "full": "unpivot(obj, keyColNames, valueColNames, [func])",
                "name": "unpivot",
                "parameters": [
                    {
                        "full": "obj",
                        "name": "obj"
                    },
                    {
                        "full": "keyColNames",
                        "name": "keyColNames"
                    },
                    {
                        "full": "valueColNames",
                        "name": "valueColNames"
                    },
                    {
                        "full": "[func]",
                        "name": "func",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [unpivot](https://docs.dolphindb.cn/zh/funcs/u/unpivot.html)\n\n\n\n#### 语法\n\nunpivot(obj, keyColNames, valueColNames, \\[func])\n\n#### 详情\n\n把多列的数据转换成一列。\n\n#### 参数\n\n**obj** 是一个表。\n\n**keyColNames** 是表示列名的标量或向量，用于指定要在输出表中保留的列。\n\n**valueColNames** 是一个列名向量。*valueColNames* 中的数据将转换成一列。 请注意 *valueColNames* 各列的数据类型应一致。\n\n**func** 是一个函数。如果指定了 *func* 函数，该函数将会应用到 *valueColNames* 上，再将其合并。\n\n#### 返回值\n\n返回一个表，列的顺序依次为 *keyColNames* 指定的各列，valueType 列和 value 列。其中，若未指定 *func* 参数，则 valueType 列存储 *valueColNames* 中的列名，否则 ，valueType 列存储 *func* 应用于 *valueColNames* 中各列的结果；value 列存储 *valueColNames* 中各列的值。\n\n#### 例子\n\n```\nt=table(1..3 as id, 2010.01.01 + 1..3 as time, 4..6 as col1, 7..9 as col2, 10..12 as col3, `aaa`bbb`ccc as col4, `ddd`eee`fff as col5, 'a' 'b' 'c' as col6);\nt;\n```\n\n| id | time       | col1 | col2 | col3 | col4 | col5 | col6 |\n| -- | ---------- | ---- | ---- | ---- | ---- | ---- | ---- |\n| 1  | 2010.01.02 | 4    | 7    | 10   | aaa  | ddd  | 'a'  |\n| 2  | 2010.01.03 | 5    | 8    | 11   | bbb  | eee  | 'b'  |\n| 3  | 2010.01.04 | 6    | 9    | 12   | ccc  | fff  | 'c'  |\n\n保留表 t 中的 id 列，将 col1 列和 col2 列转换为一列：\n\n```\nt.unpivot(keyColNames=`id, valueColNames=`col1`col2);\n```\n\n| id | valueType | value |\n| -- | --------- | ----- |\n| 1  | col1      | 4     |\n| 2  | col1      | 5     |\n| 3  | col1      | 6     |\n| 1  | col2      | 7     |\n| 2  | col2      | 8     |\n| 3  | col2      | 9     |\n\n保留表 t 中的 id 列，将 col1 列和 col2 列转换为一列，且将自定义函数应用于 col1 列和 col2 列：\n\n```\nf = def(x): x.split(\"col\")[1];\nt.unpivot(keyColNames=`id, valueColNames=`col1`col2, func=f);\n```\n\n| id | valueType | value |\n| -- | --------- | ----- |\n| 1  | 1         | 4     |\n| 2  | 1         | 5     |\n| 3  | 1         | 6     |\n| 1  | 2         | 7     |\n| 2  | 2         | 8     |\n| 3  | 2         | 9     |\n\n不保留其它列，仅仅将 col1 列和 col2 列转换为一列：\n\n```\nt.unpivot(, valueColNames=`col1`col2);\n```\n\n| valueType | value |\n| --------- | ----- |\n| col1      | 4     |\n| col1      | 5     |\n| col1      | 6     |\n| col2      | 7     |\n| col2      | 8     |\n| col2      | 9     |\n\n保留表 t 中的 id 列，将 col1 列、col2 列 和 col3 列转换为一列，且将自定义函数应用于 col1 列、col2 列和 col3 列：\n\n```\nf = def(x): x.regexReplace(\"col\", \"var\")\nt.unpivot(keyColNames=`id, valueColNames=`col1`col2`col3, func=f);\n```\n\n| id | valueType | value |\n| -- | --------- | ----- |\n| 1  | var1      | 4     |\n| 2  | var1      | 5     |\n| 3  | var1      | 6     |\n| 1  | var2      | 7     |\n| 2  | var2      | 8     |\n| 3  | var2      | 9     |\n| 1  | var3      | 10    |\n| 2  | var3      | 11    |\n| 3  | var3      | 12    |\n\n```\nt.unpivot(keyColNames=`time, valueColNames=`col4`col5)\n```\n\n| time       | valueType | value |\n| ---------- | --------- | ----- |\n| 2010.01.02 | col4      | aaa   |\n| 2010.01.03 | col4      | bbb   |\n| 2010.01.04 | col4      | ccc   |\n| 2010.01.02 | col5      | ddd   |\n| 2010.01.03 | col5      | eee   |\n| 2010.01.04 | col5      | fff   |\n\n```\nt = table(1..3 as id, 2010.01.01 + 1..3 as time, 8.1 9.2 11.3 as bid1, 12.4 11.1 10.5 as bid2, 10.1 10.2 10.3 as bid3, 10.1 10.2 10.3 as bid4, 10.1 11.2 9.3 as bid5, 7.7 8.2 10.5 as ask1, 11.4 10.1 9.5 as ask2, 9.6 9.2 11.3 as ask3, 12.1 7.2 8.3 as ask4, 10.1 12.5 8.9 as ask5);\nt;\n//保留 id 和 time 列，将 bid1~bid5 列转换到一个列\nt1 = t.unpivot(`id`time, `bid1`bid2`bid3`bid4`bid5);\n//不保留其它列，仅仅将 ask1~ask5 列转换到一个列\nt2 = t.unpivot(, `ask1`ask2`ask3`ask4`ask5);\n//分别将 t1 和 t2 的 valueType 和 value 列重命名后进行合并\nre = rename!(t1, `valueType`value, `bid_type`bid_value) join rename!(t2, `valueType`value, `ask_type`ask_value)\nre;\n```\n\n| id | time       | bid\\_type | bid\\_value | ask\\_type | ask\\_value |\n| -- | ---------- | --------- | ---------- | --------- | ---------- |\n| 1  | 2010.01.02 | bid1      | 8.1        | ask1      | 8.1        |\n| 2  | 2010.01.03 | bid1      | 9.2        | ask1      | 9.2        |\n| 3  | 2010.01.04 | bid1      | 11.3       | ask1      | 11.3       |\n| 1  | 2010.01.02 | bid2      | 12.4       | ask2      | 12.4       |\n| 2  | 2010.01.03 | bid2      | 11.1       | ask2      | 11.1       |\n| 3  | 2010.01.04 | bid2      | 10.5       | ask2      | 10.5       |\n| 1  | 2010.01.02 | bid3      | 10.1       | ask3      | 10.1       |\n| 2  | 2010.01.03 | bid3      | 10.2       | ask3      | 10.2       |\n| 3  | 2010.01.04 | bid3      | 10.3       | ask3      | 10.3       |\n| 1  | 2010.01.02 | bid4      | 10.1       | ask4      | 10.1       |\n| 2  | 2010.01.03 | bid4      | 10.2       | ask4      | 10.2       |\n| 3  | 2010.01.04 | bid4      | 10.3       | ask4      | 10.3       |\n| 1  | 2010.01.02 | bid5      | 10.1       | ask5      | 10.1       |\n| 2  | 2010.01.03 | bid5      | 11.2       | ask5      | 11.2       |\n| 3  | 2010.01.04 | bid5      | 9.3        | ask5      | 9.3        |\n"
    },
    "unsubscribeStreamingSQL": {
        "url": "https://docs.dolphindb.cn/zh/funcs/u/unsubscribeStreamingSQL.html",
        "signatures": [
            {
                "full": "unsubscribeStreamingSQL([server], queryId)",
                "name": "unsubscribeStreamingSQL",
                "parameters": [
                    {
                        "full": "[server]",
                        "name": "server",
                        "optional": true
                    },
                    {
                        "full": "queryId",
                        "name": "queryId"
                    }
                ]
            }
        ],
        "markdown": "### [unsubscribeStreamingSQL](https://docs.dolphindb.cn/zh/funcs/u/unsubscribeStreamingSQL.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\nunsubscribeStreamingSQL(\\[server], queryId)\n\n#### 详情\n\n取消订阅指定的流式 SQL 查询结果。取消订阅后，订阅端的实时结果表将停止更新。\n\n#### 参数\n\n**server** 可选参数，字符串标量，表示运行流式 SQL 查询的节点（即注册该查询的服务器）的别名或远程连接句柄。如果未指定或者为空字符串，表示流式 SQL 查询所在的服务器是本地实例。\n\n**queryId** 字符串标量，表示要取消订阅的流式 SQL 查询 ID。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\nt=table(1..10 as id,rand(100,10) as val)\nshare t as st\ndeclareStreamingSQLTable(st)\nregisterStreamingSQL(\"select avg(val) from st\",\"sql_avg\") \n\nsubscribeStreamingSQL(queryId=\"sql_avg\")\n// output: 52.1\n\nunsubscribeStreamingSQL(queryId=\"sql_avg\")\n```\n\n**相关函数：**[declareStreamingSQLTable](https://docs.dolphindb.cn/zh/funcs/d/declareStreamingSQLTable.html), [registerStreamingSQL](https://docs.dolphindb.cn/zh/funcs/r/registerStreamingSQL.html), [subscribeStreamingSQL](https://docs.dolphindb.cn/zh/funcs/s/subscribeStreamingSQL.html)\n"
    },
    "unsubscribeTable": {
        "url": "https://docs.dolphindb.cn/zh/funcs/u/unsubscribeTable.html",
        "signatures": [
            {
                "full": "unsubscribeTable([server], tableName, [actionName], [removeOffset=true], [raftGroup])",
                "name": "unsubscribeTable",
                "parameters": [
                    {
                        "full": "[server]",
                        "name": "server",
                        "optional": true
                    },
                    {
                        "full": "tableName",
                        "name": "tableName"
                    },
                    {
                        "full": "[actionName]",
                        "name": "actionName",
                        "optional": true
                    },
                    {
                        "full": "[removeOffset=true]",
                        "name": "removeOffset",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[raftGroup]",
                        "name": "raftGroup",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [unsubscribeTable](https://docs.dolphindb.cn/zh/funcs/u/unsubscribeTable.html)\n\n\n\n#### 语法\n\nunsubscribeTable(\\[server], tableName, \\[actionName], \\[removeOffset=true], \\[raftGroup])\n\n#### 详情\n\n在信息订阅端的节点执行，以停止向信息发布者订阅数据。在调用该命令时，会删除流计算执行线程的队列中未处理的消息。\n\n#### 参数\n\n**server** 是表示服务器的别名或与流数据表所在服务器创建的 xdb 连接的字符串。\n\n**tableName** 是表示取消订阅的流数据表名称的字符串。取消跨集群订阅 Orca 流表时，格式为`fqn@cluster_identifier`，例如 `demo.orca_table.trades@cluster_BeiJing`。\n\n**actionName** 是表示句柄名称的字符串。它可以包含字母、数字和下划线。如果创建订阅时指定了 *actionName*，取消订阅时必须指定 *actionName*。\n\n**removeOffset** 是一个布尔值，表示是否删除持久化保存的最新一条已经处理订阅数据的偏移量（在 [subscribeTable](https://docs.dolphindb.cn/zh/funcs/s/subscribeTable.html) 函数中通过指定 *persistOffset* 参数为 true 获得）。\n\n**raftGroup** 是在 [subscribeTable](https://docs.dolphindb.cn/zh/funcs/s/subscribeTable.html) 中设定的 raft 组的 ID，用于取消相应的订阅高端可用。\n\n**Note:** `unsubscribeTable` 函数如果指定了 *raftGroup* ，则只能在 leader 上执行。\n\n#### 例子\n\n在发布节点发布一张表 trades。\n\n```\nt=streamTable(100:0,`date`time`sym`qty`price`exch,[DATE,TIME,SYMBOL,INT,DOUBLE,SYMBOL])\nshare t as trades\nt=NULL\n```\n\n在订阅节点上创建表 trades2 来保存发布节点中的表 trades 的数据。\n\n```\nt=streamTable(100:0,`date`time`sym`qty`price`exch,[DATE,TIME,SYMBOL,INT,DOUBLE,SYMBOL])\nshare t as trades2\nt=NULL\nh=xdb(\"localhost\",8902)\nsubscribeTable(server=h, tableName=\"trades\", actionName=\"sub1\", handler=trades2);\n// output: localhost:8902:node1/trades/sub1\n```\n\n取消订阅表 trades 的数据：\n\n```\nunsubscribeTable(h, \"trades\",\"sub1\");\n```\n"
    },
    "updateDataViewItems": {
        "url": "https://docs.dolphindb.cn/zh/funcs/u/updateDataViewItems.html",
        "signatures": [
            {
                "full": "updateDataViewItems(engine, keys, valueNames, newValues)",
                "name": "updateDataViewItems",
                "parameters": [
                    {
                        "full": "engine",
                        "name": "engine"
                    },
                    {
                        "full": "keys",
                        "name": "keys"
                    },
                    {
                        "full": "valueNames",
                        "name": "valueNames"
                    },
                    {
                        "full": "newValues",
                        "name": "newValues"
                    }
                ]
            }
        ],
        "markdown": "### [updateDataViewItems](https://docs.dolphindb.cn/zh/funcs/u/updateDataViewItems.html)\n\n\n\n#### 语法\n\nupdateDataViewItems(engine, keys, valueNames, newValues)\n\n#### 详情\n\n更新 DataView 引擎中指定键值对应的指定字段的值。若 *keys* 指定的键值列（key）不存在，则更新时会报错 。\n\n该函数可在 CEP 引擎内部或外部调用。如果在 CEP 引擎内部调用此函数，系统将优先在 CEP 引擎中查找句柄为 *engine* 的 DataView 引擎；若未找到，则会在 CEP 引擎外部进行查找。如果在 CEP 引擎外部调用此函数，系统只会在 CEP 引擎外部进行查找。\n\n#### 参数\n\n**engine** DataView 引擎句柄或引擎名。\n\n**keys** 标量、向量或 tuple，表示需要更新的键值， 如果是复合键值，则需要传入一个 tuple，其中每个元素表示组成键值的列，且顺序需与引擎中 *keyedColumns* 的指定顺序保持一致。\n\n**valueNames** 字符串标量或向量，需要更新的字段的名称，需要与 DataView 引擎中 *outputTable* 指定的列名匹配。\n\n**newValues** 标量、向量或 tuple，表示需要更新的字段对应的值。指定方式同 *keys*。\n\n#### 例子\n\n```\nclass trades{\n    trader :: STRING\n    market :: STRING\n    code :: STRING\n    price :: DOUBLE\n    qty :: INT\n    eventTime :: TIMESTAMP\n    def trades(t, m, c, p, q){\n        trader = t\n        market = m\n        code = c\n        price = p\n        qty = q\n        eventTime = now()\n    }\n}\n\nclass mainMonitor:CEPMonitor{\n    tradesTable :: ANY\n    isBusy :: BOOL\n    def mainMonitor(){\n        tradesTable = array(ANY, 0)\n        isBusy = false\n    }\n\n    def updateTrades(event)\n\n    def updateTrades2(event)\n\n    def unOnload(){\n        undef('traderDV', SHARED)\n    }\n\n    def onload(){\n        addEventListener(updateTrades, `trades, , \"all\",,,,,\"trades1\")\n        addEventListener(updateTrades2, `trades, , \"all\",,,,,\"trades2\")\n        traderDV = streamTable(array(STRING, 0) as trader, array(STRING, 0) as market, array(SYMBOL, 0) as code, array(DOUBLE, 0) as price, array(INT, 0) as qty, array(INT, 0) as tradeCount, array(BOOL, 0) as busy, array(DATE, 0) as orderDate, array(TIMESTAMP, 0) as updateTime)\n        share(traderDV, 'traderDV')\n        createDataViewEngine('traderDV', objByName('traderDV'), `trader, `updateTime, true)\n    }\n\n    def updateTrades(event) {\n        tradesTable.append!([event.trader, event.market, event.code, event.price, event.qty])\n        getDataViewEngine('traderDV').append!(table(event.trader as trader, string() as market, string() as code, 0.0 as price, 0 as qty, 0 as tradeCount, false as busy, date(event.eventTime) as orderDate))\n        updateDataViewItems('traderDV', event.trader, ['market', 'code', 'price', 'qty', 'tradeCount'], [event.market, event.code, event.price, event.qty, tradesTable.size()])\n    }\n\n    def updateTrades2(event) {\n        tradesTable.append!([event.trader, event.market, event.code, event.price, event.qty])\n        getDataViewEngine('traderDV').append!(table(event.trader as trader, string() as market, string() as code, 0.0 as price, 0 as qty, 0 as tradeCount, false as busy, date(event.eventTime) as orderDate))\n        updateDataViewItems('traderDV', event.trader, ['market', 'code', 'price', 'qty', 'tradeCount'], [event.market, event.code, event.price, event.qty, tradesTable.size()])\n    }\n}\n\ndummy = table(array(TIMESTAMP, 0) as eventTime, array(STRING, 0) as eventType, array(BLOB, 0) as blobs)\nengineCep = createCEPEngine('cep1', <mainMonitor()>, dummy, [trades], 1, 'eventTime', 10000)\ntrade1 = trades('t1', 'sz', 's001', 11.0, 10)\ngo\nappendEvent(engineCep, trade1)\n// 查看 monitor\nmonitors = getCEPEngineMonitor('cep1',\"cep1\",\"mainMonitor\")\n// 查看 listener\nlisteners = monitors.getEventListener()\nprint(listeners)\n// 终止 listener\nlisteners['trades1'].terminate()\nprint(listeners)\n```\n\n**相关函数**：[createCEPEngine](https://docs.dolphindb.cn/zh/funcs/c/createCEPEngine.html), [createDataViewEngine](https://docs.dolphindb.cn/zh/funcs/c/createDataViewEngine.html), [deleteDataViewItems](https://docs.dolphindb.cn/zh/funcs/d/deleteDataViewItems.html), [getDataViewEngine](https://docs.dolphindb.cn/zh/funcs/g/getDataViewEngine.html)\n"
    },
    "updateLicense": {
        "url": "https://docs.dolphindb.cn/zh/funcs/u/updateLicense.html",
        "signatures": [
            {
                "full": "updateLicense()",
                "name": "updateLicense",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [updateLicense](https://docs.dolphindb.cn/zh/funcs/u/updateLicense.html)\n\n\n\n#### 语法\n\nupdateLicense()\n\n#### 详情\n\n用于在线更新 license。在手动替换 license 文件后执行该函数，可使新的 license 配置生效而无需重启节点。\n\n更新配置生效规则如下：\n\n* 立即生效：过期时间（expiration） 和 授权的节点个数（maxNodes） 的更新会立即生效。执行后，可通过 [getLicenseExpiration](https://docs.dolphindb.cn/zh/funcs/g/getLicenseExpiration.html) 获得当前 license 的过期时间，以判断 license 是否生效。\n\n* 需重启生效：若修改了除上述内容外的其它配置，如内存大小（maxMemoryPerNode）、CPU 核数（maxCoresPerNode）等，必须重启 DolphinDB Server 才能使新配置生效。\n\n**Note:**\n\n* 该函数仅在执行函数的节点生效。因此在集群环境下，需要在所有节点上运行该函数。\n\n* 待升级 license 需满足以下条件才能成功升级（可通过 `license` 函数查看）：\n\n  * 授权的客户名称（cilentName）和授权模式（authorization）必须与原来的 license 相同。\n\n  * 授权的节点个数（maxNodes），内存大小（maxMemoryPerNode），CPU 核数（maxCoresPerNode）不小于原 license 的授权。\n\n* 若原 license 授权模式（authorization）为 site，则无法进行在线升级。\n\n#### 参数\n\n无\n\n#### 返回值\n\n一个字典，表示许可证信息。\n\n#### 例子\n\n```\nupdateLicense()\n// output\nauthorization->commercial\nlicenseType->0\nmaxMemoryPerNode->32\nmaxCoresPerNode->8\nclientName->test license\nbindCPU->true\nexpiration->2022.03.01\nmaxNodes->8\nversion->\nmodules->-1\n```\n"
    },
    "updateMarketHoliday": {
        "url": "https://docs.dolphindb.cn/zh/funcs/u/updateMarketHoliday.html",
        "signatures": [
            {
                "full": "updateMarketHoliday(marketName, holiday)",
                "name": "updateMarketHoliday",
                "parameters": [
                    {
                        "full": "marketName",
                        "name": "marketName"
                    },
                    {
                        "full": "holiday",
                        "name": "holiday"
                    }
                ]
            }
        ],
        "markdown": "### [updateMarketHoliday](https://docs.dolphindb.cn/zh/funcs/u/updateMarketHoliday.html)\n\n\n\n#### 语法\n\nupdateMarketHoliday(marketName, holiday)\n\n#### 详情\n\n在线覆盖内存中文件名为 *marketName* 的交易市场节假日或交易日文件，并同步更新至 *marketHolidayDir*；若内存中不存在该文件，则报错。\n\n**Note:**\n\n* 该函数只能由管理员调用。\n\n* 该函数仅对当前节点有效。集群环境中，可通过 `pnodeRun` 调用该函数，使其在其它节点生效。\n\n* 若手动修改了 *marketHolidayDir* 下的交易日历，想要在不关机的情况下，同步修改内容到内存，可以通过 `loadText` 将已修改的 csv 文件加载到内存表，并转换表数据为向量（holiday），然后通过该函数将 `holiday` 更新至内存。\n\n#### 参数\n\n**marketName** 字符串标量，表示交易日历标识，例如：国外交易所的 ISO Code、国内交易所简称或自定义交易日历名称。\n\n**holiday** DATE 类型向量，用于指定交易日历的日期。其具体含义取决于该交易日历的日期类型：\n\n* 若日期类型为“节假日”（默认），则 *holiday* 应指定为非周末的休市日期。\n* 若日期类型为“交易日”，则 *holiday* 应指定为交易日期。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\ntemporalAdd(2022.01.01,1,\"CCFX\")\n```\n\n返回：2022.01.04\n\n```\nindex = [2022.01.01, 2022.01.02, 2022.01.03, 2022.01.04]\ns = indexedSeries(index, 1..4)\ns.resample(\"CCFX\", sum);\n```\n\n返回：\n\n| label      | col1 |\n| ---------- | ---- |\n| 2021.12.31 | 6    |\n| 2022.01.04 | 4    |\n\n```\nupdateMarketHoliday(\"CCFX\",2022.01.03 2022.01.04)\ntemporalAdd(2022.01.01,1,\"CCFX\")\n```\n\n返回：2022.01.05\n\n**Related information**\n\n[addMarketHoliday](https://docs.dolphindb.cn/zh/funcs/a/addMarketHoliday.html)\n\n[getMarketCalendar](https://docs.dolphindb.cn/zh/funcs/g/getMarketCalendar.html)\n\n[getTradingCalendarType](https://docs.dolphindb.cn/zh/funcs/g/gettradingcalendartype.html)\n"
    },
    "updateMCPPrompt": {
        "url": "https://docs.dolphindb.cn/zh/funcs/u/updateMCPPrompt.html",
        "signatures": [
            {
                "full": "updateMCPPrompt(name, [message], [description], [extraInfo])",
                "name": "updateMCPPrompt",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "[message]",
                        "name": "message",
                        "optional": true
                    },
                    {
                        "full": "[description]",
                        "name": "description",
                        "optional": true
                    },
                    {
                        "full": "[extraInfo]",
                        "name": "extraInfo",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [updateMCPPrompt](https://docs.dolphindb.cn/zh/funcs/u/updateMCPPrompt.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\nupdateMCPPrompt(name, \\[message], \\[description], \\[extraInfo])\n\n#### 详情\n\n更新一个 MCP prompt 模板。\n\n如果某个参数没有提供，则不修改对应的信息。空字符串会被视为没有提供参数，因此如要清空描述信息，请使用空格代替空字符串。\n\n#### 参数\n\n**name** STRING 类型标量，表示 prompt 模板的名称。\n\n**message** STRING 类型标量，表示 prompt 模板内容，允许包含 `{}`占位符。\n\n**description** 可选参数，STRING 类型标量，表示 prompt 模板说明。\n\n**extraInfo** 可选参数，一个字典，键是 STRING 类型，值是 ANY 或 STRING 类型，用于指定其他信息。目前键支持 \"title\"。\n\n#### 返回值\n\n一个字符串，表示更新 MCP prompt 模板的名称。\n\n#### 例子\n\n```\n// 定义 prompt 模板\naddMCPPrompt(\n  name = \"stock_summary\",\n  message = \"请用一句话总结 ${stock} 从 ${startDate} 到 ${endDate} 的走势。\",\n  description = \"生成某个股票在一段时间内的自然语言概述\",\n  extraInfo = {title : \"股票走势总结\"}\n)\n\n// 更新 prompt 模板\nupdateMCPPrompt(\n  name = \"stock_summary\",\n  message = \"请总结 ${stock} 在 ${startDate} 至 ${endDate} 的表现。\",\n  description = \"更新后的 Prompt 描述\"\n)\n```\n"
    },
    "updateMCPTool": {
        "url": "https://docs.dolphindb.cn/zh/funcs/u/updateMCPTool.html",
        "signatures": [
            {
                "full": "updateMCPTool(name, [func], [argNames], [argTypes], [description], [extraInfo])",
                "name": "updateMCPTool",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "[func]",
                        "name": "func",
                        "optional": true
                    },
                    {
                        "full": "[argNames]",
                        "name": "argNames",
                        "optional": true
                    },
                    {
                        "full": "[argTypes]",
                        "name": "argTypes",
                        "optional": true
                    },
                    {
                        "full": "[description]",
                        "name": "description",
                        "optional": true
                    },
                    {
                        "full": "[extraInfo]",
                        "name": "extraInfo",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [updateMCPTool](https://docs.dolphindb.cn/zh/funcs/u/updateMCPTool.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\nupdateMCPTool(name, \\[func], \\[argNames], \\[argTypes], \\[description], \\[extraInfo])\n\n#### 详情\n\n更新一个 MCP tool。\n\n如果某个参数没有提供，则不修改 tool 对应的信息。空字符串会被视为没有提供参数，因此如要清空描述信息，请使用空格代替空字符串。\n\n#### 参数\n\n**name** STRING 类型标量，表示 tool 的名称。\n\n**func** 可选参数，自定义函数。\n\n**argNames** 可选参数，STRING 类型向量，表示参数名。如无参数，请用 `[]` 表示。\n\n**argTypes**可选参数，STRING 类型向量，表示参数类型，既可指定为 DolphinDB 数据类型，也可指定为 JSON 数据类型。支持的数据类型如下：\n\n| DolphinDB 数据类型 | JSON 数据类型         |\n| -------------- | ----------------- |\n| STRING         | \"string\"          |\n| TEMPORAL       | \"string\"          |\n| DOUBLE         | \"number\"          |\n| BOOL           | \"boolean\"         |\n| STRING\\[]      | \"array\\<string>\"  |\n| TEMPORAL\\[]    | \"array\\<string>\"  |\n| DOUBLE\\[]      | \"array\\<number>\"  |\n| BOOL\\[]        | \"array\\<boolean>\" |\n\n**description** 可选参数，STRING 类型标量，表示 tool 描述。\n\n**extraInfo** 可选参数，一个字典，键是 STRING 类型，值是 ANY 或 STRING 类型，可指定其他信息。目前键支持 \"title\"。\n\n#### 返回值\n\n一个字符串，表示更新 tool 的名称。\n\n#### 例子\n\n```\n// 定义 tool\ndef myTool(x) {\n   return x * 2 + 1\n}\n\ninfo = {\n    \"title\": \"DolphinDB Tools\"\n}\n\naddMCPTool(\"myTool\", myTool, [\"a\"], [\"number\"], \"This is a tool\", info)\n\n// 更新 tool \ndef myNewTool(x, y) {\n   return x * 2 + y\n}\n\nupdateMCPTool(\"myTool\", myNewTool, [\"a\",\"b\"], [\"number\",\"number\"], \" \")\n\n// 只更新额外信息\nnewInfo = {\n    \"title\": \"Updated Tools\"\n}\n\nupdateMCPTool(name=\"myTool\", extraInfo=newInfo)\n```\n"
    },
    "updateOrderBookEngineParams": {
        "url": "https://docs.dolphindb.cn/zh/funcs/u/updateOrderBookEngineParams.html",
        "signatures": [
            {
                "full": "updateOrderBookEngineParams(engine, [prevClose], [maxPrice], [minPrice], [outputCodeMap])",
                "name": "updateOrderBookEngineParams",
                "parameters": [
                    {
                        "full": "engine",
                        "name": "engine"
                    },
                    {
                        "full": "[prevClose]",
                        "name": "prevClose",
                        "optional": true
                    },
                    {
                        "full": "[maxPrice]",
                        "name": "maxPrice",
                        "optional": true
                    },
                    {
                        "full": "[minPrice]",
                        "name": "minPrice",
                        "optional": true
                    },
                    {
                        "full": "[outputCodeMap]",
                        "name": "outputCodeMap",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [updateOrderBookEngineParams](https://docs.dolphindb.cn/zh/funcs/u/updateOrderBookEngineParams.html)\n\n\n\n#### 语法\n\nupdateOrderBookEngineParams(engine, \\[prevClose], \\[maxPrice], \\[minPrice], \\[outputCodeMap])\n\n#### 详情\n\n在线为 OrderBook 引擎设定参数值。该函数必须在创建 OrderBook 引擎后，向引擎注入数据前调用。\n\n#### 参数\n\n**engine** OrderBook 引擎名或者或 `createOrderBookSnapshotEngine` 返回的句柄。\n\n**prevClose** 字典，其 key 为字符串标量或向量，表示股票代码；其 value 为数值类型，表示对应于股票代码的上一个交易日的收盘价格。\n\n**maxPrice** 可选参数，字典。其 key 为字符串类型，表示证券代码；其 value 为 DOUBLE 类型，表示涨停价格。\n\n**minPrice** 可选参数，字典。其 key 为字符串类型，表示证券代码；其 value 为 DOUBLE 类型，表示跌停价格。\n\n**outputCodeMap**可选参数，字符串向量，表示股票代码，例如：“000803.SZ”。指定该参数后，将只输出指定股票对应的数据。\n\n#### 例子\n\n运行代码前，先下载 [../data/orderbookDemoInput.zip](https://docs.dolphindb.cn/zh/funcs/data/orderbookDemoInput.zip) 文件。\n\n```\n// 通过参数 outputTable 指定输出表\nsuffix = string(1..10)\ncolNames = `SecurityID`timestamp`lastAppSeqNum`tradingPhaseCode`modified`turnover`volume`tradeNum`totalTurnover`totalVolume`totalTradeNum`lastPx`highPx`lowPx`ask`bid`askVol`bidVol`preClosePx`invalid  join (\"bids\" + suffix) join (\"bidVolumes\" + suffix) join (\"bidOrderNums\" + suffix) join (\"asks\" + suffix)  join (\"askVolumes\" + suffix) join (\"askOrderNums\" + suffix) \ncolTypes = [SYMBOL,TIMESTAMP,LONG,INT,BOOL,DOUBLE,LONG,INT,DOUBLE,LONG,INT,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,LONG,LONG,DOUBLE,BOOL] join take(DOUBLE, 10) join take(LONG, 10) join take(INT, 10) join take(DOUBLE, 10) join take(LONG, 10) join take(INT, 10) \nshare table(10000000:0, colNames, colTypes) as outTable\n\n// 通过参数 dummyTable 指定输入表的表结构\ncolNames = `SecurityID`Date`Time`SecurityIDSource`SecurityType`Index`SourceType`Type`Price`Qty`BSFlag`BuyNo`SellNo`ApplSeqNum`ChannelNo\ncolTypes = [SYMBOL, DATE, TIME, SYMBOL, SYMBOL, LONG, INT, INT, LONG, LONG, INT, LONG, LONG, LONG, INT]\ndummyOrderStream = table(1:0, colNames, colTypes)\n\n// 通过参数 inputColMap 指定输入表各字段的含义\ninputColMap = dict(`codeColumn`timeColumn`typeColumn`priceColumn`qtyColumn`buyOrderColumn`sellOrderColumn`sideColumn`msgTypeColumn`seqColumn, `SecurityID`Time`Type`Price`Qty`BuyNo`SellNo`BSFlag`SourceType`ApplSeqNum)\nprevClose = dict(SYMBOL, DOUBLE)\n\n// 定义引擎，每 1s 计算输出深交所股票 10 档买卖盘口\nengine = createOrderBookSnapshotEngine(name=\"demo\", exchange=\"XSHE\", orderbookDepth=10, intervalInMilli = 1000, date=2022.01.10, startTime=09:15:00.000, prevClose=prevClose, dummyTable=dummyOrderStream, outputTable=outTable, inputColMap=inputColMap)\n\n// 通过 updateOrderBookEngineParams 为引擎传入 prevClose 的具体取值\nprevClose = dict(`000587.SZ`002694.SZ`002822.SZ`000683.SZ`301063.SZ`300459.SZ`300057.SZ`300593.SZ`301035.SZ`300765.SZ, [1.66, 6.56, 6.10, 8.47, 38.10, 5.34, 9.14, 48.81, 60.04, 16.52])\nupdateOrderBookEngineParams(engine, prevClose)\n\n// 导入数据\nfilePath = \"./orderbookDemoInput.csv\"\ncolNames = `SecurityID`Date`Time`SecurityIDSource`SecurityType`Index`SourceType`Type`Price`Qty`BSFlag`BuyNo`SellNo`ApplSeqNum`ChannelNo\ncolTypes = [SYMBOL, DATE, TIME, SYMBOL, SYMBOL, LONG, INT, INT, LONG, LONG, INT, LONG, LONG, LONG, INT]\norderTrade = table(1:0, colNames, colTypes)\norderTrade.append!(select * from loadText(filePath) order by Time)\n\n// 10支股票的逐笔数据批量注入快照合成引擎\nengine.append!(orderTrade)\nselect count(*) from outTable where SecurityID=\"300593.SZ\", timestamp between 2022.01.10T13:15:01.000 and 2022.01.10T13:15:10.000\n```\n"
    },
    "updatePKEYDeleteBitmap": {
        "url": "https://docs.dolphindb.cn/zh/funcs/u/updatepkeydeletebitmap.html",
        "signatures": [
            {
                "full": "updatePKEYDeleteBitmap(chunkId)",
                "name": "updatePKEYDeleteBitmap",
                "parameters": [
                    {
                        "full": "chunkId",
                        "name": "chunkId"
                    }
                ]
            }
        ],
        "markdown": "### [updatePKEYDeleteBitmap](https://docs.dolphindb.cn/zh/funcs/u/updatepkeydeletebitmap.html)\n\n\n\n#### 语法\n\nupdatePKEYDeleteBitmap(chunkId)\n\n#### 详情\n\n更新 PKEY 引擎的 delete bitmap，完成后清空主键的暂存缓冲区。\n\n#### 参数\n\n**chunkId** STRING 类型标量或向量，表示 chunk 对应的 ID。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\nupdatePKEYDeleteBitmap(chunkId=\"1486f935-6f87-479c-b341-34c6a303d4f9\")\n```\n"
    },
    "updateRule": {
        "url": "https://docs.dolphindb.cn/zh/funcs/u/updateRule.html",
        "signatures": [
            {
                "full": "updateRule(engineName, key, rules, [add=false])",
                "name": "updateRule",
                "parameters": [
                    {
                        "full": "engineName",
                        "name": "engineName"
                    },
                    {
                        "full": "key",
                        "name": "key"
                    },
                    {
                        "full": "rules",
                        "name": "rules"
                    },
                    {
                        "full": "[add=false]",
                        "name": "add",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [updateRule](https://docs.dolphindb.cn/zh/funcs/u/updateRule.html)\n\n#### 语法\n\nupdateRule(engineName, key, rules, \\[add=false])\n\n#### 详情\n\n更新规则引擎的规则集：\n\n* 如果该规则引擎中不存在这个规则 *key*，则向其增加此规则 *key* 及其 *rules*。\n\n* 如果该规则引擎中已存在指定的规则 *key*，\n\n  * 若 *add* 为 false，则修改其 value 为输入参数 *rules*。\n\n  * 若 *add* 为 true，则向其 value 中追加 *rules*。\n\n#### 参数\n\n**engineName** 是一个字符串，表示引擎名。\n\n**key** 是 STRING 或 INT 类型的标量，表示要更新的规则对应的 key 。\n\n**rules** 是一个元代码元组，表示要更新的规则对应的 value。\n\n**add** 是一个布尔标量，表示新规则是追加到已有规则中，还是覆盖已有规则。默认值为 false，表示覆盖。\n\n#### 返回值\n\n如果执行成功，返回 true，否则返回 false。\n\n#### 例子\n\n```\n// 设置规则集，并创建规则引擎\nx = [1, 2, NULL]\ny = [ [ < value>1 > ], [ < price<2 >, < price>6 > ], [ < value*price>10 > ] ]\nruleSets = dict(x, y)\nnames = `sym`value`price`quantity\ntypes = [INT, DOUBLE, DOUBLE, DOUBLE]\ndummy = table(10:0, names, types)\noutputNames = `sym`value`price`rule\noutputTypes = [INT, DOUBLE, DOUBLE, BOOL[]]\noutputTable = table(10:0, outputNames, outputTypes)\ntest = createRuleEngine(name=\"ruleEngineTest\", ruleSets=ruleSets, dummyTable=dummy, outputColumns=[\"sym\",\"value\",\"price\"], outputTable=outputTable, policy=\"all\", ruleSetColumn=\"sym\")\n\n// 修改规则前\ntest.append!(table(1 as sym, 0 as value, 2 as price, 3 as quantity))\ntest.append!(table(3 as sym, 6 as value, 1 as price, 3 as quantity))\n\n// 将 sym=1 对应的规则修改为 value >=0\nupdateRule(\"ruleEngineTest\", 1, [ <value >= 0>])\ntest.append!(table(1 as sym, 0 as value, 2 as price, 3 as quantity))\n\n// 增加 sym=3 对应的规则为 value > 5\nupdateRule(\"ruleEngineTest\",3,[<value>5>])\ntest.append!(table(3 as sym, 6 as value, 1 as price, 3 as quantity))\n\n```\n\n此时的输出表 outputTable 内容如下\n\n| sym | value | price |   rule   |\n| :-: | :---: | :---: | :------: |\n|  1  |   0   |   2   | \\[false] |\n|  3  |   6   |   1   | \\[false] |\n|  1  |   0   |   2   |  \\[true] |\n|  3  |   6   |   1   |  \\[true] |\n\n```\n// 创建规则引擎\nx = [1, 2, NULL]\ny = [ [ < value>1 > ], [ < price<2 >, < price>6 > ], [ < value*price>10 > ] ]\nruleSets = dict(x, y)\nnames = `sym`value`price`quatity\ntypes = [INT, DOUBLE, DOUBLE, DOUBLE]\ndummy = table(10:0, names, types)\noutputNames = `sym`value`price`rule\noutputTypes = [INT, DOUBLE, DOUBLE, BOOL[]]\noutputTable = table(10:0, outputNames, outputTypes)\ntest = createRuleEngine(\"ruleEngineTest\",ruleSets,dummy ,`sym`value`price, outputTable,  \"all\",`sym)\n\ntest.append!(table(1 as sym, 0 as value, 2 as price, 3 as quatity))\ntest.append!(table(3 as sym, 6 as value, 1 as price, 3 as quatity))\n/* outputTable:\n1\t0\t2\t[false]\n3\t6\t1\t[false]\n*/\n\n// 把 sym=1 的规则修改为 value>=0\nupdateRule(\"ruleEngineTest\", 1, [ <value >= 0>])\ntest.append!(table(1 as sym, 0 as value, 2 as price, 3 as quatity))\n/* outputTable:\n1\t0\t2\t[true]\n*/\n\n// 增加 sym=3 对应的规则为 value > 5\nupdateRule(\"ruleEngineTest\",3,[<value>5>])\ntest.append!(table(3 as sym, 6 as value, 1 as price, 3 as quatity))\n/* outputTable:\n3\t6\t1\t[true]\n*/\n\n// 向 sym=1 对应的规则集中追加 value < 5\nupdateRule(engineName=\"ruleEngineTest\", key=1, rules=[<value<5>], add=true)\ntest.append!(table(1 as sym, 12 as value, 1 as price, 3 as quatity))\n/* outputTable:\n1   12    1     [1,0]\n*/\n```\n\n\n\n**Related information**\n\n[createRuleEngine](https://docs.dolphindb.cn/zh/funcs/c/createRuleEngine.html)\n\n[deleteRule](https://docs.dolphindb.cn/zh/funcs/d/deleteRule.html)\n"
    },
    "update!": {
        "url": "https://docs.dolphindb.cn/zh/funcs/u/update_.html",
        "signatures": [
            {
                "full": "update!(table, colNames, newValues, [filter])",
                "name": "update!",
                "parameters": [
                    {
                        "full": "table",
                        "name": "table"
                    },
                    {
                        "full": "colNames",
                        "name": "colNames"
                    },
                    {
                        "full": "newValues",
                        "name": "newValues"
                    },
                    {
                        "full": "[filter]",
                        "name": "filter",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [update!](https://docs.dolphindb.cn/zh/funcs/u/update_.html)\n\n\n\n#### 语法\n\nupdate!(table, colNames, newValues, \\[filter])\n\n#### 详情\n\n就地更新表中的列。如果 *colNames* 中的某列不存在，将会创建新列。如果指定了过滤条件，只有符合过滤条件的记录行会被更新。\n\n如果 *table* 是分区表并且启用了并行处理功能（即配置参数 *localExcutors* > 0），那么该操作是并行操作。\n\n#### 参数\n\n**table** 是 DolphinDB 中 Table 类型的表。它可以是分区的内存表。\n\n**colNames** 是一个字符串标量/向量，表示要更新的列。\n\n**newValues** 是对指定列的操作的元代码。元代码是对象或表达式，它们包含在<>中。详情请参考元编程。\n\n**filter** 是表示过滤条件的元代码。\n\n#### 例子\n\n```\nn=20000000\nworkDir = \"C:/DolphinDB/Data\"\nif(!exists(workDir)) mkdir(workDir)\ntrades=table(rand(`IBM`MSFT`GM`C`YHOO`GOOG,n) as sym, 2000.01.01+rand(365,n) as date, 10.0+rand(2.0,n) as price, rand(1000,n) as qty)\ntrades.saveText(workDir + \"/trades.txt\");\n\ntrades = ploadText(workDir + \"/trades.txt\")\nselect top 10 * from trades;\n```\n\n| sym  | date       | price     | qty |\n| ---- | ---------- | --------- | --- |\n| MSFT | 2000.10.09 | 10.123936 | 569 |\n| IBM  | 2000.09.22 | 10.825785 | 834 |\n| MSFT | 2000.09.13 | 10.467937 | 418 |\n| IBM  | 2000.08.06 | 10.159152 | 252 |\n| IBM  | 2000.09.01 | 10.614444 | 400 |\n| MSFT | 2000.05.03 | 10.40847  | 253 |\n| MSFT | 2000.02.20 | 11.470027 | 431 |\n| YHOO | 2000.11.09 | 11.570013 | 518 |\n| GOOG | 2000.03.02 | 10.206973 | 630 |\n| C    | 2000.07.09 | 10.477621 | 287 |\n\n```\ntrades.update!(`qty, <qty+10>)\nselect top 10 * from trades;\n```\n\n| sym  | date       | price     | qty |\n| ---- | ---------- | --------- | --- |\n| MSFT | 2000.10.09 | 10.123936 | 579 |\n| IBM  | 2000.09.22 | 10.825785 | 844 |\n| MSFT | 2000.09.13 | 10.467937 | 428 |\n| IBM  | 2000.08.06 | 10.159152 | 262 |\n| IBM  | 2000.09.01 | 10.614444 | 410 |\n| MSFT | 2000.05.03 | 10.40847  | 263 |\n| MSFT | 2000.02.20 | 11.470027 | 441 |\n| YHOO | 2000.11.09 | 11.570013 | 528 |\n| GOOG | 2000.03.02 | 10.206973 | 640 |\n| C    | 2000.07.09 | 10.477621 | 297 |\n\n```\ntrades.update!(`qty`price, <[qty*2, price/2]>)\nselect top 10 * from trades;\n```\n\n| sym  | date       | price    | qty  |\n| ---- | ---------- | -------- | ---- |\n| MSFT | 2000.10.09 | 5.061968 | 1158 |\n| IBM  | 2000.09.22 | 5.412893 | 1688 |\n| MSFT | 2000.09.13 | 5.233969 | 856  |\n| IBM  | 2000.08.06 | 5.079576 | 524  |\n| IBM  | 2000.09.01 | 5.307222 | 820  |\n| MSFT | 2000.05.03 | 5.204235 | 526  |\n| MSFT | 2000.02.20 | 5.735014 | 882  |\n| YHOO | 2000.11.09 | 5.785007 | 1056 |\n| GOOG | 2000.03.02 | 5.103487 | 1280 |\n| C    | 2000.07.09 | 5.238811 | 594  |\n\n```\ntrades.update!(`qty`price, <[qty*2, price/2]>, <(sym in `IBM`MSFT`GM`GOOG) and date>=2000.07.01>)\nselect top 10 * from trades;\n```\n\n| sym  | date       | price    | qty  |\n| ---- | ---------- | -------- | ---- |\n| MSFT | 2000.10.09 | 2.530984 | 2316 |\n| IBM  | 2000.09.22 | 2.706446 | 3376 |\n| MSFT | 2000.09.13 | 2.616984 | 1712 |\n| IBM  | 2000.08.06 | 2.539788 | 1048 |\n| IBM  | 2000.09.01 | 2.653611 | 1640 |\n| MSFT | 2000.05.03 | 5.204235 | 526  |\n| MSFT | 2000.02.20 | 5.735014 | 882  |\n| YHOO | 2000.11.09 | 5.785007 | 1056 |\n| GOOG | 2000.03.02 | 5.103487 | 1280 |\n| C    | 2000.07.09 | 5.238811 | 594  |\n"
    },
    "updateStreamGraphUserTickets": {
        "url": "https://docs.dolphindb.cn/zh/funcs/u/update_stream_graph_user_tickets.html",
        "signatures": [
            {
                "full": "updateStreamGraphUserTickets()",
                "name": "updateStreamGraphUserTickets",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [updateStreamGraphUserTickets](https://docs.dolphindb.cn/zh/funcs/u/update_stream_graph_user_tickets.html)\n\n\n\n#### 语法\n\nupdateStreamGraphUserTickets()\n\n#### 详情\n\n在 ORCA 中使用 UDF Engine 时，系统会自动保存创建流图用户的认证信息，以确保 UDF Engine 中自定义函数的访问权限与该用户的权限一致。当认证信息失效时，可调用此函数更新认证状态。\n\n#### 参数\n\n无。\n\n#### 返回值\n\n无。\n"
    },
    "upper": {
        "url": "https://docs.dolphindb.cn/zh/funcs/u/upper.html",
        "signatures": [
            {
                "full": "upper(X)",
                "name": "upper",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [upper](https://docs.dolphindb.cn/zh/funcs/u/upper.html)\n\n\n\n#### 语法\n\nupper(X)\n\n#### 详情\n\n`upper` 函数把字符串或字符串列表中的所有字符转换为大写。\n\n#### 参数\n\n**X** 是一个字符串标量或向量。\n\n#### 返回值\n\n字符串标量或向量。\n\n#### 例子\n\n```\nx = `Ibm`C`AapL;\nx.upper();\n// output: [\"IBM\",\"C\",\"AAPL\"]\n\n(`Thl).upper();\n// output: THL\n```\n\n相关函数： [lower](https://docs.dolphindb.cn/zh/funcs/l/lower.html)\n"
    },
    "upsert!": {
        "url": "https://docs.dolphindb.cn/zh/funcs/u/upsert_.html",
        "signatures": [
            {
                "full": "upsert!(obj, newData, [ignoreNull=false], [keyColNames], [sortColumns])",
                "name": "upsert!",
                "parameters": [
                    {
                        "full": "obj",
                        "name": "obj"
                    },
                    {
                        "full": "newData",
                        "name": "newData"
                    },
                    {
                        "full": "[ignoreNull=false]",
                        "name": "ignoreNull",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[keyColNames]",
                        "name": "keyColNames",
                        "optional": true
                    },
                    {
                        "full": "[sortColumns]",
                        "name": "sortColumns",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [upsert!](https://docs.dolphindb.cn/zh/funcs/u/upsert_.html)\n\n\n\n#### 语法\n\nupsert!(obj, newData, \\[ignoreNull=false], \\[keyColNames], \\[sortColumns])\n\n#### 详情\n\n将新数据写入索引内存表、键值内存表，或者 DFS 表。若新数据的主键值已存在，更新该主键值的数据；否则添加数据。\n\n**Note:**\n\n* 调用该函数时，需要保证 *newData* 和 *obj* 两表各列的顺序一致，否则可能产生错误结果或报错。\n\n* 若 *keyColNames* 指定的列存在重复值，对重复值进行 `upsert!` 操作，仅会更新第一个值所在行，其余值所在行不会更新。\n\n* 函数行为会受到配置参数 *enableNullSafeJoin* 的影响：\n\n  * 当 *enableNullSafeJoin*=true 时，连接列中的 NULL 值可以匹配成功，upsert! 可能会更新包含 NULL 的记录；\n\n  * 当 *enableNullSafeJoin*=false 时，连接列中的 NULL 值无法匹配，upsert! 不会更新此类记录。\n\n#### 参数\n\n**obj** 是一个索引内存表、键值内存表，或者 DFS 表（分布式表或维度表）。\n\n**newData** 是一个内存表，且与 *obj* 的结构一样。\n\n**ignoreNull** 是一个布尔值，表示若 *newData* 中某元素为 NULL 值，是否忽略对目标表中的相应数据进行更新。默认值为 false。\n\n**keyColNames** 是一个字符串标量或向量。由于 DFS 表没有键值列，对 DFS 表进行更新时，将该参数指定的列和分区列一起视为键值列。\n\n**sortColumns** 是一个字符串标量或向量。设置该参数，更新的分区内的所有数据会根据指定的列进行排序。排序在每个分区内部进行，不会跨分区排序。\n\n**Note:**\n\n* 仅 OLAP 引擎下使用 `upsert!` 时，才支持设置 *sortColumns*。\n* 要设置 *sortColumns*， *obj* 必须为分布式表。\n* 仅对同一个分区内的数据 按照 *sortColumns* 进行排序，不同分区之间的数据不会进行排序。\n* *obj* 为一个空表时，设置 *sortColumns* 无效，即更新后不对新插入的数据进行排序。\n* 在 PKEY 引擎下不支持设置 *ignoreNull*, *keyColNames*, *sortColumns*。\n\n#### 返回值\n\n一个表。\n\n#### 例子\n\n对键值内存表使用 `upsert!`\n\n```\nsym=`A`B`C\ndate=take(2021.01.06, 3)\nx=1 2 3\ny=5 6 7\nt=keyedTable(`sym`date, sym, date, x, y)\nt;\n```\n\n| sym | date       | x | y |\n| --- | ---------- | - | - |\n| A   | 2021.01.06 | 1 | 5 |\n| B   | 2021.01.06 | 2 | 6 |\n| C   | 2021.01.06 | 3 | 7 |\n\n如果对应列的数据类型一致，就会输出结果。\n\n```\nnewData = table(`A`B`C`D as sym1, take(2021.01.06, 4) as date1, NULL NULL 300 400 as x1, NULL 600 700 800 as y1);\nnewData;\n```\n\n| sym | date       | x1  | y1  |\n| --- | ---------- | --- | --- |\n| A   | 2021.01.06 |     |     |\n| B   | 2021.01.06 |     | 600 |\n| C   | 2021.01.06 | 300 | 700 |\n| D   | 2021.01.06 | 400 | 800 |\n\n```\nupsert!(t, newData, ignoreNull=true)\nt;\n```\n\n| sym | date       | x   | y   |\n| --- | ---------- | --- | --- |\n| A   | 2021.01.06 | 1   | 5   |\n| B   | 2021.01.06 | 2   | 600 |\n| C   | 2021.01.06 | 300 | 700 |\n| D   | 2021.01.06 | 400 | 800 |\n\n以上为将 *ignoreNull* 设为 true 时的情况。此时，若新数据中有元素值为 NULL，不对目标数据表的相应的元素进行更新操作。\n\n以下为将 *ignoreNull* 设为 false（默认值）时的情况，不管新数据中值是否为 NULL，均进行更新操作。\n\n```\nsym=`A`B`C\ndate=take(2021.01.06, 3)\nx=1 2 3\ny=5 6 7\nt=keyedTable(`sym`date, sym, date, x, y)\nupsert!(t, newData)\nt;\n```\n\n| sym | date       | x   | y   |\n| --- | ---------- | --- | --- |\n| A   | 2021.01.06 |     |     |\n| B   | 2021.01.06 |     | 600 |\n| C   | 2021.01.06 | 300 | 700 |\n| D   | 2021.01.06 | 400 | 800 |\n\n对 DFS 表使用 `upsert!`：\n\n```\nID=0 1 2 2\nx=0.1*0..3\nt=table(ID, x)\ndb=database(\"dfs://rangedb128\", VALUE,  0..10)\npt=db.createPartitionedTable(t, `pt, `ID)\npt.append!(t)\nselect * from pt;\n```\n\n| ID | x   |\n| -- | --- |\n| 0  | 0   |\n| 1  | 0.1 |\n| 2  | 0.2 |\n| 2  | 0.3 |\n\n```\nt1=table(1 as ID, 111 as x)\nupsert!(pt, t1, keyColNames=`ID)\nselect * from pt;\n```\n\n| ID | x   |\n| -- | --- |\n| 0  | 0   |\n| 1  | 111 |\n| 2  | 0.2 |\n| 2  | 0.3 |\n\n```\nt1=table(2 as ID, 222 as x)\nupsert!(pt, t1, keyColNames=`ID)\nselect * from pt;\n```\n\n| ID | x   |\n| -- | --- |\n| 0  | 0   |\n| 1  | 111 |\n| 2  | 222 |\n| 2  | 0.3 |\n\n对 DFS 表使用 `upsert!` 更新数据，设置 *ignoreNull* = true，当新数据中有数据值为 NULL, 则不对目标数据表的相应的元素进行更新操作。\n\n```\nif(existsDatabase(\"dfs://valuedemo\")) {\n  dropDatabase(\"dfs://valuedemo\")\n}\ndb = database(\"dfs://valuedemo\", VALUE, 1..10)\nt = table(take(1..10, 100) as id, 1..100 as id2, 100..1 as value)\npt = db.createPartitionedTable(t, \"pt\", `id).append!(t)\nt2 = table( 1 2 as id, 1 2 as id2, 1 NULL as value)\nupsert!(pt, t2, true, \"id2\")\n```\n\n```\nif(existsDatabase(\"dfs://upsert\")) {\n  dropDatabase(\"dfs://upsert\")\n}\nsym=`A`B`C`A`D`B`A\ndate=take(2021.12.10,3) join take(2021.12.09, 3) join 2021.12.10\nprice=8.3 7.2 3.7 4.5 6.3 8.4 7.6\nval=10 19 13 9 19 16 10\nt=table(sym, date, price, val)\ndb=database(\"dfs://upsert\", VALUE,  `A`B`C)\npt=db.createPartitionedTable(t, `pt, `sym)\npt.append!(t)\nt1=table(`A`B`E as sym, take(2021.12.09, 3) as date, 11.1 10.5 6.9 as price, 12 9 11 as val)\nupsert!(pt, t1, keyColNames=`sym, sortColumns=`date`val)\nselect * from pt\n```\n\n| sym | date       | price | val |\n| --- | ---------- | ----- | --- |\n| A   | 2021.12.09 | 4.5   | 9   |\n| A   | 2021.12.09 | 11.1  | 12  |\n| A   | 2021.12.10 | 7.6   | 10  |\n| B   | 2021.12.09 | 10.5  | 9   |\n| B   | 2021.12.09 | 8.4   | 16  |\n| C   | 2021.12.10 | 3.7   | 13  |\n| D   | 2021.12.09 | 6.3   | 19  |\n| E   | 2021.12.09 | 6.9   | 11  |\n"
    },
    "useOrcaStreamEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/u/useOrcaStreamEngine.html",
        "signatures": [
            {
                "full": "useOrcaStreamEngine(name, func, args...)",
                "name": "useOrcaStreamEngine",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "args...",
                        "name": "args..."
                    }
                ]
            }
        ],
        "markdown": "### [useOrcaStreamEngine](https://docs.dolphindb.cn/zh/funcs/u/useOrcaStreamEngine.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nuseOrcaStreamEngine(name, func, args...)\n\n#### 详情\n\n该函数通过 orca 流引擎名称定位其所在节点，并在该节点获取流引擎对象。随后将该引擎作为首个参数传递给用户指定的函数 *func*并执行。\n\n该机制允许用户在本地代码中远程调用各种流引擎相关函数，无需手动管理节点和流表对象的绑定。\n\n#### 参数\n\n**name** 表示引擎名称。字符串标量，可以传入完整的全限定名（如 \"catalog\\_name.orca\\_engine.engine\\_name\"）；或引擎名（如 \"engine\\_name\"），系统会根据当前的 catalog 设置自动补全为对应的全限定名。\n\n**func**在流表所在节点上执行的函数。该函数必须至少包含一个参数，系统会将流引擎对象自动作为第一个参数传入。\n\n**args…** 传递给 *func*的其他参数，使用方式类似于远程过程调用函数 [rpc](https://docs.dolphindb.cn/zh/funcs/r/rpc.html) 的 *args…* 参数。\n\n#### 返回值\n\n返回值为用户指定的函数 *func* 的执行结果。\n\n#### 例子\n\n通过 `getStreamEngineStateTable`函数查看 orca 响应式状态引擎 test.orca\\_engine.rse 的状态：\n\n```\nif (!existsCatalog(\"test\")) {\n\tcreateCatalog(\"test\")\n}\ngo;\nuse catalog test\n\nt = table(1..100 as id, 1..100 as value, take(09:29:00.000..13:00:00.000, 100) as timestamp)\ng = createStreamGraph(\"factor\")\nbaseStream = g.source(\"snapshot\",  schema(t).colDefs.name, schema(t).colDefs.typeString)\n  .reactiveStateEngine([<ema(value, 100)>, <timestamp>])\n  .setEngineName(\"rse\")\n  .buffer(\"end\")\n  \ng.submit()\nuseOrcaStreamEngine(\"test.orca_engine.rse\", getStreamEngineStateTable)\n\n /*\n value ema(value, 100) timestamp\n----- --------------- ---------\n*/\n```\n\n**相关函数：**[getOrcaStreamEngineMeta](https://docs.dolphindb.cn/zh/funcs/g/getOrcaStreamEngineMeta.html)\n"
    },
    "useOrcaStreamTable": {
        "url": "https://docs.dolphindb.cn/zh/funcs/u/useOrcaStreamTable.html",
        "signatures": [
            {
                "full": "useOrcaStreamTable(name, func, args...)",
                "name": "useOrcaStreamTable",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "func",
                        "name": "func"
                    },
                    {
                        "full": "args...",
                        "name": "args..."
                    }
                ]
            }
        ],
        "markdown": "### [useOrcaStreamTable](https://docs.dolphindb.cn/zh/funcs/u/useOrcaStreamTable.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nuseOrcaStreamTable(name, func, args...)\n\n#### 详情\n\n该函数通过 orca 流表名称定位其所在节点，并在该节点获取流表对象。随后将该流表作为首个参数传递给用户指定的函数 *func*并执行。\n\n该机制允许用户在本地代码中远程调用与操作流表相关的函数（如 `replay`、`getStreamTableFilterColumn` 等），无需手动管理节点和流表对象的绑定。\n\n#### 参数\n\n**name** 表示流表的名称。字符串标量，可以传入完整的流表全限定名（如 \"trading.orca\\_table.trades\"）；也可以仅提供流表名（如 \"trades\"），系统会根据当前的 catalog 设置自动补全为对应的全限定名。\n\n**func**在流表所在节点上执行的函数，可以是内置函数或自定义函数。该函数必须至少包含一个参数，系统会将流表对象自动作为第一个参数传入。\n\n**args…** 传递给 *func*的其他参数，使用方式类似于远程过程调用函数 [rpc](https://docs.dolphindb.cn/zh/funcs/r/rpc.html) 的 *args…* 参数。\n\n#### 返回值\n\n返回值是用户指定的函数 *func* 的执行结果。\n\n#### 例子\n\n通过 `getStreamTableFilterColumn` 函数查看 `demo.orca_table.transaction` 流表的过滤列：\n\n```\nuseOrcaStreamTable(\"demo.orca_table.transaction\", getStreamTableFilterColumn)\n```\n"
    },
    "uuid": {
        "url": "https://docs.dolphindb.cn/zh/funcs/u/uuid.html",
        "signatures": [
            {
                "full": "uuid(X)",
                "name": "uuid",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [uuid](https://docs.dolphindb.cn/zh/funcs/u/uuid.html)\n\n\n\n#### 语法\n\nuuid(X)\n\n#### 详情\n\n把字符串转换成 UUID 类型。通过 rand(uuid(), n) 可以随机生成 n 个 UUID 类型的数据。\n\n#### 参数\n\n**X** 是一个字符串标量或向量。\n\n#### 返回值\n\nUUID 类型标量或向量。\n\n#### 例子\n\n```\nuuid(\"\");\n```\n\n返回：00000000-0000-0000-0000-000000000000\n\n```\na=uuid(\"9d457e79-1bed-d6c2-3612-b0d31c1881f6\");\na;\n```\n\n返回：9d457e79-1bed-d6c2-3612-b0d31c1881f6\n\n```\ntypestr(a);\n```\n\n返回：UUID\n"
    },
    "valueChanged": {
        "url": "https://docs.dolphindb.cn/zh/funcs/v/valueChanged.html",
        "signatures": [
            {
                "full": "valueChanged(X, [mode=\"prev\"])",
                "name": "valueChanged",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[mode=\"prev\"]",
                        "name": "mode",
                        "optional": true,
                        "default": "\"prev\""
                    }
                ]
            }
        ],
        "markdown": "### [valueChanged](https://docs.dolphindb.cn/zh/funcs/v/valueChanged.html)\n\n\n\n#### 语法\n\nvalueChanged(X, \\[mode=\"prev\"])\n\n#### 详情\n\n*X* 中每个元素较 *mode* 是否发生变化，若当前元素值发生变化，则返回 true，否则返回 false。若比较对象不存在，则返回 false。例如：valueChanged(X, \\[mode=\"prev\"]) 的第一个元素返回 false；valueChanged(X, \\[mode=\"next\"]) 的最后一个元素返回 false。\n\n若 *X* 为矩阵/表，在每列内进行上述操作，返回一个矩阵/表。\n\n#### 参数\n\n**X** 字符串、布尔、时间或数值类型的向量/矩阵/表/元组。\n\n**mode** 字符串，可选值为：\"prev\", \"next\", \"either\" 和 \"both\"，默认值为 \"prev\"。\n\n* \"prev\"：前一个元素。\n\n* \"next\"：后一个元素。\n\n* \"either\"：前一个元素或后一个元素。\n\n* \"both\"：前一个元素和后一个元素值。\n\n#### 返回值\n\n布尔类型，数据形式同 *X*。\n\n#### 例子\n\n```\nx= 1 2 2 2 2 3 NULL 3 4 8\nvalueChanged(x)\n// output\n[false,true,false,false,false,true,true,true,true,true]\n\nvalueChanged(x,\"next\")\n// output\n[true,false,false,false,true,true,true,true,true,false]\n\nvalueChanged(x,\"either\")\n// output\n[true,true,false,false,true,true,true,true,true,true]\n\nvalueChanged(x,\"both\")\n// output\n[false,false,false,false,false,true,true,true,true,false]\n\ntup=(1 2 3, `A`A`B, 2021.10.12+1 2 2)\nvalueChanged(tup)\n// output\n([false,true,true],[false,false,true],[false,true,false])\n\nm=matrix(1 2 3, 1 2 3, 1 3 3)\nvalueChanged(m)\n```\n\n| col1  | col2  | col3  |\n| ----- | ----- | ----- |\n| false | false | false |\n| true  | true  | true  |\n| true  | true  | false |\n\n```\nid= 1 2 2 2 2 3 3 4 8\nsym=`A + string(1 2 2 2 2 3 3 4 8)\nval=83.8 92.8 8.1 61.4 40.7 67.2 15.2 20.6 96.5\nt=table(id, sym, val)\nvalueChanged(t)\n```\n\n| id    | sym   | val   |\n| ----- | ----- | ----- |\n| false | false | false |\n| true  | true  | true  |\n| false | false | true  |\n| false | false | true  |\n| false | false | true  |\n| true  | true  | true  |\n| false | false | true  |\n| true  | true  | true  |\n| true  | true  | true  |\n\n相关函数：[keys](https://docs.dolphindb.cn/zh/funcs/k/keys.html)\n"
    },
    "values": {
        "url": "https://docs.dolphindb.cn/zh/funcs/v/values.html",
        "signatures": [
            {
                "full": "values(X)",
                "name": "values",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [values](https://docs.dolphindb.cn/zh/funcs/v/values.html)\n\n\n\n#### 语法\n\nvalues(X)\n\n#### 详情\n\n返回字典 *X* 中的所有值，或者以元组形式返回表 *X* 中的所有列。\n\n#### 参数\n\n**X** 是一个字典或表。\n\n#### 返回值\n\n向量或元组，数据类型取决于字典的值或表的所有列。\n\n#### 例子\n\n```\nz=dict(INT,DOUBLE)\nz[5]=7.9\nz[3]=6\nz.values();\n// output\n[6,7.9]\n\nt = table(1 2 3 as id, 4 5 6 as x, `IBM`MSFT`GOOG as name);\nvalues(t);\n// output\n([1,2,3],[4,5,6],[\"IBM\",\"MSFT\",\"GOOG\"])\n```\n\n相关函数：[keys](https://docs.dolphindb.cn/zh/funcs/k/keys.html)\n"
    },
    "vanillaOption": {
        "url": "https://docs.dolphindb.cn/zh/funcs/v/vanillaoption.html",
        "signatures": [
            {
                "full": "vanillaOption(settlement, maturity, evalDate, spot, strike, riskFree, divYield, volatility, isCall, style, basis, calendar, [method=\"BS\"], [kwargs], [mode=0])",
                "name": "vanillaOption",
                "parameters": [
                    {
                        "full": "settlement",
                        "name": "settlement"
                    },
                    {
                        "full": "maturity",
                        "name": "maturity"
                    },
                    {
                        "full": "evalDate",
                        "name": "evalDate"
                    },
                    {
                        "full": "spot",
                        "name": "spot"
                    },
                    {
                        "full": "strike",
                        "name": "strike"
                    },
                    {
                        "full": "riskFree",
                        "name": "riskFree"
                    },
                    {
                        "full": "divYield",
                        "name": "divYield"
                    },
                    {
                        "full": "volatility",
                        "name": "volatility"
                    },
                    {
                        "full": "isCall",
                        "name": "isCall"
                    },
                    {
                        "full": "style",
                        "name": "style"
                    },
                    {
                        "full": "basis",
                        "name": "basis"
                    },
                    {
                        "full": "calendar",
                        "name": "calendar"
                    },
                    {
                        "full": "[method=\"BS\"]",
                        "name": "method",
                        "optional": true,
                        "default": "\"BS\""
                    },
                    {
                        "full": "[kwargs]",
                        "name": "kwargs",
                        "optional": true
                    },
                    {
                        "full": "[mode=0]",
                        "name": "mode",
                        "optional": true,
                        "default": "0"
                    }
                ]
            }
        ],
        "markdown": "### [vanillaOption](https://docs.dolphindb.cn/zh/funcs/v/vanillaoption.html)\n\n\n\n#### 语法\n\nvanillaOption(settlement, maturity, evalDate, spot, strike, riskFree, divYield, volatility, isCall, style, basis, calendar, \\[method=\"BS\"], \\[kwargs], \\[mode=0])\n\n#### 详情\n\n对香草期权（Vanilla Option）进行估值计算。\n\n#### 参数\n\n**settlement** DATE 类型标量或向量，表示期权交易日。\n\n**maturity** DATE 类型标量或向量，表示期权到期日。\n\n**evalDate** DATE 类型标量或向量，表示估值日。\n\n**spot** 数值标量或向量，表示标的资产的当前价格。\n\n**strike** 数值标量或向量，表示标的资产的行权价格。\n\n**riskFree** 数值标量或向量，表示无风险利率。\n\n**divYield** 数值标量或向量，表示分红利率。\n\n**volatility** 数值标量或向量，表示波动率。\n\n**isCall** BOOL 标量或向量，表示是看涨期权还是看跌期权：\n\n* true：表示看涨期权（call option）。\n\n* false：表示看跌期权（put option）。\n\n**style** 字符串标量或向量，表示可行权时间的类型，有两个可选值：\n\n* ‘european’：表示欧式期权。\n\n* ‘american’：表示美式期权。\n\n**basis** 整型或 STRING 类型的标量或向量，表示要使用的日计数基准类型。可选值为：\n\n| Basis                    | 日计数基准            |\n| ------------------------ | ---------------- |\n| 0 / \"Thirty360US\"        | US (NASD) 30/360 |\n| 1 / \"ActualActual\" (默认值) | 实际/实际            |\n| 2 / \"Actual360\"          | 实际/360           |\n| 3 / \"Actual365\"          | 实际/365           |\n| 4 / \"Thirty360EU\"        | 欧洲 30/360        |\n\n**calendar** 字符串类型标量或向量，表示使用的市场日历类型，请参阅[交易日历](https://docs.dolphindb.cn/zh/modules/MarketHoliday/mkt_calendar.md#)。\n\n**method** 可选参数，字符串标量，表示使用的期权估值方法，可选值有：\n\n* ‘BS’：表示 Black-Scholes 方法，默认值，只能用于欧式期权估值。\n\n* 'FDBS'：表示结合有限差分法（Finite Difference Method, FDM）和 Black-Scholes 方法的数值求解方法。\n\n* 'heston'：表示 Heston 模型方法，只能用于欧式期权估值。\n\n* 'FDHeston'：表示结合有限差分法（Finite Difference Method, FDM）和 Heston 模型方法的数值求解方法。\n\n* 'PTDHeston'：表示分段时间依赖的 Heston 模型方法。分段时间依赖：Piecewise Time Dependent，PTD。该方法只能用于欧式期权估值。\n\n**kwargs** 可选参数，字典标量，表示期权估值的其他参数，不同的估值方法有不同的参数要求。当 method = 'BS'时无需填写该参数，其他方法的具体参数要求如下：\n\n* method = 'FDBS'，kwargs应包含以下成员：\n\n  * 'xGrid'：整数标量或向量，表示有限差分法在进行离散化时使用的空间网格数；xGrid 应大于 1。\n\n  * 'tGrid'：整数标量或向量，表示有限差分法在进行离散化时使用的时间网格数。tGrid 应大于 0。\n\n  * 'dampingSteps'：整数标量或向量，表示有限差分求解过程中应用的阻尼步骤数。dampingSteps 应大于等于 0。\n\n* method = 'heston'，kwargs应包含以下成员：\n\n  * 'theta'：数值标量或向量，表示波动率平方的长期均值。\n\n  * 'kappa'：数值标量或向量，表示波动率平方的均值回归速度。\n\n  * 'rho'：数值标量或向量，表示资产价格和波动率的相关系数。\n\n  * 'sigma'：数值标量或向量，表示波动率的波动率。\n\n* method = 'FDHeston'，kwargs 应包含以下成员：\n\n  * 'theta'：数值标量或向量，表示波动率平方的长期均值。\n\n  * 'kappa'：数值标量或向量，表示波动率平方的均值回归速度。\n\n  * 'rho'：数值标量或向量，表示资产价格和波动率的相关系数。\n\n  * 'sigma'：数值标量或向量，表示波动率的波动率。\n\n  * 'xGrid'：整数标量或向量，表示有限差分法在进行离散化时使用的空间网格数；xGrid 应大于 1。\n\n  * 'vGrid'：整数标量或向量，表示有限差分法在进行离散化时使用的波动率网格数；vGrid 应大于 1。\n\n  * 'tGrid'：整数标量或向量，表示有限差分法在进行离散化时使用的时间网格数；tGrid 应大于等于 0。\n\n  * 'dampingSteps'：整数标量或向量，表示有限差分求解过程中应用的阻尼步骤数。dampingSteps 应大于等于 0。\n\n* method = 'PTDHeston'，kwargs 应包含以下成员：\n\n  * 'times'：数值向量或数组向量，表示条件发生变化的时间点。\n\n  * 'theta'：数值向量或数组向量，表示各时间点对应的波动率平方的长期均值。\n\n  * 'kappa'：数值向量或数组向量，表示各时间点对应的波动率平方的均值回归速度。\n\n  * 'rho'：数值向量或数组向量，表示各时间点对应的资产价格和波动率的相关系数。\n\n  * 'sigma'：数值向量或数组向量，表示各时间点对应的波动率的波动率。\n\n  * 注意：所有成员长度应保持一致。\n\n**mode** 选参数，整型标量或向量，表示输出的模式，可选值为：\n\n* 0：只输出期权净现值（npv only），默认值。\n\n* 1：输出期权的净现值和希腊字母，用元组存储，每个元组中依次存放 npv, delta, gamma, theta, vega 和 rho。\n\n* 2：输出期权的净现值和希腊字母，用有序字典存储。\n\n注意：如果输入参数中，部分为标量，其余为向量时，则会将标量当作与向量长度相同，所有元素值等于该标量的向量。所有向量的长度必须一致。\n\n#### 返回值\n\n* 当 mode=0，返回一个浮点数标量或向量，表示期权的净现值。\n\n* 当 mode=1，返回一个浮点数tuple或浮点数tuple构成的向量，表示期权定价结果，包含期权的净现值和希腊字母，顺序是 npv, delta, gamma, theta, vega 和 rho。\n\n* 当 mode=2，返回一个字典标量，表示期权定价结果，包含期权的净现值和希腊字母。\n\n  * 'npv'：DOUBLE 类型标量或向量，表示期权的净现值。\n\n  * 'delta'：DOUBLE 类型标量或向量，希腊字母 Delta 衡量期权价格对标的资产价格小幅变化的敏感度。\n\n  * 'gamma'：DOUBLE 类型标量或向量，希腊字母 Gamma 衡量 Delta 随标的资产价格变化的速率。\n\n  * 'theta'：DOUBLE 类型标量或向量，希腊字母 Theta 衡量期权价格随时间流逝（时间衰减）的敏感度。\n\n  * 'vega'：DOUBLE 类型标量或向量，希腊字母 Vega 衡量期权价格对标的资产隐含波动率小幅变化的敏感度。\n\n  * 'rho'：DOUBLE 类型标量或向量，希腊字母 Rho 衡量期权价格对无风险利率小幅变化的敏感度。\n\n#### 例子\n\n**例1 使用 BS 方法进行估值**\n\n本例对 1998 年 5 月 17 日至 1999 年 5 月 17 日的期权交易，估值日在 1998 年 5 月 15 日；标的资产的当前价格为 36，行权价格为 40；无风险利率为 6%，无分红，波动率为 2%；可行权时间的类型为欧式看跌期权；使用实际/365 的日计数基准类型，中金所交易日历；使用 Black-Scholes 方法，输出期权的净现值和希腊字母的设定下，对其进行估值计算。\n\n```\nsettlement = 1998.05.17\nmaturity = 1999.05.17\nvalDay = 1998.05.15\nspot = 36\nstrike = 40\nriskFree = 0.06\ndividend = 0\nvolatility = 0.2\nisCall = false\nstyle = 'european'\nbasis = 3\ncalendar = 'CCFX'\n\nvanillaOption(settlement, maturity, valDay, spot, strike, riskFree, dividend, volatility, isCall, style, basis, calendar, mode=2)\n\n/* Output: \nnpv->[2.080759333948596,2.080759333948596]\ndelta->[-0.727790750119184,-0.727790750119184]\ngamma->[0.130419967911091,0.130419967911091]\ntheta->[1.274320988976569,1.274320988976569]\nvega->[11.951706726567239,11.951706726567239]\nrho->[-28.281226338239189,-28.281226338239189]\n*/\n```\n\n**例2 使用 PTDHeston 方法进行估值**\n\n本例对 1998 年 5 月 17 日至 1999 年 5 月 17 日的期权交易，估值日在 1998 年 5 月 15 日；标的资产的当前价格为 36，行权价格为 40；无风险利率为 6%，无分红，波动率为 2%；可行权时间的类型为欧式看跌期权；使用实际/365 的日计数基准类型，中金所、上交所交易日历；使用 PTDHeston 方法并传入相关参数，只输出期权净现值的设定下，对其进行估值计算。\n\n```\nsettlement = 1998.05.17\nmaturity = 1999.05.17\nvalDay = 1998.05.15\nspot = 36\nstrike = 40\nriskFree = 0.06\ndividend = 0\nisCall = false\ntimes = array(DOUBLE[], 0).append!( [1.0 2.0 3.0, 1.0 2.0 3.0])\nvolatility = 0.07071\nstyle = 'european'\nbasis = 3\ntheta = [0.010, 0.015, 0.02]\nkappa = [0.600, 0.500, 0.400]\nsigma = [0.400, 0.350, 0.300]\nrho = [-0.15, -0.10, -0.00]\ncalendar = 'CCFX' 'XSHG'\nkwargs = dict(STRING,ANY)\nkwargs[`times] = times\nkwargs[`theta] = theta\nkwargs[`kappa] = kappa\nkwargs[`sigma] = sigma\nkwargs[`rho] = rho\nmethod = 'PTDHeston'\nvanillaOption(settlement, maturity, valDay, spot, strike, riskFree, dividend, volatility, isCall, style, basis, calendar, method, kwargs)\n\n// Output: [1.99693345461036,1.99693345461036]\n```\n"
    },
    "var": {
        "url": "https://docs.dolphindb.cn/zh/funcs/v/var.html",
        "signatures": [
            {
                "full": "var(X)",
                "name": "var",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [var](https://docs.dolphindb.cn/zh/funcs/v/var.html)\n\n\n\n#### 语法\n\nvar(X)\n\n#### 详情\n\n若 *X* 为向量，返回 *X* 的方差(variance)。\n\n若 *X* 为矩阵，计算每列的方差，返回一个向量。\n\n若 *X* 为表，计算每列的方差，返回一个表。\n\n与所有其它聚合函数一致，计算时忽略 NULL 值。\n\n请注意，返回无偏样本方差（unbiased sample variance），而不是总体方差。\n\n无偏样本方差的公式如下：\n\n**Note:**\n\nDolphinDB `var` 与 [numpy.var](https://numpy.org/doc/stable/reference/generated/numpy.var.html) 都用于计算方差。区别如下：\n\n* DolphinDB `var` 返回无偏样本方差，而 `numpy.var` 默认返回总体方差；当需要得到与 DolphinDB `var` 一致的结果时，应指定 *ddof*=1。\n* DolphinDB `var` 会自动忽略 NULL 值，而 `numpy.var` 遇到 NaN 不会自动跳过，结果可能为 `NaN`。\n* 在计算维度上，DolphinDB `var` 对矩阵按列计算，而 `numpy.var` 默认对数组展平后整体计算，也可以通过 *axis* 参数指定维度。\n\n#### 参数\n\n**X** 可以是标量、向量、矩阵或表。\n\n#### 返回值\n\nDOUBLE 类型标量/向量/表。\n\n#### 例子\n\n```\nvar(1 1 1);\n// output\n0\nvar(1 2 3);\n// output\n1\n\nm=matrix(1 3 5 7 9, 1 4 7 10 13);\nm;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 1  |\n| 3  | 4  |\n| 5  | 7  |\n| 7  | 10 |\n| 9  | 13 |\n\n```\nvar(m);\n// output\n[10,22.5]\n```\n\n相关函数： [covar](https://docs.dolphindb.cn/zh/funcs/c/covar.html) 和 [corr](https://docs.dolphindb.cn/zh/funcs/c/corr.html)\n"
    },
    "varma": {
        "url": "https://docs.dolphindb.cn/zh/funcs/v/varma.html",
        "signatures": [
            {
                "full": "varma(ds,endogColNames,order,[exog],[trend='c'],[errorCovType='unstructured'],[measurementError=false],[enforceStationarity=true],[enforceInvertibility=true],[trendOffset=1], [maxIter=50])",
                "name": "varma",
                "parameters": [
                    {
                        "full": "ds",
                        "name": "ds"
                    },
                    {
                        "full": "endogColNames",
                        "name": "endogColNames"
                    },
                    {
                        "full": "order",
                        "name": "order"
                    },
                    {
                        "full": "[exog]",
                        "name": "exog",
                        "optional": true
                    },
                    {
                        "full": "[trend='c']",
                        "name": "trend",
                        "optional": true,
                        "default": "'c'"
                    },
                    {
                        "full": "[errorCovType='unstructured']",
                        "name": "errorCovType",
                        "optional": true,
                        "default": "'unstructured'"
                    },
                    {
                        "full": "[measurementError=false]",
                        "name": "measurementError",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[enforceStationarity=true]",
                        "name": "enforceStationarity",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[enforceInvertibility=true]",
                        "name": "enforceInvertibility",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[trendOffset=1]",
                        "name": "trendOffset",
                        "optional": true,
                        "default": "1"
                    },
                    {
                        "full": "[maxIter=50]",
                        "name": "maxIter",
                        "optional": true,
                        "default": "50"
                    }
                ]
            }
        ],
        "markdown": "### [varma](https://docs.dolphindb.cn/zh/funcs/v/varma.html)\n\n\n\n#### 语法\n\nvarma(ds,endogColNames,order,\\[exog],\\[trend='c'],\\[errorCovType='unstructured'],\\[measurementError=false],\\[enforceStationarity=true],\\[enforceInvertibility=true],\\[trendOffset=1], \\[maxIter=50])\n\n#### 详情\n\n使用向量自回归移动平均模型（Vector Autoregressive Moving-Average Model，简称 VARMA 模型）来分析多变量时间序列。返回一个字典，表示 VARMA 模型的分析结果，详细说明请参见“返回值”小节。\n\n#### 参数\n\n**ds** 内存表或数据源（DATASOURCE）向量，包含需要分析的多变量时间序列，不可为空。仅当分布式表数据源的第一列为时间列时，模型会自动根据时间列对数据排序。\n\n**endogColNames** 字符串向量，表示 *ds* 中需要分析的多变量时间序列所对应的列名。\n\n**order** 非负整数型向量，长度必须为 2，第一维表示自回归部分（AR）的阶数，第二维表示移动平均部分（MA）的阶数。\n\n**exog** 可选参数，数值矩阵，表示时间序列数据之外的外生变量。矩阵每一列表示一个外生变量的时间序列数据，矩阵行数为时间序列样本数，与 *ds* 的行数相等。\n\n**trend** 可选参数，字符串标量，表示在回归中使用的常数和趋势阶数。可取值：\n\n* \"c\" 表示只使用常量，默认值。\n\n* \"ct\" 表示使用常量和趋势。\n\n* \"ctt\" 表示使用常数，线性趋势和二次趋势。\n\n* \"n\" 表示不使用常量和趋势。\n\n**errorCovType** 可选参数，字符串标量，表示误差项的协方差矩阵的结构。可取值：\n\n* \"unstructured\" 表示会保存协方差矩阵的下三角部分，默认值。\n\n* \"diagonal\" 表示只保存对角线部分。\n\n**measurementError** 可选参数，布尔标量，表示输入的多变量时间序列是否存在误差。默认值是 false，表示不存在。\n\n**enforceStationarity** 可选参数，布尔标量，表示是否转换 AR 参数以在模型的自回归分量中增强平稳性。默认值为 true，表示转换。\n\n**enforceInvertibility** 可选参数，布尔标量，表示是否变换 MA 参数以增强模型的移动平均分量的可逆性。默认值为 true，表示转换。\n\n**trendOffset** 可选参数，正整数标量，表示开始时间序列值的偏移量。默认值为 1。\n\n**maxIter** 可选参数，正整数标量，表示拟合时最大的迭代次数，默认值为 50。\n\n#### 返回值\n\n返回一个字典，表示向量自回归移动平均模型的分析结果，字典有以下成员：\n\n* params：浮点数矩阵，表示向量自回归移动平均模型拟合得到的参数。\n\n* kAr：整数标量，表示向量自回归过程的阶数。\n\n* kMa：整数标量，表示向量移动平均部分的阶数。\n\n* kTrend：整数标量，表示向量自回归移动平均模型中的趋势数。\n\n* nobs：整数标量，表示输入的多变量时间序列的信息观测数量。\n\n* aic：浮点数标量，表示 Akaike 信息准则。\n\n* bic：浮点数标量，表示 Bayesian 信息准则。\n\n* hqic：浮点数标量，表示 Hannan-Quinn 信息准则。\n\n* llf：浮点数标量，表示向量自回归移动平均模型的对数似然值。\n\n#### 例子\n\n传入指定的 [macrodata.csv](https://docs.dolphindb.cn/zh/funcs/data/macrodata.csv) 文件，自定义相关参数，计算其使用 VARMA 进行分析的结果。\n\n```\ndata = loadText(\"macrodata.csv\")\nmy_exog = matrix(DOUBLE, size(data), 1,,1)\nresult = varma(data, [`realgdp, `realcons, `realinv],[1,1],trend=\"c\", exog=my_exog)\nprint(result)\n\n/* Output:\nparams->[0.001792375138657,0.003160556421415,-0.007883363910928,-0.339419264165185,0.755250482937653,0.058642159539323,-0.133526968617148,0.32767138782651,0.042514529460363,-2.212343999390979,4.610354288385349,0.302449619489419,0.056726965953926,-0.069554043921028,-0.024169855056237,0.03072738358672,-0.056571376624308,-0.015977637956917,0.249792348549773,-0.171657812582861,-0.075503097693781,0.001792375138657,0.003160556421415,-0.007883363910928,0.007685902441147,0.003916408996852,0.005142039118261,0.030338334390003,-0.016066874864259,0.020322423082551]\nllf->1974.199528289279214\nkAr->1\nkMa->1\nkTrend->1\nnobs->202\naic->-3888.399056578558429\nbic->-3789.151025656522506\nhqic->-3848.243123697545343\n*/\n```\n"
    },
    "varp": {
        "url": "https://docs.dolphindb.cn/zh/funcs/v/varp.html",
        "signatures": [
            {
                "full": "varp(X)",
                "name": "varp",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [varp](https://docs.dolphindb.cn/zh/funcs/v/varp.html)\n\n\n\n#### 语法\n\nvarp(X)\n\n#### 详情\n\n若 *X* 为向量，返回 *X* 的总体方差。\n\n若 *X* 为矩阵，计算每列的总体方差，返回一个向量。\n\n若 *X* 为表，计算每列的总体方差，返回一个表。\n\n与所有其它聚合函数一致，计算时忽略 NULL 值。\n\n#### 参数\n\n**X** 可以是向量、矩阵或表。\n\n#### 返回值\n\nDOUBLE 类型标量/向量/表。\n\n#### 例子\n\n```\nvarp(1 1 1);\n// output\n0\nvarp(1 2 3);\n// output\n0.666667\n\nm=matrix(1 3 5 7 9, 1 4 7 10 13);\nm;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 1  |\n| 3  | 4  |\n| 5  | 7  |\n| 7  | 10 |\n| 9  | 13 |\n\n```\nvarp(m);\n// output\n[8,18]\n```\n\n相关函数： [cumvarp](https://docs.dolphindb.cn/zh/funcs/c/cumvarp.html)\n"
    },
    "valueAtRisk": {
        "url": "https://docs.dolphindb.cn/zh/funcs/v/var_0.html",
        "signatures": [
            {
                "full": "valueAtRisk(returns, method, [confidenceLevel=0.95])",
                "name": "valueAtRisk",
                "parameters": [
                    {
                        "full": "returns",
                        "name": "returns"
                    },
                    {
                        "full": "method",
                        "name": "method"
                    },
                    {
                        "full": "[confidenceLevel=0.95]",
                        "name": "confidenceLevel",
                        "optional": true,
                        "default": "0.95"
                    }
                ]
            }
        ],
        "markdown": "### [valueAtRisk](https://docs.dolphindb.cn/zh/funcs/v/var_0.html)\n\n\n\n#### 语法\n\nvalueAtRisk(returns, method, \\[confidenceLevel=0.95])\n\n#### 详情\n\n风控指标（Value at Risk），用于量化在给定的置信水平（例如 95% 或 99%）和特定时间范围内金融资产可能遭受的最大损失。该函数将返回最低收益率的绝对值，为 DOUBLE 类型。\n\n#### 参数\n\n**returns** 数值型向量，表示收益率序列。注意，表示收益率的每个元素都应大于 -1 且不能为空。\n\n**method** 字符串类型，表示计算 VaR 的方法，可选值为：\n\n* 'normal' 正态参数法。\n\n* 'logNormal' 对数正态参数法。\n\n* 'historical' 历史模拟法。\n\n* 'monteCarlo' 蒙特卡洛模拟法，使用正态分布进行模拟。\n\n**confidenceLevel** 数值型标量，表示置信水平，合法值域为(0,1)，默认值为 0.95。\n\n#### 返回值\n\nDOUBLE 类型标量。\n\n#### 例子\n\n本例中给定一个假设的收益率序列，通过历史模拟法，计算置信水平为 0.9 的风控指标。\n\n```\nreturns = [0.0, -0.0023816107391389394, -0.0028351258634076834, 0.00789570628538656, 0.0022056267475062397, -0.004515475812603498, 0.0031189325339843646, 0.010774648811452205, 0.0030816164453268957, 0.02172541561228001, 0.011106185767699728, -0.005369098699244845, -0.0096490689793588, 0.0025152212699484314, 0.017822140037111668, -0.02837536728283525, 0.018373545076599204, -0.0026401111537113003, 0.019524374522517898, -0.010800546314337627, 0.014073362622486131, -0.00398277532382243, 0.008398647051501285, 0.0024056749358184904, 0.007093080335863512, -0.005332549248384733, -0.008471915938733665, -0.0038788486165083342, -0.01308504169086584, 0.00350496242864784, 0.009036118926745962, 0.0013358223875250545, 0.0036426642608267563, 0.003974568474545581, -0.003944066366522669, -0.011969668605022311, 0.015116930499066374, 0.006931427295653037, -0.0032650627551519267, 0.003407880132851648]\nvalueAtRisk(returns, 'historical', 0.9);\n//output:0.009764216712\n```\n\n**相关函数**：[condValueAtRisk](https://docs.dolphindb.cn/zh/funcs/c/cvar.html)\n"
    },
    "vectorAR": {
        "url": "https://docs.dolphindb.cn/zh/funcs/v/vectorar.html",
        "signatures": [
            {
                "full": "vectorAR(ds, endogColNames, [exog], [trend='c'], [maxLag], [ic])",
                "name": "vectorAR",
                "parameters": [
                    {
                        "full": "ds",
                        "name": "ds"
                    },
                    {
                        "full": "endogColNames",
                        "name": "endogColNames"
                    },
                    {
                        "full": "[exog]",
                        "name": "exog",
                        "optional": true
                    },
                    {
                        "full": "[trend='c']",
                        "name": "trend",
                        "optional": true,
                        "default": "'c'"
                    },
                    {
                        "full": "[maxLag]",
                        "name": "maxLag",
                        "optional": true
                    },
                    {
                        "full": "[ic]",
                        "name": "ic",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [vectorAR](https://docs.dolphindb.cn/zh/funcs/v/vectorar.html)\n\n\n\n#### 语法\n\nvectorAR(ds, endogColNames, \\[exog], \\[trend='c'], \\[maxLag], \\[ic])\n\n#### 详情\n\n使用向量自回归模型（Vector Autoregression model，简称 VAR 模型）来分析多变量时间序列。\n\n#### 参数\n\n**ds** 一张内存表、或者一个 DataSource 类型构成的向量，包含需要分析的多变量时间序列。注意：不可为空。\n\n**endogColNames** 字符串向量，表示需要分析的内生变量(endogenous variable)在 *ds* 中所对应的列名。通过 *endogColNames* 从 *ds* 中取出的列组成的矩阵，即为需要分析的多变量时间序列数据。\n\n**exog** 可选参数，数值矩阵，表示时间序列数据之外的外生变量。矩阵每一列表示一个外生变量的时间序列数据，矩阵行数为时间序列样本数，须与 *ds* 的行数相等。\n\n**trend** 可选参数，表示在回归中使用的常数和趋势阶数。可选值为：\n\n* 'c'：只使用常数，默认值。\n\n* 'ct'：使用常数和趋势。\n\n* 'ctt'：使用常数、线性趋势和二次趋势。\n\n* 'n'：不适用常数和趋势。\n\n**maxLag** 可选参数，非负整数标量，表示在选择阶数时使用的最大滞后期。传入空值或不填时使用默认值：![](https://docs.dolphindb.cn/zh/funcs/images/vectorar.png) ，nobs 表示样本数量。\n\n**ic** 可选参数，字符串标量，表示在选择阶数时使用的信息准则类型，默认值为空值。可选值为：\n\n* 'aic'：Akaike 信息准则。\n\n* 'bic'：Bayesian 信息准则。\n\n* 'fpe'：Final prediction error，最终预测误差准则。\n\n* 'hqic'：Hannan-Quinn 信息准则。\n\n#### 返回值\n\n返回一个字典，表示向量自回归模型的分析结果，字典有以下成员：\n\n* params：浮点数矩阵，表示向量自回归模型拟合得到的参数。\n\n* kAr：整数标量，表示向量自回归过程的阶数。\n\n* kTrend：整数标量，表示向量自回归过程的趋势数。\n\n* nobs：整数标量，表示向量自回归模型分析过程中的观测数量。\n\n* sigmaU：浮点数矩阵，表示白噪声过程方差的估计值。\n\n* sigmaUMle：浮点数矩阵，表示噪声过程协方差的有偏最大似然估计值。\n\n* aic：浮点数标量，表示 Akaike 信息准则。\n\n* bic：浮点数标量，表示 Bayesian 信息准则。\n\n* hqic：浮点数标量，表示 Hannan-Quinn 信息准则。\n\n* fpe：浮点数标量，表示最终预测误差信息准则。\n\n* llf：浮点数标量，表示向量自回归模型的对数似然值。\n\n#### 例子\n\n本例提供一个 [macrodata.csv](https://docs.dolphindb.cn/zh/funcs/data/macrodata.csv) 文件。取该文件中 realgdp, realcons, realinv 三列作为内生变量，并设置最大滞后期 *maxlag* 为 2，使用 VAR 模型来分析其多变量时间序列。\n\n```\ndata = loadText(\"macrodata.csv\")//该文件需要另外下载，请点击上方文本内的链接\nvectorAR(data, [`realgdp, `realcons, `realinv],,,2)\n\n/*\noutput:\nnobs->200\nhqic->-27.789187688321\nllf->1962.570824044325\nkTrend->1\naic->-27.929339439671\nfpe->0E-12\nparams->\n#0              #1              #2             \n0.001526972352  0.005459603048  -0.023902520885\n-0.279434735873 -0.100467978082 -1.970973673795\n0.675015751748  0.268639552522  4.414162326990 \n0.033219450793  0.025738726522  0.225478953223 \n0.008221084912  -0.123173927706 0.380785849237 \n0.290457628129  0.232499435917  0.800280917529 \n-0.007320907532 0.023503761040  -0.124079061576\nsigmaU->\n#0             #1             #2            \n0.000057113648 0.000029839495 0.000224637467\n0.000029839495 0.000042830532 0.000034191732\n0.000224637467 0.000034191732 0.001567709895\nsigmaUMle->\n#0             #1             #2            \n0.000055114670 0.000028795112 0.000216775156\n0.000028795112 0.000041331464 0.000032995021\n0.000216775156 0.000032995021 0.001512840049\n\nkAr->2\nbic->-27.583016116183\n*/\n```\n"
    },
    "vectorNorm": {
        "url": "https://docs.dolphindb.cn/zh/funcs/v/vectornorm.html",
        "signatures": [
            {
                "full": "vectorNorm(x, [ord], [axis], [keepDims])",
                "name": "vectorNorm",
                "parameters": [
                    {
                        "full": "x",
                        "name": "x"
                    },
                    {
                        "full": "[ord]",
                        "name": "ord",
                        "optional": true
                    },
                    {
                        "full": "[axis]",
                        "name": "axis",
                        "optional": true
                    },
                    {
                        "full": "[keepDims]",
                        "name": "keepDims",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [vectorNorm](https://docs.dolphindb.cn/zh/funcs/v/vectornorm.html)\n\n\n\n#### 语法\n\nvectorNorm(x, \\[ord], \\[axis], \\[keepDims])\n\n#### 详情\n\n计算矩阵/向量的范数。\n\n注意：该函数在 SQL 中的行为未定义，故不建议在 SQL 中使用。\n\n#### 参数\n\n**x** 传入除 DECIMAL 以外数值类型的向量或矩阵。注意：不可为空。\n\n**ord** 可选参数，整数、浮点数或者字符串类型的标量，用来指定计算的范数类型。注意：\n\n* *ord* 是字符串时，必须是 inf, -inf, nuc, fro 中的一个。\n\n* *ord* 小于 1 时，本函数的计算结果不符合严格数学意义上的“范数”，但对其他计算可能仍然有意义。\n\n如下为传入不同参数 *x* 和 *ord* 时，计算范数的方式说明：\n\n<table id=\"table_op5_23f_fcc\"><thead><tr><th>\n\n*ord*\n\n</th><th>\n\n*x* 为向量\n\n</th><th>\n\n*x* 为矩阵\n\n</th></tr></thead><tbody><tr><td>\n\n不传入\n\n</td><td>\n\n2-norm\n\n</td><td>\n\nFrobenius norm\n\n</td></tr><tr><td>\n\n0\n\n</td><td>\n\nsum(x != 0)\n\n</td><td>\n\n不支持计算\n\n</td></tr><tr><td>\n\n-1\n\n</td><td>\n\nsum(abs(x)^ord)^(1/ord)\n\n</td><td>\n\nmin(sum(abs(x), axis=0))\n\n</td></tr><tr><td>\n\n1\n\n</td><td>\n\nsum(abs(x)^ord)^(1/ord)\n\n</td><td>\n\nmax(sum(abs(x), axis=0))\n\n</td></tr><tr><td>\n\n-2\n\n</td><td>\n\nsum(abs(x)^ord)^(1/ord)\n\n</td><td>\n\n2-norm (largest sing. value)\n\n</td></tr><tr><td>\n\n2\n\n</td><td>\n\nsum(abs(x)^ord)^(1/ord)\n\n</td><td>\n\nsmallest singular value\n\n</td></tr><tr><td>\n\n其他整数或浮点数\n\n</td><td>\n\nsum(abs(x)^ord)^(1/ord)\n\n</td><td>\n\n不支持计算\n\n</td></tr><tr><td>\n\ninf\n\n</td><td>\n\nmax(abs(x))\n\n</td><td>\n\nmax(sum(abs(x), axis=1))\n\n</td></tr><tr><td>\n\n-inf\n\n</td><td>\n\nmin(abs(x))\n\n</td><td>\n\nmin(sum(abs(x), axis=1))\n\n</td></tr><tr><td>\n\nnuc\n\n</td><td>\n\n不支持计算\n\n</td><td>\n\nnuclear norm\n\n</td></tr><tr><td>\n\nfro\n\n</td><td>\n\n不支持计算\n\n</td><td>\n\nFrobenius norm\n\n</td></tr></tbody>\n</table>**axis** 可选参数，整型向量或标量，表示求范数的方向。注意：不可包含空元素。\n\n* 当 *x* 为向量时，*axis* 只能传入标量 0。\n\n* 当 *x* 为矩阵时，*axis*：\n\n  * 长度不能超过 2。\n\n  * 元素不能重复。\n\n  * 元素值的大小不能超过 1，即只能为 0 或 1。\n\n**keepDims** 可选参数，布尔标量，表示返回结果是否和 *x* 的形式保持一致，默认为 false。\n\n#### 返回值\n\n返回值的类型和形式由参数共同决定，可能为 INT 、LONG 或 DOUBLE 类型的标量、向量或矩阵。\n\n#### 例子\n\n若 *x* 为向量，计算传入不同参数后的范数。\n\n```\nx = 1..4\n\nvectorNorm(x) //Output: 5.477225575051661\n\nvectorNorm(x, keepDims=true) //Output: 5.477225575051661\n\nvectorNorm(x, ord=1) //Output: 10\nvectorNorm(x, ord=1, axis=0) //Output: 10 \n\nvectorNorm(x, ord=-1) //Output 0.4800000000000001\nvectorNorm(x, ord=-1, axis=0) //Output double: 10\n\nvectorNorm(x, ord=\"inf\", axis=0) //Output: 4 \nvectorNorm(x, ord=\"-inf\", axis=0) //Output: 1\n\nvectorNorm(x, ord=3) //Output: 4.641588833612778\nvectorNorm(x, ord=-20.689) //Output: 0.9999999714010688\n\nvectorNorm(x, ord=\"fro\") // throw exception\nvectorNorm(x, ord=\"nuc\") // throw exception\n```\n\n若 *x* 为矩阵，计算传入不同参数后的范数。\n\n```\nx = 1..4$2:2\n\nvectorNorm(x) //Output: 5.477225575051661\nvectorNorm(x, keepDims=true) //Output: 5.477225575051661\n\nvectorNorm(x, ord=1) //Output: 7\nvectorNorm(x, ord=1, axis=0) //Output: 3 7 \nvectorNorm(x, ord=1, axis=1) //Output: 4 6\n\nvectorNorm(x, ord=-1, axis=0) //Output: 0.6666666666666666 1.7142857142857144\nvectorNorm(x, ord=-1, axis=1) //Output: 0.75 1.3333333333333333\n\nvectorNorm(x, ord=1, axis=(0 1)) //Output: 7\nvectorNorm(x, ord=1, axis=(1 0)) //Output: 6 \n\nvectorNorm(x, ord=-1, axis=(0 1)) //Output: 3\nvectorNorm(x, ord=-1, axis=(1 0)) //Output: 4 \n\nvectorNorm(x, ord=\"inf\", axis=(0 1)) //Output: 4 \nvectorNorm(x, ord=\"inf\", axis=(1 0)) //Output: 3 \n\nvectorNorm(x, ord=\"-inf\", axis=(0 1)) //Output: 6 \nvectorNorm(x, ord=\"-inf\", axis=(1 0)) //Output: 7 \n\nvectorNorm(x, ord=\"fro\", axis=(1 0)) //Output: 5.477225575051661\nvectorNorm(x, ord=\"fro\", axis=(0 1)) //Output: 5.477225575051661\n\nvectorNorm(x, ord=-2, axis=(1 0)) //Output: 0.3659661906262574\nvectorNorm(x, ord=-2, axis=(0 1)) //Output: 0.3659661906262574\n\nvectorNorm(x, ord=2, axis=(1 0)) //Output: 5.464985704219043\nvectorNorm(x, ord=2, axis=(0 1)) //Output: 5.464985704219043\n\nvectorNorm(x, ord=\"nuc\", axis=(1 0)) //Output: 5.8309518948453\nvectorNorm(x, ord=\"nuc\", axis=(0 1)) //Output: 5.8309518948453\n\nvectorNorm(x, ord=3) // throw exception\n```\n"
    },
    "version": {
        "url": "https://docs.dolphindb.cn/zh/funcs/v/version.html",
        "signatures": [
            {
                "full": "version()",
                "name": "version",
                "parameters": [
                    {
                        "full": "",
                        "name": ""
                    }
                ]
            }
        ],
        "markdown": "### [version](https://docs.dolphindb.cn/zh/funcs/v/version.html)\n\n\n\n#### 语法\n\nversion()\n\n#### 详情\n\n返回 DolphinDB 的版本、发布日期，和当前的操作系统版本、特定编译版本（非特定版本不显示）、 CPU 指令集。信息间使用空格隔开。\n\n#### 参数\n\n无\n\n#### 返回值\n\nSTRING 类型标量。\n\n#### 例子\n\n```\nversion();\n//output: 3.00.0 2024.03.31 LINUX x86_64\n```\n"
    },
    "volumeBar": {
        "url": "https://docs.dolphindb.cn/zh/funcs/v/volumeBar.html",
        "signatures": [
            {
                "full": "volumeBar(X, interval, [label='seq'])",
                "name": "volumeBar",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "interval",
                        "name": "interval"
                    },
                    {
                        "full": "[label='seq']",
                        "name": "label",
                        "optional": true,
                        "default": "'seq'"
                    }
                ]
            }
        ],
        "markdown": "### [volumeBar](https://docs.dolphindb.cn/zh/funcs/v/volumeBar.html)\n\n\n\n#### 语法\n\nvolumeBar(X, interval, \\[label='seq'])\n\n#### 详情\n\n对 *X* 进行累加，并根据指定的阈值进行分组，返回数据所属分组的组号。分组规则为：\n\n依次累加 *X* 中的元素\n\n* 若阈值为正数，则从第一个元素开始累加，直到累加和大于等于阈值，将这些元素划分为一组。然后从下一个元素重新开始累加，并分组，以此类推。最后剩余的累加和小于阈值的元素划分为一组。\n\n* 若阈值为负数，则从第一个元素开始累加，直到累加和小于等于阈值，将这些元素划分为一组。然后从下一个元素重新开始累加，并分组，以此类推。最后剩余的累加和大于阈值的元素划分为一组。\n\n*interval* 确定了累加分组的阈值，可以是一个定值也可以是一个百分比：\n\n* 当 *interval* ∈ (0, 1) 时， 表示一个百分比，阈值为 sum(X) \\* interval。注意，系统会将阈值转换为与 *X* 相同的类型再进行比较。例如，*X* 是整型，则累加和将与 floor(sum(X) \\* interval)进行比较。\n\n* 否则，*interval* 表示一个定值，即阈值为 *interval*。\n\n#### 参数\n\n**X** 是数值型向量。\n\n**interval** 非零的数值，表示一个定值或百分比。\n\n**label** 为标记分组的方法，有以下三种类型：\n\n* 'seq'：默认值，表示按 0, 1, 2, 3… 的顺序标记组号。\n\n* 'left'：当前分组第一个元素前所有元素的累加和作为组号。第1个分组的组号为 0。\n\n* 'right'：*X* 从第一个元素开始累加到当前分组中最后一个元素的值作为组号。\n\n#### 返回值\n\nINT/LONG 类型向量。\n\n#### 例子\n\n```\nX =  1 3 4 2 2 1 1 1 1 6 8\nvolumeBar(X, 4)\n```\n\n输出返回：\\[0,0,1,2,2,3,3,3,3,4,5]\n\n```\nvolumeBar(X, 4, 'left')\n```\n\n输出返回：\\[0,0,4,8,8,12,12,12,12,16,22]\n\n```\nvolumeBar(X, 4, 'right')\n```\n\n输出返回：\\[4,4,8,12,12,16,16,16,16,22,30]\n\n```\nvolumeBar(X, 0.3)\n```\n\n输出返回：\\[0,0,0,0,1,1,1,1,1,1,2]\n\n```\nX = -6 2 -4 -5 -1 3 -2 -1\nvolumeBar(X, -2)\n```\n\n输出返回：\\[0,1,1,2,3,3,3,3]\n\n```\nvolumeBar(X, -2, 'left')\n```\n\n输出返回：\\[0,-6,-6,-8,-13,-13,-13,-13]\n\n```\nvolumeBar(X, -2, 'right')\n```\n\n输出返回：\\[-6,-8,-8,-13,-14,-14,-14,-14]\n\n应用 `volumeBar` 函数生成等量 K 线。\n\n```\ntime = [09:30:00, 09:32:15, 09:35:00, 09:37:30, 09:40:00, 09:45:00, 09:47:30, 09:50:00, 09:55:00, 10:00:00]\nprice = [100.0, 100.1, 100.05, 99.9, 100.2, 100.15, 100.1, 100.05, 100.0, 99.95]\nvolume = [200, 800, 250, 300, 1200, 250, 180, 400, 600, 350]\nt = table(time, price, volume)\n\nselect \n    first(time) as barStartTime,\n    first(price) as open,\n    max(price) as high,\n    min(price) as low,\n    last(price) as close,\n    sum(volume) as totalVolume\nfrom t \ngroup by volumeBar(tradeVolume, 1500) as volumeBarNo\n```\n\n| volumeBarNo | barStartTime | open   | high   | low   | close | totalVolume |\n| ----------- | ------------ | ------ | ------ | ----- | ----- | ----------- |\n| 0           | 09:30:00     | 100    | 100.1  | 99.9  | 99.9  | 1,550       |\n| 1           | 09:40:00     | 100.2  | 100.2  | 100.1 | 100.1 | 1,630       |\n| 2           | 09:50:00     | 100.05 | 100.05 | 99.95 | 99.95 | 1,350       |\n"
    },
    "warmupComputeNodeCache": {
        "url": "https://docs.dolphindb.cn/zh/funcs/w/warmupcomputenodecache.html",
        "signatures": [
            {
                "full": "warmupComputeNodeCache(sqlObj, [parallelism])",
                "name": "warmupComputeNodeCache",
                "parameters": [
                    {
                        "full": "sqlObj",
                        "name": "sqlObj"
                    },
                    {
                        "full": "[parallelism]",
                        "name": "parallelism",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [warmupComputeNodeCache](https://docs.dolphindb.cn/zh/funcs/w/warmupcomputenodecache.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nwarmupComputeNodeCache(sqlObj, \\[parallelism])\n\n#### 详情\n\n创建数据预热任务，将指定数据缓存至计算组。\n\n#### 参数\n\n**sqlObj** SQL 元代码，表示预热的数据。\n\n**parallelism** 可选参数，正整数，表示分配给该任务的线程数上限。\n\n#### 返回值\n\n任务的 jobId。\n\n#### 例子\n\n```\nwarmupComputeNodeCache(sqlObj=<select * from loadTable(\"dfs://test\",\"pt\") where date>=2025.04.01>, parallelism=3)\n```\n"
    },
    "warmupOrcaStreamEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/w/warmupOrcaStreamEngine.html",
        "signatures": [
            {
                "full": "warmupOrcaStreamEngine(name, data)",
                "name": "warmupOrcaStreamEngine",
                "parameters": [
                    {
                        "full": "name",
                        "name": "name"
                    },
                    {
                        "full": "data",
                        "name": "data"
                    }
                ]
            }
        ],
        "markdown": "### [warmupOrcaStreamEngine](https://docs.dolphindb.cn/zh/funcs/w/warmupOrcaStreamEngine.html)\n\n首发版本：3.00.3\n\n\n\n#### 语法\n\nwarmupOrcaStreamEngine(name, data)\n\n#### 详情\n\n将指定表写入目标流引擎中进行预热处理，但不会产生任何输出。这么做的目的是利用这批预热数据提前计算中间状态，下一批次数据写入此流数据引擎，可以利用已计算的结果来加速计算。\n\n目前仅支持响应式状态引擎，时间序列聚合引擎和日级时间序列引擎。\n\n与现有 [warmupStreamEngine](https://docs.dolphindb.cn/zh/funcs/w/warmupStreamEngine.html) 不同，`warmupOrcaStreamEngine` 支持在集群任意节点上调用，其本质是在引擎所在节点上远程执行 `warmupStreamEngine`。\n\n#### 参数\n\n**name** 表示引擎名称。字符串标量，可以传入完整的全限定名（如 \"catalog\\_name.orca\\_engine.engine\\_name\"）；或引擎名（如 \"engine\\_name\"），系统会根据当前的 catalog 设置自动补全为对应的全限定名。\n\n**data** 数据表对象。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n下例中，`warmupOrcaStreamEngine(\"rse\", t)` 先将数据表 t 写入响应式状态引擎 rse 进行预热，由此确保 `<ema(value, 100)>` 指标在预热阶段窗口内已有完整历史数据。\n\n```\nif (!existsCatalog(\"test\")) {\n\tcreateCatalog(\"test\")\n}\ngo;\nuse catalog test\n\nt = table(1..100 as id, 1..100 as value, take(09:29:00.000..13:00:00.000, 100) as timestamp)\ng = createStreamGraph(\"factor\")\nbaseStream = g.source(\"snapshot\",  schema(t).colDefs.name, schema(t).colDefs.typeString)\n  .reactiveStateEngine([<ema(value, 100)>, <timestamp>])\n  .setEngineName(\"rse\")\n  .buffer(\"end\")\n  \ng.submit()\n\nwarmupOrcaStreamEngine(\"rse\", t)\nappendOrcaStreamTable(\"snapshot\", t)\n```\n"
    },
    "warmupStreamEngine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/w/warmupStreamEngine.html",
        "signatures": [
            {
                "full": "warmupStreamEngine(engine, msgs)",
                "name": "warmupStreamEngine",
                "parameters": [
                    {
                        "full": "engine",
                        "name": "engine"
                    },
                    {
                        "full": "msgs",
                        "name": "msgs"
                    }
                ]
            }
        ],
        "markdown": "### [warmupStreamEngine](https://docs.dolphindb.cn/zh/funcs/w/warmupStreamEngine.html)\n\n\n\n#### 语法\n\nwarmupStreamEngine(engine, msgs)\n\n#### 详情\n\n将预热数据写入流数据引擎，但不输出计算结果，仅将结果保留为中间状态。当下一批数据写入引擎时，可以基于该中间状态进行计算。\n\n目前仅支持响应式状态引擎，时间序列聚合引擎和日级时间序列引擎。\n\n#### 参数\n\n**engine** 是创建流数据引擎时返回的表对象。\n\n**msgs** 是一个数据表，表示预热数据。。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n下例比较了使用 `warmupStreamEngine` 预热对计算结果的影响。创建两个相同的响应式状态引擎，对 engineA 注入预热数据；engineB 未注入预热数据。\n\n```\n// 模拟数据\ntrade=table(1000:0, `date`sym`price`volume, [DATE, SYMBOL, DOUBLE, INT])\nn=3000*100\ndate=take(2021.03.08, n)\nsym=take(\"A\"+string(1..3000), n)\nprice=round(rand(100.0, n), 2)\nvolume=rand(100, n)\ntable1 = table(date, sym, price, volume)\noutputTableA = table(n:0, `sym`factor1, [STRING,DOUBLE])\noutputTableB = table(n:0, `sym`factor1, [STRING,DOUBLE])\n\n// 创建流数据引擎并注入数据\ndropStreamEngine(\"test1\")\ndropStreamEngine(\"test2\")\nengineA = createReactiveStateEngine(\"test1\", <ema(volume, 40)>, table1, outputTableA, \"sym\")\nengineB = createReactiveStateEngine(\"test2\", <ema(volume, 40)>, table1, outputTableB, \"sym\")\nwarmupStreamEngine(engineA, table1) // 使用 warmupStreamEngine 预热\n\n\n// 向引擎分别写入数据：\ndate=take(2021.03.09, n)\nsym=take(\"A\"+string(1..3000), n)\nprice=round(rand(100.0, n), 2)\nvolume=rand(100, n)\ntable2 = table(date, sym, price, volume)\nengineA.append!(table2)\nengineB.append!(table2)\n```\n\noutputTableA：\n\n![](https://docs.dolphindb.cn/zh/funcs/images/warmupStreamEngine1.png)\n\noutputTableB：\n\n![](https://docs.dolphindb.cn/zh/funcs/images/warmupStreamEngine2.png)\n\n使用 `warmupStreamEngine` 将预热数据写入流数据引擎 engineA，基于中间状态计算，输出表 outputTableA 自第 1 行开始返回非空数据。由于窗口长度为 40，输出表 outputTableB 前39个分组返回值为空，自 117001 行开始返回非空数据。\n"
    },
    "wavg": {
        "url": "https://docs.dolphindb.cn/zh/funcs/w/wavg.html",
        "signatures": [
            {
                "full": "wavg(X, Y)",
                "name": "wavg",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [wavg](https://docs.dolphindb.cn/zh/funcs/w/wavg.html)\n\n\n\n#### 语法\n\nwavg(X, Y)\n\n#### 详情\n\n对 *X*，以 *Y* 为权重，计算其加权平均数。\n\n请注意，权重向量会自动调整，使得 *X* 向量中非 NULL 之值对应的权重向量之和为1。\n\n#### 参数\n\n**X** 与 **Y** 是向量、矩阵或表。*Y* 表示权重。\n\n#### 返回值\n\n一个数值型标量。\n\n#### 例子\n\n```\nwavg(2.2 1.1 3.3, 4 5 6);\n// output\n2.273333\n//  (2.2*4+1.1*5+3.3*6)/(4+5+6)\n\nwavg(1 NULL 1, 1 1 1);\n// output\n1\n```\n\n相关函数：[wsum](https://docs.dolphindb.cn/zh/funcs/w/wsum.html)\n"
    },
    "wc": {
        "url": "https://docs.dolphindb.cn/zh/funcs/w/wc.html",
        "signatures": [
            {
                "full": "wc(X)",
                "name": "wc",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [wc](https://docs.dolphindb.cn/zh/funcs/w/wc.html)\n\n\n\n#### 语法\n\nwc(X)\n\n#### 详情\n\n计算 *X* 中包含的单词数量。\n\n#### 参数\n\n**X** 是一个字符串。它可以是标量或向量。\n\n#### 返回值\n\n一个 INT 类型的标量或向量。\n\n#### 例子\n\n```\nwc(`apple);\n// output\n1\n\nwc(\"This is a 7th generation iphone!\");\n// output\n6\n\nwc(\"This is a 7th generation iphone!\" \"I wonder what the 8th generation looks like\");\n// output\n[6,8]\n```\n"
    },
    "wcovar": {
        "url": "https://docs.dolphindb.cn/zh/funcs/w/wcovar.html",
        "signatures": [
            {
                "full": "wcovar(X, Y, W)",
                "name": "wcovar",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "W",
                        "name": "W"
                    }
                ]
            }
        ],
        "markdown": "### [wcovar](https://docs.dolphindb.cn/zh/funcs/w/wcovar.html)\n\n\n\n#### 语法\n\nwcovar(X, Y, W)\n\n#### 详情\n\n返回 *X* 和 *Y* 的加权协方差。\n\n#### 参数\n\n**X**, **Y** 和 **W** 是相同长度的数值型向量。\n\n*W* 表示权重。它不能包含 NULL 值。\n\n#### 返回值\n\n一个数值型标量。\n\n#### 例子\n\n```\nx=7 4 5 8 9 3 3 5 2 6 12 1 0 -5 32\ny=1.1 7 8 9 9 5 4 8.6 2 1 -9 -3 5 8 13\nwt=iterate(1,0.9,x.size())\nwcovar(x,y,wt);\n\n// output\n4.201899\n```\n"
    },
    "weekBegin": {
        "url": "https://docs.dolphindb.cn/zh/funcs/w/weekBegin.html",
        "signatures": [
            {
                "full": "weekBegin(X, [weekday=0], [offset], [n=1])",
                "name": "weekBegin",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[weekday=0]",
                        "name": "weekday",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[offset]",
                        "name": "offset",
                        "optional": true
                    },
                    {
                        "full": "[n=1]",
                        "name": "n",
                        "optional": true,
                        "default": "1"
                    }
                ]
            }
        ],
        "markdown": "### [weekBegin](https://docs.dolphindb.cn/zh/funcs/w/weekBegin.html)\n\n\n\n#### 语法\n\nweekBegin(X, \\[weekday=0], \\[offset], \\[n=1])\n\n#### 详情\n\n用于计算 *X* 所在周期的开始日期。默认情况下，周期长度为 1 周，周期开始日由参数 *weekday* 指定，默认 *weekday*=0 即周一。\n\n如果指定 *offset* 和 *n*，且 *n* > 1，则函数按长度为 *n* 周的周期计算。此时，*offset* 用于确定周期边界的对齐方式：系统会先根据 *weekday* 计算出 *offset* 所在周期的开始日，然后以该日期为基准，每隔 *n* 周生成一个周期开始边界，并返回 *X* 所属周期对应的开始日期。\n\n#### 参数\n\n**X** 可以是 DATE, DATETIME, DATEHOUR, TIMESTAMP 或 NANOTIMESTAMP 类型的标量或向量，表示需要计算周期开始日期的输入日期或日期时间。\n\n**weekday** 是0到6之间的整数，用于指定每周的开始日期。0表示星期一，1表示星期二，... ，6表示星期日。默认值为0。\n\n**offset** 可选参数，与 *X* 类型相同的标量，并且它必须小于等于 *X* 中的最小值。当 *n* > 1 时，*offset* 用于确定多周周期的对齐基准。如果没有指定 *offset*，则默认使用 *X* 中的最小值作为 *offset*。\n\n**n** 可选参数，一个正整数，用于指定每个周期包含多少个星期，默认值为1。当 *n*=1 时，函数按自然周计算，*offset* 不生效。；当 *n*>1 时，函数按 *n* 周为一个周期计算，此时必须同时指定 *offset* 和 *n*。\n\n#### 返回值\n\n一个 DATE 类型的标量或向量。\n\n#### 例子\n\n例1：\n\n```\nt = table(2017.12.01..2017.12.14 as date);\nupdate t set weekday=weekday(date, false), weekBegin=weekBegin(date), weekBegin4=weekBegin(date,4);\nt;\n```\n\n得到：\n\n| date       | weekday | weekBegin  | weekBegin4 |\n| ---------- | ------- | ---------- | ---------- |\n| 2017.12.01 | 4       | 2017.11.27 | 2017.12.01 |\n| 2017.12.02 | 5       | 2017.11.27 | 2017.12.01 |\n| 2017.12.03 | 6       | 2017.11.27 | 2017.12.01 |\n| 2017.12.04 | 0       | 2017.12.04 | 2017.12.01 |\n| 2017.12.05 | 1       | 2017.12.04 | 2017.12.01 |\n| 2017.12.06 | 2       | 2017.12.04 | 2017.12.01 |\n| 2017.12.07 | 3       | 2017.12.04 | 2017.12.01 |\n| 2017.12.08 | 4       | 2017.12.04 | 2017.12.08 |\n| 2017.12.09 | 5       | 2017.12.04 | 2017.12.08 |\n| 2017.12.10 | 6       | 2017.12.04 | 2017.12.08 |\n| 2017.12.11 | 0       | 2017.12.11 | 2017.12.08 |\n| 2017.12.12 | 1       | 2017.12.11 | 2017.12.08 |\n| 2017.12.13 | 2       | 2017.12.11 | 2017.12.08 |\n| 2017.12.14 | 3       | 2017.12.11 | 2017.12.08 |\n\n例2：\n\n```\n t = table(2018.01.03+0..10*3 as date, 0..10 as x);\n update t set weekday=weekday(date, false), weekBegin=weekBegin(date,,2018.01.02,2);\n t;\n```\n\n得到：\n\n| date       | x  | weekday | weekBegin  |\n| ---------- | -- | ------- | ---------- |\n| 2018.01.03 | 0  | 2       | 2018.01.01 |\n| 2018.01.06 | 1  | 5       | 2018.01.01 |\n| 2018.01.09 | 2  | 1       | 2018.01.01 |\n| 2018.01.12 | 3  | 4       | 2018.01.01 |\n| 2018.01.15 | 4  | 0       | 2018.01.15 |\n| 2018.01.18 | 5  | 3       | 2018.01.15 |\n| 2018.01.21 | 6  | 6       | 2018.01.15 |\n| 2018.01.24 | 7  | 2       | 2018.01.15 |\n| 2018.01.27 | 8  | 5       | 2018.01.15 |\n| 2018.01.30 | 9  | 1       | 2018.01.29 |\n| 2018.02.02 | 10 | 4       | 2018.01.29 |\n\n例3：\n\n```\ndate=2012.10.02 2012.10.03 2012.10.07 2012.10.08 2012.10.12 2012.10.16 2012.10.18 2012.10.20 2012.10.25 2012.10.28\ntime=[09:34:07,09:36:42,09:36:51,09:36:59,09:32:47,09:35:26,09:34:16,09:34:26,09:38:12,09:38:13]\nsym = take(`MSFT,10)\nprice= 49.6 29.46 29.52 30.02 174.97 175.23 50.76 50.32 51.29 52.38\nqty = 2200 1900 2100 3200 6800 5400 1300 2500 8800 4500\nt1 = table(date, time, sym, qty, price);\n\nt1;\n```\n\n得到：\n\n| date       | time     | sym  | qty  | price  |\n| ---------- | -------- | ---- | ---- | ------ |\n| 2012.10.02 | 09:34:07 | MSFT | 2200 | 49.6   |\n| 2012.10.03 | 09:36:42 | MSFT | 1900 | 29.46  |\n| 2012.10.07 | 09:36:51 | MSFT | 2100 | 29.52  |\n| 2012.10.08 | 09:36:59 | MSFT | 3200 | 30.02  |\n| 2012.10.12 | 09:32:47 | MSFT | 6800 | 174.97 |\n| 2012.10.16 | 09:35:26 | MSFT | 5400 | 175.23 |\n| 2012.10.18 | 09:34:16 | MSFT | 1300 | 50.76  |\n| 2012.10.20 | 09:34:26 | MSFT | 2500 | 50.32  |\n| 2012.10.25 | 09:38:12 | MSFT | 8800 | 51.29  |\n| 2012.10.28 | 09:38:13 | MSFT | 4500 | 52.38  |\n\n```\nselect avg(price),sum(qty) from t1 group by weekBegin(date, 4, 2012.10.01, 2);\n```\n\n得到：\n\n| weekBegin\\_date | avg\\_price | sum\\_qty |\n| --------------- | ---------- | -------- |\n| 2012.09.28      | 34.65      | 9400     |\n| 2012.10.12      | 100.514    | 24800    |\n| 2012.10.26      | 52.38      | 4500     |\n\n**Related information**\n\n[week](https://docs.dolphindb.cn/zh/funcs/w/weekEnd.html)\n"
    },
    "weekday": {
        "url": "https://docs.dolphindb.cn/zh/funcs/w/weekday.html",
        "signatures": [
            {
                "full": "weekday(X, [startFromSunday=true])",
                "name": "weekday",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[startFromSunday=true]",
                        "name": "startFromSunday",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [weekday](https://docs.dolphindb.cn/zh/funcs/w/weekday.html)\n\n\n\n#### 语法\n\nweekday(X, \\[startFromSunday=true])\n\n#### 详情\n\n返回一个表示与 *X* 对应的一周中日期编号。\n\n如果 *startFromSunday* =true，那么0表示星期日，1表示星期一，...，6表示星期六。如果 *startFromSunday* =false，那么0表示星期一，1表示星期二，...，6表示星期日。\n\n#### 参数\n\n**X** 是一个时间标量或向量。\n\n**startFromSunday** 是一个布尔值，表示一周是否从星期日开始。默认值为 true。\n\n#### 返回值\n\n一个 INT 类型的标量或向量。\n\n#### 例子\n\n```\nweekday 2012.12.05;\n// output: 3\n\nweekday(2012.12.05, false);\n// output: 2\n\nweekday 2013.05.23T12:00:00;\n// output: 4\n\nweekday(2014.01.11T23:04:28.113);\n// output: 6\n\nweekday 2012.12.05 2012.12.06 2013.01.05;\n// output: [3,4,6]\n```\n"
    },
    "weekEnd": {
        "url": "https://docs.dolphindb.cn/zh/funcs/w/weekEnd.html",
        "signatures": [
            {
                "full": "weekEnd(X, [weekday=6], [offset], [n=1])",
                "name": "weekEnd",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[weekday=6]",
                        "name": "weekday",
                        "optional": true,
                        "default": "6"
                    },
                    {
                        "full": "[offset]",
                        "name": "offset",
                        "optional": true
                    },
                    {
                        "full": "[n=1]",
                        "name": "n",
                        "optional": true,
                        "default": "1"
                    }
                ]
            }
        ],
        "markdown": "### [weekEnd](https://docs.dolphindb.cn/zh/funcs/w/weekEnd.html)\n\n\n\n#### 语法\n\nweekEnd(X, \\[weekday=6], \\[offset], \\[n=1])\n\n别名：week\n\n#### 详情\n\n用于计算 *X* 所在周期的结束日期。默认情况下，周期长度为 1 周，周期结束日由参数 *weekday* 指定，默认 *weekday*=6 即周日。\n\n如果指定 *offset* 和 *n*，且 *n* > 1，则函数按长度为 *n* 周的周期计算。此时，*offset* 用于确定周期边界的对齐方式：系统会先根据 *weekday* 计算出 *offset* 所在周期的结束日，然后以该日期为基准，每隔 *n* 周生成一个周期结束边界，并返回 *X* 所属周期对应的结束日期。\n\n#### 参数\n\n**X** 可以是 DATE, DATETIME, DATEHOUR, TIMESTAMP 或 NANOTIMESTAMP 类型的标量或向量，表示需要计算周末日期的输入日期或日期时间。\n\n**weekday** 是0到6之间的整数，用于指定每周的结束日。0表示星期一，1表示星期二，... ，6表示星期日。默认值为6。\n\n**offset** 可选参数，与 *X* 类型相同的标量，并且它必须小于等于 *X* 中的最小值。当 *n* > 1 时，*offset* 用于确定多周周期的对齐基准。如果没有指定 *offset*，则默认使用 *X* 中的最小值作为 *offset*。\n\n**n** 可选参数，一个正整数，用于指定每个周期包含多少个星期，默认值为1。当 *n*=1 时，函数按自然周计算，*offset* 不生效。；当 *n*>1 时，函数按 *n* 周为一个周期计算，此时必须同时指定 *offset* 和 *n*。\n\n#### 返回值\n\n一个 DATE 类型的标量或向量。\n\n#### 例子\n\n例1：\n\n```\nt = table(2017.12.01..2017.12.14 as date)\nupdate t set weekday=weekday(date, false), weekEnd=weekEnd(date), weekEnd4=weekEnd(date,4)\nt;\n```\n\n得到：\n\n| date       | weekday | weekEnd    | weekEnd4   |\n| ---------- | ------- | ---------- | ---------- |\n| 2017.12.01 | 4       | 2017.12.04 | 2017.12.01 |\n| 2017.12.02 | 5       | 2017.12.04 | 2017.12.08 |\n| 2017.12.03 | 6       | 2017.12.04 | 2017.12.08 |\n| 2017.12.04 | 0       | 2017.12.04 | 2017.12.08 |\n| 2017.12.05 | 1       | 2017.12.11 | 2017.12.08 |\n| 2017.12.06 | 2       | 2017.12.11 | 2017.12.08 |\n| 2017.12.07 | 3       | 2017.12.11 | 2017.12.08 |\n| 2017.12.08 | 4       | 2017.12.11 | 2017.12.08 |\n| 2017.12.09 | 5       | 2017.12.11 | 2017.12.15 |\n| 2017.12.10 | 6       | 2017.12.11 | 2017.12.15 |\n| 2017.12.11 | 0       | 2017.12.11 | 2017.12.15 |\n| 2017.12.12 | 1       | 2017.12.18 | 2017.12.15 |\n| 2017.12.13 | 2       | 2017.12.18 | 2017.12.15 |\n| 2017.12.14 | 3       | 2017.12.18 | 2017.12.15 |\n\n例2：\n\n```\nt = table(2018.01.03+0..10*3 as date, 0..10 as x)\nupdate t set weekday=weekday(date, false), weekEnd2=weekEnd(date,,2018.01.02,2)\nt;\n```\n\n得到：\n\n| date       | x  | weekday | weekEnd2   |\n| ---------- | -- | ------- | ---------- |\n| 2018.01.03 | 0  | 2       | 2018.01.08 |\n| 2018.01.06 | 1  | 5       | 2018.01.08 |\n| 2018.01.09 | 2  | 1       | 2018.01.22 |\n| 2018.01.12 | 3  | 4       | 2018.01.22 |\n| 2018.01.15 | 4  | 0       | 2018.01.22 |\n| 2018.01.18 | 5  | 3       | 2018.01.22 |\n| 2018.01.21 | 6  | 6       | 2018.01.22 |\n| 2018.01.24 | 7  | 2       | 2018.02.05 |\n| 2018.01.27 | 8  | 5       | 2018.02.05 |\n| 2018.01.30 | 9  | 1       | 2018.02.05 |\n| 2018.02.02 | 10 | 4       | 2018.02.05 |\n\n例3：\n\n```\ndate=2012.10.02 2012.10.03 2012.10.07 2012.10.08 2012.10.12 2012.10.16 2012.10.18 2012.10.20 2012.10.25 2012.10.28\ntime=[09:34:07,09:36:42,09:36:51,09:36:59,09:32:47,09:35:26,09:34:16,09:34:26,09:38:12,09:38:13]\nsym = take(`MSFT,10)\nprice= 49.6 29.46 29.52 30.02 174.97 175.23 50.76 50.32 51.29 52.38\nqty = 2200 1900 2100 3200 6800 5400 1300 2500 8800 4500\nt1 = table(date, time, sym, qty, price);\n\nt1;\n```\n\n得到：\n\n| date       | time     | sym  | qty  | price  |\n| ---------- | -------- | ---- | ---- | ------ |\n| 2012.10.02 | 09:34:07 | MSFT | 2200 | 49.6   |\n| 2012.10.03 | 09:36:42 | MSFT | 1900 | 29.46  |\n| 2012.10.07 | 09:36:51 | MSFT | 2100 | 29.52  |\n| 2012.10.08 | 09:36:59 | MSFT | 3200 | 30.02  |\n| 2012.10.12 | 09:32:47 | MSFT | 6800 | 174.97 |\n| 2012.10.16 | 09:35:26 | MSFT | 5400 | 175.23 |\n| 2012.10.18 | 09:34:16 | MSFT | 1300 | 50.76  |\n| 2012.10.20 | 09:34:26 | MSFT | 2500 | 50.32  |\n| 2012.10.25 | 09:38:12 | MSFT | 8800 | 51.29  |\n| 2012.10.28 | 09:38:13 | MSFT | 4500 | 52.38  |\n\n```\nselect avg(price),sum(qty) from t1 group by weekEnd(date, 4, 2012.10.01, 2);\n```\n\n得到：\n\n| weekEnd\\_date | avg\\_price | sum\\_qty |\n| ------------- | ---------- | -------- |\n| 2012.10.05    | 39.53      | 4100     |\n| 2012.10.19    | 92.1       | 18800    |\n| 2012.11.02    | 51.33      | 15800    |\n\n**Related information**\n\n[weekBegin](https://docs.dolphindb.cn/zh/funcs/w/weekBegin.html)\n"
    },
    "weekOfMonth": {
        "url": "https://docs.dolphindb.cn/zh/funcs/w/weekOfMonth.html",
        "signatures": [
            {
                "full": "weekOfMonth(X, [week=0], [weekday=0], [offset], [n=1])",
                "name": "weekOfMonth",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[week=0]",
                        "name": "week",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[weekday=0]",
                        "name": "weekday",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[offset]",
                        "name": "offset",
                        "optional": true
                    },
                    {
                        "full": "[n=1]",
                        "name": "n",
                        "optional": true,
                        "default": "1"
                    }
                ]
            }
        ],
        "markdown": "### [weekOfMonth](https://docs.dolphindb.cn/zh/funcs/w/weekOfMonth.html)\n\n\n\n#### 语法\n\nweekOfMonth(X, \\[week=0], \\[weekday=0], \\[offset], \\[n=1])\n\n#### 详情\n\n返回 *X* 所在月份或上一个月中第 *week* 个 *weekday* 对应的日期。假设 *X* 所在月份的第 *week* 个 *weekday* 对应日期为 d：\n\n如果 *X* < *d* ，*weekOfMonth* 函数返回 *X* 的上一个月中第 *week* 个 *weekday* 对应的日期。\n\n如果 *X* >= *d* ，*weekOfMonth* 函数返回 *X* 所在月份的第 *week* 个 *weekday* 对应的日期。\n\n如果指定了 *offset* 和 *n*，且 *n* > 1，则函数按长度为 *n* 个月的周期计算。此时，*offset* 用于确定多月周期的对齐方式：系统会先根据 *week* 和 *weekday* 计算出 *offset* 所在月份对应的目标日期，然后以该日期为基准，每隔 *n* 个月更新一次结果，并返回 *X* 所属周期对应的目标日期。\n\n#### 参数\n\n**X** 可以是 DATE, DATETIME, TIMESTAMP 或 NANOTIMESTAMP 类型的标量或向量。\n\n**week** 是0到3的整数，表示第几个星期。默认值为0。\n\n**weekday** 是0到6之间的整数，表示星期编号。0表示星期一，1表示星期二，... ，6表示星期日。默认值为0。\n\n**offset** 是与 *X* 类型相同的标量，并且它必须小于等于 *X* 中的最小值。它是一个可选参数。如果没有指定，*offset* 默认为 *X* 中的最小值。\n\n**n** 是一个正整数。它是一个可选参数，默认值为1。\n\n#### 返回值\n\n一个 DATE 类型的标量或向量。\n\n#### 例子\n\n```\nweekOfMonth(2019.11.01,2,4);\n// output: 2019.10.18\n// 2019年11月的第三个星期五为2019.11.15，2019.11.01在2019.11.15之前，因此返回2019年10月的第三个星期五\n\nweekOfMonth(2019.11.20,2,4);\n// output: 2019.11.15\n\ndate=2012.01.02 2012.02.03 2012.03.07 2012.04.08 2012.05.12 2012.06.16 2012.07.18 2012.08.20 2012.09.25 2012.10.28\ntime = [09:34:07,09:36:42,09:36:51,09:36:59,09:32:47,09:35:26,09:34:16,09:34:26,09:38:12,09:38:13]\nsym = take(`MSFT,10)\nprice= 49.6 29.46 29.52 30.02 174.97 175.23 50.76 50.32 51.29 52.38\nqty = 2200 1900 2100 3200 6800 5400 1300 2500 8800 4500\nt1 = table(date, time, sym, qty, price);\n\nselect avg(price),sum(qty) from t1 group by weekOfMonth(date,3,4,2012.01.01,2);\n```\n\n| weekOfMonth\\_date | avg\\_price | sum\\_qty |\n| ----------------- | ---------- | -------- |\n| 2011.12.23        | 39.53      | 4100     |\n| 2012.02.24        | 29.77      | 5300     |\n| 2012.04.27        | 175.1      | 12200    |\n| 2012.06.22        | 50.54      | 3800     |\n| 2012.08.24        | 51.29      | 8800     |\n| 2012.10.26        | 52.38      | 4500     |\n"
    },
    "weekOfYear": {
        "url": "https://docs.dolphindb.cn/zh/funcs/w/weekOfYear.html",
        "signatures": [
            {
                "full": "weekOfYear(X)",
                "name": "weekOfYear",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [weekOfYear](https://docs.dolphindb.cn/zh/funcs/w/weekOfYear.html)\n\n\n\n#### 语法\n\nweekOfYear(X)\n\n#### 详情\n\n计算 *X* 的周数（1\\~53）。\n\n**Note:**\n\n* 该函数假设一周的第一天是周日，且每年的第一周至少有4天。\n* 如果12月31日是星期一、星期二或星期三，则该周为下一年的第 01 周。如果是星期四，则该周为刚刚结束的一年的第53周；如果是星期五，则该周为第52周（如果刚刚结束的年份是闰年，则该周为第53周）；如果是周六或周日，则该周为刚刚结束的一年的第52周。\n\n#### 参数\n\n**X** 可以是 DATE, DATETIME, TIMESTAMP 或 NANOTIMESTAMP 类型的标量或向量。\n\n#### 返回值\n\n一个整型标量或向量。\n\n#### 例子\n\n```\nweekOfYear(2012.01.07);\n```\n\n输出返回：1\n\n```\nweekOfYear(2013.01.07);\n```\n\n输出返回：2\n\n```\nweekOfYear(2012.07.02);\n```\n\n输出返回：27\n\n```\nweekOfYear([2012.06.12T12:30:00,2012.10.28T12:35:00,2013.01.06T12:36:47,2013.04.06T08:02:14]);\n```\n\n输出返回：\\[24,43,1,14]\n\n相关函数：[dayOfYear](https://docs.dolphindb.cn/zh/funcs/d/dayOfYear.html), [dayOfMonth](https://docs.dolphindb.cn/zh/funcs/d/dayOfMonth.html), [quarterOfYear](https://docs.dolphindb.cn/zh/funcs/q/quarterOfYear.html), [monthOfYear](https://docs.dolphindb.cn/zh/funcs/m/monthOfYear.html), [hourOfDay](https://docs.dolphindb.cn/zh/funcs/h/hourOfDay.html), [minuteOfHour](https://docs.dolphindb.cn/zh/funcs/m/minuteOfHour.html), [secondOfMinute](https://docs.dolphindb.cn/zh/funcs/s/secondOfMinute.html), [millisecond](https://docs.dolphindb.cn/zh/funcs/m/millisecond.html), [microsecond](https://docs.dolphindb.cn/zh/funcs/m/microsecond.html), [nanosecond](https://docs.dolphindb.cn/zh/funcs/n/nanosecond.html)\n"
    },
    "wilder": {
        "url": "https://docs.dolphindb.cn/zh/funcs/w/wilder.html",
        "signatures": [
            {
                "full": "wilder(X, window)",
                "name": "wilder",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    }
                ]
            }
        ],
        "markdown": "### [wilder](https://docs.dolphindb.cn/zh/funcs/w/wilder.html)\n\n\n\n#### 语法\n\nwilder(X, window)\n\nTA-lib 系列函数参数说明和窗口计算规则请参考：[TAlib](https://docs.dolphindb.cn/zh/funcs/themes/TAlib.html)\n\n#### 详情\n\n在给定长度（以元素个数衡量）的滑动窗口内，计算 *X* 的指数移动平均（Exponential Moving Average），该函数是 [ema](https://docs.dolphindb.cn/zh/funcs/e/ema.html) 的扩展。\n\n与 [ema](https://docs.dolphindb.cn/zh/funcs/e/ema.html) 的区别在于，该函数使用 Welles Wilder 指数平滑率，其计算公式为：\n\n![wilderXk](https://docs.dolphindb.cn/zh/images/wilderxk.png)\n\n其中：![wilderXk](https://docs.dolphindb.cn/zh/images/wilderxk_name.png)为第 k 个指数移动平均值，n 为移动窗口长度，![Xk](https://docs.dolphindb.cn/zh/images/xk.png) 为向量 ![X](https://docs.dolphindb.cn/zh/images/x.png) 中第 k 个元素。\n\n#### 返回值\n\n若 *X* 是向量，返回一个与 *X* 长度相同的向量；若 *X* 是矩阵，在每列内进行计算，返回一个与 *X* 维度相同的矩阵。\n\n#### 例子\n\n```\nx=12.1 12.2 12.6 12.8 11.9 11.6 11.2\nwilder(x,3);\n// output\n[,,12.299999999999998,12.466666666666668,12.27777777777778,12.051851851851854,11.767901234567903]\n\nx=matrix(12.1 12.2 12.6 12.8 11.9 11.6 11.2, 14 15 18 19 21 12 10)\nwilder(x,3);\n```\n\n| col1    | col2    |\n| ------- | ------- |\n|         |         |\n|         |         |\n| 12.3    | 15.6667 |\n| 12.4667 | 16.7778 |\n| 12.2778 | 18.1852 |\n| 12.0519 | 16.1235 |\n| 11.7679 | 14.0823 |\n\n相关函数：[ema](https://docs.dolphindb.cn/zh/funcs/e/ema.html), [gema](https://docs.dolphindb.cn/zh/funcs/g/gema.html), [tema](https://docs.dolphindb.cn/zh/funcs/t/tema.html)\n"
    },
    "winsorize": {
        "url": "https://docs.dolphindb.cn/zh/funcs/w/winsorize.html",
        "signatures": [
            {
                "full": "winsorize(X, limit, [inclusive=true], [nanPolicy='upper'])",
                "name": "winsorize",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "limit",
                        "name": "limit"
                    },
                    {
                        "full": "[inclusive=true]",
                        "name": "inclusive",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[nanPolicy='upper']",
                        "name": "nanPolicy",
                        "optional": true,
                        "default": "'upper'"
                    }
                ]
            }
        ],
        "markdown": "### [winsorize](https://docs.dolphindb.cn/zh/funcs/w/winsorize.html)\n\n\n\n#### 语法\n\nwinsorize(X, limit, \\[inclusive=true], \\[nanPolicy='upper'])\n\n#### 详情\n\n将向量 *X* 中指定百分比的极值掩盖。将第 (limits \\[0]) 个最低值设置为第 (limits \\[0]) 个百分位数，将第 (limits \\[1]) 个最高值设置为第 (1-limits \\[1]) 个百分位数。\n\n`winsorize!` 是 `winsorize` 的原地改变版本。\n\n#### 参数\n\n**X** 是一个向量。\n\n**limit** 是一个标量或两个元素组成的向量，表示相对于未屏蔽数据的数目，数组的每一侧要掩盖的百分比，取值为0到1之间。若为标量，表示每侧均要掩盖的百分比。若 *X* 有 n 个元素（包括 NULL值 ），第 (n \\* limit\\[0]) 个最小的元素和第 (n \\* limit\\[1]) 个最大的元素被屏蔽，未屏蔽的数据总数为 n \\*(1-sum(limit))。若 *limit* 中一个元素为0，表示此侧不掩盖。\n\n**inclusive** 是一个标量或两个元素组成的向量，表示在每一侧被屏蔽的数据数量应被截断（true）还是四舍五入（false）。\n\n**nanPolicy** 是一个字符串，表示如何处理 NULL 值。可取以下值，默认值为 'upper'。\n\n* 'upper'：将 NULL 值视为最大值进行掩盖。\n\n* 'lower'：将 NULL 值视为最小值进行掩盖。\n\n* 'raise'：抛出异常。\n\n* 'omit'：不掩盖 NULL 值。\n\n#### 返回值\n\n一个与 *X* 长度相同的向量。\n\n#### 例子\n\n```\nx=1..10\n// output\nwinsorize(x, 0.1);\n[2,2,3,4,5,6,7,8,9,9]\n\nwinsorize(x, 0.12 0.17);\n// output\n[2,2,3,4,5,6,7,8,9,9]\n\nwinsorize(x, 0.12 0.17, inclusive=false);\n// output\n[2,2,3,4,5,6,7,8,8,8]\n\n\nx=1..20;\nx[19:]=NULL;\nx;\n// output\n[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,]\n\nwinsorize(x, 0.1);\n// output\n[3,3,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,18,18]\n\nwinsorize(x, 0.1, nanPolicy='upper');\n// output\n[3,3,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,18,18]\n\nwinsorize(x, 0.1, nanPolicy='lower');\n// output\n[2,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,17,17,2]\n```\n"
    },
    "winsorize!": {
        "url": "https://docs.dolphindb.cn/zh/funcs/w/winsorize_.html",
        "signatures": [
            {
                "full": "winsorize!(X, limit, [inclusive=true], [nanPolicy='omit'])",
                "name": "winsorize!",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "limit",
                        "name": "limit"
                    },
                    {
                        "full": "[inclusive=true]",
                        "name": "inclusive",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[nanPolicy='omit']",
                        "name": "nanPolicy",
                        "optional": true,
                        "default": "'omit'"
                    }
                ]
            }
        ],
        "markdown": "### [winsorize!](https://docs.dolphindb.cn/zh/funcs/w/winsorize_.html)\n\n\n\n#### 语法\n\nwinsorize!(X, limit, \\[inclusive=true], \\[nanPolicy='omit'])\n\n#### 详情\n\n`winsorize!` 是 [winsorize](https://docs.dolphindb.cn/zh/funcs/w/winsorize.html) 函数原地修改版本，它会改变输入对象 *X* 的值。参考 [winsorize](https://docs.dolphindb.cn/zh/funcs/w/winsorize.html)\n"
    },
    "withdrawMCPPrompts": {
        "url": "https://docs.dolphindb.cn/zh/funcs/w/withdrawMCPPrompts.html",
        "signatures": [
            {
                "full": "withdrawMCPPrompts([names])",
                "name": "withdrawMCPPrompts",
                "parameters": [
                    {
                        "full": "[names]",
                        "name": "names",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [withdrawMCPPrompts](https://docs.dolphindb.cn/zh/funcs/w/withdrawMCPPrompts.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\nwithdrawMCPPrompts(\\[names])\n\n#### 详情\n\n撤销已发布的 MCP prompt 模板。\n\n#### 参数\n\n**names** 可选参数，STRING 类型标量或向量，表示 prompt 模板的名称。\n\n#### 返回值\n\n一个 STRING 类型向量，表示撤销成功的 prompt 模板。\n\n#### 例子\n\n```\nwithdrawMCPPrompts(\"stock_summary\")\n// output:[\"stock_summary\"]\n```\n"
    },
    "withdrawMCPTools": {
        "url": "https://docs.dolphindb.cn/zh/funcs/w/withdrawMCPTools.html",
        "signatures": [
            {
                "full": "withdrawMCPTools([names])",
                "name": "withdrawMCPTools",
                "parameters": [
                    {
                        "full": "[names]",
                        "name": "names",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [withdrawMCPTools](https://docs.dolphindb.cn/zh/funcs/w/withdrawMCPTools.html)\n\n首发版本：3.00.4\n\n\n\n#### 语法\n\nwithdrawMCPTools(\\[names])\n\n#### 详情\n\n撤销已发布的 MCP tool。\n\n#### 参数\n\n**names** 可选参数，STRING 类型标量或向量，表示 tool 的名称。\n\n#### 返回值\n\n一个 STRING 类型向量，表示撤销成功的 tool。\n\n#### 例子\n\n```\nwithdrawMCPTools(\"myTool\")\n```\n"
    },
    "wls": {
        "url": "https://docs.dolphindb.cn/zh/funcs/w/wls.html",
        "signatures": [
            {
                "full": "wls(Y, X, W, [intercept=true], [mode=0])",
                "name": "wls",
                "parameters": [
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "W",
                        "name": "W"
                    },
                    {
                        "full": "[intercept=true]",
                        "name": "intercept",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[mode=0]",
                        "name": "mode",
                        "optional": true,
                        "default": "0"
                    }
                ]
            }
        ],
        "markdown": "### [wls](https://docs.dolphindb.cn/zh/funcs/w/wls.html)\n\n\n\n#### 语法\n\nwls(Y, X, W, \\[intercept=true], \\[mode=0])\n\n#### 详情\n\n返回对 *X* 和 *Y* 计算加权最小二乘回归的结果。\n\n#### 参数\n\n**Y** 是因变量；**X** 是自变量。\n\n**Y** 是一个向量；**X** 是一个矩阵、表或元组。当 *X* 是矩阵时，如果行数等于 *Y* 的长度，*X* 的每一列都是一个因子；如果行数不等于 *Y* 的长度，并且如果列数等于 *Y* 的长度，*X* 的每一行都是一个因子。\n\n**W** 是一个向量，表示权重，各元素为一个非负数。\n\n**intercept** 是一个布尔变量，表示是否包含回归中的截距。默认值是 true。当它为 true 时，系统自动给 *X* 添加一列 \"1\" 以生成截距。\n\n**mode** 是一个整数，默认值为 0，可取以下 3 个值\n\n* 0：输出一个系数估计向量\n\n* 1：输出一个具有系数估计，标准差，t 统计量和 p 值的表\n\n* 2：输出一个具有 ANOVA（方差分析）、RegressionStat（回归统计）、Cofficient（系数）和 Residual（残差）的字典，具体含义见下表：\n\n键 ANOVA 对应值：\n\n| Source of Variance | 自由度（Degree of freedom） | 平方和（Sum of Square） | 均方差（Mean of square） | F统计量          | Significance |\n| ------------------ | ---------------------- | ------------------ | ------------------- | ------------- | ------------ |\n| Regression（回归）     | 变量个数（p）                | 回归平方和（SSR）         | 回归均方差（MSR=SSR/R）    | MSR 对 MSE 的比值 | 显著性，即统计出的P值  |\n| Residual（残差）       | 残差自由度（n-p-1）           | 残差平方和（SSE）         | 残差均方差（MSE=MSE/E）    |               |              |\n| Total              | 样本自由度， 不包括常数项（n-1）     | 总离差平方和（SST）        |                     |               |              |\n\n键 RegressionStat 对应值：\n\n| item         | 统计值                                                             |\n| ------------ | --------------------------------------------------------------- |\n| R2           | R 决定系数，描述回归曲线对真实数据点拟合程度的统计量。范围在\\[0,1]之间，越接近1 ，说明对y的解释能力越强，拟合越好。 |\n| AdjustedR2   | 经自由度修正后的决定系数，通过样本数量与模型数量对 R-squared 进行修正。                       |\n| StdError     | 回归残差标准误差，残差经自由度修正后的标准差。                                         |\n| Observations | 观察样本个数。                                                         |\n\n键 Coefficient 对应值：\n\n| 元素       | 说明                           |\n| -------- | ---------------------------- |\n| factor   | 自变量名称。                       |\n| beta     | 回归系数估计值。                     |\n| stdError | 回归系数标准误差。标准差越大，回归系数的估计值越不靠谱。 |\n| tstat    | T 统计值，衡量系数的统计显著性。            |\n\n键 Residual 对应每一个预测值和实际值之间的残差。\n\n#### 返回值\n\n取决于 *mode* 参数值。\n\n#### 例子\n\n```\nx1=1 3 5 7 11 16 23\nx2=2 8 11 34 56 54 100\ny=0.1 4.2 5.6 8.8 22.1 35.6 77.2;\nw=rand(10,7)​\nwls(y, x1, w)\n\n// output\n[-17.6177  4.0016]\n\nwls(y, (x1,x2), w);\n\n// output\n[-17.4168  3.0481 0.2214]\n```\n\n```\nwls(y, (x1,x2), w, 1, 1);\n```\n\n| factor    | beta     | stdError | tstat   | pvalue |\n| --------- | -------- | -------- | ------- | ------ |\n| Intercept | -17.4168 | 4.8271   | -3.6081 | 0.0226 |\n| x1        | 3.0481   | 1.6232   | 1.8779  | 0.1336 |\n| x2        | 0.2214   | 0.3699   | 0.5986  | 0.5817 |\n\n```\nwls(y, (x1,x2), w,1, 2);\n\n// output\nCoefficient->\nfactor    beta      stdError tstat     pvalue\n--------- --------- -------- --------- --------\nintercept -10.11392 4.866583 -2.078239 0.106234\nx1        3.938138  2.061191 1.910613  0.128655\nx2        -0.088542 0.446667 -0.198227 0.852534\n\nResidual->[6.452866,3.207839,-3.002812,-5.642629,-6.147264,-12.515038,5.590914]\nRegressionStat->\nitem         statistics\n------------ ----------\nR2           0.957998\nAdjustedR2   0.936997\nStdError     17.172833\nObservations 7\n\nANOVA->\nBreakdown  DF SS           MS           F         Significance\n---------- -- ------------ ------------ --------- ------------\nRegression 2  26905.306594 13452.653297 45.616718 0.001764\nResidual   4  1179.624835  294.906209\nTotal      6  28084.931429\n```\n\n```\nx=matrix(1 4 8 2 3, 1 4 2 3 8, 1 5 1 1 5);\nw=rand(8,5)\nwls(1..5, x,w,0,1);\n```\n\n| factor | beta   | stdError | tstat   | pvalue |\n| ------ | ------ | -------- | ------- | ------ |\n| beta0  | 0.0026 | 1.4356   | 0.0018  | 0.9988 |\n| beta1  | -1     | 1.2105   | -0.8261 | 0.5605 |\n| beta2  | 0.4511 | 0.5949   | 0.7582  | 0.587  |\n| beta3  | 1.687  | 1.7389   | 0.9701  | 0.5097 |\n"
    },
    "wma": {
        "url": "https://docs.dolphindb.cn/zh/funcs/w/wma.html",
        "signatures": [
            {
                "full": "wma(X, window)",
                "name": "wma",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "window",
                        "name": "window"
                    }
                ]
            }
        ],
        "markdown": "### [wma](https://docs.dolphindb.cn/zh/funcs/w/wma.html)\n\n\n\n#### 语法\n\nwma(X, window)\n\nTA-lib 系列函数参数说明和窗口计算规则请参考：[TAlib](https://docs.dolphindb.cn/zh/funcs/themes/TAlib.html)\n\n#### 详情\n\n在给定长度（以元素个数衡量）的滑动窗口内，计算 *X* 的加权移动平均（Weighted Moving Average）。\n\n其计算公式为：\n\n![wma](https://docs.dolphindb.cn/zh/images/wma.png)\n\n#### 返回值\n\n返回数值类型的结果，形式与 *X* 一致。\n\n#### 例子\n\n```\nx=12.1 12.2 12.6 12.8 11.9 11.6 11.2\nwma(x,3);\n// output\n[,,12.383333333333332,12.633333333333334,12.316666666666668,11.9,11.450000000000001]\n\nx=matrix(12.1 12.2 12.6 12.8 11.9 11.6 11.2, 14 15 18 19 21 12 10)\nwma(x,3);\n```\n\n| col1    | col2    |\n| ------- | ------- |\n|         |         |\n|         |         |\n| 12.3833 | 16.3333 |\n| 12.6333 | 18      |\n| 12.3167 | 19.8333 |\n| 11.9    | 16.1667 |\n| 11.45   | 12.5    |\n\n相关函数：[sma](https://docs.dolphindb.cn/zh/funcs/s/sma.html), [trima](https://docs.dolphindb.cn/zh/funcs/t/trima.html)\n"
    },
    "write": {
        "url": "https://docs.dolphindb.cn/zh/funcs/w/write.html",
        "signatures": [
            {
                "full": "write(handle, object, [offset=0], [length])",
                "name": "write",
                "parameters": [
                    {
                        "full": "handle",
                        "name": "handle"
                    },
                    {
                        "full": "object",
                        "name": "object"
                    },
                    {
                        "full": "[offset=0]",
                        "name": "offset",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[length]",
                        "name": "length",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [write](https://docs.dolphindb.cn/zh/funcs/w/write.html)\n\n\n\n#### 语法\n\nwrite(handle, object, \\[offset=0], \\[length])\n\n#### 详情\n\n`write` 函数把指定的缓冲区转换为字节流，并保存到文件中。缓冲区可以是各种数据类型。如果发生了错误，将抛出 IOException。否则，函数返回写入元素的个数（而不是字节数）。`read!` 函数将给定数量的元素读取到缓冲区。例如，如果缓冲区是 INT 向量，该函数将把文件中的字节转换为 INT。`write` 和 `read` 函数都涉及到流和字节之间的转换问题，和计算机科学中多字节的字的0端问题。大端的最重要位位于最低地址，而小端的最不重要位位于最低地址。`write` 函数总是使用操作系统的大小端。如果文件的大小端和操作系统的大小端不同，`read!` 函数将转换大小端。在使用 `file` 函数打开文件时，有可选的布尔参数用于表明文件采用的大小端。默认情况下，采用操作系统的大小端。\n\n#### 参数\n\n**handle** 文件句柄，表示写入的目标文件。\n\n**object** 要写入的数据对象，可以是各种数据类型的标量或向量。\n\n**offset** 可选参数，整型标量，表示从 *object* 的哪个位置开始写入，默认值为 0。\n\n**length** 可选参数，整型标量，表示要写入的元素个数（而非字节数）。若未指定，则从 *offset* 开始全部写入。\n\n#### 返回值\n\nLONG 类型标量。\n\n#### 例子\n\n```\nx=10h\ny=0h\nfile(\"test.bin\",\"w\").write(x);\n// output: 1\nfile(\"test.bin\",\"r\",true).read!(y);                // 假设文件格式是小端\n// output: 1\ny;\n// output: 10\nfile(\"test.bin\",\"r\",false).read!(y);        // 假设文件格式是大端\n// output: 1\ny;\n// output: 2560\n```\n"
    },
    "writeBytes": {
        "url": "https://docs.dolphindb.cn/zh/funcs/w/writeBytes.html",
        "signatures": [
            {
                "full": "writeBytes(handle, bytes)",
                "name": "writeBytes",
                "parameters": [
                    {
                        "full": "handle",
                        "name": "handle"
                    },
                    {
                        "full": "bytes",
                        "name": "bytes"
                    }
                ]
            }
        ],
        "markdown": "### [writeBytes](https://docs.dolphindb.cn/zh/funcs/w/writeBytes.html)\n\n\n\n#### 语法\n\nwriteBytes(handle, bytes)\n\n#### 详情\n\n`writeBytes` 函数把整个缓冲区写入文件。缓冲区必须是一个字符标量或字符向量。如果操作成功，函数返回实际写入的字节数；否则，抛出一个 IOException。\n\n#### 参数\n\n**handle** 文件句柄，表示写入的目标文件。\n\n**bytes** 字符类型标量或向量，表示要写入的数据对象。\n\n#### 返回值\n\n整型标量。\n\n#### 例子\n\n```\n// 定义一个文件复制函数\ndef fileCopy(source, target){\n   s = file(source)\n   len = s.seek(0,TAIL)\n   s.seek(0,HEAD)\n   t = file(target,\"w\")\n   if(len==0) return\n   do{\n       buf = s.readBytes(min(len,1024))\n       t.writeBytes(buf)\n       len -= buf.size()\n   }while(len)\n};\n\nfileCopy(\"test.txt\",\"testcopy.txt\");\n```\n"
    },
    "writeLine": {
        "url": "https://docs.dolphindb.cn/zh/funcs/w/writeLine.html",
        "signatures": [
            {
                "full": "writeLine(handle, string, [windowsLineEnding])",
                "name": "writeLine",
                "parameters": [
                    {
                        "full": "handle",
                        "name": "handle"
                    },
                    {
                        "full": "string",
                        "name": "string"
                    },
                    {
                        "full": "[windowsLineEnding]",
                        "name": "windowsLineEnding",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [writeLine](https://docs.dolphindb.cn/zh/funcs/w/writeLine.html)\n\n\n\n#### 语法\n\nwriteLine(handle, string, \\[windowsLineEnding])\n\n#### 详情\n\n在给定的句柄中写一行。函数自动将一个行分隔符添加到字符串结尾。所以字符串不应该以行分隔符结尾。如果该操作成功，函数返回 1；否则，将抛出一个 IOException。\n\n#### 参数\n\n**handle**句柄，指向目标文件或套接字的对象。\n\n**string** 字符串，表示要写入的一行文本，末尾不需要加换行符。\n\n**windowsLineEnding**可选参数，布尔值，用于指定是否强制使用 Windows 风格的换行符（ \\r\\n）。如果未指定该参数，换行符的默认行为如下：\n\n* 如果句柄是一个套接字，行结束符是 \\r\\n\n\n* 如果句柄是一个文件，且操作系统不是 Windows，行结束符是 \\n\n\n* 如果句柄是一个文件，且操作系统是 Windows，行结束符是 \\r\\n\n\n#### 返回值\n\n数字 1。\n\n#### 例子\n\n```\nx=`IBM`MSFT`GOOG`YHOO`ORCL\neachRight(writeLine, file(\"test.txt\",\"w\"), x);\n// output\n[1,1,1,1,1]\n\nfin = file(\"test.txt\")\ndo{\n   x=fin.readLine()\n   if(x.isVoid()) break\n   print x\n}\nwhile(true);\n\n// output\nIBM\nMSFT\nGOOG\nYHOO\nORCL\n```\n"
    },
    "writeLines": {
        "url": "https://docs.dolphindb.cn/zh/funcs/w/writeLines.html",
        "signatures": [
            {
                "full": "writeLines(handle, object, [offset=0], [length], [windowsLineEnding])",
                "name": "writeLines",
                "parameters": [
                    {
                        "full": "handle",
                        "name": "handle"
                    },
                    {
                        "full": "object",
                        "name": "object"
                    },
                    {
                        "full": "[offset=0]",
                        "name": "offset",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[length]",
                        "name": "length",
                        "optional": true
                    },
                    {
                        "full": "[windowsLineEnding]",
                        "name": "windowsLineEnding",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [writeLines](https://docs.dolphindb.cn/zh/funcs/w/writeLines.html)\n\n\n\n#### 语法\n\nwriteLines(handle, object, \\[offset=0], \\[length], \\[windowsLineEnding])\n\n#### 详情\n\n向句柄中写入给定的行数。\n\n#### 参数\n\n**length** 是往句柄中写入的行数。\n\n其他参数同 [writeLine](https://docs.dolphindb.cn/zh/funcs/w/writeLine.html) 函数。\n\n#### 返回值\n\n整型标量，表示成功写入的行数。\n\n#### 例子\n\n```\ntimer(10){\n   x=rand(`IBM`MSFT`GOOG`YHOO`ORCL,10240)\n   eachRight(writeLine, file(\"test.txt\",\"w\"),x)\n   fin = file(\"test.txt\")\n   do{ y=fin.readLine() } while(!y.isVoid())\n    fin.close()\n};\n\n// output\nTime elapsed: 277.548 ms\n\ntimer(10){\n   x=rand(`IBM`MSFT`GOOG`YHOO`ORCL,10240)\n   file(\"test.txt\",\"w\").writeLines(x)\n   fin = file(\"test.txt\")\n   do{ y=fin.readLines(1024) } while(y.size()==1024)\n   fin.close()\n};\n\n// output\nTime elapsed: 28.003 ms\n\n```\n"
    },
    "writeLog": {
        "url": "https://docs.dolphindb.cn/zh/funcs/w/writeLog.html",
        "signatures": [
            {
                "full": "writeLog(X1, [X2, X3....Xn])",
                "name": "writeLog",
                "parameters": [
                    {
                        "full": "X1",
                        "name": "X1"
                    },
                    {
                        "full": "[X2",
                        "name": "[X2"
                    },
                    {
                        "full": "X3....Xn]",
                        "name": "X3....Xn]"
                    }
                ]
            }
        ],
        "markdown": "### [writeLog](https://docs.dolphindb.cn/zh/funcs/w/writeLog.html)\n\n\n\n#### 语法\n\nwriteLog(X1, \\[X2, X3....Xn])\n\n#### 详情\n\n在日志文件中写入日志。该函数必须要用户登录后才能执行。\n\n#### 参数\n\n**X1**, **X2**, **X3** ... **Xn** 是要写入日志文件的字符串。每个字符串都是日志文件中的一行。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\nwriteLog(\"This is a message written into the log file.\")\nwriteLog(\"line1.\",\"line2.\",\"line3\");\n\n// Check the log file.\n// output\nSun Aug 06 16:41:05 2017 <INFO> :This is a message written into the log file.\nSun Aug 06 16:50:35 2017 <INFO> :line1.\nSun Aug 06 16:50:35 2017 <INFO> :line2.\nSun Aug 06 16:50:35 2017 <INFO> :line3\n```\n"
    },
    "writeLogLevel": {
        "url": "https://docs.dolphindb.cn/zh/funcs/w/writeloglevel.html",
        "signatures": [
            {
                "full": "writeLogLevel(level,X1,[X2, X3,...,Xn])",
                "name": "writeLogLevel",
                "parameters": [
                    {
                        "full": "level",
                        "name": "level"
                    },
                    {
                        "full": "X1",
                        "name": "X1"
                    },
                    {
                        "full": "[X2",
                        "name": "[X2"
                    },
                    {
                        "full": "X3",
                        "name": "X3"
                    },
                    {
                        "full": "...",
                        "name": "..."
                    },
                    {
                        "full": "Xn]",
                        "name": "Xn]"
                    }
                ]
            }
        ],
        "markdown": "### [writeLogLevel](https://docs.dolphindb.cn/zh/funcs/w/writeloglevel.html)\n\n\n\n#### 语法\n\nwriteLogLevel(level,X1,\\[X2, X3,...,Xn])\n\n#### 详情\n\n在日志文件中写入指定等级的日志。该命令只能由管理员调用。\n\n**Note:**\n\n*level* 的等级必须等于或高于配置项 *logLevel* 或命令 `setLogLevel` 设置的等级，否则不会输出日志到文件中。\n\n#### 参数\n\n**level** 日志等级，从低到高可选值为：DEBUG, INFO, WARNING, ERROR，分别对应数字 0, 1, 2, 3。\n\n**X1**, **X2**, **X3** ... **Xn** 要写入日志文件的内容。每个 Xi 都是日志文件中的一行。支持以下数据类型：Logical, Integral, Temporal, Floating, Literal, Decimal。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\nwriteLogLevel(INFO,111111111111,\"This is an INFO message\") \n// Check the log file.\n<INFO> :111111111111\n<INFO> :This is an INFO message\n```\n"
    },
    "writeObject": {
        "url": "https://docs.dolphindb.cn/zh/funcs/w/writeObject.html",
        "signatures": [
            {
                "full": "writeObject(handle, object)",
                "name": "writeObject",
                "parameters": [
                    {
                        "full": "handle",
                        "name": "handle"
                    },
                    {
                        "full": "object",
                        "name": "object"
                    }
                ]
            }
        ],
        "markdown": "### [writeObject](https://docs.dolphindb.cn/zh/funcs/w/writeObject.html)\n\n\n\n#### 语法\n\nwriteObject(handle, object)\n\n#### 详情\n\n*object* 是要写入的数据，可以把所有类型的数据结构（包括标量、向量、矩阵、集合、字典和表）写入句柄。该函数必须要用户登录后才能执行。\n\n#### 返回值\n\n无。\n\n#### 例子\n\n```\na1=10.5\na2=1..10\na3=cross(*,1..5,1..10)\na4=set(`IBM`MSFT`GOOG`YHOO)\na5=dict(a4.keys(),125.6 53.2 702.3 39.7)\na6=table(1 2 3 as id, `Jenny`Tom`Jack as name)\na7=(1 2 3, \"hello world!\", 25.6);\nfout=file(\"test.bin\",\"w\")\nfout.writeObject(a1)\nfout.writeObject(a2)\nfout.writeObject(a3)\nfout.writeObject(a4)\nfout.writeObject(a5)\nfout.writeObject(a6)\nfout.writeObject(a7)\nfout.close();\n```\n"
    },
    "writeRecord": {
        "url": "https://docs.dolphindb.cn/zh/funcs/w/writeRecord.html",
        "signatures": [
            {
                "full": "writeRecord(handle, object, [offset=0], [length])",
                "name": "writeRecord",
                "parameters": [
                    {
                        "full": "handle",
                        "name": "handle"
                    },
                    {
                        "full": "object",
                        "name": "object"
                    },
                    {
                        "full": "[offset=0]",
                        "name": "offset",
                        "optional": true,
                        "default": "0"
                    },
                    {
                        "full": "[length]",
                        "name": "length",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [writeRecord](https://docs.dolphindb.cn/zh/funcs/w/writeRecord.html)\n\n\n\n#### 语法\n\nwriteRecord(handle, object, \\[offset=0], \\[length])\n\n#### 详情\n\n`writeRecord` 函数把 DolphinDB 对象（例如表或元组）转换为二进制文件。\n\n#### 参数\n\n**handle** 是二进制文件句柄。\n\n**object** 是一个表或一个由多个等长向量组成的元组。\n\n**offset** 表示写入的起始位置。\n\n**length** 是向文件写入的行数。\n\n#### 返回值\n\n整型标量，表示向文件写入的行数。\n\n#### 例子\n\n```\nt=table(1..10000 as id, 1..10000+100 as value);\n\nf1=file(\"C:/DolphinDB/a.bin\", \"w\");        // 创建一个用于写入记录的文件句柄\nf1.writeRecord(t);\n// output\n10000\n\nf2=file(\"C:/DolphinDB/b.bin\", \"w\");\nf2.writeRecord(t, 100, 1000);\n// output\n1000\n\nf3=file(\"C:/DolphinDB/c.bin\", \"w\");\nf3.writeRecord(t, 100, 10000);\n// output\nThe optional argument length is invalid.\n```\n"
    },
    "wslr": {
        "url": "https://docs.dolphindb.cn/zh/funcs/w/wslr.html",
        "signatures": [
            {
                "full": "wslr(Y, X, W, [mse=false])",
                "name": "wslr",
                "parameters": [
                    {
                        "full": "Y",
                        "name": "Y"
                    },
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "W",
                        "name": "W"
                    },
                    {
                        "full": "[mse=false]",
                        "name": "mse",
                        "optional": true,
                        "default": "false"
                    }
                ]
            }
        ],
        "markdown": "### [wslr](https://docs.dolphindb.cn/zh/funcs/w/wslr.html)\n\n\n\n#### 语法\n\nwslr(Y, X, W, \\[mse=false])\n\n#### 详情\n\nwslr 是 weighted single linear regression 的缩写，计算 Y 在 X 上加权线性回归的结果。返回一个元组，其元素依次代表截距 alpha、回归系数 beta 和残差均方差 mse (若有)。\n\n其中\n\n![](https://docs.dolphindb.cn/zh/images/wslr.png)\n\nn 为非空数据个数。\n\n相比于函数 wls：\n\n* wls 以向量的形式返回结果，wslr 返回元组\n\n* wls 是向量函数，wlsr 是聚合函数\n\n* wls 可在查询时应用于分布式表，wlsr 不支持\n\n#### 参数\n\n**Y** INTEGRAL, FLOATING 或 DECIMAL类型向量，表示因变量。\n\n**X**INTEGRAL, FLOATING 或 DECIMAL类型向量，表示自变量。\n\n**W** INTEGRAL, FLOATING 或 DECIMAL类型向量，表示权重，其元素非负。\n\n**mse**布尔标量，设置是否输出残差均方差。默认值为false，表示不输出。\n\n其中，Y, X, W 的长度必须相等。\n\n#### 返回值\n\n一个元组。\n\n#### 例子\n\n```\nx = [0.78,0.38,0.2,0.52,0.12,0.49,0.02,0.67,0.94,0.85]\ny = [0.11,0.63,0.19,0.36,0.02,0.35,0.98,0.07,0.55,0.43]\nw = [0.05665,0.155172,0.142857,0.236453,0.125616,0.061576,0.064039,0.051724,0.004926,0.100985]\nwslr(y,x,w)\n//output:(0.385342531009792,-0.076256407696962)\nwslr(y,x,w,true)\n//output:(0.385342531009792,-0.076256407696962,0.007842049148797)\n```\n\n由于 wls 是向量函数，无法直接与 moving 结合使用，需要用户自定义聚合函数。而 wlsr 可直接与 moving 结合使用。\n\n```\ns = [\"001\",\"002\",\"003\",\"004\",\"005\",\"006\",\"007\",\"008\",\"009\",\"010\"]\ny = [0.2531,0.5672,0.8347,0.6436,0.699,0.3732,0.0676,0.9129,0.0167,0.755]\nx = [0.5782,0.8064,0.5035,0.7857,0.5955,0.4156,0.7609,0.093,0.6504,0.9092]\nw = [0,0.095909021199675,0.195930114343433,0.300024080233914,0.408136784222979]\n\nt = table(s,y,x)\nselect moving(wslr{,,w,true},[y,x],5,5) as `alpha`beta`mse from t\n```\n\n| alpha               | beta                 | mse                   |\n| ------------------- | -------------------- | --------------------- |\n|                     |                      |                       |\n|                     |                      |                       |\n|                     |                      |                       |\n|                     |                      |                       |\n| 1.0968659790128028  | -0.6117304039349463  | 0.0004078518285504836 |\n| 0.14198850512877909 | 0.7741808484080007   | 0.005713017371341482  |\n| 0.7303333678486678  | -0.6250737654103594  | 0.01852879218352463   |\n| 1.0082522818242372  | -1.1740015481453143  | 0.006523442161727362  |\n| 1.0214599029781481  | -1.4342061326057263  | 0.002086531347398113  |\n| 0.6657822330605759  | -0.25445296261591593 | 0.04738923724610222   |\n"
    },
    "wsum": {
        "url": "https://docs.dolphindb.cn/zh/funcs/w/wsum.html",
        "signatures": [
            {
                "full": "wsum(X, Y)",
                "name": "wsum",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [wsum](https://docs.dolphindb.cn/zh/funcs/w/wsum.html)\n\n\n\n#### 语法\n\nwsum(X, Y)\n\n#### 详情\n\n返回 *X* 和 *Y* 的内积。即使 *X* 和 *Y* 都是整型，返回结果仍为 DOUBLE 类型。\n\n#### 参数\n\n**X** 和 **Y** 可以是标量、向量、矩阵或表。\n\n#### 返回值\n\nDOUBLE 类型的标量/向量/表。\n\n#### 例子\n\n```\nwsum(7 8 9, 1 2 3);\n// output\n50\n// 7*1 + 8*2 + 9*3 = 50\n```\n\n相关函数：[wavg](https://docs.dolphindb.cn/zh/funcs/w/wavg.html)\n"
    },
    "wsum2": {
        "url": "https://docs.dolphindb.cn/zh/funcs/w/wsum2.html",
        "signatures": [
            {
                "full": "wsum2(X, Y)",
                "name": "wsum2",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [wsum2](https://docs.dolphindb.cn/zh/funcs/w/wsum2.html)\n\n\n\n#### 语法\n\nwsum2(X, Y)\n\n#### 详情\n\n返回 *X* 和 *Y* 的加权平方和。即使 *X* 和 *Y* 都是整型，返回结果仍为 DOUBLE 类型。\n\n#### 参数\n\n**X** 和 **Y** 可以是标量、向量、矩阵或表。\n\n#### 返回值\n\nDOUBLE 类型的标量/向量/表。\n\n#### 例子\n\n```\nwsum2(3 4 1, 1 2 3);\n// output\n44\n// 9*1 + 16*2 + 1*3 = 44\n```\n\n相关函数：[wsum](https://docs.dolphindb.cn/zh/funcs/w/wsum.html)\n"
    },
    "xdb": {
        "url": "https://docs.dolphindb.cn/zh/funcs/x/xdb.html",
        "signatures": [
            {
                "full": "xdb(siteAlias, [userId], [password], [enableSSL])",
                "name": "xdb",
                "parameters": [
                    {
                        "full": "siteAlias",
                        "name": "siteAlias"
                    },
                    {
                        "full": "[userId]",
                        "name": "userId",
                        "optional": true
                    },
                    {
                        "full": "[password]",
                        "name": "password",
                        "optional": true
                    },
                    {
                        "full": "[enableSSL]",
                        "name": "enableSSL",
                        "optional": true
                    }
                ]
            },
            {
                "full": "xdb(host, port, [userId], [password], [enableSSL])",
                "name": "xdb",
                "parameters": [
                    {
                        "full": "host",
                        "name": "host"
                    },
                    {
                        "full": "port",
                        "name": "port"
                    },
                    {
                        "full": "[userId]",
                        "name": "userId",
                        "optional": true
                    },
                    {
                        "full": "[password]",
                        "name": "password",
                        "optional": true
                    },
                    {
                        "full": "[enableSSL]",
                        "name": "enableSSL",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [xdb](https://docs.dolphindb.cn/zh/funcs/x/xdb.html)\n\n\n\n#### 语法\n\nxdb(siteAlias, \\[userId], \\[password], \\[enableSSL])\n\n或\n\nxdb(host, port, \\[userId], \\[password], \\[enableSSL])\n\n#### 详情\n\n连接到节点的远程站点。如果连接成功，则返回远程连接的句柄。\n\n#### 参数\n\n**siteAlias** 是远程节点的别名。它需要在配置文件中定义。\n\n**host** 是远程节点的主机名（IP 地址或站点）。\n\n**port** 整型，是远程节点的端口号。\n\n**userId** 和 **password** 可选参数。基于用户的配置文件。如果管理员启用用户访问控制，需要输入用户名和密码。\n\n**enableSSL** 可选参数。布尔值，表示是否使用 SSL 协议进行加密通信。默认值为 false。\n\n#### 返回值\n\nHANDLE 类型，表示远程连接的句柄。\n\n#### 例子\n\n```\nh2=xdb(\"local8081\");\nh2;\n// output\n\"Conn[localhost:8081:1166953221]\"\n\nh21=xdb(\"localhost\",8081);\nh21;\n// output\n\"Conn[localhost:8081:1441295757]\"\n\nh4=xdb(\"local8083\",\"userAdm\",\"passAdm\");\nh4;\n// output\n\"Conn[localhost:8083:1166953221]\"\n\nh41=xdb(\"localhost\",8083, \"user001\",\"pass001\");\nh41;\n// output\n\"Conn[localhost:8083:597793698]\"\n```\n"
    },
    "xor": {
        "url": "https://docs.dolphindb.cn/zh/funcs/x/xor.html",
        "signatures": [
            {
                "full": "xor(X, Y)",
                "name": "xor",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "Y",
                        "name": "Y"
                    }
                ]
            }
        ],
        "markdown": "### [xor](https://docs.dolphindb.cn/zh/funcs/x/xor.html)\n\n\n\n#### 语法\n\nxor(X, Y)\n\n#### 详情\n\n按元素逐个返回 *X* 逻辑异或 (`XOR`)*Y* 的结果。\n\n#### 参数\n\n**X** 和 **Y** 可以是标量、数据对、向量、矩阵或表。\n\n#### 返回值\n\n布尔型标量、数据对、向量、矩阵或表，表示 *X* 逻辑异或 *Y* 的结果。\n\n#### 例子\n\n```\n1 xor 0\n// output: true\n\nx = 5 6 7\nx xor 0\n// output: [true,true,true]\n\nx = 1 2 3\ny = 2 1 3\nx xor y\n// output: [false,false,false]\n\ntrue xor false\n// output: true\n```\n\n相关函数：[or](https://docs.dolphindb.cn/zh/funcs/o/or.html), [not](https://docs.dolphindb.cn/zh/funcs/n/not.html)\n"
    },
    "zigzag": {
        "url": "https://docs.dolphindb.cn/zh/funcs/z/zigzag.html",
        "signatures": [
            {
                "full": "zigzag(HL, [change=10], [percent=true], [retrace=false], [lastExtreme=true])",
                "name": "zigzag",
                "parameters": [
                    {
                        "full": "HL",
                        "name": "HL"
                    },
                    {
                        "full": "[change=10]",
                        "name": "change",
                        "optional": true,
                        "default": "10"
                    },
                    {
                        "full": "[percent=true]",
                        "name": "percent",
                        "optional": true,
                        "default": "true"
                    },
                    {
                        "full": "[retrace=false]",
                        "name": "retrace",
                        "optional": true,
                        "default": "false"
                    },
                    {
                        "full": "[lastExtreme=true]",
                        "name": "lastExtreme",
                        "optional": true,
                        "default": "true"
                    }
                ]
            }
        ],
        "markdown": "### [zigzag](https://docs.dolphindb.cn/zh/funcs/z/zigzag.html)\n\n\n\n#### 语法\n\nzigzag(HL, \\[change=10], \\[percent=true], \\[retrace=false], \\[lastExtreme=true])\n\n#### 详情\n\n`zigzag` 主要用于过滤掉 *HL* 中较小波动的值，只有满足条件的极值点会被输出。\n\n#### 参数\n\n**HL** 数值向量或者包含两列的数值矩阵。\n\n**change** 极值波动的最小阈值。\n\n**percent** 布尔值，表示 *change* 是否是一个百分数。\n\n**retrace** 是一个布尔值，默认为 false。\n\n* true：*change* 当前值相对于前一次波动的回撤。\n\n* false：*change* 当前值相对于两端极值点间的变化。\n\n**Note:**\n\n当 *percent*=false 时， *retrace* 的 true 值将不生效。\n\n**lastExtreme** 布尔值，表示有多个连续且值相同的极值点时，是否输出最后一个极值点，默认为 true。\n\n#### 返回值\n\n若 *HL* 是向量，返回一个与 *HL* 长度相同的向量；若 *HL* 是矩阵，返回与 *HL* 行数相同的向量。\n\n#### 例子\n\n```\nt = table(1.1 2.3 4.45 3.67 4.9 as `low, 1.3 2.8 4.9 3.73 6.28 as `high)\nHL = matrix(t[`low], t[`high])\nzz = zigzag(HL, change=10, percent=true, retrace=false, lastExtreme=true)\nzz;\n```\n\n| 0   | 1 | 2    | 3    | 4   |\n| --- | - | ---- | ---- | --- |\n| 1.2 |   | 4.45 | 3.73 | 4.9 |\n\n```\nHL = 1.2 3 3.1 14 14.5 14.7 25.0 17.8 19 10\nzz = zigzag(HL, change=10, percent=true, retrace=false, lastExtreme=true)\nzz;\n```\n\n| 0   | 1 | 2 | 3 | 4 | 5 | 6  | 7 | 8 | 9  |\n| --- | - | - | - | - | - | -- | - | - | -- |\n| 1.2 |   |   |   |   |   | 25 |   |   | 10 |\n"
    },
    "zscore": {
        "url": "https://docs.dolphindb.cn/zh/funcs/z/zscore.html",
        "signatures": [
            {
                "full": "zscore(X)",
                "name": "zscore",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [zscore](https://docs.dolphindb.cn/zh/funcs/z/zscore.html)\n\n\n\n#### 语法\n\nzscore(X)\n\n#### 详情\n\n若 *X* 为向量，为 *X* 中的每个元素计算标准分数（z-score）。\n\n若 *X* 为矩阵或表，上述计算对每列分别进行。\n\n计算中使用了样本标准差，而不是总体标准差。\n\n**Note:**\n\nDolphinDB `zscore` 和 [scipy.stats.zscore](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.zscore.html) 都用于计算标准分数（Z-score）。区别如下：\n\n* DolphinDB `zscore` 使用样本标准差进行计算，而 `scipy.stats.zscore` 默认使用总体标准差；当需要得到与 DolphinDB `zscore` 一致的结果时，应指定 *ddof*=1。\n* DolphinDB `zscore` 会自动忽略 NULL 值，而 `scipy.stats.zscore` 默认会传播 NaN，如需忽略缺失值，应指定 *nan\\_policy*='omit'。\n* DolphinDB `zscore` 仅支持一个参数 *X*；而 `scipy.stats.zscore` 可通过 *axis*、*ddof* 和 *nan\\_policy* 参数更灵活地控制计算行为。\n\n#### 参数\n\n**X** 是一个向量、矩阵或表。\n\n#### 返回值\n\n若 *X* 为向量，返回一个与 *X* 长度相等的向量；若 *X* 为矩阵或表，返回一个与 *X* 行列数相同的矩阵或表。\n\n#### 例子\n\n```\nzscore(1 2 3 4 5);\n// output\n[-1.264911,-0.632456,0,0.632456,1.264911]\n\nm=matrix(1 2 3, 4 5 6);\nm;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1  | 4  |\n| 2  | 5  |\n| 3  | 6  |\n\n```\nzscore(m);\n```\n\n| #0 | #1 |\n| -- | -- |\n| -1 | -1 |\n| 0  | 0  |\n| 1  | 1  |\n"
    },
    "zTest": {
        "url": "https://docs.dolphindb.cn/zh/funcs/z/zTest.html",
        "signatures": [
            {
                "full": "zTest(X, [Y], [mu=0.0], [sigmaX=1.0], [sigmaY=1.0], [confLevel=0.95])",
                "name": "zTest",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[Y]",
                        "name": "Y",
                        "optional": true
                    },
                    {
                        "full": "[mu=0.0]",
                        "name": "mu",
                        "optional": true,
                        "default": "0.0"
                    },
                    {
                        "full": "[sigmaX=1.0]",
                        "name": "sigmaX",
                        "optional": true,
                        "default": "1.0"
                    },
                    {
                        "full": "[sigmaY=1.0]",
                        "name": "sigmaY",
                        "optional": true,
                        "default": "1.0"
                    },
                    {
                        "full": "[confLevel=0.95]",
                        "name": "confLevel",
                        "optional": true,
                        "default": "0.95"
                    }
                ]
            }
        ],
        "markdown": "### [zTest](https://docs.dolphindb.cn/zh/funcs/z/zTest.html)\n\n\n\n#### 语法\n\nzTest(X, \\[Y], \\[mu=0.0], \\[sigmaX=1.0], \\[sigmaY=1.0], \\[confLevel=0.95])\n\n#### 详情\n\n如果没有指定 *Y*，对正态分布 *X* 进行单样本 Z 检验。如果指定了 *Y*，对独立正态分布 *X* 和 *Y* 进行双样本 Z 检验。\n\n#### 参数\n\n**X** 是一个数值向量，表示用于 Z 检验的样本。\n\n**Y** 是一个数值向量，表示用于独立双样本 Z 检验的另一个样本。它是一个可选参数。\n\n**mu** 是一个浮点数，默认值是0。如果没有指定 *Y*，*mu* 表示 *X* 的均值的假设值；如果指定了 *Y*，*mu* 表示 *X*、*Y* 均值之差的假设值。\n\n**sigmaX** 是一个浮点数，表示 *X* 的标准差。默认值是1。\n\n**sigmaY** 是一个浮点数，表示 *Y* 的标准差。默认值是1。\n\n**confLevel** 是0到1之间的浮点数，表示置信区间的置信水平。\n\n#### 返回值\n\n一个字典，包含以下 key：\n\n* stat：一张表，包含三种不同备择假设下的 p 值和置信区间\n\n* confLevel：置信水平\n\n* method：如果没有指定 *Y*，为字符串 \"One sample z-test\"；如果指定了 *Y*，为字符串 \"Two sample z-test\"\n\n* zValue：z 的统计量\n\n#### 例子\n\n单样本 Z 检验：\n\n```\nx = norm(5.0, 2.0, 30)\nzTest(x, , 5.0, 2.0);\n\n// output\nstat->\n\nalternativeHypothesis       pValue   lowerBound upperBound\n--------------------------- -------- ---------- -----------\ntrue mean is not equal to 5 0.035765 3.517659   4.949014\ntrue mean is less than 5    0.017882 -Infinity  4.833952\ntrue mean is greater than 5 0.982118 3.632721   Infinity\n\nconfLevel->0.95\nmethod->One sample z-test\nzValue->-2.099594\n```\n\n双样本 Z 检验：\n\n```\nx = norm(5.0, 2.0, 30)\ny = norm(10.0, 3.0, 40)\nzTest(x, y, -5.0, 2.0, 3.0);\n\n// output\nstat->\n\n------------------------------------- -------- ---------- -----------\nalternativeHypothesis                 pValue   lowerBound upperBound\ndifference of mean is not equal to -5 0.976133 -6.191162  -3.844655\ndifference of mean is less than -5    0.488067 -Infinity  -4.033283\ndifference of mean is greater than -5 0.511933 -6.002533  Infinity\n\nconfLevel->0.95\nmethod->Two sample z-test\nzValue->-0.029917\n```\n"
    },
    "year": {
        "url": "https://docs.dolphindb.cn/zh/funcs/y/year.html",
        "signatures": [
            {
                "full": "year(X)",
                "name": "year",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    }
                ]
            }
        ],
        "markdown": "### [year](https://docs.dolphindb.cn/zh/funcs/y/year.html)\n\n\n\n#### 语法\n\nyear(X)\n\n#### 详情\n\n根据输入的值得到其对应的年份。\n\n#### 参数\n\n**X** 是一个时间标量或向量。\n\n#### 返回值\n\n一个 INT 类型的标量或向量。\n\n#### 例子\n\n```\nyear(2012.12.03);\n```\n\n返回：2012\n\n```\nyear(2012.12.03 2011.11.05);\n```\n\n返回：\\[2012,2011]\n\n```\n(2012.12.03).year();\n```\n\n返回：2012\n"
    },
    "yearBegin": {
        "url": "https://docs.dolphindb.cn/zh/funcs/y/yearBegin.html",
        "signatures": [
            {
                "full": "yearBegin(X, [startingMonth=1], [offset], [n=1])",
                "name": "yearBegin",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[startingMonth=1]",
                        "name": "startingMonth",
                        "optional": true,
                        "default": "1"
                    },
                    {
                        "full": "[offset]",
                        "name": "offset",
                        "optional": true
                    },
                    {
                        "full": "[n=1]",
                        "name": "n",
                        "optional": true,
                        "default": "1"
                    }
                ]
            }
        ],
        "markdown": "### [yearBegin](https://docs.dolphindb.cn/zh/funcs/y/yearBegin.html)\n\n\n\n#### 语法\n\nyearBegin(X, \\[startingMonth=1], \\[offset], \\[n=1])\n\n#### 详情\n\n返回 *X* 所在的以 *startingMonth* 为起始月份的年份的第一天。\n\n默认情况下，一个周期对应一年，函数返回 *X* 所在年度的第一天。年度的起始月份由参数 *startingMonth* 决定。 如果指定了 *offset* 和 *n*，且 *n* > 1，则函数按长度为 *n* 年的周期计算。此时，*offset* 用于确定多年周期的对齐方式：系统会先根据 *startingMonth* 计算出 *offset* 所在年度的第一天，然后以该日期为基准，每隔 *n* 年生成一个周期起始边界，并返回 *X* 所属周期对应的日期。\n\n#### 参数\n\n**X** 可以是 DATE, DATETIME, DATEHOUR, TIMESTAMP 或 NANOTIMESTAMP 类型的标量或向量。\n\n**startingMonth** 是1到12之间的整数，表示一年的起始月份。默认值是1。\n\n**offset** 是与 *X* 类型相同的标量，并且它必须小于等于 *X* 中的最小值。它是一个可选参数。如果没有指定，*offset* 默认为 *X* 中的最小值。\n\n**n** 是一个正整数。它是一个可选参数，默认值为1。\n\n#### 返回值\n\n一个 DATE 类型的标量或向量。\n\n#### 例子\n\n```\nyearBegin(2012.06.12, 10);\n// output: 2011.10.01\n\nyearBegin(2012.06.12, 4);\n// output: 2012.04.01\n\nyearBegin(2012.06.12);\n// output: 2012.01.01\n\nyearBegin(2012.06.12, 1, 2009.04.03, 2);\n// output: 2011.01.01\n\ndate=2011.04.25+(1..10)*365\ntime = take(09:30:00, 10);\nsym = take(`MSFT,10)\nprice= 49.6 29.46 29.52 30.02 174.97 175.23 50.76 50.32 51.29 52.38\nqty = 2200 1900 2100 3200 6800 5400 1300 2500 8800 4500\nt1 = table(date, time, sym, qty, price);\n\nt1;\n```\n\n| date       | time     | sym  | qty  | price  |\n| ---------- | -------- | ---- | ---- | ------ |\n| 2012.04.24 | 09:30:00 | MSFT | 2200 | 49.6   |\n| 2013.04.24 | 09:30:00 | MSFT | 1900 | 29.46  |\n| 2014.04.24 | 09:30:00 | MSFT | 2100 | 29.52  |\n| 2015.04.24 | 09:30:00 | MSFT | 3200 | 30.02  |\n| 2016.04.23 | 09:30:00 | MSFT | 6800 | 174.97 |\n| 2017.04.23 | 09:30:00 | MSFT | 5400 | 175.23 |\n| 2018.04.23 | 09:30:00 | MSFT | 1300 | 50.76  |\n| 2019.04.23 | 09:30:00 | MSFT | 2500 | 50.32  |\n| 2020.04.22 | 09:30:00 | MSFT | 8800 | 51.29  |\n| 2021.04.22 | 09:30:00 | MSFT | 4500 | 52.38  |\n\n```\nselect avg(price),sum(qty) from t1 group by yearBegin(date, 10, 2010.10.01, 2);\n```\n\n| yearBegin\\_date | avg\\_price | sum\\_qty |\n| --------------- | ---------- | -------- |\n| 2010.10.01      | 49.6       | 2200     |\n| 2012.10.01      | 29.49      | 4000     |\n| 2014.10.01      | 102.495    | 10000    |\n| 2016.10.01      | 112.995    | 6700     |\n| 2018.10.01      | 50.805     | 11300    |\n| 2020.10.01      | 52.38      | 4500     |\n\n相关函数：[yearEnd](https://docs.dolphindb.cn/zh/funcs/y/yearEnd.html), [businessYearBegin](https://docs.dolphindb.cn/zh/funcs/b/businessYearBegin.html), [businessYearEnd](https://docs.dolphindb.cn/zh/funcs/b/businessYearEnd.html)\n"
    },
    "yearEnd": {
        "url": "https://docs.dolphindb.cn/zh/funcs/y/yearEnd.html",
        "signatures": [
            {
                "full": "yearEnd(X, [endingMonth=12], [offset], [n=1])",
                "name": "yearEnd",
                "parameters": [
                    {
                        "full": "X",
                        "name": "X"
                    },
                    {
                        "full": "[endingMonth=12]",
                        "name": "endingMonth",
                        "optional": true,
                        "default": "12"
                    },
                    {
                        "full": "[offset]",
                        "name": "offset",
                        "optional": true
                    },
                    {
                        "full": "[n=1]",
                        "name": "n",
                        "optional": true,
                        "default": "1"
                    }
                ]
            }
        ],
        "markdown": "### [yearEnd](https://docs.dolphindb.cn/zh/funcs/y/yearEnd.html)\n\n\n\n#### 语法\n\nyearEnd(X, \\[endingMonth=12], \\[offset], \\[n=1])\n\n#### 详情\n\n返回 *X* 所在的以 *endingMonth* 为结束月份的年份的最后一天。\n\n默认情况下，一个周期对应一年，函数返回 *X* 所在年度的最后一天。年度的起始月份由参数 *endingMonth* 决定。 如果指定了 *offset* 和 *n*，且 *n* > 1，则函数按长度为 *n* 年的周期计算。此时，*offset* 用于确定多年周期的对齐方式：系统会先根据 *endingMonth* 计算出 *offset* 所在年度的最后一天，然后以该日期为基准，每隔 *n* 年生成一个周期结束边界，并返回 *X* 所属周期对应的日期。\n\n#### 参数\n\n**X** 可以是 DATE, DATETIME, DATEHOUR, TIMESTAMP 或 NANOTIMESTAMP 类型的标量或向量。\n\n**endingMonth** 是1到12之间的整数，表示一年的结束月份。默认值是12。\n\n**offset** 是与 *X* 类型相同的标量，并且它必须小于等于 *X* 中的最小值。它是一个可选参数。如果没有指定，*offset* 默认为 *X* 中的最小值。\n\n**n** 是一个正整数。它是一个可选参数，默认值为1。\n\n#### 返回值\n\n一个 DATE 类型的标量或向量。\n\n#### 例子\n\n```\nyearEnd(2012.06.12, 3);\n// output: 2013.03.31\n\nyearEnd(2012.06.12, 9);\n// output: 2012.09.30\n\nyearEnd(2012.06.12);\n// output: 2012.12.31\n\nyearEnd(2012.06.12, 12, 2009.04.03, 2);\n// output: 2013.12.31\n\ndate=2011.04.25+(1..10)*365\ntime = take(09:30:00, 10);\nsym = take(`MSFT,10)\nprice= 49.6 29.46 29.52 30.02 174.97 175.23 50.76 50.32 51.29 52.38\nqty = 2200 1900 2100 3200 6800 5400 1300 2500 8800 4500\nt1 = table(date, time, sym, qty, price);\n\nt1;\n```\n\n| date       | time     | sym  | qty  | price  |\n| ---------- | -------- | ---- | ---- | ------ |\n| 2012.04.24 | 09:30:00 | MSFT | 2200 | 49.6   |\n| 2013.04.24 | 09:30:00 | MSFT | 1900 | 29.46  |\n| 2014.04.24 | 09:30:00 | MSFT | 2100 | 29.52  |\n| 2015.04.24 | 09:30:00 | MSFT | 3200 | 30.02  |\n| 2016.04.23 | 09:30:00 | MSFT | 6800 | 174.97 |\n| 2017.04.23 | 09:30:00 | MSFT | 5400 | 175.23 |\n| 2018.04.23 | 09:30:00 | MSFT | 1300 | 50.76  |\n| 2019.04.23 | 09:30:00 | MSFT | 2500 | 50.32  |\n| 2020.04.22 | 09:30:00 | MSFT | 8800 | 51.29  |\n| 2021.04.22 | 09:30:00 | MSFT | 4500 | 52.38  |\n\n```\nselect avg(price),sum(qty) from t1 group by yearEnd(date, 4, 2010.04.01, 2);\n```\n\n| yearEnd\\_date | avg\\_price | sum\\_qty |\n| ------------- | ---------- | -------- |\n| 2012.04.30    | 49.6       | 2200     |\n| 2014.04.30    | 29.49      | 4000     |\n| 2016.04.30    | 102.495    | 10000    |\n| 2018.04.30    | 112.995    | 6700     |\n| 2020.04.30    | 50.805     | 11300    |\n| 2022.04.30    | 52.38      | 4500     |\n\n相关函数：[yearBegin](https://docs.dolphindb.cn/zh/funcs/y/yearBegin.html), [businessYearBegin](https://docs.dolphindb.cn/zh/funcs/b/businessYearBegin.html), [businessYearEnd](https://docs.dolphindb.cn/zh/funcs/b/businessYearEnd.html)\n"
    },
    "yearFrac": {
        "url": "https://docs.dolphindb.cn/zh/funcs/y/yearFrac.html",
        "signatures": [
            {
                "full": "yearFrac(dayCountConvention, start, end, [referenceStart], [referenceEnd])",
                "name": "yearFrac",
                "parameters": [
                    {
                        "full": "dayCountConvention",
                        "name": "dayCountConvention"
                    },
                    {
                        "full": "start",
                        "name": "start"
                    },
                    {
                        "full": "end",
                        "name": "end"
                    },
                    {
                        "full": "[referenceStart]",
                        "name": "referenceStart",
                        "optional": true
                    },
                    {
                        "full": "[referenceEnd]",
                        "name": "referenceEnd",
                        "optional": true
                    }
                ]
            }
        ],
        "markdown": "### [yearFrac](https://docs.dolphindb.cn/zh/funcs/y/yearFrac.html)\n\n首发版本：3.00.5\n\n\n\n#### 语法\n\nyearFrac(dayCountConvention, start, end, \\[referenceStart], \\[referenceEnd])\n\n#### 详情\n\n按指定计息规则计算的起止日期之间的年化时间长度，常用于利息、贴现及期权定价等金融计算。\n\n#### 参数\n\n**dayCountConvention** STRING 类型标量，表示计息日数规则，可选值为：\n\n* \"Actual360\": 实际/360\n\n* \"Actual365\": 实际/365\n\n* \"ActualActualISDA\"：实际/实际，遵循 ISDA（International Swaps and Derivatives Association，国际掉期及衍生工具协会）规则\n\n* \"ActualActualISMA\": 实际/实际，遵循 ISMA（International Securities Market Association，国际证券市场协会）规则\n\n**start** DATE 类型标量，表示开始日期。\n\n**end** DATE 类型标量，表示结束日期。\n\n**referenceStart** 可选参数，DATE 类型标量，表示当前计息区间所属的标准付息周期的参考。仅在 *dayCountConvention* 为 \"ActualActualISMA\" 时有效。\n\n**referenceEnd** 可选参数，DATE 类型标量，表示当前计息区间所属的标准付息周期的结束日期。仅在 *dayCountConvention* 为 \"ActualActualISMA\" 时有效。\n\n#### 返回值\n\nDOUBLE 类型标量。\n\n#### 例子\n\n对于具有固定付息周期的金融产品（如半年付息债券），ActualActualISMA 计息规则需要通过 *referenceStart* 和 *referenceEnd* 指定当前计息区间所属的标准付息周期。\n\n假设某债券每半年付息一次，其付息周期为：2025-01-01 至 2025-07-01，计算该付息周期内一段时间的年化比例：\n\n```\nstart =  2025.02.15\nend = 2025.05.15\nreferenceStart = 2025.01.01\nreferenceEnd = 2025.07.01\nyearFrac(\"ActualActualISMA\", start, end, referenceStart, referenceEnd)\n\n// output: 0.25\n```\n"
    }
}