dolphindb 2.0.927 → 2.0.929

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (3) hide show
  1. package/docs.en.json +55 -20
  2. package/docs.zh.json +1133 -1033
  3. package/package.json +3 -3
package/docs.zh.json CHANGED
@@ -1173,7 +1173,7 @@
1173
1173
  {
1174
1174
  "type": "text",
1175
1175
  "value": [
1176
- "把一个用户添加到群组。它可能会改变该用户的权限。"
1176
+ "把一个用户添加到群组。它可能会改变该用户的权限。该函数只能由管理员在控制节点/数据节点上执行。"
1177
1177
  ]
1178
1178
  }
1179
1179
  ]
@@ -2859,8 +2859,8 @@
2859
2859
  }
2860
2860
  ]
2861
2861
  },
2862
- "asfreq": {
2863
- "title": "asfreq",
2862
+ "asFreq": {
2863
+ "title": "asFreq",
2864
2864
  "type": "function",
2865
2865
  "children": [
2866
2866
  {
@@ -2870,7 +2870,9 @@
2870
2870
  {
2871
2871
  "type": "text",
2872
2872
  "value": [
2873
- "asfreq(X, rule, [closed], [label], [origin='start_day'])"
2873
+ "asFreq(X, rule, [closed], [label], [origin='start_day'])",
2874
+ "",
2875
+ "别名：asfreq"
2874
2876
  ]
2875
2877
  }
2876
2878
  ]
@@ -2918,7 +2920,10 @@
2918
2920
  "\"N\" nanosecond",
2919
2921
  "============ =================",
2920
2922
  "",
2921
- "参数 *rule* 字符串亦可配合使用数字，例如\"2M\"表示频率为每两个月。",
2923
+ ".. versionadded:: 2.00.9 ",
2924
+ " 用户自定义交易日历",
2925
+ "",
2926
+ "`rule` 上述字符串亦可配合使用数字，例如 \"2M\" 表示频率为每两个月月末。此外，*rule* 也可指定为用户自定义交易日历的标识（配置参数 *marketHolidayDir* 指定目录下的文件名，系统将根据该交易日历进行计算）。",
2922
2927
  "",
2923
2928
  ".. versionadded:: 2.00.6",
2924
2929
  " 参数 *closed*, *label*, *origin*",
@@ -2996,7 +3001,7 @@
2996
3001
  "language": "console",
2997
3002
  "value": [
2998
3003
  " ",
2999
- " $ s.asfreq(\"M\")",
3004
+ " $ s.asFreq(\"M\")",
3000
3005
  ""
3001
3006
  ]
3002
3007
  },
@@ -3023,7 +3028,7 @@
3023
3028
  "language": "console",
3024
3029
  "value": [
3025
3030
  "",
3026
- " $ s.asfreq(\"2M\")",
3031
+ " $ s.asFreq(\"2M\")",
3027
3032
  ""
3028
3033
  ]
3029
3034
  },
@@ -3070,7 +3075,7 @@
3070
3075
  "language": "console",
3071
3076
  "value": [
3072
3077
  "",
3073
- " $ s.asfreq(\"D\")",
3078
+ " $ s.asFreq(\"D\")",
3074
3079
  ""
3075
3080
  ]
3076
3081
  },
@@ -3095,7 +3100,7 @@
3095
3100
  "language": "console",
3096
3101
  "value": [
3097
3102
  "",
3098
- " $ s.asfreq(\"2D\")",
3103
+ " $ s.asFreq(\"2D\")",
3099
3104
  ""
3100
3105
  ]
3101
3106
  },
@@ -3119,7 +3124,7 @@
3119
3124
  "",
3120
3125
  " $ index = temporalAdd(2022.10.01 23:30:00,7*(0..8),`m)",
3121
3126
  " $ s = indexedSeries(index, 3*(0..8))",
3122
- " $ s.asfreq(\"8min\")",
3127
+ " $ s.asFreq(\"8min\")",
3123
3128
  ""
3124
3129
  ]
3125
3130
  },
@@ -3146,7 +3151,7 @@
3146
3151
  "language": "console",
3147
3152
  "value": [
3148
3153
  "",
3149
- " $ s.asfreq(rule=`8min,closed=`right)",
3154
+ " $ s.asFreq(rule=`8min,closed=`right)",
3150
3155
  ""
3151
3156
  ]
3152
3157
  },
@@ -3173,7 +3178,7 @@
3173
3178
  "language": "console",
3174
3179
  "value": [
3175
3180
  "",
3176
- " $ s.asfreq(rule=`8min,closed=`right,origin=`end)",
3181
+ " $ s.asFreq(rule=`8min,closed=`right,origin=`end)",
3177
3182
  ""
3178
3183
  ]
3179
3184
  },
@@ -3481,7 +3486,7 @@
3481
3486
  "value": [
3482
3487
  "如果只指定了一个参数，`X` 是布尔表达式或向量。",
3483
3488
  "",
3484
- "如果指定了两个参数，`X` 可以是标量、向量或矩阵，`index` 是布尔表达式/向量/元组/数据对/数组向量。"
3489
+ "如果指定了两个参数，`X` 可以是一个标量、向量（常规向量/元组/数组向量)、矩阵、表、字典、数据对、函数。`index` 可以是一个布尔表达式/布尔值、标量、向量（常规向量/元组/数组向量)、数据对."
3485
3490
  ]
3486
3491
  }
3487
3492
  ]
@@ -3503,7 +3508,9 @@
3503
3508
  "* 如果 *index* 是数据对，如 a:b, 则表示索引范围为 [a,b)，寻找 *X* 中该范围的值并返回。",
3504
3509
  "* 如果 *index* 是数组向量，则 *X* 只能为向量，对于 *index* 中的每行元素都作为一个索引值，寻找 *X* 中对应该索引位置的元素，然后返回一个和 *index* 结构相同的数组向量。",
3505
3510
  "",
3506
- "请注意，index 作为索引值或索引范围时，若其值不在 [0, size(X)-1] 内，则超出 [0, size(X)-1] 的值所对应的位置返回空值。"
3511
+ "请注意，index 作为索引值或索引范围时，若其值不在 [0, size(X)-1] 内，则超出 [0, size(X)-1] 的值所对应的位置返回空值。",
3512
+ "",
3513
+ "若 X 是函数，则 index 将作为函数的参数。"
3507
3514
  ]
3508
3515
  }
3509
3516
  ]
@@ -4603,7 +4610,7 @@
4603
4610
  "",
4604
4611
  "`interval` 是一个大于0的整型/DURATION 类型的标量或和 *X* 长度相同的向量。",
4605
4612
  "",
4606
- "*interval* 是 DURATION 类型时，支持以下时间单位：w, d, H, m, s, ms, us, ns。",
4613
+ "*interval* 是 DURATION 类型时，支持以下时间单位（区分大小写）：w, d, H, m, s, ms, us, ns。",
4607
4614
  "",
4608
4615
  "注：由于 *interval* 不支持年(y)和月(M)的时间单位，如果需要对 *X* 以年或月进行分组时，可以调用 :doc:`../y/year` 或 :doc:`../m/month` 对 *X* 进行转换后，指定 *interval* 为整数进行计算。可以参考 Example 2。",
4609
4616
  "",
@@ -8822,7 +8829,7 @@
8822
8829
  {
8823
8830
  "type": "text",
8824
8831
  "value": [
8825
- "修改用户密码。该命令只能在控制节点上执行。"
8832
+ "修改用户密码。该命令只能由管理员在控制节点/数据节点上执行。"
8826
8833
  ]
8827
8834
  }
8828
8835
  ]
@@ -8901,6 +8908,11 @@
8901
8908
  " $ a=char(99);",
8902
8909
  " $ a;",
8903
8910
  " 'c'",
8911
+ " $ a=char(\"99\"); //char 函数会把输入的字符串识别为 ASCII 码，超出 ASCII 码范围的输入字符无法转换",
8912
+ " $ a;",
8913
+ " 'c'",
8914
+ " $ char(\"990\"); ",
8915
+ " Failed to convert the string to CHAR'",
8904
8916
  " $ typestr a;",
8905
8917
  " CHAR",
8906
8918
  " $ char(a+5);",
@@ -10049,7 +10061,7 @@
10049
10061
  {
10050
10062
  "type": "text",
10051
10063
  "value": [
10052
- "`sessionId` 是一个LONG类型的标量或向量，表示一个或多个session ID。"
10064
+ "`sessionId` 是一个 LONG 类型的标量或向量，表示一个或多个 session ID。"
10053
10065
  ]
10054
10066
  }
10055
10067
  ]
@@ -10076,18 +10088,41 @@
10076
10088
  "value": [
10077
10089
  "",
10078
10090
  " $ getSessionMemoryStat();",
10091
+ "",
10079
10092
  ""
10080
10093
  ]
10081
10094
  },
10082
10095
  {
10083
10096
  "type": "text",
10084
10097
  "value": [
10085
- "======== ============ ========== =========== ============ ======================= ==========================",
10086
- "userId sessionId memSize remoteIP remotePort createTime lastActiveTime",
10087
- "======== ============ ========== =========== ============ ======================= ==========================",
10088
- "admin 1441295757 16 127.0.0.1 55030 2020.08.16T03:07:45.161 2020.08.16T03:07:45.162",
10089
- "guest 1166953221 75796984 127.0.0.1 57489 2020.08.14T13:20:01.902 2020.08.16T19:33:34.690",
10090
- "======== ============ ========== =========== ============ ======================= ==========================",
10098
+ "+-------------------------+---------------+--------------+----------+-------------------------+-------------------------+",
10099
+ "| userId | sessionId | memSize | remoteIP | remotePort createTime | lastActiveTime |",
10100
+ "+=========================+===============+==============+==========+=========================+=========================+",
10101
+ "| __DimensionalTable__ | 0 | 0.0.0.0 | | | |",
10102
+ "+-------------------------+---------------+--------------+----------+-------------------------+-------------------------+",
10103
+ "| __SharedTable__ | 0 | 0.0.0.0 | | | |",
10104
+ "+-------------------------+---------------+--------------+----------+-------------------------+-------------------------+",
10105
+ "| __OLAPTablet__ | 0 | 0.0.0.0 | | | |",
10106
+ "+-------------------------+---------------+--------------+----------+-------------------------+-------------------------+",
10107
+ "| __OLAPCacheEngine__ | 0 | 0.0.0.0 | | | |",
10108
+ "+-------------------------+---------------+--------------+----------+-------------------------+-------------------------+",
10109
+ "| __OLAPCachedSymbolBa... | 0 | 0.0.0.0 | | | |",
10110
+ "+-------------------------+---------------+--------------+----------+-------------------------+-------------------------+",
10111
+ "| __DFSMetadata__ | 2769 | 0.0.0.0 | | | |",
10112
+ "+-------------------------+---------------+--------------+----------+-------------------------+-------------------------+",
10113
+ "| __TSDBCacheEngine__ | 0 | 0.0.0.0 | | | |",
10114
+ "+-------------------------+---------------+--------------+----------+-------------------------+-------------------------+",
10115
+ "| __TSDBLevelFileIndex__ | 0 | 0.0.0.0 | | | |",
10116
+ "+-------------------------+---------------+--------------+----------+-------------------------+-------------------------+",
10117
+ "| __TSDBCachedSymbolBa... | 0 | 0.0.0.0 | | | |",
10118
+ "+-------------------------+---------------+--------------+----------+-------------------------+-------------------------+",
10119
+ "| __StreamingPubQueue__ | 0 | 0.0.0.0 | | | |",
10120
+ "+-------------------------+---------------+--------------+----------+-------------------------+-------------------------+",
10121
+ "| __StreamingSubQueue__ | 0 | 0.0.0.0 | | | |",
10122
+ "+-------------------------+---------------+--------------+----------+-------------------------+-------------------------+",
10123
+ "| admin | 1823289176 32 | 60.176.105.0 | 20882 | 2023.02.15T02:36:14.906 | 2023.02.15T02:36:22.314 |",
10124
+ "+-------------------------+---------------+--------------+----------+-------------------------+-------------------------+",
10125
+ "",
10091
10126
  ""
10092
10127
  ]
10093
10128
  },
@@ -10096,7 +10131,7 @@
10096
10131
  "language": "console",
10097
10132
  "value": [
10098
10133
  "",
10099
- " $ closeSessions(getSessionMemoryStat().sessionId[1]);",
10134
+ " $ closeSessions(getSessionMemoryStat().sessionId[11]);",
10100
10135
  ""
10101
10136
  ]
10102
10137
  },
@@ -14195,7 +14230,7 @@
14195
14230
  {
14196
14231
  "type": "text",
14197
14232
  "value": [
14198
- "创建组。它只能由管理员在控制器节点上执行。",
14233
+ "创建组。该命令只能由管理员在控制节点/数据节点上执行。",
14199
14234
  "",
14200
14235
  "组中的用户必须是已经创建了的用户。"
14201
14236
  ]
@@ -14797,17 +14832,24 @@
14797
14832
  "",
14798
14833
  "`compressMethods` 一个字典，指定某些列使用 lz4 或者 delta 压缩算法存储。key 为字段名，value 为压缩算法（\"lz4\"或\"delta\"）。若未指定，默认采用 lz4 压缩算法。",
14799
14834
  "",
14835
+ ".. versionadded:: 2.00.9",
14836
+ " 支持 DECIMAL 类型数据进行 delta 压缩",
14837
+ "",
14800
14838
  "* 对于SHORT, INT, LONG 与时间或日期类型数据，建议采用 delta 算法压缩。",
14801
14839
  "* 将字符串存储为 SYMBOL 类型数据，实现对字符串类型的压缩。",
14802
14840
  "",
14803
- "`sortColumns` 字符串标量或向量，用于指定表的排序列。系统默认 *sortColumns* 最后一列为时间列，其余列字段作为排序的索引列，称作 sort key。同一个 sort key 组合值（sort key entry）对应的数据将按时间列顺序连续存放在一起。查询时，若查询条件包含索引列，可以快速定位数据所在的位置，提高查询性能。",
14841
+ "`sortColumns` 字符串标量或向量，用于指定表的排序列，写入的数据将按 *sortColumns* 进行排序。系统默认 *sortColumns* （指定多列时） 最后一列为时间列，其余列字段作为排序的索引列，称作 sort key。同一个 sort key 组合值(sort key entry)对应的数据将按时间列顺序连续存放在一起。查询时，若查询条件包含索引列，可以快速定位数据所在的数据块位置，提高查询性能。",
14842
+ "",
14843
+ "- *sortColumns* 只能是 integer, temporal, string, 或 symbol 类型。",
14804
14844
  "",
14805
- "* 频繁查询的字段适合设置为 *sortColumns*。",
14806
- "* *sortColumns* 必须是 integer, temporal, string, 或 symbol 类型。",
14807
- "* 若 *sortColumns* 含有多列，TSDB 引擎根据 *sortColumns* 各列的顺序维护一个索引，因此可以优先把查询频率高的字段作为 *sortColumns* 中位置靠前的列。",
14808
- "* *sortColumns* 的最后一列必须为时间列。",
14809
- "* 为保证性能最优，建议每个分区内 sort key 的组合数不超过1000个。",
14810
- "* *sortColumns* 是每个分区内部 level file 内数据的排序依据，与其是否为分区字段无关。",
14845
+ " - 若 *sortColumns* 指定为多列，则 *sortColumns* 的最后一列必须为时间列，其余列为索引列，且索引列不能为为 TIME, TIMESTAMP, NANOTIME, NANOTIMESTAMP 类型。",
14846
+ " - 若 *sortColumns* 仅指定一列，不要求必须为时间类型。若 *sortColumns* 指定为一列时间列 （非分区列），且同时指定了 *sortKeyMappingFunction*，则查询的过滤条件中 *sortColumns* 只能与相同时间类型的值进行比较。",
14847
+ "",
14848
+ "- 频繁查询的字段适合设置为 *sortColumns*，且建议优先把查询频率高的字段作为 *sortColumns* 中位置靠前的列。",
14849
+ "",
14850
+ "- 为保证性能最优，建议每个分区内索引列的组合数（sort key）不超过1000个。",
14851
+ "",
14852
+ "- *sortColumns* 是每个分区内部 level file 内数据的排序依据，与其是否为分区字段无关。",
14811
14853
  "",
14812
14854
  "`keepDuplicates` 指定在每个分区内如何处理所有 *sortColumns* 之值皆相同的数据。提供以下选项：",
14813
14855
  "",
@@ -15131,13 +15173,13 @@
15131
15173
  "下列状态函数在 DolphinDB 的响应式状态引擎中的实现均得到了优化。目前，状态引擎不允许使用未经优化的状态函数，且需避免使用聚合函数。",
15132
15174
  "",
15133
15175
  "* 累计窗口函数：:doc:`../c/cumavg`, :doc:`../c/cumsum`, :doc:`../c/cumprod`, :doc:`../c/cumcount`, :doc:`../c/cummin`, :doc:`../c/cummax`, :doc:`../c/cumvar`, :doc:`../c/cumvarp`, :doc:`../c/cumstd`, :doc:`../c/cumstdp`, :doc:`../c/cumcorr`, :doc:`../c/cumcovar`, :doc:`../c/cumbeta`, :doc:`../c/cumwsum`, :doc:`../c/cumwavg`, :doc:`../c/cumfirstNot`, :doc:`../c/cumlastNot`, :doc:`../c/cummed`, :doc:`../c/cumpercentile`, :doc:`../c/cumnunique`, :doc:`../c/cumPositiveStreak`",
15134
- "* 滑动窗口函数：:doc:`../e/ema`, :doc:`../m/mavg`, :doc:`../m/msum`, :doc:`../m/mcount`, :doc:`../m/mprod`, :doc:`../m/mvar`, :doc:`../m/mvarp`, :doc:`../m/mstd`, :doc:`../m/mstdp`, :doc:`../m/mskew`, :doc:`../m/mkurtosis`, :doc:`../m/mmin`, :doc:`../m/mmax`, :doc:`../m/mimin`, :doc:`../m/mimax`, :doc:`../m/mmed`, :doc:`../m/mpercentile`, :doc:`../m/mrank`, :doc:`../m/mcorr`, :doc:`../m/mcovar`, :doc:`../m/mbeta`, :doc:`../m/mwsum`, :doc:`../m/mwavg`, :doc:`../m/mmad`, :doc:`../m/mfirst`, :doc:`../m/mlast`, :doc:`../m/mslr`, :doc:`../t/tmove`, :doc:`../t/tmfirst`, :doc:`../t/tmlast`, :doc:`../t/tmsum`, :doc:`../t/tmavg`, :doc:`../t/tmcount`, :doc:`../t/tmvar`, :doc:`../t/tmvarp`, :doc:`../t/tmstd`, :doc:`../t/tmstdp`, :doc:`../t/tmprod`, :doc:`../t/tmskew`, :doc:`../t/tmkurtosis`, :doc:`../t/tmmin`, :doc:`../t/tmmax`, :doc:`../t/tmmed`, :doc:`../t/tmpercentile`, :doc:`../t/tmrank`, :doc:`../t/tmcovar`, :doc:`../t/tmbeta`, :doc:`../t/tmcorr`, :doc:`../t/tmwavg`, :doc:`../t/tmwsum`, :doc:`/Functionalprogramming/TemplateFunctions/tmoving`, :doc:`/Functionalprogramming/TemplateFunctions/moving`, :doc:`../s/sma`, :doc:`../w/wma`, :doc:`../d/dema`, :doc:`../t/tema`, :doc:`../t/trima`, :doc:`../l/linearTimeTrend`, :doc:`/Functionalprogramming/TemplateFunctions/talib`, :doc:`../t/t3`, :doc:`../m/ma`, :doc:`../m/mmaxPositiveStreak`",
15176
+ "* 滑动窗口函数：:doc:`../e/ema`, :doc:`../m/mavg`, :doc:`../m/msum`, :doc:`../m/mcount`, :doc:`../m/mprod`, :doc:`../m/mvar`, :doc:`../m/mvarp`, :doc:`../m/mstd`, :doc:`../m/mstdp`, :doc:`../m/mskew`, :doc:`../m/mkurtosis`, :doc:`../m/mmin`, :doc:`../m/mmax`, :doc:`../m/mimin`, :doc:`../m/mimax`, :doc:`../m/mmed`, :doc:`../m/mpercentile`, :doc:`../m/mrank`, :doc:`../m/mcorr`, :doc:`../m/mcovar`, :doc:`../m/mbeta`, :doc:`../m/mwsum`, :doc:`../m/mwavg`, :doc:`../m/mmad`, :doc:`../m/mfirst`, :doc:`../m/mlast`, :doc:`../m/mslr`, :doc:`../t/tmove`, :doc:`../t/tmfirst`, :doc:`../t/tmlast`, :doc:`../t/tmsum`, :doc:`../t/tmavg`, :doc:`../t/tmcount`, :doc:`../t/tmvar`, :doc:`../t/tmvarp`, :doc:`../t/tmstd`, :doc:`../t/tmstdp`, :doc:`../t/tmprod`, :doc:`../t/tmskew`, :doc:`../t/tmkurtosis`, :doc:`../t/tmmin`, :doc:`../t/tmmax`, :doc:`../t/tmmed`, :doc:`../t/tmpercentile`, :doc:`../t/tmrank`, :doc:`../t/tmcovar`, :doc:`../t/tmbeta`, :doc:`../t/tmcorr`, :doc:`../t/tmwavg`, :doc:`../t/tmwsum`, :doc:`/Functionalprogramming/TemplateFunctions/tmoving`, :doc:`/Functionalprogramming/TemplateFunctions/moving`, :doc:`../s/sma`, :doc:`../w/wma`, :doc:`../d/dema`, :doc:`../t/tema`, :doc:`../t/trima`, :doc:`../l/linearTimeTrend`, :doc:`/Functionalprogramming/TemplateFunctions/talib`, :doc:`../t/t3`, :doc:`../m/ma`, :doc:`../m/mmaxPositiveStreak`, :doc:`../m/movingWindowData`, :doc:`../t/tmovingWindowData`",
15135
15177
  "* 行计算函数： :doc:`../r/rowMin`, :doc:`../r/rowMax`, :doc:`../r/rowAnd`, :doc:`../r/rowOr`, :doc:`../r/rowXor`, :doc:`../r/rowProd`, :doc:`../r/rowSum`, :doc:`../r/rowSum2`, :doc:`../r/rowSize`, :doc:`../r/rowCount`, :doc:`../r/rowAvg`, :doc:`../r/rowKurtosis`, :doc:`../r/rowSkew`, :doc:`../r/rowVar`, :doc:`../r/rowVarp`, :doc:`../r/rowStd`, :doc:`../r/rowStdp`",
15136
15178
  "* 序列相关函数：:doc:`../d/deltas`, :doc:`../r/ratios`, :doc:`../f/ffill`, :doc:`../m/move`, :doc:`../p/prev`, :doc:`../i/iterate`, :doc:`../e/ewmMean`, :doc:`../e/ewmVar`, :doc:`../e/ewmStd`, :doc:`../e/ewmCov`, :doc:`../e/ewmCorr`, :doc:`../p/prevState`",
15137
15179
  "* topN相关函数：:doc:`../m/msumTopN`, :doc:`../m/mavgTopN`, :doc:`../m/mstdpTopN`, :doc:`../m/mstdTopN`, :doc:`../m/mvarpTopN`, :doc:`../m/mvarTopN`, :doc:`../m/mcorrTopN`, :doc:`../m/mbetaTopN`, :doc:`../m/mcovarTopN`, :doc:`../m/mwsumTopN`",
15138
- "* 高阶函数：:doc:`/Functionalprogramming/TemplateFunctions/segmentby` (参数 *func* 暂支持 cumsum, cummax, cummin, cumcount, cumavg, cumstd, cumvar, cumstdp, cumvarp)",
15180
+ "* 高阶函数：:doc:`/Functionalprogramming/TemplateFunctions/segmentby` (参数 *func* 暂支持 cumsum, cummax, cummin, cumcount, cumavg, cumstd, cumvar, cumstdp, cumvarp), :doc:`/Functionalprogramming/TemplateFunctions/moving`, :doc:`/Functionalprogramming/TemplateFunctions/byColumn`, :doc:`/Functionalprogramming/TemplateFunctions/accumulate`",
15139
15181
  "* 其他函数：:doc:`../t/talibNull`, :doc:`../d/dynamicGroupCumsum`, :doc:`../d/dynamicGroupCumcount`, :doc:`../t/topRange`, :doc:`../l/lowRange`, :doc:`../t/trueRange`",
15140
- "* 特殊函数（仅支持在引擎内使用）：:doc:`../s/stateIterate`, :doc:`../c/conditionalIterate`, :doc:`../s/stateMavg`",
15182
+ "* 特殊函数（仅支持在引擎内使用）：:doc:`../s/stateIterate`, :doc:`../c/conditionalIterate`, :doc:`../s/stateMavg`, :doc:`../g/genericStateIterate`, :doc:`../g/genericTStateIterate`",
15141
15183
  "",
15142
15184
  "注意，:doc:`/Functionalprogramming/TemplateFunctions/talib` 作为状态函数时，第一个参数 `func` 只能是响应式状态引擎支持的状态函数。",
15143
15185
  "",
@@ -15358,7 +15400,41 @@
15358
15400
  " //若要重复调试以上代码，需要先执行以下代码",
15359
15401
  " $ unsubscribeTable(tableName=`trades, actionName=\"test\")",
15360
15402
  " $ dropStreamEngine(`test)",
15361
- " $ undef(`trades, SHARED)"
15403
+ " $ undef(`trades, SHARED)",
15404
+ ""
15405
+ ]
15406
+ },
15407
+ {
15408
+ "type": "text",
15409
+ "value": [
15410
+ "2.00.9 版本后，支持在响应式状态引擎中调用 moving 高阶函数计算 array vector。",
15411
+ ""
15412
+ ]
15413
+ },
15414
+ {
15415
+ "type": "code",
15416
+ "language": "console",
15417
+ "value": [
15418
+ " ",
15419
+ " $ defg myFactor(x){"
15420
+ ]
15421
+ },
15422
+ {
15423
+ "type": "text",
15424
+ "value": [
15425
+ "\t$ return avg(var(x));",
15426
+ " $ }",
15427
+ " $ share streamTable(1:0, `DateTime`SecurityID`Trade, [TIMESTAMP, SYMBOL, DOUBLE[]]) as tickStream",
15428
+ " $ result = table(1000:0, `SecurityID`DateTime`result, [SYMBOL, DATETIME, DOUBLE])",
15429
+ " $ rse = createReactiveStateEngine(name=\"reactiveDemo\", metrics =<[DateTime, moving(myFactor, Trade, 3, 1)]>, dummyTable=tickStream, outputTable=result, keyColumn=\"SecurityID\")",
15430
+ " $ DateTime = 2022.09.15T09:00:00.000+1..12",
15431
+ " $ SecurityID = take(`600021, 12)",
15432
+ " $ Trade = [[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]]",
15433
+ " $ t = table(1:0, `DateTime`SecurityID`Trade, [TIMESTAMP, SYMBOL, DOUBLE[]])",
15434
+ " $ tableInsert(t, DateTime, SecurityID, Trade)",
15435
+ " $ rse.append!(t)",
15436
+ " $ select * from result",
15437
+ " $ dropStreamEngine(\"reactiveDemo\") "
15362
15438
  ]
15363
15439
  }
15364
15440
  ]
@@ -15565,14 +15641,18 @@
15565
15641
  "* 对于SHORT, INT, LONG 与时间或日期类型数据，建议采用 delta 算法压缩。",
15566
15642
  "* 将字符串存储为 SYMBOL 类型数据，实现对字符串类型的压缩。",
15567
15643
  "",
15568
- "`sortColumns` 字符串标量或向量，用于指定表的排序列。系统默认 *sortColumns* 最后一列为时间列，其余列字段作为排序的索引列，称作 sort key。同一个 sortKey 组合值（sort key entry）对应的数据将按时间列顺序连续存放在一起。查询时，若查询条件包含索引列，可以快速定位数据所在的位置，提高查询性能。",
15644
+ "`sortColumns` 字符串标量或向量，用于指定表的排序列，写入的数据将按 *sortColumns* 进行排序。系统默认 *sortColumns* （指定多列时） 最后一列为时间列，其余列字段作为排序的索引列，其组合值称作 sort key。若 *sortColumns* 只指定一列，则该列的值将作为 sort key。系统将同一个 sort key 内的数据划分为固定大小的数据块，并在内存中维护一个指向数据块地址的索引。查询时，若查询条件包含索引列，可以快速定位数据所在的数据块位置，提高查询性能。",
15645
+ "",
15646
+ "- *sortColumns* 只能是 integer, temporal, string, 或 symbol 类型。",
15647
+ "",
15648
+ " - 若 *sortColumns* 指定为多列，则 *sortColumns* 的最后一列必须为时间列，其余列为索引列，且索引列不能为为 TIME, TIMESTAMP, NANOTIME, NANOTIMESTAMP 类型。",
15649
+ " - 若 *sortColumns* 仅指定一列，不要求必须为时间类型。若 *sortColumns* 指定为一列时间列 （非分区列），且同时指定了 *sortKeyMappingFunction*，则查询的过滤条件中 *sortColumns* 只能与相同时间类型的值进行比较。",
15650
+ "",
15651
+ "- 频繁查询的字段适合设置为 *sortColumns*，且建议优先把查询频率高的字段作为 *sortColumns* 中位置靠前的列。",
15652
+ "",
15653
+ "- 为保证性能最优，建议每个分区内索引列的组合数（sort key）不超过1000个。",
15569
15654
  "",
15570
- "* 频繁查询的字段适合设置为 *sortColumns*。",
15571
- "* *sortColumns* 必须是 integer, temporal, string, 或 symbol 类型。",
15572
- "* 若 *sortColumns* 含有多列，TSDB 引擎根据 *sortColumns* 各列的顺序维护一个索引，因此可以优先把查询频率高的字段作为 *sortColumns* 中位置靠前的列。",
15573
- "* *sortColumns* 的最后一列必须为时间列。",
15574
- "* 为保证性能最优，建议每个分区内 sort key 的组合数不超过1000个。",
15575
- "* *sortColumns* 是每个分区内部 level file 内数据的排序依据，与其是否为分区字段无关。",
15655
+ "- *sortColumns* 是每个分区内部 level file 内数据的排序依据，与其是否为分区字段无关。",
15576
15656
  "",
15577
15657
  "`keepDuplicates` 指定在每个分区内如何处理所有 *sortColumns* 之值皆相同的数据。提供以下选项：",
15578
15658
  "",
@@ -15594,6 +15674,8 @@
15594
15674
  "value": [
15595
15675
  "在分布式数据库中创建一个维度表。维度表是分布式数据库中没有进行分区的表，适用于存储不频繁更新的小数据集。",
15596
15676
  "",
15677
+ "使用 ``loadTable`` 函数将维度表加载到内存后，其占用的缓存空间不会被系统自动释放，用户可以手动调用命令 ``clearCachedDatabase()`` 进行清理。因此，不建议用户将记录数超过200万条的表存储为维度表。",
15678
+ "",
15597
15679
  "维度表与分区表都是根据设置参数 *dfsReplicationFactor* 决定副本的数量。维度表的读写操作也支持事务。",
15598
15680
  "",
15599
15681
  "通过在配置项配置 *enableConcurrentDimensionalTableWrite* = true，可以支持对维度表进行并发的写入、修改或删除操作。"
@@ -16408,7 +16490,7 @@
16408
16490
  {
16409
16491
  "type": "text",
16410
16492
  "value": [
16411
- "创建用户。该命令只能由管理员在控制器节点上执行。",
16493
+ "创建用户。该函数只能由管理员在控制节点/数据节点上执行。",
16412
16494
  "",
16413
16495
  "*groupIds* 表示的组必须是已经创建了的组。"
16414
16496
  ]
@@ -21287,7 +21369,7 @@
21287
21369
  {
21288
21370
  "type": "text",
21289
21371
  "value": [
21290
- "删除一个群组。这可能会影响群组内所有成员的权限。"
21372
+ "删除一个群组。这可能会影响群组内所有成员的权限。该命令只能由管理员在控制节点/数据节点上执行。"
21291
21373
  ]
21292
21374
  }
21293
21375
  ]
@@ -21355,7 +21437,7 @@
21355
21437
  {
21356
21438
  "type": "text",
21357
21439
  "value": [
21358
- "删除多个组中的同一个成员，或删除同一个组中的多个成员。该命令只能由管理员在控制节点上执行。"
21440
+ "删除多个组中的同一个成员，或删除同一个组中的多个成员。该函数只能由管理员在控制节点/数据节点上执行。"
21359
21441
  ]
21360
21442
  }
21361
21443
  ]
@@ -21557,7 +21639,7 @@
21557
21639
  {
21558
21640
  "type": "text",
21559
21641
  "value": [
21560
- "删除一个用户。"
21642
+ "删除一个用户。该函数只能由管理员在控制节点/数据节点上执行。"
21561
21643
  ]
21562
21644
  }
21563
21645
  ]
@@ -21933,29 +22015,13 @@
21933
22015
  {
21934
22016
  "type": "text",
21935
22017
  "value": [
21936
- "`id` 是表示用户名或组名的字符串。",
21937
- "",
21938
- "`accessType` 是权限类型。主要有以下8种权限：",
21939
- "",
21940
- "1. TABLE_READ：读取指定数据表",
21941
- "",
21942
- "2. TABLE_WRITE：写入指定数据表",
21943
- "",
21944
- "3. DBOBJ_CREATE：在某个数据库中创建数据表",
22018
+ "`userId` | `groupId` 是表示用户名或组名的字符串。",
21945
22019
  "",
21946
- "4. DBOBJ_DELETE：删除某个数据库中的数据表",
22020
+ "`accessType` 是权限类型。",
21947
22021
  "",
21948
- "5. VIEW_EXEC：执行某个视图",
22022
+ "`objs` 标量或向量，表示权限类型的应用对象。",
21949
22023
  "",
21950
- "6. DB_MANAGE：创建以及删除数据库。可删除任何人所建数据库，包括具有DB_OWNER权限之用户所建数据库。",
21951
- "",
21952
- "7. DB_OWNER：创建数据库并管理其创建的数据库，包括删除数据库、创建或删除数据表、增加或删除分区、可赋予、禁止或取消其他用户对自己创建的数据库的以下权限：TABLE_READ, TABLE_WRITE, DBOBJ_CREATE, DBOBJ_DELETE。",
21953
- "",
21954
- "8. SCRIPT_EXEC：执行脚本",
21955
- "",
21956
- "9. TEST_EXEC：执行测试脚本",
21957
- "",
21958
- "`objs` 是表示权限类型的应用对象。若权限类型为TABLE_READ, TABLE_WRITE, DBOBJ_CREATE, DBOBJ_DELETE或VIEW_EXEC, 它是一个必需参数。若权限类型为DB_MANAGE, DB_OWNER, SCRIPT_EXEC和TEST_EXEC, 它可以省略。"
22024
+ "*accessType* 和 *objs* 的取值请参照 :doc:`/SystemManagement/UserAccessControl` 权限类型表。"
21959
22025
  ]
21960
22026
  }
21961
22027
  ]
@@ -21967,7 +22033,7 @@
21967
22033
  {
21968
22034
  "type": "text",
21969
22035
  "value": [
21970
- "拒绝某个用户或某个群的权限。该命令只能由管理员在控制器节点上执行。"
22036
+ "拒绝某个用户或某个组的权限。该命令只能由管理员在控制节点/数据节点上执行。"
21971
22037
  ]
21972
22038
  }
21973
22039
  ]
@@ -21985,7 +22051,7 @@
21985
22051
  "",
21986
22052
  ".. $ deny(`production, TABLE_READ, \"dfs://db1\")",
21987
22053
  "",
21988
- "组“research”中的所有成员都不能向表 ``dfs://db1/t1`` 中写入数据：",
22054
+ "组 \"research\" 中的所有成员都不能向表 ``dfs://db1/t1`` 中写入数据：",
21989
22055
  ""
21990
22056
  ]
21991
22057
  },
@@ -22001,7 +22067,7 @@
22001
22067
  {
22002
22068
  "type": "text",
22003
22069
  "value": [
22004
- "组“research”中的所有成员都不能在数据库 ``dfs://db1`` 和 ``dfs://db2`` 中创建表：",
22070
+ "组 \"research\" 中的所有成员都不能在数据库 ``dfs://db1`` 和 ``dfs://db2`` 中创建表：",
22005
22071
  ""
22006
22072
  ]
22007
22073
  },
@@ -22017,7 +22083,7 @@
22017
22083
  {
22018
22084
  "type": "text",
22019
22085
  "value": [
22020
- "用户“AlexSmith”不能创建或删除数据库：",
22086
+ "用户 \"AlexSmith\" 不能创建或删除数据库：",
22021
22087
  ""
22022
22088
  ]
22023
22089
  },
@@ -22033,7 +22099,7 @@
22033
22099
  {
22034
22100
  "type": "text",
22035
22101
  "value": [
22036
- "用户“AlexSmith”不能执行脚本：",
22102
+ "用户 \"AlexSmith\" 不能执行脚本：",
22037
22103
  ""
22038
22104
  ]
22039
22105
  },
@@ -22049,7 +22115,7 @@
22049
22115
  {
22050
22116
  "type": "text",
22051
22117
  "value": [
22052
- "用户“AlexSmith”不能测试脚本：",
22118
+ "用户 \"AlexSmith\" 不能测试脚本：",
22053
22119
  ""
22054
22120
  ]
22055
22121
  },
@@ -22385,11 +22451,11 @@
22385
22451
  {
22386
22452
  "type": "text",
22387
22453
  "value": [
22388
- "dict(keyObj, valueObj) ",
22454
+ "dict(keyObj, valueObj, [ordered=false])",
22389
22455
  "",
22390
22456
  "或",
22391
22457
  "",
22392
- "dict(keyType, valueType)"
22458
+ "dict(keyType, valueType, [ordered=false])"
22393
22459
  ]
22394
22460
  }
22395
22461
  ]
@@ -22403,7 +22469,9 @@
22403
22469
  "value": [
22404
22470
  "对于第一种情形，`keyObj` 是表示键的向量，`valueObj` 是表示值的向量。",
22405
22471
  "",
22406
- "对于第二种情形，`keyType` 是字典键的数据类型，`valueType` 是字典值的数据类型。系统支持以下键的数据类型：Logical, Integral, Floating和Temporal。字典中的值可以是任意数据类型。"
22472
+ "对于第二种情形，`keyType` 是字典键的数据类型，`valueType` 是字典值的数据类型。系统支持以下键的数据类型：Logical, Integral, Floating和Temporal。字典中的值不支持 COMPLEX, POINT 和 Decimal 类别。",
22473
+ "",
22474
+ "ordered 一个布尔值，默认为 false，表示创建一个无序字典。当 ordered = true 时，创建一个有序字典。无序字典在输出或进行遍历时，其键值对不保留输入时的顺序；有序字典在输出或进行遍历时，键值对的顺序与输入顺序保持一致。"
22407
22475
  ]
22408
22476
  }
22409
22477
  ]
@@ -22415,7 +22483,7 @@
22415
22483
  {
22416
22484
  "type": "text",
22417
22485
  "value": [
22418
- "返回一个字典对象。"
22486
+ "返回一个无序字典或有序字典对象。"
22419
22487
  ]
22420
22488
  }
22421
22489
  ]
@@ -22450,13 +22518,20 @@
22450
22518
  " $ dt=dict([`test], [1]);",
22451
22519
  " $ dt;",
22452
22520
  " test->1",
22521
+ "",
22522
+ " //创建有序字典",
22523
+ " $z=dict(x,y,true)",
22524
+ " $z;",
22525
+ " 1->4.5",
22526
+ " 2->7.8",
22527
+ " 3->4.3",
22453
22528
  ""
22454
22529
  ]
22455
22530
  },
22456
22531
  {
22457
22532
  "type": "text",
22458
22533
  "value": [
22459
- "获取键和值",
22534
+ "获取键和值:",
22460
22535
  ""
22461
22536
  ]
22462
22537
  },
@@ -22480,7 +22555,7 @@
22480
22555
  {
22481
22556
  "type": "text",
22482
22557
  "value": [
22483
- "相关函数：:doc:`../a/array`, :doc:`../m/matrix`"
22558
+ "相关函数：:doc:`../a/array`, :doc:`../m/matrix`， :doc:`../d/dictUpdate!`, :doc:`../s/syncDict`"
22484
22559
  ]
22485
22560
  }
22486
22561
  ]
@@ -25054,8 +25129,8 @@
25054
25129
  "",
25055
25130
  "注意：",
25056
25131
  "",
25057
- "* 用于分组的时间区间单位需不小于时间列的单位。",
25058
- "* M 表示月份，m 表示分钟；若分组的时间区间单位为 M，时间列需要通过函数 :doc:`../m/month` 转换为对应月份。",
25132
+ "* 用于分组的时间区间单位应需不小于时间列的单位。",
25133
+ "* 时间单位区分大小写，例如：M 表示月份，m 表示分钟；若分组的时间区间单位为 M，时间列需要通过函数 :doc:`../m/month` 转换为对应月份。",
25059
25134
  "* DURATION 类型数据之间不能进行任何运算。"
25060
25135
  ]
25061
25136
  }
@@ -26257,6 +26332,80 @@
26257
26332
  }
26258
26333
  ]
26259
26334
  },
26335
+ "enlist": {
26336
+ "title": "enlist",
26337
+ "type": "function",
26338
+ "children": [
26339
+ {
26340
+ "title": "语法",
26341
+ "type": "grammer",
26342
+ "children": [
26343
+ {
26344
+ "type": "text",
26345
+ "value": [
26346
+ "enlist()"
26347
+ ]
26348
+ }
26349
+ ]
26350
+ },
26351
+ {
26352
+ "title": "参数",
26353
+ "type": "parameters",
26354
+ "children": [
26355
+ {
26356
+ "type": "text",
26357
+ "value": [
26358
+ "`X` 任意数据形式。"
26359
+ ]
26360
+ }
26361
+ ]
26362
+ },
26363
+ {
26364
+ "title": "详情",
26365
+ "type": "detail",
26366
+ "children": [
26367
+ {
26368
+ "type": "text",
26369
+ "value": [
26370
+ "返回一个由 X 组成的向量或元组。",
26371
+ "",
26372
+ "* X 是标量时，返回一个向量。",
26373
+ "",
26374
+ "* X 是向量、元组等其他数据形式时，返回一个元组。"
26375
+ ]
26376
+ }
26377
+ ]
26378
+ },
26379
+ {
26380
+ "title": "例子",
26381
+ "type": "example",
26382
+ "children": [
26383
+ {
26384
+ "type": "code",
26385
+ "language": "console",
26386
+ "value": [
26387
+ "",
26388
+ " $ enlist(1)",
26389
+ " [1]",
26390
+ "",
26391
+ " $ enlist(`aaa)",
26392
+ " [\"aaa\"]",
26393
+ "",
26394
+ " $ enlist([2022.01.01,2022.01.02,2022.01.03])",
26395
+ " ([2022.01.01,2022.01.02,2022.01.03])",
26396
+ "",
26397
+ " $ enlist([\"a\",2,3])",
26398
+ " ((\"a\",2,3))",
26399
+ "",
26400
+ " $ a = array(INT[], 0, 10).append!([1 2 3, 4 5,6 7 8, 9 NULL])",
26401
+ " $ enlist(a)",
26402
+ " ([[1,2,3],[4,5],[6,7,8],[9,00i]])"
26403
+ ]
26404
+ }
26405
+ ]
26406
+ }
26407
+ ]
26408
+ },
26260
26409
  "eq": {
26261
26410
  "title": "eq",
26262
26411
  "type": "function",
@@ -31472,166 +31621,6 @@
31472
31621
  }
31473
31622
  ]
31474
31623
  },
31475
- "getAsyncReplicationStatus": {
31476
- "title": "getAsyncReplicationStatus",
31477
- "type": "function",
31478
- "children": [
31479
- {
31480
- "title": "语法",
31481
- "type": "grammer",
31482
- "children": [
31483
- {
31484
- "type": "text",
31485
- "value": [
31486
- "getAsyncReplicationStatus()"
31487
- ]
31488
- }
31489
- ]
31490
- },
31491
- {
31492
- "title": "参数",
31493
- "type": "parameters",
31494
- "children": [
31495
- {
31496
- "type": "text",
31497
- "value": [
31498
- "无"
31499
- ]
31500
- }
31501
- ]
31502
- },
31503
- {
31504
- "title": "详情",
31505
- "type": "detail",
31506
- "children": [
31507
- {
31508
- "type": "text",
31509
- "value": [
31510
- "查询集群间异步复制的运行状态。在主集群的数据节点上执行，只返回该节点的运行状态。",
31511
- "",
31512
- "返回一个表，包含以下列：",
31513
- "",
31514
- "* Status: 运行状态(running / stop)",
31515
- "",
31516
- "* Tasks: 剩余任务的个数",
31517
- "",
31518
- "* Last_Failed_Cid: 上一次失败的任务的cid",
31519
- "",
31520
- "* Last_Failed_Time: 上一次失败的时间 ",
31521
- "",
31522
- "* Reason: 失败的原因",
31523
- "",
31524
- "对于失败的任务，系统会不断尝试重新发送，因此如果不调用 :doc:`/FunctionsandCommands/CommandsReferences/s/stopAsyncReplication` 暂停发送任务，该任务会不断尝试重发，十分钟后如果仍然发送失败则主动停止。"
31525
- ]
31526
- }
31527
- ]
31528
- },
31529
- {
31530
- "title": "例子",
31531
- "type": "example",
31532
- "children": [
31533
- {
31534
- "type": "code",
31535
- "language": "console",
31536
- "value": [
31537
- " ",
31538
- " $ getAsyncReplicationStatus();",
31539
- "",
31540
- ""
31541
- ]
31542
- },
31543
- {
31544
- "type": "text",
31545
- "value": [
31546
- "========= ======= ================= ================== ========",
31547
- "Status Tasks Last_Failed_Cid Last_Failed_Time Reason ",
31548
- "========= ======= ================= ================== ========",
31549
- "running 0 -1 ",
31550
- "========= ======= ================= ================== ========"
31551
- ]
31552
- }
31553
- ]
31554
- }
31555
- ]
31556
- },
31557
- "getAsyncReplicationTasks": {
31558
- "title": "getAsyncReplicationTasks",
31559
- "type": "function",
31560
- "children": [
31561
- {
31562
- "title": "语法",
31563
- "type": "grammer",
31564
- "children": [
31565
- {
31566
- "type": "text",
31567
- "value": [
31568
- "getAsyncReplicationTasks([n])"
31569
- ]
31570
- }
31571
- ]
31572
- },
31573
- {
31574
- "title": "参数",
31575
- "type": "parameters",
31576
- "children": [
31577
- {
31578
- "type": "text",
31579
- "value": [
31580
- "`n` 是一个可选参数，表示从 *asyncReplicationWorkDir* 指定的路径读取的任务数量。若不指定 n，则表示获取所有任务。"
31581
- ]
31582
- }
31583
- ]
31584
- },
31585
- {
31586
- "title": "详情",
31587
- "type": "detail",
31588
- "children": [
31589
- {
31590
- "type": "text",
31591
- "value": [
31592
- "启用集群间的异步复制后，在主集群的数据节点上执行，返回该节点从 *asyncReplicationWorkDir* 指定的路径读取的需要发送的任务。运行此函数前，异步复制应当处于 stop 状态。",
31593
- "",
31594
- "返回一个表，包含以下列：",
31595
- "",
31596
- "* Skip: 布尔值，表示是否跳过此任务。True 表示跳过",
31597
- "",
31598
- "* Cid: 任务编号 ",
31599
- "",
31600
- "* Function: 任务对应的函数命令",
31601
- "",
31602
- "* Args: 函数的参数个数 "
31603
- ]
31604
- }
31605
- ]
31606
- },
31607
- {
31608
- "title": "例子",
31609
- "type": "example",
31610
- "children": [
31611
- {
31612
- "type": "code",
31613
- "language": "console",
31614
- "value": [
31615
- " ",
31616
- " $ getAsyncReplicationTasks();",
31617
- ""
31618
- ]
31619
- },
31620
- {
31621
- "type": "text",
31622
- "value": [
31623
- "======= ===== ============================================== ======",
31624
- "Skip Cid Function Args ",
31625
- "======= ===== ============================================== ======",
31626
- "false 5 dropTable(database('dfs://test_copy'),'pt1') 0 ",
31627
- "true 6 append!{database('dfs://test_copy'),'pt2')} 1 ",
31628
- "======= ===== ============================================== ======"
31629
- ]
31630
- }
31631
- ]
31632
- }
31633
- ]
31634
- },
31635
31624
  "getAuthenticatedUsers": {
31636
31625
  "title": "getAuthenticatedUsers",
31637
31626
  "type": "function",
@@ -32545,7 +32534,7 @@
32545
32534
  {
32546
32535
  "type": "text",
32547
32536
  "value": [
32548
- "`top` 是一个正整数。"
32537
+ "`top` 是一个正整数。可选参数，默认值为 10。"
32549
32538
  ]
32550
32539
  }
32551
32540
  ]
@@ -32557,7 +32546,31 @@
32557
32546
  {
32558
32547
  "type": "text",
32559
32548
  "value": [
32560
- "返回本地节点上最近完成的 top 条查询分布式数据库的 SQL 语句的描述信息。top 是可选参数，默认值为 10。",
32549
+ "返回本地节点上最近完成的 top 条查询分布式数据库的 SQL 语句的描述信息表，包含以下字段：",
32550
+ "",
32551
+ "+-----------+---------------------------------------------------------------------------------------------------------+",
32552
+ "| 参数 | 含义 |",
32553
+ "+===========+=========================================================================================================+",
32554
+ "| userID | 用户 ID 。 |",
32555
+ "+-----------+---------------------------------------------------------------------------------------------------------+",
32556
+ "| sessionID | 发起查询的会话 ID。 |",
32557
+ "+-----------+---------------------------------------------------------------------------------------------------------+",
32558
+ "| jobID | 系统中查询任务的唯一标识。 |",
32559
+ "+-----------+---------------------------------------------------------------------------------------------------------+",
32560
+ "| rootID | 当前任务所属根任务的 jobID。 |",
32561
+ "+-----------+---------------------------------------------------------------------------------------------------------+",
32562
+ "| level | 任务的级别。根任务的 level 为 0，其分解的子任务 level 为 1，该子任务分解的子任务 level 为 2，以此类推。 |",
32563
+ "+-----------+---------------------------------------------------------------------------------------------------------+",
32564
+ "| startTime | 查询任务开始时间，为 NANOTIMESTAMP 类型。 |",
32565
+ "+-----------+---------------------------------------------------------------------------------------------------------+",
32566
+ "| endTime | 查询任务结束时间，为 NANOTIMESTAMP 类型。 |",
32567
+ "+-----------+---------------------------------------------------------------------------------------------------------+",
32568
+ "| jobDesc | 查询语句描述。 |",
32569
+ "+-----------+---------------------------------------------------------------------------------------------------------+",
32570
+ "| errorMsg | 报错信息。 |",
32571
+ "+-----------+---------------------------------------------------------------------------------------------------------+",
32572
+ "| remoteIP | 发起查询的客户端 IP。 |",
32573
+ "+-----------+---------------------------------------------------------------------------------------------------------+",
32561
32574
  "",
32562
32575
  "本函数只可由系统管理员执行。在使用该函数之前，必须设定配置参数 *perfMonitoring* = 1 以启动性能监控。"
32563
32576
  ]
@@ -32945,7 +32958,47 @@
32945
32958
  {
32946
32959
  "type": "text",
32947
32960
  "value": [
32948
- "返回本地节点上正在执行的交互式任务的描述信息。"
32961
+ "返回本地节点上正在执行的交互式任务的描述信息。",
32962
+ "",
32963
+ "包含以下字段：",
32964
+ "",
32965
+ "+---------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+",
32966
+ "| 参数 | 含义 |",
32967
+ "+=====================+======================================================================================================================================================+",
32968
+ "| node | 本地节点的别名。 |",
32969
+ "+---------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+",
32970
+ "| userID | 用户 ID。 |",
32971
+ "+---------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+",
32972
+ "| rootJobId | 系统中作业的唯一标识。 |",
32973
+ "+---------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+",
32974
+ "| jobType | 作业类型。 |",
32975
+ "+---------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+",
32976
+ "| desc | 作业描述。 |",
32977
+ "+---------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+",
32978
+ "| priority | 作业的优先级，为 0-9 之间的整数。 |",
32979
+ "+---------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+",
32980
+ "| parallelism | 作业的并行度，即分配给该作业的线程数上限。 |",
32981
+ "+---------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+",
32982
+ "| receiveTime | 作业被节点接收的时间。 |",
32983
+ "+---------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+",
32984
+ "| sessionId | 发起作业的会话 ID。 |",
32985
+ "+---------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+",
32986
+ "| remoteIP | 发起作业的客户端 IP。 |",
32987
+ "+---------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+",
32988
+ "| remotePort | 发起作业的客户端的端口号。 |",
32989
+ "+---------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+",
32990
+ "| totalTasks | 作业分解出的总任务数。 |",
32991
+ "+---------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+",
32992
+ "| finishedTasks | 作业分解出的任务中已经完成的任务数。 |",
32993
+ "+---------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+",
32994
+ "| runningTask | 作业分解出的任务中正在执行的任务数。 |",
32995
+ "+---------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+",
32996
+ "| firstTaskStartTime | 第一个任务的开始时间。 |",
32997
+ "+---------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+",
32998
+ "| latestTaskStartTime | 最近一个任务的开始时间。 |",
32999
+ "+---------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+",
33000
+ "| queue | 任务队列类型： normal queue（worker 队列），web queue（web 端 worker 队列），local task queue（local executor 队列），batchJob queue（批作业队列）。 |",
33001
+ "+---------------------+------------------------------------------------------------------------------------------------------------------------------------------------------+"
32949
33002
  ]
32950
33003
  }
32951
33004
  ]
@@ -33430,7 +33483,12 @@
33430
33483
  {
33431
33484
  "type": "text",
33432
33485
  "value": [
33433
- "返回所有的函数视图。"
33486
+ "返回所有的函数视图。",
33487
+ "",
33488
+ "返回一张表，包含两个字段：",
33489
+ "",
33490
+ "* name：函数名。",
33491
+ "* body：函数体。"
33434
33492
  ]
33435
33493
  }
33436
33494
  ]
@@ -33498,7 +33556,7 @@
33498
33556
  {
33499
33557
  "type": "text",
33500
33558
  "value": [
33501
- "返回组的权限。该函数只能由管理员在控制节点上执行。"
33559
+ "返回组的权限。该函数只能由管理员在控制节点/数据节点上执行。"
33502
33560
  ]
33503
33561
  }
33504
33562
  ]
@@ -33555,7 +33613,7 @@
33555
33613
  {
33556
33614
  "type": "text",
33557
33615
  "value": [
33558
- "返回所有组。该函数只能由管理员在控制节点上执行。"
33616
+ "返回所有组。该函数只能由管理员在控制节点/数据节点上执行。"
33559
33617
  ]
33560
33618
  }
33561
33619
  ]
@@ -33614,7 +33672,7 @@
33614
33672
  {
33615
33673
  "type": "text",
33616
33674
  "value": [
33617
- "返回用户所在的组。它只能由管理员在控制节点上执行。"
33675
+ "返回用户所在的组。该函数只能由管理员在控制节点/数据节点上执行。"
33618
33676
  ]
33619
33677
  }
33620
33678
  ]
@@ -33945,7 +34003,21 @@
33945
34003
  {
33946
34004
  "type": "text",
33947
34005
  "value": [
33948
- "监控正在执行或者队列中的作业和任务的数量。"
34006
+ "监控正在执行或者队列中的作业和任务的数量。返回一个字典，其 key 的含义为：",
34007
+ "",
34008
+ "+-------------------+--------------------------+",
34009
+ "| 参数 | 含义 |",
34010
+ "+===================+==========================+",
34011
+ "| queuedLocalTasks | 等待执行的本地任务数。 |",
34012
+ "+-------------------+--------------------------+",
34013
+ "| runningLocalTasks | 正在执行的本地任务数。 |",
34014
+ "+-------------------+--------------------------+",
34015
+ "| queuedJobs | 队列中的作业数。 |",
34016
+ "+-------------------+--------------------------+",
34017
+ "| runningJobs | 正在执行的作业数。 |",
34018
+ "+-------------------+--------------------------+",
34019
+ "| queuedRemoteTasks | 发送到远程执行的任务数。 |",
34020
+ "+-------------------+--------------------------+"
33949
34021
  ]
33950
34022
  }
33951
34023
  ]
@@ -34007,7 +34079,42 @@
34007
34079
  {
34008
34080
  "type": "text",
34009
34081
  "value": [
34010
- "取得批处理作业返回的对象。详情请参考 :doc:`/SystemManagement/BatchJobManagement`。"
34082
+ "取得批处理作业返回的对象。",
34083
+ "",
34084
+ "返回一个表，包含以下字段：",
34085
+ "",
34086
+ "+--------------+--------------------------------------------+",
34087
+ "| 参数 | 含义 |",
34088
+ "+==============+============================================+",
34089
+ "| node | 本地节点的别名。 |",
34090
+ "+--------------+--------------------------------------------+",
34091
+ "| userID | 提交作业任务的用户 ID。 |",
34092
+ "+--------------+--------------------------------------------+",
34093
+ "| jobId | 在提交批作业时指定的作业名。 |",
34094
+ "+--------------+--------------------------------------------+",
34095
+ "| rootJobId | 系统中作业的唯一标识。 |",
34096
+ "+--------------+--------------------------------------------+",
34097
+ "| jobDesc | 用于描述作业的字符串。 |",
34098
+ "+--------------+--------------------------------------------+",
34099
+ "| priority | 作业的优先级，为 0-9 之间的整数。 |",
34100
+ "+--------------+--------------------------------------------+",
34101
+ "| parallelism | 作业的并行度，即分配给该作业的线程数上限。 |",
34102
+ "+--------------+--------------------------------------------+",
34103
+ "| clientIp | 发起作业任务的客户端 IP。 |",
34104
+ "+--------------+--------------------------------------------+",
34105
+ "| clientPort | 发起作业任务的客户端端口号。 |",
34106
+ "+--------------+--------------------------------------------+",
34107
+ "| receivedTime | 作业接收的时间，为 TIMESTAMP 类型。 |",
34108
+ "+--------------+--------------------------------------------+",
34109
+ "| startTime | 作业开始时间，为 TIMESTAMP 类型。 |",
34110
+ "+--------------+--------------------------------------------+",
34111
+ "| endTime | 作业结束时间，为 TIMESTAMP 类型。 |",
34112
+ "+--------------+--------------------------------------------+",
34113
+ "| errorMessage | 报错信息。 |",
34114
+ "+--------------+--------------------------------------------+",
34115
+ "",
34116
+ "",
34117
+ "详情请参考 :doc:`/SystemManagement/BatchJobManagement`。"
34011
34118
  ]
34012
34119
  }
34013
34120
  ]
@@ -34301,9 +34408,9 @@
34301
34408
  }
34302
34409
  ]
34303
34410
  },
34304
- "getMachineFingerprint": {
34305
- "title": "getMachineFingerprint",
34306
- "type": "command",
34411
+ "getLicenseServerResourceInfo": {
34412
+ "title": "getLicenseServerResourceInfo",
34413
+ "type": "function",
34307
34414
  "children": [
34308
34415
  {
34309
34416
  "title": "语法",
@@ -34312,9 +34419,7 @@
34312
34419
  {
34313
34420
  "type": "text",
34314
34421
  "value": [
34315
- "getMachineFingerprint(outputPath)",
34316
- "",
34317
- "别名：generateMachineFingerprint"
34422
+ "getLicenseServerResourceInfo()"
34318
34423
  ]
34319
34424
  }
34320
34425
  ]
@@ -34326,7 +34431,7 @@
34326
34431
  {
34327
34432
  "type": "text",
34328
34433
  "value": [
34329
- "`outputPath` 是字符串，表示存放机器指纹的目录。"
34434
+ "无"
34330
34435
  ]
34331
34436
  }
34332
34437
  ]
@@ -34338,7 +34443,22 @@
34338
34443
  {
34339
34444
  "type": "text",
34340
34445
  "value": [
34341
- "生成机器指纹，用于 license 验证。该命令必须要用户登录后才能执行。Windows 操作系统下执行该函数需要管理员权限。"
34446
+ "License Server 是一个单节点 server，负责与其它非 License Server 的节点进行通信，并控制节点的启动。它收集其它节点对于资源（内存和CPU 内核数）的需求数量，当存在可用资源时，便允许节点正常启动，否则拒绝节点启动。通过配置项 localSite 和 licenseServerSite 控制是否启用 License Server。",
34447
+ "该函数用于获取由 License Server 管理的许可证等信息，返回一个字典，包含以下信息：",
34448
+ "",
34449
+ "* expiration：许可证到期时间",
34450
+ "",
34451
+ "* availableCores：可用内核数量",
34452
+ "",
34453
+ "* availableMemory：可用内存，单位为 GB",
34454
+ "",
34455
+ "* maxNodes：最大节点数量",
34456
+ "",
34457
+ "* maxMemory：最大内存，单位为 GB",
34458
+ "",
34459
+ "* maxCores：最大内核数",
34460
+ "",
34461
+ "该函数只能由管理员在 License Server 上调用。"
34342
34462
  ]
34343
34463
  }
34344
34464
  ]
@@ -34352,16 +34472,22 @@
34352
34472
  "language": "console",
34353
34473
  "value": [
34354
34474
  "",
34355
- " $ generateMachineFingerprint(\"/home/DolphinDB\")"
34475
+ " $ getLicenseServerResourceInfo()",
34476
+ " expiration->2023.03.10",
34477
+ " availableCores->10",
34478
+ " availableMemory->52",
34479
+ " maxNodes->4",
34480
+ " maxMemory->64",
34481
+ " maxCores->16"
34356
34482
  ]
34357
34483
  }
34358
34484
  ]
34359
34485
  }
34360
34486
  ]
34361
34487
  },
34362
- "getMemLimitOfQueryResult": {
34363
- "title": "getMemLimitOfQueryResult",
34364
- "type": "function",
34488
+ "getMachineFingerprint": {
34489
+ "title": "getMachineFingerprint",
34490
+ "type": "command",
34365
34491
  "children": [
34366
34492
  {
34367
34493
  "title": "语法",
@@ -34370,7 +34496,9 @@
34370
34496
  {
34371
34497
  "type": "text",
34372
34498
  "value": [
34373
- "getMemLimitOfQueryResult()"
34499
+ "getMachineFingerprint(outputPath)",
34500
+ "",
34501
+ "别名：generateMachineFingerprint"
34374
34502
  ]
34375
34503
  }
34376
34504
  ]
@@ -34382,7 +34510,7 @@
34382
34510
  {
34383
34511
  "type": "text",
34384
34512
  "value": [
34385
- "无"
34513
+ "`outputPath` 是字符串，表示存放机器指纹的目录。"
34386
34514
  ]
34387
34515
  }
34388
34516
  ]
@@ -34394,7 +34522,7 @@
34394
34522
  {
34395
34523
  "type": "text",
34396
34524
  "value": [
34397
- "获取单次查询结果占用的内存上限（单位为字节），返回一个 DOUBLE 类型数据。"
34525
+ "生成机器指纹，用于 license 验证。该命令必须要用户登录后才能执行。Windows 操作系统下执行该函数需要管理员权限。"
34398
34526
  ]
34399
34527
  }
34400
34528
  ]
@@ -34407,25 +34535,16 @@
34407
34535
  "type": "code",
34408
34536
  "language": "console",
34409
34537
  "value": [
34410
- " ",
34411
- " $ setMemLimitOfQueryResult(0.2)",
34412
- " $ getMemLimitOfQueryResult() / 1024 / 1024 / 1024",
34413
- " 0.2",
34414
- ""
34415
- ]
34416
- },
34417
- {
34418
- "type": "text",
34419
- "value": [
34420
- "相关函数：:doc:`/FunctionsandCommands/CommandsReferences/s/setMemLimitOfQueryResult`"
34538
+ "",
34539
+ " $ generateMachineFingerprint(\"/home/DolphinDB\")"
34421
34540
  ]
34422
34541
  }
34423
34542
  ]
34424
34543
  }
34425
34544
  ]
34426
34545
  },
34427
- "getMemLimitOfTaskGroupResult": {
34428
- "title": "getMemLimitOfTaskGroupResult",
34546
+ "getMemLimitOfQueryResult": {
34547
+ "title": "getMemLimitOfQueryResult",
34429
34548
  "type": "function",
34430
34549
  "children": [
34431
34550
  {
@@ -34435,7 +34554,72 @@
34435
34554
  {
34436
34555
  "type": "text",
34437
34556
  "value": [
34438
- "getMemLimitOfTaskGroupResult()"
34557
+ "getMemLimitOfQueryResult()"
34558
+ ]
34559
+ }
34560
+ ]
34561
+ },
34562
+ {
34563
+ "title": "参数",
34564
+ "type": "parameters",
34565
+ "children": [
34566
+ {
34567
+ "type": "text",
34568
+ "value": [
34569
+ "无"
34570
+ ]
34571
+ }
34572
+ ]
34573
+ },
34574
+ {
34575
+ "title": "详情",
34576
+ "type": "detail",
34577
+ "children": [
34578
+ {
34579
+ "type": "text",
34580
+ "value": [
34581
+ "获取单次查询结果占用的内存上限（单位为字节），返回一个 DOUBLE 类型数据。"
34582
+ ]
34583
+ }
34584
+ ]
34585
+ },
34586
+ {
34587
+ "title": "例子",
34588
+ "type": "example",
34589
+ "children": [
34590
+ {
34591
+ "type": "code",
34592
+ "language": "console",
34593
+ "value": [
34594
+ " ",
34595
+ " $ setMemLimitOfQueryResult(0.2)",
34596
+ " $ getMemLimitOfQueryResult() / 1024 / 1024 / 1024",
34597
+ " 0.2",
34598
+ ""
34599
+ ]
34600
+ },
34601
+ {
34602
+ "type": "text",
34603
+ "value": [
34604
+ "相关函数：:doc:`/FunctionsandCommands/CommandsReferences/s/setMemLimitOfQueryResult`"
34605
+ ]
34606
+ }
34607
+ ]
34608
+ }
34609
+ ]
34610
+ },
34611
+ "getMemLimitOfTaskGroupResult": {
34612
+ "title": "getMemLimitOfTaskGroupResult",
34613
+ "type": "function",
34614
+ "children": [
34615
+ {
34616
+ "title": "语法",
34617
+ "type": "grammer",
34618
+ "children": [
34619
+ {
34620
+ "type": "text",
34621
+ "value": [
34622
+ "getMemLimitOfTaskGroupResult()"
34439
34623
  ]
34440
34624
  }
34441
34625
  ]
@@ -34524,7 +34708,10 @@
34524
34708
  {
34525
34709
  "type": "text",
34526
34710
  "value": [
34527
- "返回当前节点已分配的内存和未使用的内存。"
34711
+ "返回当前节点已分配的内存和未使用的内存。返回一个字典其 key 值的含义为：",
34712
+ "",
34713
+ "* freeBytes：当前节点已分配的内存，单位为字节。 ",
34714
+ "* allocatedBytes：当前节点未使用的内存，单位为字节。 "
34528
34715
  ]
34529
34716
  }
34530
34717
  ]
@@ -34945,6 +35132,48 @@
34945
35132
  }
34946
35133
  ]
34947
35134
  },
35135
+ "getOLAPCachedSymbolBaseMemSize": {
35136
+ "title": "getOLAPCachedSymbolBaseMemSize",
35137
+ "type": "function",
35138
+ "children": [
35139
+ {
35140
+ "title": "语法",
35141
+ "type": "grammer",
35142
+ "children": [
35143
+ {
35144
+ "type": "text",
35145
+ "value": [
35146
+ "getOLAPCachedSymbolBaseMemSize()"
35147
+ ]
35148
+ }
35149
+ ]
35150
+ },
35151
+ {
35152
+ "title": "参数",
35153
+ "type": "parameters",
35154
+ "children": [
35155
+ {
35156
+ "type": "text",
35157
+ "value": [
35158
+ "无"
35159
+ ]
35160
+ }
35161
+ ]
35162
+ },
35163
+ {
35164
+ "title": "详情",
35165
+ "type": "detail",
35166
+ "children": [
35167
+ {
35168
+ "type": "text",
35169
+ "value": [
35170
+ "获取 OLAP 引擎中 SYMBOL 类型的字典编码的缓存大小，单位是 Bytes。 "
35171
+ ]
35172
+ }
35173
+ ]
35174
+ }
35175
+ ]
35176
+ },
34948
35177
  "getOS": {
34949
35178
  "title": "getOS",
34950
35179
  "type": "function",
@@ -35428,7 +35657,42 @@
35428
35657
  {
35429
35658
  "type": "text",
35430
35659
  "value": [
35431
- "取得本地节点上最近N个批处理作业的状态。详情请参考 :doc:`/SystemManagement/BatchJobManagement`。"
35660
+ "取得本地节点上最近N个批处理作业的状态。",
35661
+ "",
35662
+ "返回一个表，包含以下字段：",
35663
+ "",
35664
+ "+--------------+--------------------------------------------+",
35665
+ "| 参数 | 含义 |",
35666
+ "+==============+============================================+",
35667
+ "| node | 本地节点的别名。 |",
35668
+ "+--------------+--------------------------------------------+",
35669
+ "| userID | 提交作业任务的用户 ID。 |",
35670
+ "+--------------+--------------------------------------------+",
35671
+ "| jobId | 在提交批作业时指定的作业名。 |",
35672
+ "+--------------+--------------------------------------------+",
35673
+ "| rootJobId | 系统中作业的唯一标识。 |",
35674
+ "+--------------+--------------------------------------------+",
35675
+ "| jobDesc | 用于描述作业的字符串。 |",
35676
+ "+--------------+--------------------------------------------+",
35677
+ "| priority | 作业的优先级，为 0-9 之间的整数。 |",
35678
+ "+--------------+--------------------------------------------+",
35679
+ "| parallelism | 作业的并行度，即分配给该作业的线程数上限。 |",
35680
+ "+--------------+--------------------------------------------+",
35681
+ "| clientIp | 发起作业任务的客户端 IP。 |",
35682
+ "+--------------+--------------------------------------------+",
35683
+ "| clientPort | 发起作业任务的客户端端口号。 |",
35684
+ "+--------------+--------------------------------------------+",
35685
+ "| receivedTime | 作业接收的时间，为 TIMESTAMP 类型。 |",
35686
+ "+--------------+--------------------------------------------+",
35687
+ "| startTime | 作业开始时间，为 TIMESTAMP 类型。 |",
35688
+ "+--------------+--------------------------------------------+",
35689
+ "| endTime | 作业结束时间，为 TIMESTAMP 类型。 |",
35690
+ "+--------------+--------------------------------------------+",
35691
+ "| errorMessage | 报错信息。 |",
35692
+ "+--------------+--------------------------------------------+",
35693
+ "",
35694
+ "",
35695
+ "详情请参考 :doc:`/SystemManagement/BatchJobManagement`。"
35432
35696
  ]
35433
35697
  }
35434
35698
  ]
@@ -35689,6 +35953,88 @@
35689
35953
  }
35690
35954
  ]
35691
35955
  },
35956
+ "getRegisteredNodeInfo": {
35957
+ "title": "getRegisteredNodeInfo",
35958
+ "type": "function",
35959
+ "children": [
35960
+ {
35961
+ "title": "语法",
35962
+ "type": "grammer",
35963
+ "children": [
35964
+ {
35965
+ "type": "text",
35966
+ "value": [
35967
+ "getRegisteredNodeInfo()"
35968
+ ]
35969
+ }
35970
+ ]
35971
+ },
35972
+ {
35973
+ "title": "参数",
35974
+ "type": "parameters",
35975
+ "children": [
35976
+ {
35977
+ "type": "text",
35978
+ "value": [
35979
+ "无"
35980
+ ]
35981
+ }
35982
+ ]
35983
+ },
35984
+ {
35985
+ "title": "详情",
35986
+ "type": "detail",
35987
+ "children": [
35988
+ {
35989
+ "type": "text",
35990
+ "value": [
35991
+ "获取在 License Server 上注册的各个节点，及所在物理机的信息，返回一个张表，包括以下列：",
35992
+ "",
35993
+ "* type：node 或 machine",
35994
+ "",
35995
+ "* host：主机地址",
35996
+ "",
35997
+ "* port：type 是 node 时，为该节点的端口号，否则为空",
35998
+ "",
35999
+ "* alias：type 是 node 时，为该节点别名，否则为空",
36000
+ "",
36001
+ "* usedMem：节点或物理机已使用内存",
36002
+ "",
36003
+ "* usedCores：节点或物理机已使用内核数量",
36004
+ "",
36005
+ "* bindCores：节点绑定的 CPU 内核编号",
36006
+ "",
36007
+ "* lastUpdate：type 是 node 时，表述最后一次给节点分配资源的时间；type 是 machine 时，表示最后一次给物理机上所有节点分配资源时间",
36008
+ "",
36009
+ "该函数只能由管理员在 licenseServer 上调用。"
36010
+ ]
36011
+ }
36012
+ ]
36013
+ },
36014
+ {
36015
+ "title": "例子",
36016
+ "type": "example",
36017
+ "children": [
36018
+ {
36019
+ "type": "code",
36020
+ "language": "console",
36021
+ "value": [
36022
+ "",
36023
+ " $ getRegisteredNodeInfo()",
36024
+ " type \thost\t port\talias\t usedMem\t usedCores\tbindCores\tlastedUpdateTime",
36025
+ " node\t10.6.0.12\t33,795\ttest33\t 4\t 2\t\t 2023.02.15T15:23:54.487",
36026
+ " node\t10.6.0.12\t33,785\tdatanode3\t4\t 2\t\t 2023.02.15T15:11:48.454",
36027
+ " machine\t10.6.0.12\t\t\t 8\t 4\t\t 2023.02.15T15:23:54.487",
36028
+ " node\t10.6.0.11\t33,782\tdatanode1\t4\t 2\t\t 2023.02.15T11:47:27.534",
36029
+ " node\t10.6.0.11\t33,780\tcontroller1\t4\t 2\t\t 2023.02.15T11:30:07.358",
36030
+ " machine\t10.6.0.11\t\t\t 8\t 4\t\t 2023.02.15T11:47:27.534",
36031
+ ""
36032
+ ]
36033
+ }
36034
+ ]
36035
+ }
36036
+ ]
36037
+ },
35692
36038
  "getRightStream": {
35693
36039
  "title": "getRightStream",
35694
36040
  "type": "function",
@@ -35775,7 +36121,35 @@
35775
36121
  {
35776
36122
  "type": "text",
35777
36123
  "value": [
35778
- "获取本地节点上正在执行的查询任务的描述信息。使用该函数之前，必须设定参数 *perfMonitoring* = 1 来启用性能监控。"
36124
+ "获取本地节点上正在执行的查询任务的描述信息。",
36125
+ "",
36126
+ "返回一张表，包含以下字段：",
36127
+ "",
36128
+ "+-----------+---------------------------------------------------------------------------------------------------------+",
36129
+ "| 参数 | 含义 |",
36130
+ "+===========+=========================================================================================================+",
36131
+ "| userID | 用户 ID 。 |",
36132
+ "+-----------+---------------------------------------------------------------------------------------------------------+",
36133
+ "| sessionID | 发起查询的会话 ID。 |",
36134
+ "+-----------+---------------------------------------------------------------------------------------------------------+",
36135
+ "| jobID | 系统中查询任务的唯一标识。 |",
36136
+ "+-----------+---------------------------------------------------------------------------------------------------------+",
36137
+ "| rootID | 当前任务所属根任务的 jobID。 |",
36138
+ "+-----------+---------------------------------------------------------------------------------------------------------+",
36139
+ "| level | 任务的级别。根任务的 level 为 0，其分解的子任务 level 为 1，该子任务分解的子任务 level 为 2，以此类推。 |",
36140
+ "+-----------+---------------------------------------------------------------------------------------------------------+",
36141
+ "| startTime | 查询任务开始时间，为 NANOTIMESTAMP 类型。 |",
36142
+ "+-----------+---------------------------------------------------------------------------------------------------------+",
36143
+ "| endTime | 查询任务结束时间，为 NANOTIMESTAMP 类型。 |",
36144
+ "+-----------+---------------------------------------------------------------------------------------------------------+",
36145
+ "| jobDesc | 查询语句描述。 |",
36146
+ "+-----------+---------------------------------------------------------------------------------------------------------+",
36147
+ "| errorMsg | 报错信息。 |",
36148
+ "+-----------+---------------------------------------------------------------------------------------------------------+",
36149
+ "| remoteIP | 发起查询的客户端 IP。 |",
36150
+ "+-----------+---------------------------------------------------------------------------------------------------------+",
36151
+ "",
36152
+ "使用该函数之前，必须设定参数 *perfMonitoring* = 1 来启用性能监控。"
35779
36153
  ]
35780
36154
  }
35781
36155
  ]
@@ -35843,7 +36217,29 @@
35843
36217
  {
35844
36218
  "type": "text",
35845
36219
  "value": [
35846
- "以表格的形式返回定时任务。如果jobIdPattern没有指定，返回所有已有的定时作业。"
36220
+ "以表格的形式返回定时任务。如果jobIdPattern没有指定，返回所有已有的定时作业。",
36221
+ "",
36222
+ "包含以下字段：",
36223
+ "",
36224
+ "+---------------+--------------------------------------------------+",
36225
+ "| 参数 | 含义 |",
36226
+ "+===============+==================================================+",
36227
+ "| userId | 用户 ID。 |",
36228
+ "+---------------+--------------------------------------------------+",
36229
+ "| jobId | 在提交定时作业时指定的作业名。 |",
36230
+ "+---------------+--------------------------------------------------+",
36231
+ "| jobDesc | 作业描述。 |",
36232
+ "+---------------+--------------------------------------------------+",
36233
+ "| startDate | 定时作业的开始日期，为 DATE 类型。 |",
36234
+ "+---------------+--------------------------------------------------+",
36235
+ "| endDate | 定时作业的结束日期，为 DATE 类型。 |",
36236
+ "+---------------+--------------------------------------------------+",
36237
+ "| frequency | 定时作业的执行频率。 |",
36238
+ "+---------------+--------------------------------------------------+",
36239
+ "| scheduledTime | 定时作业的执行间隔，为 MINUTE 类型。 |",
36240
+ "+---------------+--------------------------------------------------+",
36241
+ "| days | frequency 为 'W' 或 'M' 时，执行定时任务的日期。 |",
36242
+ "+---------------+--------------------------------------------------+"
35847
36243
  ]
35848
36244
  }
35849
36245
  ]
@@ -35912,7 +36308,53 @@
35912
36308
  {
35913
36309
  "type": "text",
35914
36310
  "value": [
35915
- "返回当前节点的所有会话的内存使用信息、IP地址、端口、被创建的时间，以及最后使用时间。由于共享表和分布式表不属于某个用户或会话，因此返回结果中不包含它们占用的内存信息。",
36311
+ "获取会话的内存占用状态，返回一张表包含以下字段：",
36312
+ "",
36313
+ "+----------------+---------------------------------------------------+",
36314
+ "| 参数 | 含义 |",
36315
+ "+================+===================================================+",
36316
+ "| userId | 用户 ID 或缓存类型的标识符（形如：\\_\\_xxx\\_\\_）。 |",
36317
+ "+----------------+---------------------------------------------------+",
36318
+ "| sessionId | 会话 ID。 |",
36319
+ "+----------------+---------------------------------------------------+",
36320
+ "| memSize | 会话所占用的内存，单位为字节。 |",
36321
+ "+----------------+---------------------------------------------------+",
36322
+ "| remoteIP | 发起会话的客户端的 IP。 |",
36323
+ "+----------------+---------------------------------------------------+",
36324
+ "| remotePort | 发起会话的客户端的端口号。 |",
36325
+ "+----------------+---------------------------------------------------+",
36326
+ "| createTime | 会话创建的时间，为 TIMESTAMP 类型。 |",
36327
+ "+----------------+---------------------------------------------------+",
36328
+ "| lastActiveTime | 会话最近一次执行脚本的时间戳。 |",
36329
+ "+----------------+---------------------------------------------------+",
36330
+ "",
36331
+ "缓存类型说明:",
36332
+ "",
36333
+ "+------------------------------+-----------------------------------------------------+",
36334
+ "| 缓存类型 | 含义 |",
36335
+ "+==============================+=====================================================+",
36336
+ "| \\_\\_DimensionalTable\\_\\_ | 维度表缓存，单位为 Bytes。 |",
36337
+ "+------------------------------+-----------------------------------------------------+",
36338
+ "| \\_\\_SharedTable\\_\\_ | 共享表缓存，单位为 Bytes。 |",
36339
+ "+------------------------------+-----------------------------------------------------+",
36340
+ "| \\_\\_OLAPTablet\\_\\_ | OLAP 引擎数据库表的缓存，单位为 Bytes。 |",
36341
+ "+------------------------------+-----------------------------------------------------+",
36342
+ "| \\_\\_OLAPCacheEngine\\_\\_ | OLAP 引擎 cache engine 的内存占用，单位为 Bytes。 |",
36343
+ "+------------------------------+-----------------------------------------------------+",
36344
+ "| \\_\\_OLAPCachedSymbolBase\\_\\_ | OLAP 引擎 SYMBOL 类型字典编码的缓存，单位为 Bytes。 |",
36345
+ "+------------------------------+-----------------------------------------------------+",
36346
+ "| \\_\\_DFSMetadata\\_\\_ | 分布式存储的元数据缓存，单位为 Bytes。 |",
36347
+ "+------------------------------+-----------------------------------------------------+",
36348
+ "| \\_\\_TSDBCacheEngine\\_\\_ | TSDB 引擎 cache engine 的内存占用，单位为 Bytes。 |",
36349
+ "+------------------------------+-----------------------------------------------------+",
36350
+ "| \\_\\_TSDBLevelFileIndex\\_\\_ | TSDB 引擎 level file 索引的缓存，单位为 Bytes。 |",
36351
+ "+------------------------------+-----------------------------------------------------+",
36352
+ "| \\_\\_TSDBCachedSymbolBase\\_\\_ | TSDB 引擎 SYMBOL 类型字典编码的缓存，单位为 Bytes。 |",
36353
+ "+------------------------------+-----------------------------------------------------+",
36354
+ "| \\_\\_StreamingPubQueue\\_\\_ | 流数据发布队列里未处理的消息数。 |",
36355
+ "+------------------------------+-----------------------------------------------------+",
36356
+ "| \\_\\_StreamingSubQueue\\_\\_ | 流数据订阅队列里未处理的消息数。 |",
36357
+ "+------------------------------+-----------------------------------------------------+",
35916
36358
  "",
35917
36359
  "注：此函数无法统计到会话中正在执行的任务所占用的内存情况。",
35918
36360
  "",
@@ -35938,12 +36380,33 @@
35938
36380
  {
35939
36381
  "type": "text",
35940
36382
  "value": [
35941
- "====== ========== ======== ========= ========== ======================= ======================= ",
35942
- "userId sessionId memSize remoteIP remotePort createTime lastActiveTime ",
35943
- "====== ========== ======== ========= ========== ======================= ======================= ",
35944
- "admin 1441295757 16 127.0.0.1 55030 2020.08.15T23:07:45.161 2020.08.15T23:07:45.161",
35945
- "admin 1166953221 77878188 127.0.0.1 57489 2020.08.14T09:20:01.902 2020.08.16T22:25:31.649",
35946
- "====== ========== ======== ========= ========== ======================= ======================= ",
36383
+ "=========================== ============ ======== ============== ========== =========================== ========================= ",
36384
+ "userId sessionId memSize remoteIP remotePort createTime lastActiveTime ",
36385
+ "=========================== ============ ======== ============== ========== =========================== ========================= ",
36386
+ "__DimensionalTable__ 0 0.0.0.0 ",
36387
+ "",
36388
+ "__SharedTable__ 0 0.0.0.0 ",
36389
+ "",
36390
+ "__OLAPTablet__ 0 0.0.0.0 ",
36391
+ "",
36392
+ "__OLAPCacheEngine__ 0 0.0.0.0 ",
36393
+ "",
36394
+ "__OLAPCachedSymbolBa... 0 0.0.0.0 ",
36395
+ "",
36396
+ "__DFSMetadata__ 2769 0.0.0.0 ",
36397
+ "",
36398
+ "__TSDBCacheEngine__ 0 0.0.0.0 ",
36399
+ "",
36400
+ "__TSDBLevelFileIndex__ 0 0.0.0.0 ",
36401
+ "",
36402
+ "__TSDBCachedSymbolBa... 0 0.0.0.0 ",
36403
+ "",
36404
+ "__StreamingPubQueue__ 0 0.0.0.0 ",
36405
+ "",
36406
+ "__StreamingSubQueue__ 0 0.0.0.0 ",
36407
+ "",
36408
+ "admin 2882591513 1416 60.176.105.0 20861 2023.02.15T02:15:22.384 2023.02.15T02:24:16.307",
36409
+ "=========================== ============ ======== ============== ========== =========================== ========================= ",
35947
36410
  ""
35948
36411
  ]
35949
36412
  },
@@ -35952,20 +36415,40 @@
35952
36415
  "language": "console",
35953
36416
  "value": [
35954
36417
  "",
35955
- " $ update t set createTime=localtime(createTime), lastActiveTime=localtime(lastActiveTime);",
35956
- " $ t;",
36418
+ " $ update t set createTime=localtime(createTime), lastActiveTime=localtime(lastActiveTime) where not userId like \"__%__\"",
35957
36419
  ""
35958
36420
  ]
35959
36421
  },
35960
36422
  {
35961
36423
  "type": "text",
35962
36424
  "value": [
35963
- "====== ========== ======== ========= ========== ======================= ======================= ",
35964
- "userId sessionId memSize remoteIP remotePort createTime lastActiveTime ",
35965
- "====== ========== ======== ========= ========== ======================= ======================= ",
35966
- "admin 1441295757 16 127.0.0.1 55030 2020.08.15T23:07:45.161 2020.08.15T23:07:45.161",
35967
- "admin 1166953221 77878188 127.0.0.1 57489 2020.08.14T09:20:01.902 2020.08.16T22:25:31.649",
35968
- "====== ========== ======== ========= ========== ======================= ======================="
36425
+ "================================= ============ ======== ============== ========== ======================= ========================= ",
36426
+ "userId sessionId memSize remoteIP remotePort createTime lastActiveTime ",
36427
+ "================================= ============ ======== ============== ========== ======================= =========================",
36428
+ "__DimensionalTable__ 0 0.0.0.0 ",
36429
+ "",
36430
+ "__SharedTable__ 0 0.0.0.0 ",
36431
+ "",
36432
+ "__OLAPTablet__ 0 0.0.0.0 ",
36433
+ "",
36434
+ "__OLAPCacheEngine__ 0 0.0.0.0 ",
36435
+ "",
36436
+ "__OLAPCachedSymbolBa... 0 0.0.0.0 ",
36437
+ "",
36438
+ "__DFSMetadata__ 2769 0.0.0.0 ",
36439
+ "",
36440
+ "__TSDBCacheEngine__ 0 0.0.0.0 ",
36441
+ "",
36442
+ "__TSDBLevelFileIndex__ 0 0.0.0.0 ",
36443
+ "",
36444
+ "__TSDBCachedSymbolBa... 0 0.0.0.0 ",
36445
+ "",
36446
+ "__StreamingPubQueue__ 0 0.0.0.0 ",
36447
+ "",
36448
+ "__StreamingSubQueue__ 0 0.0.0.0 ",
36449
+ "",
36450
+ "admin 1195587396 1416 60.176.105.0 20874 2023.02.14T21:26:14.004 2023.02.14T21:27:27.463",
36451
+ "================================= ============ ======== ============== ========== ======================= ========================= "
35969
36452
  ]
35970
36453
  }
35971
36454
  ]
@@ -36837,7 +37320,7 @@
36837
37320
  "| DB AND TABLE SCHEMA | 所有数据库和表的结构。 | ``schema`` |",
36838
37321
  "+----------------------+--------------------------------------------------------------------------------+-----------------------------------------+",
36839
37322
  "| LICENSE AND MACHINE | license、机器核数和内存信息。 | 许可证: dolphindb.lic |",
36840
- "| INFO | | |",
37323
+ "| INFO | 节点绑定的 CPU 内核绑定和端口信息。 | |",
36841
37324
  "+----------------------+--------------------------------------------------------------------------------+-----------------------------------------+",
36842
37325
  "| OLAP CACHE ENGINE | OLAP 引擎 cache Engine 的状态信息，包含各节点的内存信息以及当前节点的状态表。 | ``pnodeRun(getOLAPCacheEngineSize)`` |",
36843
37326
  "| STATUS | | ``pnodeRun(getOLAPCacheEngineStat)`` |",
@@ -36916,7 +37399,9 @@
36916
37399
  {
36917
37400
  "type": "text",
36918
37401
  "value": [
36919
- "返回实时CPU利用空间。使用该函数前，需要启动性能监控，即在配置文件中把perfMonitoring设为1。"
37402
+ "返回当前节点上DolphinDB进程实时占用 CPU 的百分比。",
37403
+ "",
37404
+ "注意，若 DolphinDB 进程占用多个 CPU，则返回各个 CPU 占用率的总和。"
36920
37405
  ]
36921
37406
  }
36922
37407
  ]
@@ -37063,6 +37548,48 @@
37063
37548
  }
37064
37549
  ]
37065
37550
  },
37551
+ "getTSDBCachedSymbolBaseMemSize": {
37552
+ "title": "getTSDBCachedSymbolBaseMemSize",
37553
+ "type": "function",
37554
+ "children": [
37555
+ {
37556
+ "title": "语法",
37557
+ "type": "grammer",
37558
+ "children": [
37559
+ {
37560
+ "type": "text",
37561
+ "value": [
37562
+ "getOLAPCachedSymbolBaseMemSize()"
37563
+ ]
37564
+ }
37565
+ ]
37566
+ },
37567
+ {
37568
+ "title": "参数",
37569
+ "type": "parameters",
37570
+ "children": [
37571
+ {
37572
+ "type": "text",
37573
+ "value": [
37574
+ "无"
37575
+ ]
37576
+ }
37577
+ ]
37578
+ },
37579
+ {
37580
+ "title": "详情",
37581
+ "type": "detail",
37582
+ "children": [
37583
+ {
37584
+ "type": "text",
37585
+ "value": [
37586
+ "获取 TSDB 引擎中 SYMBOL 类型的字典编码的缓存大小，单位是 Bytes。 "
37587
+ ]
37588
+ }
37589
+ ]
37590
+ }
37591
+ ]
37592
+ },
37066
37593
  "getTSDBCompactionTaskStatus": {
37067
37594
  "title": "getTSDBCompactionTaskStatus",
37068
37595
  "type": "function",
@@ -37467,7 +37994,7 @@
37467
37994
  "",
37468
37995
  "`tableName` 是字符串，表示数据表名。",
37469
37996
  "",
37470
- "`diskUsage` 是一个Boolean值，表示结果是否输出磁盘占用。",
37997
+ "`diskUsage` 是一个Boolean 值，表示结果是否输出磁盘占用。",
37471
37998
  "",
37472
37999
  "`top` 是一个正整数，表示结果中返回的chunk的个数上限。默认值为1024。若不设上限，需将 top 参数设为-1。"
37473
38000
  ]
@@ -37493,7 +38020,7 @@
37493
38020
  "* rowNum: 分区的记录条数",
37494
38021
  "* createCids：update/delete表时创建的版本号",
37495
38022
  "* latestPhysicalDir：最新版本号（cid）对应的存储数据的临时物理路径",
37496
- "* diskUsage：分区占用的磁盘空间"
38023
+ "* diskUsage：分区占用的磁盘空间，单位为字节。"
37497
38024
  ]
37498
38025
  }
37499
38026
  ]
@@ -37764,116 +38291,6 @@
37764
38291
  }
37765
38292
  ]
37766
38293
  },
37767
- "getUserAccess": {
37768
- "title": "getUserAccess",
37769
- "type": "function",
37770
- "children": [
37771
- {
37772
- "title": "语法",
37773
- "type": "grammer",
37774
- "children": [
37775
- {
37776
- "type": "text",
37777
- "value": [
37778
- "getUserAccess([userIds])"
37779
- ]
37780
- }
37781
- ]
37782
- },
37783
- {
37784
- "title": "参数",
37785
- "type": "parameters",
37786
- "children": [
37787
- {
37788
- "type": "text",
37789
- "value": [
37790
- "`userId` 是表示一个或多个用户的字符串标量或向量。"
37791
- ]
37792
- }
37793
- ]
37794
- },
37795
- {
37796
- "title": "详情",
37797
- "type": "detail",
37798
- "children": [
37799
- {
37800
- "type": "text",
37801
- "value": [
37802
- "返回指定用户所单独被赋予的权限，不包括用户所属组的权限。",
37803
- "",
37804
- "当没有指定userId时，返回当前登录用户的权限。只有管理员能够使用该函数来获取其他用户的权限。",
37805
- "",
37806
- "以下分别介绍返回表的各参数的详情：",
37807
- "",
37808
- "+------------------+----------------------------------------------------------------------------------------+",
37809
- "| 参数 | 详情 |",
37810
- "+==================+========================================================================================+",
37811
- "| userId | 用户名 |",
37812
- "+------------------+----------------------------------------------------------------------------------------+",
37813
- "| groups | 组名 |",
37814
- "+------------------+----------------------------------------------------------------------------------------+",
37815
- "| isAdmin | 是否是管理员 |",
37816
- "+------------------+----------------------------------------------------------------------------------------+",
37817
- "| MAX_JOB_PRIORITY | 该用户对应的作业最高优先级，范围是0-8，可以通过 setMaxJobPriority 指定 |",
37818
- "+------------------+----------------------------------------------------------------------------------------+",
37819
- "| MAX_PARALLELISM | 该用户提交的作业最多可以有多少个子任务同时并行执行，可以通过 setMaxJobParallelism 指定 |",
37820
- "+------------------+----------------------------------------------------------------------------------------+",
37821
- "",
37822
- "以下九个字段对应九种权限，其值为 “allow\" / \"none\" / \"deny\" ：",
37823
- "",
37824
- "+--------------+",
37825
- "|权限 |",
37826
- "+==============+",
37827
- "| TABLE_READ |",
37828
- "+--------------+",
37829
- "| TABLE_WRITE |",
37830
- "+--------------+",
37831
- "| VIEW_EXEC |",
37832
- "+--------------+",
37833
- "| SCRIPT_EXEC |",
37834
- "+--------------+",
37835
- "| TEST_EXEC |",
37836
- "+--------------+",
37837
- "| DBOBJ_CREATE |",
37838
- "+--------------+",
37839
- "| DBOBJ_DELETE |",
37840
- "+--------------+",
37841
- "| DB_MANAGE |",
37842
- "+--------------+",
37843
- "| DB_OWNER |",
37844
- "+--------------+",
37845
- "",
37846
- "以下几个字段表示权限应用的具体对象：",
37847
- "",
37848
- "+----------------------+",
37849
- "| 对象 |",
37850
- "+======================+",
37851
- "| TABLE_READ_allowed |",
37852
- "+----------------------+",
37853
- "| TABLE_READ_denied |",
37854
- "+----------------------+",
37855
- "| TABLE_WRITE_allowed |",
37856
- "+----------------------+",
37857
- "| TABLE_WRITE_denied |",
37858
- "+----------------------+",
37859
- "| VIEW_EXEC_allowed |",
37860
- "+----------------------+",
37861
- "| VIEW_EXEC_denied |",
37862
- "+----------------------+",
37863
- "| DBOBJ_CREATE_allowed |",
37864
- "+----------------------+",
37865
- "| DBOBJ_CREATE_denied |",
37866
- "+----------------------+",
37867
- "| DBOBJ_DELETE_allowed |",
37868
- "+----------------------+",
37869
- "| DBOBJ_DELETE_denied |",
37870
- "+----------------------+"
37871
- ]
37872
- }
37873
- ]
37874
- }
37875
- ]
37876
- },
37877
38294
  "getUserList": {
37878
38295
  "title": "getUserList",
37879
38296
  "type": "function",
@@ -37897,7 +38314,7 @@
37897
38314
  {
37898
38315
  "type": "text",
37899
38316
  "value": [
37900
- "返回包含除管理员之外的所有用户名称的向量。该函数只能由管理员在控制节点上执行。"
38317
+ "返回包含除管理员之外的所有用户名称的向量。该函数只能由管理员在控制节点/数据节点上执行。"
37901
38318
  ]
37902
38319
  }
37903
38320
  ]
@@ -37956,7 +38373,7 @@
37956
38373
  {
37957
38374
  "type": "text",
37958
38375
  "value": [
37959
- "返回属于指定组的用户。它只能由管理员在控制节点上执行。",
38376
+ "返回属于指定组的用户。该函数只能由管理员在控制节点/数据节点上执行。",
37960
38377
  "",
37961
38378
  ""
37962
38379
  ]
@@ -38395,7 +38812,7 @@
38395
38812
  {
38396
38813
  "type": "text",
38397
38814
  "value": [
38398
- "grant(id, accessType, [objs])"
38815
+ "grant(userId|groupId, accessType, [objs])"
38399
38816
  ]
38400
38817
  }
38401
38818
  ]
@@ -38407,29 +38824,13 @@
38407
38824
  {
38408
38825
  "type": "text",
38409
38826
  "value": [
38410
- "`id` 是表示用户名或组名的字符串。",
38827
+ "`userId` | `groupId` 是表示用户名或组名的字符串。",
38411
38828
  "",
38412
- "`accessType` 是权限类型。包括以下9种权限：",
38829
+ "`accessType` 权限类型/内存限制。",
38413
38830
  "",
38414
- "1. TABLE_READ：读取指定数据表",
38831
+ "`objs` 标量或向量，表示权限类型的应用对象/约束规则。",
38415
38832
  "",
38416
- "2. TABLE_WRITE：写入指定数据表",
38417
- "",
38418
- "3. DBOBJ_CREATE：在某个数据库中创建数据表",
38419
- "",
38420
- "4. DBOBJ_DELETE：删除某个数据库中的数据表",
38421
- "",
38422
- "5. VIEW_EXEC：执行某个视图",
38423
- "",
38424
- "6. DB_MANAGE：创建以及删除数据库。可删除任何人所建数据库，包括具有DB_OWNER权限之用户所建数据库。",
38425
- "",
38426
- "7. DB_OWNER：创建数据库并管理其创建的数据库，包括删除数据库、创建或删除数据表、增加或删除分区、可赋予、禁止或取消其他用户对自己创建的数据库的以下权限：TABLE_READ, TABLE_WRITE, DBOBJ_CREATE, DBOBJ_DELETE。",
38427
- "",
38428
- "8. SCRIPT_EXEC：执行脚本",
38429
- "",
38430
- "9. TEST_EXEC：执行测试脚本",
38431
- "",
38432
- "`objs` 是表示权限类型的应用对象。若权限类型为TABLE_READ, TABLE_WRITE, DBOBJ_CREATE, DBOBJ_DELETE或VIEW_EXEC, 它是一个必需参数。若权限类型为DB_MANAGE, DB_OWNER, SCRIPT_EXEC和TEST_EXEC, 它可以省略。"
38833
+ "*accessType* 和 *objs* 的取值请参照 :doc:`/SystemManagement/UserAccessControl` 权限类型表。"
38433
38834
  ]
38434
38835
  }
38435
38836
  ]
@@ -38441,7 +38842,13 @@
38441
38842
  {
38442
38843
  "type": "text",
38443
38844
  "value": [
38444
- "授予某个用户或某个群权限。该命令只能是管理员在控制器节点上执行。"
38845
+ "grant 函数执行以下操作：",
38846
+ "",
38847
+ "（1）授予某个用户或某个用户组权限。当 *accessType* = DB_OWNER 时，还支持约束某个用户只能创建指定前缀的数据库。",
38848
+ "",
38849
+ "（2）约束某个用户查询返回结果的内存上限（指定 *accessType* = QUERY_RESULT_MEM_LIMIT）和发送的批量子查询占用的内存上限（指定 *accessType* = TASK_GROUP_MEM_LIMIT）。其功能等效于 :doc:`/FunctionsandCommands/CommandsReferences/s/setMemLimitOfQueryResult` 函数和 :doc:`/FunctionsandCommands/CommandsReferences/s/setMemLimitOfTaskGroupResult` 函数，区别在于 grant 只对指定用户生效（暂不支持用户组），setMemLimitOfQueryResult 函数和 setMemLimitOfTaskGroupResult 函数对所有用户生效。",
38850
+ "",
38851
+ "该命令只能由管理员在控制节点/数据节点上执行。"
38445
38852
  ]
38446
38853
  }
38447
38854
  ]
@@ -38542,7 +38949,53 @@
38542
38949
  "language": "console",
38543
38950
  "value": [
38544
38951
  "",
38545
- " $ grant(\"AlexSmith\", TEST_EXEC)"
38952
+ " $ grant(\"AlexSmith\", TEST_EXEC)",
38953
+ ""
38954
+ ]
38955
+ },
38956
+ {
38957
+ "type": "text",
38958
+ "value": [
38959
+ "约束用户查询所占用的内存：",
38960
+ "",
38961
+ "指定 accessType 为 QUERY_RESULT_MEM_LIMIT，此时 objs 表示限制的内存大小，单位为 GB。下述脚本限制用户 \"AlexSmith\" 查询时，查询结果所占用的内存大小不能超过 4 GB。 ",
38962
+ ""
38963
+ ]
38964
+ },
38965
+ {
38966
+ "type": "code",
38967
+ "language": "console",
38968
+ "value": [
38969
+ " ",
38970
+ " $ grant(\"AlexSmith\", QUERY_RESULT_MEM_LIMIT, 4)",
38971
+ " ",
38972
+ ""
38973
+ ]
38974
+ },
38975
+ {
38976
+ "type": "text",
38977
+ "value": [
38978
+ "约束用户只能创建指定前缀的数据库：",
38979
+ "",
38980
+ "假设需要创建名为 \"dbxxx\" 的 1000 个数据库，其中 \"xxx\" 为 000 到 999。管理员要求限制用户 \"AlexSmith\" 只能创建并管理 000~099 这 100 个数据库，可以通过以下脚本实现：",
38981
+ ""
38982
+ ]
38983
+ },
38984
+ {
38985
+ "type": "code",
38986
+ "language": "console",
38987
+ "value": [
38988
+ " ",
38989
+ " $ grant(\"AlexSmith\", DB_OWNER, \"dfs://db0*\")",
38990
+ ""
38991
+ ]
38992
+ },
38993
+ {
38994
+ "type": "text",
38995
+ "value": [
38996
+ "当指定 grant 函数的 accessType 为 DB_OWNER 时，可以指定 objs 为一个规则，目前仅支持约束用户可以创建的库名前缀，便于不同用户管理不同范围的数据库。",
38997
+ "",
38998
+ "注意：特定的约束规则，只能通过 grant 指定，且不能通过 deny/revoke 移除。当 accessType 为 DB_OWNER 时，deny/revoke 只能对全局生效。"
38546
38999
  ]
38547
39000
  }
38548
39001
  ]
@@ -38578,7 +39031,19 @@
38578
39031
  ".. versionadded:: 2.00.3",
38579
39032
  " 参数 *mode*",
38580
39033
  "",
38581
- "`mode` 是一个可选参数，默认为\"dict\"。可选参数为\"dict\"和\"table\"。指定为\"table\"时，返回一个两列的表，分别表示key和index。此时index为数组向量类型。"
39034
+ ".. versionadded:: 2.00.9",
39035
+ " 参数 *mode* 支持 \"vector\", \"tuple\"",
39036
+ "",
39037
+ "`mode` 可选参数，用于指定 groups 返回值的数据形式，默认为\"dict\"。可指定为以下值：",
39038
+ "",
39039
+ "- \"dict\"：返回一个字典。字典的 key 存储 *X* 中的独特值（unique value）；字典的 value 为一个向量，存储该值在 *X* 中对应的下标。",
39040
+ "",
39041
+ "- \"table\"：返回一个包含两列的表。字段为 \"key\" 和 \"index\"，分别存储 *X* 中的独特值和其在 *X* 中对应的下标。",
39042
+ "",
39043
+ "- \"vector\"：返回一个 array vector，按照 *X* 中独特值升序排列，存储每个独特值在 *X* 中对应的下标。",
39044
+ "",
39045
+ "- \"tuple\"：返回一个 tuple，其存储方式同 mode=\"vector\"。",
39046
+ ""
38582
39047
  ]
38583
39048
  }
38584
39049
  ]
@@ -38615,6 +39080,12 @@
38615
39080
  " 14->[7]",
38616
39081
  " 15->[3,6]",
38617
39082
  "",
39083
+ " $ groups(x, \"vector\")",
39084
+ " [[0,1,8,9],[2,4],[7],[3,6],[5]]",
39085
+ "",
39086
+ " $ groups(x, \"tuple\")",
39087
+ " ([0,1,8,9],[2,4],[7],[3,6],[5])",
39088
+ "",
38618
39089
  " $ groups(x, \"table\")",
38619
39090
  ""
38620
39091
  ]
@@ -47942,7 +48413,37 @@
47942
48413
  {
47943
48414
  "type": "text",
47944
48415
  "value": [
47945
- "显示DolphinDB的许可证信息。"
48416
+ "显示 DolphinDB 的许可证信息。",
48417
+ "",
48418
+ "返回值说明：",
48419
+ "",
48420
+ "+------------------+---------------------------------------------------------------------------------------+",
48421
+ "| 参数 | 含义 |",
48422
+ "+==================+=======================================================================================+",
48423
+ "| authorization | 授权的类型：trial（试用版）/test（测试版）/commercial（商业版）。 |",
48424
+ "+------------------+---------------------------------------------------------------------------------------+",
48425
+ "| licenseType | 许可证验证类型，有以下可选值：1：机器指纹绑定 2：在线验证 0：其他方式 |",
48426
+ "+------------------+---------------------------------------------------------------------------------------+",
48427
+ "| maxMemoryPerNode | 每个节点的内存上限，单位为 GB。 |",
48428
+ "+------------------+---------------------------------------------------------------------------------------+",
48429
+ "| bindCores | 进程绑定的 CPU 内核的编号（从0开始）。注意，仅当 bindCPU 为 true 时有效。 |",
48430
+ "+------------------+---------------------------------------------------------------------------------------+",
48431
+ "| maxCoresPerNode | 每个节点允许最大 CPU 核数。 |",
48432
+ "+------------------+---------------------------------------------------------------------------------------+",
48433
+ "| clientName | 客户名称。 |",
48434
+ "+------------------+---------------------------------------------------------------------------------------+",
48435
+ "| port | 为节点绑定的端口号。仅 License Server 和连接它的节点会返回此字段。 |",
48436
+ "+------------------+---------------------------------------------------------------------------------------+",
48437
+ "| bindCPU | 进程是否绑定 CPU。 |",
48438
+ "+------------------+---------------------------------------------------------------------------------------+",
48439
+ "| expiration | 许可证到期时间。 |",
48440
+ "+------------------+---------------------------------------------------------------------------------------+",
48441
+ "| maxNodes | 集群允许的最大节点数。 |",
48442
+ "+------------------+---------------------------------------------------------------------------------------+",
48443
+ "| version | server 的版本号。用户只能使用不高于 version 版本的 server。若为空，则对版本没有限制。 |",
48444
+ "+------------------+---------------------------------------------------------------------------------------+",
48445
+ "| modules | 模块名。用户只能使用 modules 指定的模块。若为 -1 表示对使用的模块没有限制。 |",
48446
+ "+------------------+---------------------------------------------------------------------------------------+"
47946
48447
  ]
47947
48448
  }
47948
48449
  ]
@@ -47957,15 +48458,17 @@
47957
48458
  "value": [
47958
48459
  "",
47959
48460
  " $ license();",
47960
- " authorization->free",
48461
+ " authorization->trial",
48462
+ " maxMemoryPerNode->128",
47961
48463
  " licenseType->0",
47962
- " maxMemoryPerNode->4",
47963
- " maxCoresPerNode->2",
47964
- " clientName->Trial Users",
48464
+ " bindCores->0 1 3 5",
48465
+ " maxCoresPerNode->8",
48466
+ " clientName->test1",
48467
+ " port->",
47965
48468
  " bindCPU->true",
47966
- " expiration->2021.09.30",
47967
- " maxNodes->3",
47968
- " version->",
48469
+ " expiration->2023.02.12",
48470
+ " maxNodes->6",
48471
+ " version->2.00",
47969
48472
  " modules->-1"
47970
48473
  ]
47971
48474
  }
@@ -51241,7 +51744,7 @@
51241
51744
  {
51242
51745
  "type": "text",
51243
51746
  "value": [
51244
- "用户可在控制器节点或数据节点/计算节点上登录。"
51747
+ "用户可在控制节点或数据节点/计算节点上登录。"
51245
51748
  ]
51246
51749
  }
51247
51750
  ]
@@ -51456,6 +51959,8 @@
51456
51959
  {
51457
51960
  "type": "text",
51458
51961
  "value": [
51962
+ "该函数可以在控制节点/数据节点/计算节点上执行。",
51963
+ "",
51459
51964
  "如果没有指定 *userId*，用户自己退出登录。",
51460
51965
  "",
51461
51966
  "如果 *sessionOnly* 为true，用户只退出登录当前会话。",
@@ -52732,15 +53237,15 @@
52732
53237
  {
52733
53238
  "type": "text",
52734
53239
  "value": [
52735
- "相关函数：:doc:`makeOrderedKey`"
53240
+ "相关函数：:doc:`makeSortedKey`"
52736
53241
  ]
52737
53242
  }
52738
53243
  ]
52739
53244
  }
52740
53245
  ]
52741
53246
  },
52742
- "makeOrderedKey": {
52743
- "title": "makeOrderedKey",
53247
+ "makeSortedKey": {
53248
+ "title": "makeSortedKey",
52744
53249
  "type": "function",
52745
53250
  "children": [
52746
53251
  {
@@ -52750,7 +53255,7 @@
52750
53255
  {
52751
53256
  "type": "text",
52752
53257
  "value": [
52753
- "makeOrderedKey(args...)"
53258
+ "makeSortedKey(args...)"
52754
53259
  ]
52755
53260
  }
52756
53261
  ]
@@ -52774,7 +53279,7 @@
52774
53279
  {
52775
53280
  "type": "text",
52776
53281
  "value": [
52777
- "对于输入的多个 *args*，将它们的值组合为一个 BLOB 标量或向量。返回的结果保留了多个字段的排序顺序。"
53282
+ "对于输入的多个 *args*，将它们的值组合为一个 BLOB 标量或向量。相较于 makeKey，makeSortedKey 内部会保存组合值的排序结果，但输出结果与 makeKey 相同。"
52778
53283
  ]
52779
53284
  }
52780
53285
  ]
@@ -52788,19 +53293,10 @@
52788
53293
  "language": "console",
52789
53294
  "value": [
52790
53295
  "",
52791
- " $ makeOrderedKey(`a1,`b1,`c1) ",
52792
- " a1b1c1",
52793
- "",
52794
- " $ set(makeOrderedKey(1 2, 4 5))",
53296
+ " $ makeSortedKey([`b,`a,`c], [`4,`2,`1]) ",
53297
+ " [\"b4\",\"a2\",\"c1\"]",
52795
53298
  "",
52796
- " $ makeOrderedKey(`a1`a2, 10.5 11.8) ",
52797
- ""
52798
- ]
52799
- },
52800
- {
52801
- "type": "text",
52802
- "value": [
52803
- "相关函数：:doc:`makeKey`"
53299
+ " $ set(makeSortedKey(1 2, 4 5))"
52804
53300
  ]
52805
53301
  }
52806
53302
  ]
@@ -72768,348 +73264,6 @@
72768
73264
  }
72769
73265
  ]
72770
73266
  },
72771
- "replay": {
72772
- "title": "replay",
72773
- "type": "function",
72774
- "children": [
72775
- {
72776
- "title": "语法",
72777
- "type": "grammer",
72778
- "children": [
72779
- {
72780
- "type": "text",
72781
- "value": [
72782
- "replay(inputTables, outputTables, [dateColumn], [timeColumn], [replayRate], [absoluteRate=true], [parallelLevel=1])"
72783
- ]
72784
- }
72785
- ]
72786
- },
72787
- {
72788
- "title": "详情",
72789
- "type": "detail",
72790
- "children": [
72791
- {
72792
- "type": "text",
72793
- "value": [
72794
- "按时间顺序将一个或多个数据表或数据源回放到数据表，以模拟流数据实时注入。如需回放历史数据， 可通过 :doc:`replayDS` 函数生成数据源来输入 replay 。",
72795
- "",
72796
- "根据输入表和输出表的映射关系（map），``replay`` 支持一对一，N 对一，N 对 N 三种回放形式。注意 N 对 N 回放时，若多表时间段存在重合，不能保证该段时间完全按时间序回放。",
72797
- "",
72798
- ".. versionadded:: 2.00.5",
72799
- " 异构回放",
72800
- "",
72801
- "对于 N 对一回放，2.00.5 版本前，输入表结构必须相同，称为同构回放。该版本后，replay 支持以字典的形式输入结构不同的表，称为异构回放。异构回放时，replay 的输出结果可以通过 :doc:`../s/streamFilter` 进行反序列化，并进行数据过滤和分离，详情请参考 :doc:`../s/streamFilter`。 ",
72802
- "",
72803
- "注意：进行多对一回放时，若 *inputTables* 为数据源，各数据源 size 以及其 *dateColumn* 列对应的时间范围必须保持一致。",
72804
- "",
72805
- "如需终止回放，使用 :doc:`../../CommandsReferences/c/cancelJob` 和 :doc:`../../CommandsReferences/c/cancelConsoleJob` 命令可以终止回放。",
72806
- ""
72807
- ]
72808
- }
72809
- ]
72810
- },
72811
- {
72812
- "title": "参数",
72813
- "type": "parameters",
72814
- "children": [
72815
- {
72816
- "type": "text",
72817
- "value": [
72818
- "`inputTables` 是未分区的内存表或 :doc:`replayDS` 函数生成的数据源。",
72819
- "",
72820
- "* 如果 *inputTables* 是单个或多个结构相同的表对象或数据源， 用标量或元组表示。",
72821
- "* 如果 *inputTables* 是多个结构不同的表对象或数据源，用字典表示。字典的 key 是用户自定义的字符串，表示输入表或数据源的唯一标识，value 是表对象或数据源。",
72822
- "",
72823
- "`outputTables` 是内存表或流数据表对象。若输出表是共享表，可以指定为共享表的表名。根据回放形式的不同，*outputTables* 的取值有所区别：",
72824
- "",
72825
- "\\（1）一对一回放或 N 对一同构回放时，*outputTables* 是一个表对象或字符串标量，必须与输入表的 schema 相同。",
72826
- "",
72827
- "\\（2）N 对 N 回放，outputTables 是字符串向量或表单对象组成的元组，且它的长度必须与 inputTables 相同。输出表和输入表一一对应，且表的 schema 必须相同。",
72828
- "",
72829
- "\\（3）N 对一异构回放时 outputTables 是一个标量，至少包含三列：",
72830
- "",
72831
- " * 第一列为 *dateColumn* 和 *timeColumn* 指定的回放时间的时间戳；",
72832
- " * 第二列为 SYMBOL 或 STRING 类型，对应 *inputTables* 字典的 key；",
72833
- " * 第三列为 BLOB 类型，用于存储被回放的每条记录序列化后的结果。",
72834
- "",
72835
- "此外，可输出各输入表的公共列（列名和类型一致的列）。",
72836
- "",
72837
- "`dateColumn` 和 `timeColumn` 为时间列的列名，至少指定其中一个参数。根据回放形式的不同，*dateColumn* 和 *timeColumn* 的取值有所区别：",
72838
- "",
72839
- "* 一对一回放或 N 对一同构回放: 输入表与输出表的时间列列名必须相同，指定为字符串标量；",
72840
- "* N 对 N 回放：输入表时间列的列名不同，指定为字符串向量；",
72841
- "* N 对一异构回放：输入表时间列的列名不同，指定为字典，其中 key 为输入表的唯一标识符，value 是对应表时间列的列名。",
72842
- "",
72843
- "只指定 *dateColumn* 或 *timeColumn* 中的一个参数，或者 *dateColumn* 和 *timeColumn* 指定为同一列时，对指定的时间列的类型没有限制。",
72844
- "",
72845
- "若指定 *dateColumn* 和 *timeColumn* 为不同列，*dateColumn* 必须是 DATE 类型，*timeColumn* 只能是 SECOND, TIME 或 NANOTIME 类型。",
72846
- "",
72847
- "`replayRate` 整数，和参数 *absoluteRate* 共同决定了回放的速率。 ",
72848
- "",
72849
- "`absoluteRate` 布尔值。默认值为 true，表示每秒按 *replayRate* 指定的记录数回放。若为 false，表示依照数据中的时间戳加速 *replayRate* 倍回放。",
72850
- "",
72851
- "根据不同的场景需求，replay 提供以下三种回放模式：",
72852
- "",
72853
- "- 匀速回放：如果 *replayRate* 为正整数，且 *absoluteRate* 为 true，则回放的速率基于记录数计算，按照每秒 *replayRate* 条记录进行回放。假设输入表的总记录条数为 total（多表回放时为所有表的总记录数），那么回放该表所需的时间大致为 total/replayRate 秒。",
72854
- "",
72855
- "- 倍速回放：如果 *replayRate* 为正整数，并且 *absoluteRate* 为 false，则将输入表中的数据按照时间加速 *replayRate* 倍回放。假设输入表中 *dateColumn* 或 *timeColumn* 的最大时间戳和最小时间戳相差 n 秒，数据总数为 s，则系统每秒回放 replayRate*s/n 条记录（每秒至少回放 1 条），即回放时间大致为 n/replayRate 秒。",
72856
- "",
72857
- "- 极速回放：如果 *replayRate* 未指定或者为负，无论 *absoluteRate* 为 false 还是 true，系统都将以最快的速率进行回放。回放所需的时间与 DolphinDB 所在的服务器性能有关。",
72858
- "",
72859
- "上述回放耗时主要基于同构回放估算，异构回放的耗时开销会略高于上述估算的回放耗时。",
72860
- "",
72861
- "`parallelLevel` 正整数，表示从数据源加载数据到内存的工作线程数量，默认值为 1。如果 *inputTables* 不是数据源，无需指定该参数。",
72862
- ""
72863
- ]
72864
- }
72865
- ]
72866
- },
72867
- {
72868
- "title": "例子",
72869
- "type": "example",
72870
- "children": [
72871
- {
72872
- "type": "text",
72873
- "value": [
72874
- "例1. 回放一张表",
72875
- ""
72876
- ]
72877
- },
72878
- {
72879
- "type": "code",
72880
- "language": "console",
72881
- "value": [
72882
- ""
72883
- ]
72884
- },
72885
- {
72886
- "type": "text",
72887
- "value": [
72888
- " $ n=1000",
72889
- " $ sym = take(`IBM,n)",
72890
- " $ timestamp= take(temporalAdd(2012.12.06T09:30:12.000,1..500,'s'),n)",
72891
- " $ volume = rand(100,n)",
72892
- " $ trades=table(sym,timestamp,volume)",
72893
- " $ trades.sortBy!(`timestamp)",
72894
- " $ share streamTable(100:0,`sym`timestamp`volume,[SYMBOL,TIMESTAMP,INT]) as st",
72895
- "",
72896
- "* 每秒回放100条数据：",
72897
- ""
72898
- ]
72899
- },
72900
- {
72901
- "type": "code",
72902
- "language": "console",
72903
- "value": [
72904
- ""
72905
- ]
72906
- },
72907
- {
72908
- "type": "text",
72909
- "value": [
72910
- " $ timer replay(inputTables=trades, outputTables=st, dateColumn=`timestamp, timeColumn=`timestamp,replayRate=100, absoluteRate=true);",
72911
- " Time elapsed: 10001.195 ms",
72912
- "",
72913
- "表 trades 中一共有1000条数据，每秒回放100条耗时大约10秒。",
72914
- "",
72915
- "* 加速100倍时间回放：",
72916
- ""
72917
- ]
72918
- },
72919
- {
72920
- "type": "code",
72921
- "language": "console",
72922
- "value": [
72923
- ""
72924
- ]
72925
- },
72926
- {
72927
- "type": "text",
72928
- "value": [
72929
- " $ timer replay(inputTables=trades,outputTables=st,dateColumn=`timestamp,timeColumn=`timestamp,replayRate=100,absoluteRate=false);",
72930
- " Time elapsed: 5001.909 ms",
72931
- "",
72932
- "表 trades 中的最大时间与最小时间相差500秒，加速 100 倍时间回放耗时大约5秒。",
72933
- "",
72934
- "* 以最快的速率回放：",
72935
- ""
72936
- ]
72937
- },
72938
- {
72939
- "type": "code",
72940
- "language": "console",
72941
- "value": [
72942
- ""
72943
- ]
72944
- },
72945
- {
72946
- "type": "text",
72947
- "value": [
72948
- " $ timer replay(inputTables=trades,outputTables=st,dateColumn=`timestamp,timeColumn=`timestamp);",
72949
- " Time elapsed: 2.026 ms",
72950
- "",
72951
- "例2. 可以将多个数据源回放到一个或多个输出表中。",
72952
- ""
72953
- ]
72954
- },
72955
- {
72956
- "type": "code",
72957
- "language": "console",
72958
- "value": [
72959
- ""
72960
- ]
72961
- },
72962
- {
72963
- "type": "text",
72964
- "value": [
72965
- " $ n=5000000",
72966
- " $ sym = rand(symbol(`IBM`APPL`MSFT`GOOG`GS),n)",
72967
- " $ date=take(2012.06.12..2012.06.16,n)",
72968
- " $ time=rand(13:30:11.008..13:30:11.012,n)",
72969
- " $ volume = rand(100,n)",
72970
- " $ t=table(sym,date,time,volume)",
72971
- " $ if(existsDatabase(\"dfs://test_stock\")){",
72972
- " $ dropDatabase(\"dfs://test_stock\")",
72973
- " $ }",
72974
- " $ db=database(\"dfs://test_stock\",VALUE,2012.06.12..2012.06.16)",
72975
- " $ trades=db.createPartitionedTable(t,`trades,`date)",
72976
- " $ trades.append!(t)",
72977
- "",
72978
- " $ share streamTable(100:0,`sym`date`time`volume,[SYMBOL,DATE,TIME,INT]) as st1",
72979
- " $ share streamTable(100:0,`sym`date`time`volume,[SYMBOL,DATE,TIME,INT]) as st2",
72980
- "",
72981
- " $ ds1=replayDS(sqlObj=<select * from trades where date=2012.06.12>,dateColumn=`date,timeColumn=`time,timeRepartitionSchema=[13:30:11.008,13:30:11.010,13:30:11.013])",
72982
- " $ ds2=replayDS(sqlObj=<select * from trades where date=2012.06.16>,dateColumn=`date,timeColumn=`time,timeRepartitionSchema=[13:30:11.008,13:30:11.010,13:30:11.013])",
72983
- "",
72984
- " $ replay(inputTables=[ds1,ds2],outputTables=[st1,st2],dateColumn=`date,timeColumn=`time); //将ds1和ds2分别回放到st1和st2中",
72985
- " $ select * from st1;",
72986
- "",
72987
- "===== ========== ============ =========",
72988
- "sym date time price ",
72989
- "===== ========== ============ =========",
72990
- "GOOG 2012.06.12 13:30:11.008 80.257105",
72991
- "MSFT 2012.06.12 13:30:11.008 19.509125",
72992
- "MSFT 2012.06.12 13:30:11.008 16.856134",
72993
- "GS 2012.06.12 13:30:11.008 77.784879",
72994
- "MSFT 2012.06.12 13:30:11.008 33.182977",
72995
- "GOOG 2012.06.12 13:30:11.008 0.411022",
72996
- "IBM 2012.06.12 13:30:11.008 64.201467",
72997
- "GS 2012.06.12 13:30:11.008 2.961122",
72998
- "GOOG 2012.06.12 13:30:11.008 19.06283",
72999
- "IBM 2012.06.12 13:30:11.008 9.793819",
73000
- "...",
73001
- "===== ========== ============ =========",
73002
- ""
73003
- ]
73004
- },
73005
- {
73006
- "type": "code",
73007
- "language": "console",
73008
- "value": [
73009
- ""
73010
- ]
73011
- },
73012
- {
73013
- "type": "text",
73014
- "value": [
73015
- " $ select * from st2;",
73016
- "",
73017
- "===== ========== ============ =========",
73018
- "sym date time price ",
73019
- "===== ========== ============ =========",
73020
- "GS 2012.06.16 13:30:11.008 65.34449",
73021
- "GS 2012.06.16 13:30:11.008 69.313035",
73022
- "GOOG 2012.06.16 13:30:11.008 83.343602",
73023
- "IBM 2012.06.16 13:30:11.008 1.09428 ",
73024
- "APPL 2012.06.16 13:30:11.008 37.420217",
73025
- "APPL 2012.06.16 13:30:11.008 29.142734",
73026
- "IBM 2012.06.16 13:30:11.008 81.364092",
73027
- "GS 2012.06.16 13:30:11.008 94.248142",
73028
- "GS 2012.06.16 13:30:11.008 35.037498",
73029
- "GS 2012.06.16 13:30:11.008 19.514272",
73030
- "...",
73031
- "===== ========== ============ =========",
73032
- ""
73033
- ]
73034
- },
73035
- {
73036
- "type": "code",
73037
- "language": "console",
73038
- "value": [
73039
- ""
73040
- ]
73041
- },
73042
- {
73043
- "type": "text",
73044
- "value": [
73045
- " $ share streamTable(200:0,`sym`date`time`volume,[SYMBOL,DATE,TIME,INT]) as st3",
73046
- " $ replay(inputTables=[ds1,ds2],outputTables=st3,dateColumn=`date,timeColumn=`time); //将 ds1 和 ds2 都回放到 st3 中",
73047
- " $ select count(*) from st3",
73048
- " 2000000",
73049
- "",
73050
- "",
73051
- "例3. 异构回放",
73052
- ""
73053
- ]
73054
- },
73055
- {
73056
- "type": "code",
73057
- "language": "console",
73058
- "value": [
73059
- ""
73060
- ]
73061
- },
73062
- {
73063
- "type": "text",
73064
- "value": [
73065
- " $ n=1000",
73066
- " $ sym = take(take(`IBM,n).join(take(`GS,n)), n)",
73067
- " $ myDate=take(2021.01.02..2021.01.06, n).sort!()",
73068
- " $ myTime=take(09:30:00..15:59:59,n)",
73069
- " $ vol = array(INT[], 0, 10)",
73070
- " $ for(i in 0:n){vol.append!([rand(100,3)])}",
73071
- " $ t=table(sym,myDate,myTime,vol)",
73072
- "",
73073
- "",
73074
- " $ n=1000",
73075
- " $ sym = take(take(`IBM,n).join(take(`GS,n)), n)",
73076
- " $ date=take(2021.01.02..2021.01.06, n).sort!()",
73077
- " $ time=take(09:30:00..15:59:59,n)",
73078
- " $ vol = array(INT[], 0, 10)",
73079
- " $ for(i in 0:n){vol.append!([rand(100,3)])}",
73080
- " $ t1=table(sym, date,time,vol)",
73081
- "",
73082
- " $ if(existsDatabase(\"dfs://test_stock\")){",
73083
- " $ dropDatabase(\"dfs://test_stock\")",
73084
- " $}",
73085
- " $ db1=database(\"\",RANGE, 2021.01.01..2021.01.12)",
73086
- " $ db2=database(\"\",VALUE,`IBM`GS)",
73087
- " $ db=database(\"dfs://test_stock\",COMPO,[db1, db2], engine=\"TSDB\")",
73088
- " $ trades=db.createPartitionedTable(t,`trades,`myDate`sym, sortColumns=`sym`myDate`myTime)",
73089
- " $ trades.append!(t);",
73090
- " $ trades1=db.createPartitionedTable(t1,`trades1,`date`sym, sortColumns=`sym`date`time)",
73091
- " $ trades1.append!(t1);",
73092
- "",
73093
- " //获取数据源",
73094
- "",
73095
- " $ ds = replayDS(sqlObj=<select * from loadTable(db, `trades)>, dateColumn=`myDate, timeColumn=`myTime)",
73096
- " $ ds.size();",
73097
- "",
73098
- " $ ds1 = replayDS(sqlObj=<select * from loadTable(db, `trades1)>, dateColumn=`date, timeColumn=`time)",
73099
- " $ ds1.size();",
73100
- "",
73101
- " $ input_dict = dict([\"msg1\", \"msg2\"], [ds, ds1])",
73102
- " $ date_dict = dict([\"msg1\", \"msg2\"], [`myDate, `date])",
73103
- " $ time_dict = dict([\"msg1\", \"msg2\"], [`myTime, `time])",
73104
- " $ opt = streamTable(100:0,`timestamp`sym`blob`vol, [DATETIME,SYMBOL, BLOB, INT[]])",
73105
- " $ replay(inputTables=input_dict, outputTables=opt, dateColumn = date_dict, timeColumn=time_dict, replayRate=1000, absoluteRate=false);",
73106
- " $ select top 10 * from opt;"
73107
- ]
73108
- }
73109
- ]
73110
- }
73111
- ]
73112
- },
73113
73267
  "replayDS": {
73114
73268
  "title": "replayDS",
73115
73269
  "type": "function",
@@ -73133,11 +73287,18 @@
73133
73287
  {
73134
73288
  "type": "text",
73135
73289
  "value": [
73136
- "`sqlObj` 表示 SQL 查询的元代码。SQL 查询的表对象是 DFS 表，且至少有一个分区列为 DATE 类型。",
73290
+ "`sqlObj` 表示 SQL 查询的元代码。SQL 查询的表对象是 DFS 表，且至少有一个分区列为时间类型。",
73137
73291
  "",
73138
- "`dateColumn` 和 `timeColumn` 是一个字符串，表示 SQL 查询的表对象的日期列和时间列。dateColumn 的每一天会产生一个数据源。dateColumn 必须是 SQL 查询的表对象的分区列之一。如果没有指定 dateColumn 与 timeColumn，原数据表的第一列将会作为 dateColumn。",
73292
+ "`dateColumn` 列必须为 SQL 查询的表对象的时间类型列，一般为 DATE 类型，亦可为 MONTH 类型或其它时间类型。作为数据的排序依据。dateColumn 列必须为表的分区列之一，系统将根据 dateColumn 列的分区粒度划分数据源，如 dateColumn 列按天进行分区，则数据源也按天进行划分。",
73139
73293
  "",
73140
- "`timeRepartitionSchema` 时间类型的向量。如果指定了 *timeColumn*，*timeRepartitionSchema* 可用于划分更小粒度的数据源。如果为 [t1, t2, t3]，那么将每天的数据进一步划分为 4 个数据源：[00:00:00.000,t1), [t1,t2), [t2,t3) 和 [t3,23:59:59.999)。"
73294
+ "`timeColumn` 列必须为 SQL 查询的表对象的时间列，作为数据的排序依据。若 dateColumn 为 DATE 类型时，可以指定 timeColumn 为 SECOND, TIME 或 NANOTIME 类型的列作为第二排序列。此外，配合 timeRepartitionSchema 参数，timeColumn 列也可以作为数据源划分依据。",
73295
+ "",
73296
+ "注意：",
73297
+ "",
73298
+ "* dateColumn 和 timeColumn 暂不支持 DATEHOUR 类型的时间列。",
73299
+ "* 如果没有指定 dateColumn，原数据表的第一列将会作为 dateColumn。",
73300
+ "",
73301
+ "`timeRepartitionSchema` 时间类型的向量。如果指定了 timeColumn，timeRepartitionSchema 可用于划分更小粒度的数据源。如果 timeRepartitionSchema 为 [t1, t2, t3]，均为 TIME 类型，那么将每天的数据进一步划分为 4 个数据源：[00:00:00.000,t1), [t1,t2), [t2,t3) 和 [t3,23:59:59.999)。"
73141
73302
  ]
73142
73303
  }
73143
73304
  ]
@@ -73149,7 +73310,9 @@
73149
73310
  {
73150
73311
  "type": "text",
73151
73312
  "value": [
73152
- "用于 DFS 表，生成一组数据源，作为 :doc:`replay` 函数的输入。"
73313
+ "将一个SQL表达式，根据时间维度划分为多个数据源，作为 replay 函数的输入，逐一进行回放。时间维度既可以为 DFS 表的时间列的分区粒度，也可以是基于该分区粒度的进一步的划分（由参数 timeColumn 与 timeRepartitionSchema 决定）。返回一个由数据源列表（类型为 ANY VECTOR）。",
73314
+ "",
73315
+ "若要回放 DFS 表中的数据，只能使用 ReplayDS 函数配合 replay 函数进行。"
73153
73316
  ]
73154
73317
  }
73155
73318
  ]
@@ -73362,7 +73525,10 @@
73362
73525
  "\"S\" secondOfMinute",
73363
73526
  "============= ===================",
73364
73527
  "",
73365
- "`rule` 字符串亦可配合使用数字，例如 \"2M\" 表示频率为每两个月月末。",
73528
+ ".. versionadded:: 2.00.9 ",
73529
+ " 用户自定义交易日历",
73530
+ "",
73531
+ "`rule` 上述字符串亦可配合使用数字，例如 \"2M\" 表示频率为每两个月月末。此外，*rule* 也可指定为用户自定义交易日历的标识（配置参数 *marketHolidayDir* 指定目录下的文件名，系统将根据该交易日历进行计算）。",
73366
73532
  "",
73367
73533
  "`func` 一个聚合函数。",
73368
73534
  "",
@@ -73399,7 +73565,7 @@
73399
73565
  {
73400
73566
  "type": "text",
73401
73567
  "value": [
73402
- "依照指定时间频率，对给定数据使用给定函数。"
73568
+ "依照指定时间频率（或用户自定义的交易日历），对给定数据使用给定函数。注意，*rule* 指定为交易日历标识时，对于非交易日的数据，将并入上一个交易日计算。"
73403
73569
  ]
73404
73570
  }
73405
73571
  ]
@@ -73523,7 +73689,7 @@
73523
73689
  "language": "console",
73524
73690
  "value": [
73525
73691
  "",
73526
- " $ s.resample(rule=`3min, func=sum, closed=`right,origin=`end);",
73692
+ " $ s.resample(rule=`3min, func=sum, closed=`left,origin=`end);",
73527
73693
  ""
73528
73694
  ]
73529
73695
  },
@@ -73674,7 +73840,7 @@
73674
73840
  {
73675
73841
  "type": "text",
73676
73842
  "value": [
73677
- "重置用户的密码。该命令只能由管理员在控制器节点上执行。"
73843
+ "重置用户的密码。该命令只能由管理员在控制节点/数据节点上执行。"
73678
73844
  ]
73679
73845
  }
73680
73846
  ]
@@ -74332,6 +74498,8 @@
74332
74498
  "destNode 目标节点的别名",
74333
74499
  "================== =================================================",
74334
74500
  "",
74501
+ "注意：该函数必须在控制节点下运行。",
74502
+ "",
74335
74503
  "调用该函数后，可以在进行数据平衡的数据节点上执行 :doc:`/FunctionsandCommands/FunctionReferences/g/getRecoveryTaskStatus` 查看任务执行的状态。"
74336
74504
  ]
74337
74505
  }
@@ -74634,29 +74802,13 @@
74634
74802
  {
74635
74803
  "type": "text",
74636
74804
  "value": [
74637
- "`id` 是表示用户名或组名的字符串。",
74638
- "",
74639
- "`accessType` 是权限类型。主要有以下8种权限：",
74640
- "",
74641
- "1. TABLE_READ：读取指定数据表",
74642
- "",
74643
- "2. TABLE_WRITE：写入指定数据表",
74644
- "",
74645
- "3. DBOBJ_CREATE：在某个数据库中创建数据表",
74646
- "",
74647
- "4. DBOBJ_DELETE：删除某个数据库中的数据表",
74805
+ "`userId` | `groupId` 是表示用户名或组名的字符串。",
74648
74806
  "",
74649
- "5. VIEW_EXEC：执行某个视图",
74807
+ "`accessType` 是权限类型。",
74650
74808
  "",
74651
- "6. DB_MANAGE：创建以及删除数据库。可删除任何人所建数据库，包括具有DB_OWNER权限之用户所建数据库。",
74809
+ "`objs` 标量或向量，表示权限类型的应用对象。",
74652
74810
  "",
74653
- "7. DB_OWNER：创建数据库并管理其创建的数据库，包括删除数据库、创建或删除数据表、增加或删除分区、可赋予、禁止或取消其他用户对自己创建的数据库的以下权限：TABLE_READ, TABLE_WRITE, DBOBJ_CREATE, DBOBJ_DELETE。",
74654
- "",
74655
- "8. SCRIPT_EXEC：执行脚本",
74656
- "",
74657
- "9. TEST_EXEC：执行测试脚本",
74658
- "",
74659
- "`objs` 是表示权限类型的应用对象。若权限类型为TABLE_READ, TABLE_WRITE, DBOBJ_CREATE, DBOBJ_DELETE或VIEW_EXEC, 它是一个必需参数。若权限类型为DB_MANAGE, DB_OWNER, SCRIPT_EXEC和TEST_EXEC, 它可以省略。"
74811
+ "*accessType* 和 *objs* 的取值请参照 :doc:`/SystemManagement/UserAccessControl` 权限类型表。"
74660
74812
  ]
74661
74813
  }
74662
74814
  ]
@@ -74668,7 +74820,13 @@
74668
74820
  {
74669
74821
  "type": "text",
74670
74822
  "value": [
74671
- "撤销某个用户或某个组的之前被赋予或禁止的权限。该命令只能由管理员在控制器节点上执行。"
74823
+ "revoke 函数执行以下操作：",
74824
+ "",
74825
+ "（1）撤销某个用户或某个组的之前被赋予或禁止的权限。",
74826
+ "",
74827
+ "（2）撤销 grant 给某个用户的内存约束，包含：查询返回结果的内存上限（指定 accessType = QUERY_RESULT_MEM_LIMIT）和发送的批量子查询占用的内存上限（指定 accessType = TASK_GROUP_MEM_LIMIT）。撤销后，将恢复为系统的默认值。",
74828
+ "",
74829
+ "该命令只能由管理员在控制节点/数据节点上执行。"
74672
74830
  ]
74673
74831
  }
74674
74832
  ]
@@ -74680,7 +74838,7 @@
74680
74838
  {
74681
74839
  "type": "text",
74682
74840
  "value": [
74683
- "撤销组\"production\"的所有成员读取所有数据库表的权限：",
74841
+ "撤销组 \"production\" 的所有成员读取所有数据库表的权限：",
74684
74842
  ""
74685
74843
  ]
74686
74844
  },
@@ -74697,7 +74855,7 @@
74697
74855
  {
74698
74856
  "type": "text",
74699
74857
  "value": [
74700
- "撤销组\"research\"的所有成员读写表 ``dfs://db1/t1`` 的权限：",
74858
+ "撤销组 \"research\" 的所有成员读写表 ``dfs://db1/t1`` 的权限：",
74701
74859
  ""
74702
74860
  ]
74703
74861
  },
@@ -74714,7 +74872,7 @@
74714
74872
  {
74715
74873
  "type": "text",
74716
74874
  "value": [
74717
- "撤销组\"research\"的所有成员在数据库 ``dfs://db1`` 和 ``dfs://db2`` 创建表的权限：",
74875
+ "撤销组 \"research\" 的所有成员在数据库 ``dfs://db1`` 和 ``dfs://db2`` 创建表的权限：",
74718
74876
  ""
74719
74877
  ]
74720
74878
  },
@@ -74730,7 +74888,7 @@
74730
74888
  {
74731
74889
  "type": "text",
74732
74890
  "value": [
74733
- "撤销用户\"AlexSmith\"创建和删除数据库的权限：",
74891
+ "撤销用户 \"AlexSmith\" 创建和删除数据库的权限：",
74734
74892
  ""
74735
74893
  ]
74736
74894
  },
@@ -74746,7 +74904,7 @@
74746
74904
  {
74747
74905
  "type": "text",
74748
74906
  "value": [
74749
- "撤销用户\"AlexSmith\"执行脚本的权限：",
74907
+ "撤销用户 \"AlexSmith\" 执行脚本的权限：",
74750
74908
  ""
74751
74909
  ]
74752
74910
  },
@@ -74762,7 +74920,7 @@
74762
74920
  {
74763
74921
  "type": "text",
74764
74922
  "value": [
74765
- "撤销用户\"AlexSmith\"测试脚本的权限：",
74923
+ "撤销用户 \"AlexSmith\" 测试脚本的权限：",
74766
74924
  ""
74767
74925
  ]
74768
74926
  },
@@ -75586,6 +75744,20 @@
75586
75744
  }
75587
75745
  ]
75588
75746
  },
75747
+ {
75748
+ "title": "参数",
75749
+ "type": "parameters",
75750
+ "children": [
75751
+ {
75752
+ "type": "text",
75753
+ "value": [
75754
+ "`X`：矩阵或数组向量。",
75755
+ "",
75756
+ "`Y`：和 X 行数相等的向量或数组向量。"
75757
+ ]
75758
+ }
75759
+ ]
75760
+ },
75589
75761
  {
75590
75762
  "title": "详情",
75591
75763
  "type": "detail",
@@ -75593,7 +75765,11 @@
75593
75765
  {
75594
75766
  "type": "text",
75595
75767
  "value": [
75596
- "以 *Y* 的元素为 *X* 每行的列索引，逐行取出 *X* 中对应索引的元素，返回一个长度与输入参数行数相同的向量。"
75768
+ "若 Y 是向量，则 Y 的每个元素表示 X 每行的列索引，逐行取出 X 中对应索引的元素，返回一个与 Y 长度相同的向量。",
75769
+ "",
75770
+ "若 Y 是数组向量，则 Y 的每行元素表示 X 每行的列索引，逐行取出 X 中对应索引的元素，返回一个与 Y 维度相同的数组向量。",
75771
+ "",
75772
+ "注意：若索引无对应元素，则返回空值。"
75597
75773
  ]
75598
75774
  }
75599
75775
  ]
@@ -75612,14 +75788,15 @@
75612
75788
  " $ rowAt(m, index)",
75613
75789
  " [7.1,4.5,2.2]",
75614
75790
  "",
75615
- " $ trades = table(10:0,`time`sym`p1`p2`p3`p4`p5`vol1`vol2`vol3`vol4`vol5,[TIMESTAMP,SYMBOL,DOUBLE,DOUBLE,DOUBLE,DOUBLE,DOUBLE,INT,INT,INT,INT,INT])",
75616
- " $ insert into trades values(2022.01.01T09:00:00, `A, 33.2, 33.8, 33.6, 33.3, 33.1, 200, 180, 180, 220, 200)",
75617
- " $ insert into trades values(2022.01.01T09:00:00, `A, 33.1, 32.8, 33.2, 34.3, 32.3, 150, 280, 190, 100, 220)",
75618
- " $ insert into trades values(2022.01.01T09:00:00, `A, 31.2, 32.6, 33.6, 35.3, 34.5, 220, 160, 130, 100, 110)",
75619
- " $ insert into trades values(2022.01.01T09:00:00, `A, 30.2, 32.5, 33.6, 35.3, 34.1, 200, 180, 150, 140, 120)",
75620
- " $ insert into trades values(2022.01.01T09:00:00, `A, 33.2, 33.8, 33.6, 33.3, 33.1, 180, 160, 160, 180, 200)",
75621
- " $ select rowAt(matrix(p1, p2, p3, p4, p5), rowImin(vol1, vol2, vol3, vol4, vol5)) as price1, rowAt(matrix(p1, p2, p3, p4, p5), rowImax(vol1, vol2, vol3, vol4, vol5)) as price2 from trades",
75622
- ""
75791
+ " $ index = array(INT[], 0, 10).append!([0 1, 2 4, 3 4 5])",
75792
+ " $ rowAt(m, index)",
75793
+ " [[3.1,4.2],[7.1,8.4],[5.3,3.5,]]",
75794
+ "",
75795
+ " $ x = array(DOUBLE[], 0, 10).append!([3.3 3.6 3.8, 3.7 3.4 3.5, 3.4 3.4 3.5])",
75796
+ " $ index = array(INT[], 0, 10).append!([0 1, 2, 0 2])",
75797
+ " $ rowAt(x, index)",
75798
+ " [[3.3,3.6],[3.5],[3.4,3.5]]",
75799
+ " "
75623
75800
  ]
75624
75801
  },
75625
75802
  {
@@ -80031,6 +80208,7 @@
80031
80208
  " * typeInt：列类型对应的ID",
80032
80209
  " * extra：仅在列类型为 DECIMAL 时，显示 DECIMAL 的 scale",
80033
80210
  " * comment：列字段的注释信息",
80211
+ "* clusterReplicationEnabled：是否开启异步复制。",
80034
80212
  "",
80035
80213
  "相关函数：:doc:`/FunctionsandCommands/FunctionReferences/d/database`, :doc:`/FunctionsandCommands/FunctionReferences/c/createTable`, :doc:`/FunctionsandCommands/FunctionReferences/c/createPartitionedTable`"
80036
80214
  ]
@@ -84809,7 +84987,7 @@
84809
84987
  {
84810
84988
  "type": "text",
84811
84989
  "value": [
84812
- "`str` 是STRING类型标量；",
84990
+ "`str` 是STRING类型标量或向量；",
84813
84991
  "",
84814
84992
  "`delimiter` 是CHAR类型或STRING类型标量。"
84815
84993
  ]
@@ -84823,9 +85001,11 @@
84823
85001
  {
84824
85002
  "type": "text",
84825
85003
  "value": [
84826
- "如果没有指定delimiter，把str分割为CHAR类型向量。",
85004
+ "若 *str* 为标量：",
85005
+ "* 如果没有指定 *delimiter*，把str分割为CHAR类型向量。",
85006
+ "* 如果指定了 *delimiter*，把它作为分隔符，把 *str* 分成CHAR类型或STRING类型的向量。",
84827
85007
  "",
84828
- "如果指定了delimiter，把它作为分隔符，把str分成CHAR类型或STRING类型的向量。"
85008
+ "若 *str* 为向量，则对 *str* 的每一个元素进行分割，返回一个列式元组（columnar tuple）。"
84829
85009
  ]
84830
85010
  }
84831
85011
  ]
@@ -84851,6 +85031,20 @@
84851
85031
  " $ split(`xyz1,`xyz)[1];",
84852
85032
  " 1",
84853
85033
  "",
85034
+ " $ a = split(\"20220101 09:00:00\" \"20220101 09:12:20\" \"20220101 10:00:00\", \" \")",
85035
+ " ([\"20220101\",\"09:00:00\"],[\"20220101\",\"09:12:20\"],[\"20220101\",\"10:00:00\"])",
85036
+ "",
85037
+ " // 按列取数",
85038
+ " $ a[0];",
85039
+ " [\"20220101\",\"20220101\",\"20220101\"]",
85040
+ "",
85041
+ " $ a[1];",
85042
+ " [\"09:00:00\",\"09:12:20\",\"10:00:00\"]",
85043
+ "",
85044
+ " //按行取数",
85045
+ " $ a.row(0)",
85046
+ " [\"20220101\",\"09:00:00\"]",
85047
+ "",
84854
85048
  ""
84855
85049
  ]
84856
85050
  }
@@ -85942,70 +86136,6 @@
85942
86136
  }
85943
86137
  ]
85944
86138
  },
85945
- "startAsyncReplication": {
85946
- "title": "startAsyncReplication",
85947
- "type": "command",
85948
- "children": [
85949
- {
85950
- "title": "语法",
85951
- "type": "grammer",
85952
- "children": [
85953
- {
85954
- "type": "text",
85955
- "value": [
85956
- "startAsyncReplication()"
85957
- ]
85958
- }
85959
- ]
85960
- },
85961
- {
85962
- "title": "参数",
85963
- "type": "parameters",
85964
- "children": [
85965
- {
85966
- "type": "text",
85967
- "value": [
85968
- "无"
85969
- ]
85970
- }
85971
- ]
85972
- },
85973
- {
85974
- "title": "详情",
85975
- "type": "detail",
85976
- "children": [
85977
- {
85978
- "type": "text",
85979
- "value": [
85980
- "启用集群间的异步复制后，在主集群的数据节点上执行，用于恢复发送到从集群的任务。"
85981
- ]
85982
- }
85983
- ]
85984
- },
85985
- {
85986
- "title": "例子",
85987
- "type": "example",
85988
- "children": [
85989
- {
85990
- "type": "code",
85991
- "language": "console",
85992
- "value": [
85993
- " ",
85994
- " $ startAsyncReplication();",
85995
- "",
85996
- ""
85997
- ]
85998
- },
85999
- {
86000
- "type": "text",
86001
- "value": [
86002
- "相关函数： :doc:`stopAsyncReplication`"
86003
- ]
86004
- }
86005
- ]
86006
- }
86007
- ]
86008
- },
86009
86139
  "startDataNode": {
86010
86140
  "title": "startDataNode",
86011
86141
  "type": "command",
@@ -86807,69 +86937,6 @@
86807
86937
  }
86808
86938
  ]
86809
86939
  },
86810
- "stopAsyncReplication": {
86811
- "title": "stopAsyncReplication",
86812
- "type": "command",
86813
- "children": [
86814
- {
86815
- "title": "语法",
86816
- "type": "grammer",
86817
- "children": [
86818
- {
86819
- "type": "text",
86820
- "value": [
86821
- "stopAsyncReplication()"
86822
- ]
86823
- }
86824
- ]
86825
- },
86826
- {
86827
- "title": "参数",
86828
- "type": "parameters",
86829
- "children": [
86830
- {
86831
- "type": "text",
86832
- "value": [
86833
- "无"
86834
- ]
86835
- }
86836
- ]
86837
- },
86838
- {
86839
- "title": "详情",
86840
- "type": "detail",
86841
- "children": [
86842
- {
86843
- "type": "text",
86844
- "value": [
86845
- "启用集群间的异步复制后，在主集群的数据节点上执行，用于暂停发送到从集群的任务。"
86846
- ]
86847
- }
86848
- ]
86849
- },
86850
- {
86851
- "title": "例子",
86852
- "type": "example",
86853
- "children": [
86854
- {
86855
- "type": "code",
86856
- "language": "console",
86857
- "value": [
86858
- " ",
86859
- " $ stopAsyncReplication();",
86860
- ""
86861
- ]
86862
- },
86863
- {
86864
- "type": "text",
86865
- "value": [
86866
- "相关函数： :doc:`startAsyncReplication`"
86867
- ]
86868
- }
86869
- ]
86870
- }
86871
- ]
86872
- },
86873
86940
  "stopDataNode": {
86874
86941
  "title": "stopDataNode",
86875
86942
  "type": "command",
@@ -87067,27 +87134,21 @@
87067
87134
  {
87068
87135
  "type": "text",
87069
87136
  "value": [
87070
- "streamEngineParser 返回一个表对象，为解析后流水线上第一个流计算引擎返回的表，向该表写入数据意味着这些数据进入流水线进行计算。",
87071
- "",
87072
- "若要使用 streamEngineParser，必须根据业务场景提供的指标，分析业务中涉及的流计算引擎，将指标改写成 streamEngineParser 能够识别分解的 metrics。",
87073
- "",
87074
- "* 注意点：",
87075
- "",
87076
- "\\(1) 由于横截面引擎暂不支持启用快照机制，因此若流水线中涉及横截面引擎，``streamEngineParser`` 暂时不支持指定 *snapshotDir* 和 *snapshotIntervalInMsgCount* 这两个参数。",
87077
- "",
87078
- "\\(2) 若要删除引擎流水线，需要根据 ``streamEngineParser`` 解析出的引擎对应的名称（详见 name）单独进行删除。",
87137
+ "在实际场景下，用户的因子可能嵌套横截面、历史状态、时序窗口、表连接等多种复杂逻辑，需要多个计算引擎的级联才能实现。streamEngineParser 为只涉及横截面、历史状态、时序窗口三种逻辑嵌套的复杂因子，提供了一个统一的计算入口。用户无需编写复杂的级联代码，只需将嵌套因子按规则改写后传入 streamEngineParser，系统将自动解析各层嵌套涉及的计算逻辑，形成流计算引擎流水线，自动分发给对应的引擎进行计算。",
87079
87138
  "",
87080
- "根据业务场景设计到的计算引擎， *metrics* 的改写规则如下：",
87139
+ "为满足各逻辑对应引擎的功能，该函数集合了（日级）时序引擎、响应式状态引擎和横截面引擎的参数。需要注意的是，由于部分为公共参数（如 keyColumn），若公共参数在不同计算逻辑下需要指定的值不同（如时序窗口按天分组，状态逻辑要求按股票代码分组，则需要配置不同的 keyColumn），不能使用该函数，只能通过级联实现。",
87081
87140
  "",
87082
- "注意：",
87141
+ "返回一个表对象，为解析后流水线上第一个流计算引擎返回的表，向该表写入数据意味着这些数据进入流水线进行计算。删除时，需要根据 streamEngineParser 解析出的引擎对应的名称（详见 name）单独进行删除，暂不支持。",
87083
87142
  "",
87084
- "（1）若 metrics 中包含用户自定义函数，则引擎解析器会按下文的分解原则将函数体进行分解，将各分解得到的操作分发给对应引擎进行处理。",
87143
+ "根据上文，若要使用 streamEngineParser，必须根据业务场景提供的指标，分析业务中涉及的流计算引擎，将指标改写成 streamEngineParser 能够识别分解的 metrics。若 metrics 中包含了用户自定义函数，引擎对函数体内部的嵌套逻辑进一步进行解析。",
87085
87144
  "",
87086
- "（2）若用户自定义函数用 @state 进行标识，则引擎解析器会将其分配给响应式状态引擎处理。",
87145
+ "改写规则如下：",
87087
87146
  "",
87088
87147
  "\\1. 引擎分解标识",
87089
87148
  "",
87090
- "* 若指标中的某一步操作需要使用横截面引擎，需改成以 “row开头” 的函数作为标识，若不添加 row 则该操作默认在响应式状态引擎处理。横截面引擎的标识函数如下：",
87149
+ "* 若指标中的某一层嵌套逻辑要求计算截面数据，需将对应的计算函数改成以 “row开头” 的函数作为标识，若不添加 row 则该操作默认在响应式状态引擎处理。如：需要在截面计算排名，则需要将该层嵌套改写为 rowRank。",
87150
+ "",
87151
+ "目前支持的标识函数如下：",
87091
87152
  "",
87092
87153
  "::",
87093
87154
  "",
@@ -87095,17 +87156,21 @@
87095
87156
  " \"rowSize\", \"rowSkew\", \"rowStd\", \"rowStdp\", \"rowSum\", \"rowSum2\", \"rowVar\", \"rowVarp\", ",
87096
87157
  " \"rowAnd\", \"rowOr\", \"rowXor\", \"rowKurtosis\", \"rowCorr\", \"rowCovar\", \"rowBeta\", \"rowWsum\", \"rowWavg\"",
87097
87158
  "",
87098
- "* 若指标中的某一步操作需要使用时间序列聚合引擎，必须在指标中以 :doc:`/Functionalprogramming/TemplateFunctions/rolling` 作为标识，如果涉及到时间序列引擎的 windowSize， step 和 fill 需要作为 rolling 的参数给出，形式如下：",
87159
+ "用户自定义函数或者 row 系列函数不支持的逻辑可以通过 byRow 高阶函数实现。",
87160
+ "",
87161
+ "* 若指标中的某一层嵌套逻辑涉及到时序聚合窗口的计算，必须在指标中以 :doc:`/Functionalprogramming/TemplateFunctions/rolling` 作为标识进行改写。如：窗口为 3， 步长为 3，窗口内进行求和计算，计算列为 price，空值以前值填充，则可以写为 rolling(sum, price, 3, 3, 'ffill')。",
87162
+ "",
87163
+ "形式如下： ",
87099
87164
  "",
87100
87165
  "::",
87101
87166
  "",
87102
87167
  " rolling(func, funcArgs, window, [step=1], [fill='none']) ",
87103
87168
  "",
87104
- "* 其他指标中的操作默认在响应式状态引擎中处理。",
87169
+ "* 分解时，不包含上述标识的内置函数均在响应式状态引擎中处理。",
87105
87170
  " ",
87106
87171
  "\\2. 中间引擎输入表结构",
87107
87172
  "",
87108
- "某些业务场景下，*metrics* 中使用的列名可能涉及到中间引擎输入表中的列。由于用户只能通过参数 *dummyTable* 指定第一个引擎输入表的 schema，但是中间引擎的 dummyTable 对用户而言是透明的，因此 ``streamEngineParser`` 提供了一套中间引擎 dummyTable 的命名规范：",
87173
+ "在 streamEngineParser 中，用户只能通过参数 *dummyTable* 指定第一个引擎输入表的 schema ，中间引擎的 *dummyTable* 对用户而言是透明的， 为了能在 *metrics* 和部分参数中指定中间表的列名，streamEngineParser 提供了一套中间引擎 *dummyTable* 的命名规范：",
87109
87174
  "",
87110
87175
  "* 第一列为时间列。",
87111
87176
  "* 之后几列对应指定的 *keyColumn*。",
@@ -87120,7 +87185,7 @@
87120
87185
  "* 横截面引擎：*contextByColumn*",
87121
87186
  "* 响应式状态引擎：*filter*, *keyPurgeFilter* ",
87122
87187
  "",
87123
- "若要指定中间引擎的 *dummyTable* 的列名，则可以根据如上的命名规则给出的列名进行指定，如 \"*contextByColumn* = col\\_0\\_\"。",
87188
+ "若这些参数需要指定中间引擎的 *dummyTable* 的列名，则可以根据如上的命名规则给出的列名进行指定，如 \"*contextByColumn* = col\\_0\\_\"。",
87124
87189
  "",
87125
87190
  "若指定的列为 *timeColumn* 和 *keyColumn*，则也可以指定参数对应的列名。"
87126
87191
  ]
@@ -87336,11 +87401,11 @@
87336
87401
  {
87337
87402
  "type": "text",
87338
87403
  "value": [
87339
- "创建流数据过滤引擎，返回一个表对象。对注入该表的数据进行过滤和分发处理。",
87404
+ "创建流数据过滤引擎，对输入引擎的数据进行过滤和分发处理，返回一个表对象。",
87340
87405
  "",
87341
- "该引擎的处理流程如下：",
87406
+ "该引擎的处理流程包含以下步骤：",
87342
87407
  "",
87343
- "\\1. 订阅异构流表（由 :doc:`../r/replay` 函数回放得到）时，解析（反序列化）注入的数据。输入数据为普通流表时无此步骤。注意：2.00.6 版本开始，streamFilter 函数支持过滤普通流表数据，并进行分发处理。",
87408
+ "\\1. 输入数据为异构流表（由 :doc:`../r/replay` 函数回放得到）时，解析（反序列化）数据。输入数据为普通流表时无此步骤。注意：1.30.18 版本开始，streamFilter 函数支持过滤普通流表数据，并进行分发处理。",
87344
87409
  "",
87345
87410
  "\\2. 根据 *filter* 指定的规则对流表进行过滤。",
87346
87411
  "",
@@ -87384,7 +87449,7 @@
87384
87449
  "* 'condition'：表示过滤条件。",
87385
87450
  "",
87386
87451
  " * 若分发异构流表，则 'condition' 是一个字符串，且必须是 replay 参数 *inputTables* 的键值（表的标识）。用于过滤出异构表中具有 *condition* 标识的数据。",
87387
- " * 若分发普通流表，则 'condition' 可以是一个表示列名的字符串标量/向量，或者是包含一个或多个布尔表达式的元代码，且表达式中不能调用函数。请注意，若 'condition' 指定为字符串标量/向量，必须为 *conditionColumn* 指定列的元素。",
87452
+ " * 若分发普通流表，则 'condition' 可以是一个字符串标量/向量，或者是包含一个或多个布尔表达式的元代码。其中表达式中可以使用内置函数，但不支持部分应用。请注意，若 'condition' 指定为字符串标量/向量，必须为 *conditionColumn* 指定列的元素。",
87388
87453
  "",
87389
87454
  "* 'handler'：一元函数或表对象（包括流数据引擎返回的表对象）。",
87390
87455
  "",
@@ -90283,11 +90348,11 @@
90283
90348
  {
90284
90349
  "type": "text",
90285
90350
  "value": [
90286
- "syncDict(keyObj, valueObj, [sharedName])",
90351
+ "syncDict(keyObj, valueObj, [sharedName], [ordered=false])",
90287
90352
  "",
90288
90353
  "或",
90289
90354
  "",
90290
- "syncDict(keyType, valueType, [sharedName])"
90355
+ "syncDict(keyType, valueType, [sharedName], [ordered=false])"
90291
90356
  ]
90292
90357
  }
90293
90358
  ]
@@ -90301,9 +90366,12 @@
90301
90366
  "value": [
90302
90367
  "第一种用法中，`keyObj` 是表示键的标量或向量，`valueObj` 是表示值的标量或向量。",
90303
90368
  "",
90304
- "第二种用法中，`keyType` 是字典键的数据类型； `valueType` 是字典值的数据类型。系统支持以下键的数据类型：Logical, Integral, Floating和Temporal。字典中的值可以是任意数据类型。",
90369
+ "第二种用法中，`keyType` 是字典键的数据类型； `valueType` 是字典值的数据类型。系统支持以下键的数据类型：Logical, Integral, Floating和Temporal。字典中的值不支持 COMPLEX, POINT 和 Decimal 类别。",
90305
90370
  "",
90306
- "`sharedName` 为一个字符串。指定后此字典会被共享，共享的字典名为sharedName。"
90371
+ "`sharedName` 为一个字符串。指定后此字典会被共享，共享的字典名为sharedName。",
90372
+ "",
90373
+ "ordered 一个布尔值，默认为 false，表示创建一个无序字典。当 ordered = true 时，创建一个有序字典。无序字典在输出或进行遍历时，其键值对不保留输入时的顺序；有序字典在输出或进行遍历时，键值对的顺序与输入顺序保持一致。",
90374
+ ""
90307
90375
  ]
90308
90376
  }
90309
90377
  ]
@@ -90398,7 +90466,16 @@
90398
90466
  " $ jobId4=submitJob(\"task2\",,task2,z2,n)",
90399
90467
  " $ getJobReturn(jobId3, true)",
90400
90468
  " $ getJobReturn(jobId4, true)",
90401
- " $ z2;"
90469
+ " $ z2;",
90470
+ ""
90471
+ ]
90472
+ },
90473
+ {
90474
+ "type": "text",
90475
+ "value": [
90476
+ "相关函数",
90477
+ "",
90478
+ ":doc:`../a/array`, :doc:`../m/matrix`, :doc:`../d/dictUpdate!`, :doc:`../d/dict`"
90402
90479
  ]
90403
90480
  }
90404
90481
  ]
@@ -90766,13 +90843,13 @@
90766
90843
  {
90767
90844
  "type": "text",
90768
90845
  "value": [
90769
- "第一种用法中，`X`, `X1`, `X2` ... 可以是向量、矩阵或元组。每个向量的长度、矩阵中每列长度、以及元组中每个元素的长度都必须相同。",
90846
+ "第一种用法中，`X`, `X1`, `X2` ... 可以是向量、矩阵或元组。",
90770
90847
  "",
90771
90848
  "第二种用法中：",
90772
90849
  "",
90773
90850
  "`capacity` 是正整数，表示建表时系统为该表分配的内存（以记录数为单位）。当记录数超过 *capacity* 时，系统首先会分配 *capacity* 1.2~2倍的新的内存空间，然后复制数据到新的内存空间，最后释放原来的内存。对于规模较大的表，此类操作的内存占用会很高。因此，建议创建内存表时预先分配一个合理的 *capacity*。",
90774
90851
  "",
90775
- "`size` 是正整数，表示该表新建时的行数。若size=0，创建一个空表。 注意如果colTypes指定为数组向量，size必须为0。",
90852
+ "`size` 是正整数，表示该表新建时的行数。若 *size* =0，创建一个空表。 注意如果 *colTypes* 指定为数组向量， *size* 必须为0。",
90776
90853
  "",
90777
90854
  "`colNames` 是一个向量，表示列名。",
90778
90855
  "",
@@ -90788,7 +90865,16 @@
90788
90865
  {
90789
90866
  "type": "text",
90790
90867
  "value": [
90791
- "创建一个内存数据表。"
90868
+ "用法一：将单个或多个向量/矩阵/元组，或多个向量和元组的混合数据形式转换成表。",
90869
+ "",
90870
+ "注意：",
90871
+ "",
90872
+ "* 若 Xk 是普通元组，则其元素必须是等长的向量，长度等于表的行数。元组的每个元素将作为表的每列。",
90873
+ "* 若 Xk 是列式元组，则其元素可以不等长，但其元素的个数必须和表的行数保持一致。Xk 将单独作为表的一列（列类型为 ANY），其每个元素将作为该列每行的元素值。注意，只能通过用法一创建一个包含列式元组的表。",
90874
+ "",
90875
+ "DolphinDB 支持将元素不等长的普通元组自动识别为列式元组存储；对于元素等长的元组，必须通过 setColumnarTuple! 函数转化为列式元组才能将每个元素按行存储。",
90876
+ "",
90877
+ "用法二：创建一个固定数据类型的空表或初始化的表。"
90792
90878
  ]
90793
90879
  }
90794
90880
  ]
@@ -91875,7 +91961,17 @@
91875
91961
  "",
91876
91962
  "`duration` 是一个整数或 DURATION 类型数据。",
91877
91963
  "",
91878
- "`unit` 是一个字符串向量。它表示 *duration* 的单位。它的取值可以是：\"ns\"(nanosecond), \"us\"(microsecond), \"ms\"(millisecond), \"s\"(second), \"m\"(minute), \"H\"(hour), \"d\"(day), \"w\"(week), \"M\"(month), \"y\"(year), “B”(business day)。当 *duration* 取 DURATION 类型数据时，该参数无需设置。",
91964
+ ".. versionadded:: 1.30.13",
91965
+ " 参数 *unit*",
91966
+ "",
91967
+ ".. versionadded:: 2.00.9",
91968
+ " 用户自定义交易日历",
91969
+ "",
91970
+ "`unit` 是一个字符串标量。它表示 *duration* 的单位或用户自定义交易日历的标识。",
91971
+ "",
91972
+ "- 若为 *duration* 单位，它的取值可以是：\"ns\"(nanosecond), \"us\"(microsecond), \"ms\"(millisecond), \"s\"(second), \"m\"(minute), \"H\"(hour), \"d\"(day), \"w\"(week), \"M\"(month), \"y\"(year), “B”(business day)。",
91973
+ "- 若需要根据交易日历的规则进行计算，须填写 *marketHolidayDir* 保存的文件名（即交易日历的标识）。",
91974
+ "- 当 *duration* 取 DURATION 类型数据时，该参数无需设置。",
91879
91975
  "",
91880
91976
  "注：时间单位为 year 或 month 时，计算结果与 mysql 保持一致。Pandas 提供了一个时间偏移对象（Date offsets）来完成时间偏移工作，当 DateOffset 参数取 months 或 years 时，与 ``temporalAdd`` 单位为 M 或 y 的计算结果也一致。"
91881
91977
  ]
@@ -96275,7 +96371,10 @@
96275
96371
  "\"N\" nanosecond",
96276
96372
  "================ =======================",
96277
96373
  "",
96278
- "以上字符串亦可配合数字用于 *rule* 参数，例如\"2M\"表示频率为每两个月的月末。",
96374
+ ".. versionadded:: 2.00.9 ",
96375
+ " 用户自定义交易日历",
96376
+ "",
96377
+ "`rule` 上述字符串亦可配合使用数字，例如 \"2M\" 表示频率为每两个月月末。此外，*rule* 也可指定为用户自定义交易日历的标识（配置参数 *marketHolidayDir* 指定目录下的文件名，系统将根据该交易日历进行计算）。",
96279
96378
  "",
96280
96379
  ".. versionadded:: 2.00.6",
96281
96380
  " 参数 *closed*, *label*, *origin*",
@@ -96310,7 +96409,7 @@
96310
96409
  {
96311
96410
  "type": "text",
96312
96411
  "value": [
96313
- "将给定日期或时间变量转换为给定的时间格式。结果长度与X相同。"
96412
+ "将给定日期或时间变量转换为给定的时间格式（或对应的交易日）。结果长度与X相同。"
96314
96413
  ]
96315
96414
  }
96316
96415
  ]
@@ -96393,13 +96492,13 @@
96393
96492
  {
96394
96493
  "type": "text",
96395
96494
  "value": [
96396
- "如果X是一个元组，每个向量的长度必须相同，*transpose* 函数返回的是一个与X中每个向量长度相同的元组，返回结果中的第n个元素是由X中每个向量的第n个值组成的向量。",
96495
+ "如果X是一个元组，每个向量的长度必须相同，*transpose* 函数返回的是一个与X中每个向量长度相同的元组，返回结果中的第 n 个元素是由 X 中每个向量的第 n 个值组成的向量。",
96397
96496
  "",
96398
- "如果X是一个矩阵，*transpose* 函数返回X的转置矩阵。",
96497
+ "如果X是一个矩阵，*transpose* 函数返回 X 的转置矩阵。",
96399
96498
  "",
96400
- "如果X是一个表，*transpose* 函数把表X转换为一个字典，表中的列名为key，每列的值为value。",
96499
+ "如果X是一个表，*transpose* 函数把表 X 转换为一个有序字典（从 2.00.9 版本开始支持有序字典），表中的列名为 key，每列的值为 value。",
96401
96500
  "",
96402
- "如果X是一个字典，它的key必须是STRING类型，*transpose* 函数把字典X转换为一个表，key为列名，每个key对应的value都是等长的向量，表示每列的值。"
96501
+ "如果 X 是一个字典，它的 key 必须是 STRING 类型，*transpose* 函数把字典 X 转换为一个表，key 为列名，每个 key 对应的 value 都是等长的向量，表示每列的值。"
96403
96502
  ]
96404
96503
  }
96405
96504
  ]
@@ -96411,7 +96510,7 @@
96411
96510
  {
96412
96511
  "type": "text",
96413
96512
  "value": [
96414
- "例1. X是一个元组。",
96513
+ "例1. X 是一个元组。",
96415
96514
  ""
96416
96515
  ]
96417
96516
  },
@@ -96517,11 +96616,11 @@
96517
96616
  "language": "console",
96518
96617
  "value": [
96519
96618
  "",
96520
- " $ transpose(t);",
96521
- " price->[49.6,29.46,29.52,30.02,174.97,175.23,50.76,50.32,51.29]",
96619
+ " transpose(t);",
96620
+ " timestamp->[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]",
96522
96621
  " sym->[C,MS,MS,MS,IBM,IBM,C,C,C]",
96523
96622
  " qty->[2200,1900,2100,3200,6800,5400,1300,2500,8800]",
96524
- " timestamp->[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]",
96623
+ " price->[49.6,29.46,29.52,30.02,174.97,175.23,50.76,50.32,51.29]",
96525
96624
  ""
96526
96625
  ]
96527
96626
  },
@@ -98778,6 +98877,7 @@
98778
98877
  " * 授权的节点个数（maxNodes），内存大小（maxMemoryPerNode），CPU 核数（maxCoresPerNode）不小于原 license 的授权。",
98779
98878
  "",
98780
98879
  "* 若原 license 授权模式（authorization）为 trial 和 site，则无法进行在线升级。",
98880
+ "* 从 1.30.21/2.00.9 版本开始，支持将 DolphinDB 进程绑定到具体的 CPU 内核上。若待升级 license 中修改了绑定核信息，则升级 license 后须重启 DolphinDB 以使 CPU 内核绑定的设置生效。",
98781
98881
  "",
98782
98882
  ""
98783
98883
  ]
@@ -98792,24 +98892,24 @@
98792
98892
  "type": "code",
98793
98893
  "language": "console",
98794
98894
  "value": [
98895
+ "",
98896
+ " $ updateLicense()",
98897
+ " authorization->commercial",
98898
+ " licenseType->0",
98899
+ " maxMemoryPerNode->32",
98900
+ " maxCoresPerNode->8",
98901
+ " clientName->test license",
98902
+ " bindCPU->true",
98903
+ " expiration->2022.03.01",
98904
+ " maxNodes->8",
98905
+ " version->",
98906
+ " modules->-1",
98795
98907
  ""
98796
98908
  ]
98797
98909
  },
98798
98910
  {
98799
98911
  "type": "text",
98800
98912
  "value": [
98801
- " $ updateLicense()",
98802
- " authorization->commercial",
98803
- " licenseType->0",
98804
- " maxMemoryPerNode->32",
98805
- " maxCoresPerNode->8",
98806
- " clientName->test license",
98807
- " bindCPU->true",
98808
- " expiration->2022.03.01",
98809
- " maxNodes->8",
98810
- " version->",
98811
- " modules->-1",
98812
- "",
98813
98913
  ".. meta::",
98814
98914
  " :keywords: update, license"
98815
98915
  ]