dolphindb 2.0.801 → 2.0.900
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.
- package/README.md +80 -5
- package/README.zh.md +83 -9
- package/browser.d.ts +22 -25
- package/browser.js +155 -133
- package/browser.js.map +1 -1
- package/docs.en.json +492 -49
- package/docs.zh.json +433 -100
- package/index.d.ts +22 -25
- package/index.js +151 -130
- package/index.js.map +1 -1
- package/language.d.ts +5 -5
- package/language.js +3 -1
- package/language.js.map +1 -1
- package/package.json +7 -7
package/docs.zh.json
CHANGED
|
@@ -857,7 +857,7 @@
|
|
|
857
857
|
{
|
|
858
858
|
"type": "text",
|
|
859
859
|
"value": [
|
|
860
|
-
"`table`
|
|
860
|
+
"`table` 内存表、流数据表、分布式表或维度表。",
|
|
861
861
|
"",
|
|
862
862
|
"`colNames` 是字符串标量或向量，表示要添加的列的名称。",
|
|
863
863
|
"",
|
|
@@ -4300,7 +4300,7 @@
|
|
|
4300
4300
|
"value": [
|
|
4301
4301
|
"备份数据库到指定路径。",
|
|
4302
4302
|
"",
|
|
4303
|
-
"该函数是 :doc:`backup` 函数的特例，其等价于调用 backup(backupDir, dbPath, force=false,
|
|
4303
|
+
"该函数是 :doc:`backup` 函数的特例，其等价于调用 backup(backupDir, dbPath, force=false, parallel=true, snapshot=true)。",
|
|
4304
4304
|
"调用该函数可以简化代码，方便用户一次性备份整个数据库。"
|
|
4305
4305
|
]
|
|
4306
4306
|
}
|
|
@@ -10676,12 +10676,10 @@
|
|
|
10676
10676
|
" $ concat (`hello, `world);",
|
|
10677
10677
|
" helloworld",
|
|
10678
10678
|
"",
|
|
10679
|
-
" // 返回在 IBM, GOOG 和 APPL 间用 \"
|
|
10680
|
-
" $ x = concat(`IBM`GOOG`APPL, \"
|
|
10679
|
+
" // 返回在 IBM, GOOG 和 APPL 间用 \",\" 分隔的结果",
|
|
10680
|
+
" $ x = concat(`IBM`GOOG`APPL, \",\");",
|
|
10681
10681
|
" $ x;",
|
|
10682
|
-
" IBM",
|
|
10683
|
-
" GOOG",
|
|
10684
|
-
" APPL",
|
|
10682
|
+
" IBM,GOOG,APPL",
|
|
10685
10683
|
"",
|
|
10686
10684
|
" $ typestr x;",
|
|
10687
10685
|
" STRING",
|
|
@@ -11148,7 +11146,7 @@
|
|
|
11148
11146
|
"假设该函数计算结果对应输出表的列为 factor，且迭代仅基于前一个值，对于第 k 条记录(k = 0, 1, 2 …)，其计算逻辑为：",
|
|
11149
11147
|
"",
|
|
11150
11148
|
"* cond[k] == true：factor[k] = trueValue",
|
|
11151
|
-
"* cond[k] == false：factor[k] = falseIterFunc(factor[k-1]
|
|
11149
|
+
"* cond[k] == false：factor[k] = falseIterFunc(factor)[k-1]",
|
|
11152
11150
|
"",
|
|
11153
11151
|
"注意：若 *falseIterFunc* 为窗口函数，则会基于前多个 factor 值进行计算。"
|
|
11154
11152
|
]
|
|
@@ -11162,7 +11160,95 @@
|
|
|
11162
11160
|
{
|
|
11163
11161
|
"type": "text",
|
|
11164
11162
|
"value": [
|
|
11165
|
-
"
|
|
11163
|
+
"例1. 通过一个简单的例子，快速了解 conditionalIterate 函数的计算逻辑：",
|
|
11164
|
+
""
|
|
11165
|
+
]
|
|
11166
|
+
},
|
|
11167
|
+
{
|
|
11168
|
+
"type": "code",
|
|
11169
|
+
"language": "console",
|
|
11170
|
+
"value": [
|
|
11171
|
+
"",
|
|
11172
|
+
" $ trade = table(take(\"A\", 10) as sym, take(1 3 6, 10) as val0, take(10, 10) as val1)",
|
|
11173
|
+
" $ trade",
|
|
11174
|
+
""
|
|
11175
|
+
]
|
|
11176
|
+
},
|
|
11177
|
+
{
|
|
11178
|
+
"type": "text",
|
|
11179
|
+
"value": [
|
|
11180
|
+
"+-----+------+------+",
|
|
11181
|
+
"| sym | val0 | val1 |",
|
|
11182
|
+
"+=====+======+======+",
|
|
11183
|
+
"| A | 1 | 10 |",
|
|
11184
|
+
"+-----+------+------+",
|
|
11185
|
+
"| A | 3 | 10 |",
|
|
11186
|
+
"+-----+------+------+",
|
|
11187
|
+
"| A | 6 | 10 |",
|
|
11188
|
+
"+-----+------+------+",
|
|
11189
|
+
"| A | 1 | 10 |",
|
|
11190
|
+
"+-----+------+------+",
|
|
11191
|
+
"| A | 3 | 10 |",
|
|
11192
|
+
"+-----+------+------+",
|
|
11193
|
+
"| A | 6 | 10 |",
|
|
11194
|
+
"+-----+------+------+",
|
|
11195
|
+
"| A | 1 | 10 |",
|
|
11196
|
+
"+-----+------+------+",
|
|
11197
|
+
"| A | 3 | 10 |",
|
|
11198
|
+
"+-----+------+------+",
|
|
11199
|
+
"| A | 6 | 10 |",
|
|
11200
|
+
"+-----+------+------+",
|
|
11201
|
+
"| A | 1 | 10 |",
|
|
11202
|
+
"+-----+------+------+",
|
|
11203
|
+
"",
|
|
11204
|
+
"创建一个响应式状态引擎，并按 sym 列分组进行计算。组内的计算逻辑如下：",
|
|
11205
|
+
"",
|
|
11206
|
+
"* 若满足 val0 > 5，若返回 true，则 `factor[k]=trueValue`，即以 val1 值作为输出。 ",
|
|
11207
|
+
"* 若不满足 val0 > 5，则对应计算公式为 `factor[k]=falseIterFunc(factor)[k-1]`。当 k=3 时，对应 val0=1，val1=10，factor=[NULL, NULL, 10]，带入公式计算即 `msum([NULL, NULL, 10], 3)[2]=10`；当 k=4 时，对应 val0=3，val1=10，factor=[NULL, NULL, 10, 10]，带入公式计算即 `msum([NULL, NULL, 10, 10], 3)[3]=20`，以此类推。",
|
|
11208
|
+
""
|
|
11209
|
+
]
|
|
11210
|
+
},
|
|
11211
|
+
{
|
|
11212
|
+
"type": "code",
|
|
11213
|
+
"language": "console",
|
|
11214
|
+
"value": [
|
|
11215
|
+
"",
|
|
11216
|
+
" $ inputTable = streamTable(1:0, `sym`val0`val1, [SYMBOL, INT, INT]) ",
|
|
11217
|
+
" $ outputTable = table(100:0, `sym`factor, [STRING, DOUBLE])",
|
|
11218
|
+
" $ rse = createReactiveStateEngine(name=\"rsTest\", metrics=<conditionalIterate(val0 > 5, val1, msum{, 3})>, dummyTable=inputTable, outputTable=outputTable, keyColumn=\"sym\")",
|
|
11219
|
+
" $ rse.append!(trade)",
|
|
11220
|
+
" $ select * from outputTable",
|
|
11221
|
+
""
|
|
11222
|
+
]
|
|
11223
|
+
},
|
|
11224
|
+
{
|
|
11225
|
+
"type": "text",
|
|
11226
|
+
"value": [
|
|
11227
|
+
"+-----+--------+",
|
|
11228
|
+
"| sym | factor |",
|
|
11229
|
+
"+=====+========+",
|
|
11230
|
+
"| A | |",
|
|
11231
|
+
"+-----+--------+",
|
|
11232
|
+
"| A | |",
|
|
11233
|
+
"+-----+--------+",
|
|
11234
|
+
"| A | 10 |",
|
|
11235
|
+
"+-----+--------+",
|
|
11236
|
+
"| A | 10 |",
|
|
11237
|
+
"+-----+--------+",
|
|
11238
|
+
"| A | 20 |",
|
|
11239
|
+
"+-----+--------+",
|
|
11240
|
+
"| A | 10 |",
|
|
11241
|
+
"+-----+--------+",
|
|
11242
|
+
"| A | 40 |",
|
|
11243
|
+
"+-----+--------+",
|
|
11244
|
+
"| A | 70 |",
|
|
11245
|
+
"+-----+--------+",
|
|
11246
|
+
"| A | 10 |",
|
|
11247
|
+
"+-----+--------+",
|
|
11248
|
+
"| A | 120 |",
|
|
11249
|
+
"+-----+--------+",
|
|
11250
|
+
"",
|
|
11251
|
+
"例2. 某因子在函数中算法逻辑如下：",
|
|
11166
11252
|
""
|
|
11167
11253
|
]
|
|
11168
11254
|
},
|
|
@@ -12783,7 +12869,9 @@
|
|
|
12783
12869
|
"",
|
|
12784
12870
|
".. _table_aj:",
|
|
12785
12871
|
"",
|
|
12786
|
-
"`leftTable`
|
|
12872
|
+
"`leftTable` 表对象。可以不包含数据，但结构必须与订阅的流数据表相同。",
|
|
12873
|
+
"",
|
|
12874
|
+
"`rightTable` 表对象。可以不包含数据，但结构必须与订阅的流数据表相同。",
|
|
12787
12875
|
"",
|
|
12788
12876
|
".. _outputTable_aj:",
|
|
12789
12877
|
"",
|
|
@@ -14116,6 +14204,151 @@
|
|
|
14116
14204
|
}
|
|
14117
14205
|
]
|
|
14118
14206
|
},
|
|
14207
|
+
"createLeftSemiJoinEngine": {
|
|
14208
|
+
"title": "createLeftSemiJoinEngine",
|
|
14209
|
+
"type": "function",
|
|
14210
|
+
"children": [
|
|
14211
|
+
{
|
|
14212
|
+
"title": "语法",
|
|
14213
|
+
"type": "grammer",
|
|
14214
|
+
"children": [
|
|
14215
|
+
{
|
|
14216
|
+
"type": "text",
|
|
14217
|
+
"value": [
|
|
14218
|
+
"createLeftSemiJoinEngine(name, leftTable, rightTable, outputTable, metrics, matchingColumn, [garbageSize=5000], [updateRightTable=false])"
|
|
14219
|
+
]
|
|
14220
|
+
}
|
|
14221
|
+
]
|
|
14222
|
+
},
|
|
14223
|
+
{
|
|
14224
|
+
"title": "详情",
|
|
14225
|
+
"type": "detail",
|
|
14226
|
+
"children": [
|
|
14227
|
+
{
|
|
14228
|
+
"type": "text",
|
|
14229
|
+
"value": [
|
|
14230
|
+
"创建流数据左半等值连接引擎，返回一个左、右表关联后的表对象。对于左表每一条数据，都去匹配右表相同 :ref:`matchingColumn <matchingColumnLSJ>` 的数据，若无匹配的右表记录，则不输出。若匹配多条右表记录，则由 :ref:`updateRightTable <updateRightTableLSJ>` 参数决定连接右表的第一条记录还是最后一条记录。",
|
|
14231
|
+
"",
|
|
14232
|
+
"注意：右表根据 :ref:`updateRightTable <updateRightTableLSJ>` 指定的策略，同一 :ref:`matchingColumn <matchingColumnLSJ>` 只保留第一条或者最后一条数据，历史数据不再进行垃圾回收，因此用户需要控制 :ref:`matchingColumn <matchingColumnLSJ>` 的唯一值数量，否则可能会导致内存溢出。",
|
|
14233
|
+
"",
|
|
14234
|
+
"更多流数据引擎的应用场景说明可以参考 :doc:`../../SeriesOfFunctions/streamingEngine`。"
|
|
14235
|
+
]
|
|
14236
|
+
}
|
|
14237
|
+
]
|
|
14238
|
+
},
|
|
14239
|
+
{
|
|
14240
|
+
"title": "参数",
|
|
14241
|
+
"type": "parameters",
|
|
14242
|
+
"children": [
|
|
14243
|
+
{
|
|
14244
|
+
"type": "text",
|
|
14245
|
+
"value": [
|
|
14246
|
+
"`name` 表示流数据 left semi join 引擎的名称，作为其在一个数据节点/计算节点上的唯一标识。可包含字母，数字和下划线，但必须以字母开头。",
|
|
14247
|
+
"",
|
|
14248
|
+
"`leftTable` 表对象。可以不包含数据，但结构必须与订阅的流数据表相同。",
|
|
14249
|
+
"",
|
|
14250
|
+
"`rightTable` 表对象。可以不包含数据，但结构必须与订阅的流数据表相同。",
|
|
14251
|
+
"",
|
|
14252
|
+
"`outputTable` 为计算结果的输出表。在使用 ``createLeftSemiJoinEngine`` 函数之前，需要将输出表预先设立为一个空表，并指定各列列名以及数据类型。",
|
|
14253
|
+
"",
|
|
14254
|
+
"输出表的各列的顺序为：连接列，计算结果列。",
|
|
14255
|
+
"",
|
|
14256
|
+
"其中：",
|
|
14257
|
+
"",
|
|
14258
|
+
"\\(1) 前几列与 *matchingColumn* 中的列以及其顺序一致，可为多列。",
|
|
14259
|
+
"",
|
|
14260
|
+
"\\(2) 最后为计算结果列，可为多列。",
|
|
14261
|
+
"",
|
|
14262
|
+
"`metrics` 以元代码的格式表示计算指标，支持输入元组。有关元代码的更多信息可参考 :doc:`/Objects/Metaprogramming`。",
|
|
14263
|
+
"",
|
|
14264
|
+
"* 计算指标可以是一个或多个表达式、系统内置或用户自定义函数，但不能是聚合函数。",
|
|
14265
|
+
"* *metrics* 内支持调用具有多个返回值的函数，且必须指定列名，例如 <func(price) as \\`col1\\`col2>。",
|
|
14266
|
+
"",
|
|
14267
|
+
"若在 *metrics* 指定了 *leftTable* 和 *rightTable* 中具有相同名称的列，默认取左表的列，可以通过 \"tableName.colName\" 指定该列来自哪个表。",
|
|
14268
|
+
"",
|
|
14269
|
+
".. _matchingColumnLSJ:",
|
|
14270
|
+
"",
|
|
14271
|
+
"`matchingColumn` 表示连接列的字符串标量/向量或字符串向量组成的 tuple，支持 Integral, Temproal 或 Literal(UUID 除外)类型。",
|
|
14272
|
+
"",
|
|
14273
|
+
"*matchingColumn* 指定规则：",
|
|
14274
|
+
"",
|
|
14275
|
+
"\\1. 只有一个连接列。当左表和右表的连接列名相同时，*matchingColumn* 是一个字符串标量，否则是一个长度为 2 的 tuple。例如：左表连接列名为 sym，右表连接列名为 sym1，则 *matchingColumn* = [[\\`sym],[\\`sym1]]。",
|
|
14276
|
+
"",
|
|
14277
|
+
"\\2. 有多个连接列。当左表和右表的连接列名相同时，*matchingColumn* 是一个字符串向量，否则是一个长度为 2 的 tuple。例如：左表连接列名为 timestamp, sym，右表连接列名为 timestamp, sym1，则 *matchingColumn* = [[\\`timestamp, \\`sym], [\\`timestamp,\\`sym1]]。",
|
|
14278
|
+
"",
|
|
14279
|
+
".. _garbageSizeLSJ:",
|
|
14280
|
+
"",
|
|
14281
|
+
"`garbageSize` 可选参数，正整数，默认值是 5,000（单位为行）。和其他连接引擎不同，该函数的 garbageSize 参数只用于清理左表的历史数据。当左表发生过 join 的记录数超过 garbageSize 时，系统会触发清理。",
|
|
14282
|
+
"",
|
|
14283
|
+
".. _updateRightTableLSJ:",
|
|
14284
|
+
"",
|
|
14285
|
+
"`updateRightTable` 可选参数，布尔值，默认为 false，表示右表存在多条相同 matchingColumn 的记录时，是保留第一条（true）还是最后一条记录（false）。"
|
|
14286
|
+
]
|
|
14287
|
+
}
|
|
14288
|
+
]
|
|
14289
|
+
},
|
|
14290
|
+
{
|
|
14291
|
+
"title": "例子",
|
|
14292
|
+
"type": "example",
|
|
14293
|
+
"children": [
|
|
14294
|
+
{
|
|
14295
|
+
"type": "code",
|
|
14296
|
+
"language": "console",
|
|
14297
|
+
"value": [
|
|
14298
|
+
"",
|
|
14299
|
+
" $ share streamTable(1:0, `time`sym`price, [TIMESTAMP, SYMBOL, DOUBLE]) as leftTable ",
|
|
14300
|
+
" $ share streamTable(1:0, `time`sym1`vol, [TIMESTAMP, SYMBOL, INT]) as rightTable",
|
|
14301
|
+
"",
|
|
14302
|
+
" $ output=table(100:0, `time`sym`price`vol`total, [TIMESTAMP, SYMBOL, DOUBLE, INT, DOUBLE])",
|
|
14303
|
+
" $ lsjEngine=createLeftSemiJoinEngine(name=\"test1\", leftTable=leftTable, rightTable=rightTable, outputTable=output, metrics=<[price, vol,price*vol]>, matchingColumn=[[`time,`sym], [`time,`sym1]], updateRightTable=true)",
|
|
14304
|
+
"",
|
|
14305
|
+
" $ subscribeTable(tableName=\"leftTable\", actionName=\"joinLeft\", offset=0, handler=appendForJoin{lsjEngine, true}, msgAsTable=true)",
|
|
14306
|
+
" $ subscribeTable(tableName=\"rightTable\", actionName=\"joinRight\", offset=0, handler=appendForJoin{lsjEngine, false}, msgAsTable=true)",
|
|
14307
|
+
"",
|
|
14308
|
+
" $ v = [1, 5, 10, 15]",
|
|
14309
|
+
" $ tp1=table(2012.01.01T00:00:00.000+v as time, take(`AAPL, 4) as sym, rand(100,4) as price)",
|
|
14310
|
+
" $ leftTable.append!(tp1)",
|
|
14311
|
+
"",
|
|
14312
|
+
" $ v = [1, 1, 3, 4, 5, 5, 5, 15]",
|
|
14313
|
+
" $ tp2=table(2012.01.01T00:00:00.000+v as time, take(`AAPL, 8) as sym, rand(100,8) as vol)",
|
|
14314
|
+
" $ rightTable.append!(tp2)",
|
|
14315
|
+
"",
|
|
14316
|
+
" $ select * from output ",
|
|
14317
|
+
""
|
|
14318
|
+
]
|
|
14319
|
+
},
|
|
14320
|
+
{
|
|
14321
|
+
"type": "text",
|
|
14322
|
+
"value": [
|
|
14323
|
+
"+-------------------------+------+-------+-----+-------+",
|
|
14324
|
+
"| time | sym | price | vol | total |",
|
|
14325
|
+
"+=========================+======+=======+=====+=======+",
|
|
14326
|
+
"| 2012.01.01T00:00:00.001 | AAPL | 44 | 76 | 3344 |",
|
|
14327
|
+
"+-------------------------+------+-------+-----+-------+",
|
|
14328
|
+
"| 2012.01.01T00:00:00.005 | AAPL | 15 | 64 | 960 |",
|
|
14329
|
+
"+-------------------------+------+-------+-----+-------+",
|
|
14330
|
+
"| 2012.01.01T00:00:00.015 | AAPL | 24 | 75 | 1800 |",
|
|
14331
|
+
"+-------------------------+------+-------+-----+-------+",
|
|
14332
|
+
"",
|
|
14333
|
+
"若要再次执行以上脚本，需要先删除引擎并取消订阅：",
|
|
14334
|
+
""
|
|
14335
|
+
]
|
|
14336
|
+
},
|
|
14337
|
+
{
|
|
14338
|
+
"type": "code",
|
|
14339
|
+
"language": "console",
|
|
14340
|
+
"value": [
|
|
14341
|
+
"",
|
|
14342
|
+
" $ dropStreamEngine(\"test1\")",
|
|
14343
|
+
" $ lsjEngine=NULL",
|
|
14344
|
+
" $ unsubscribeTable(tableName=\"leftTable\", actionName=\"joinLeft\")",
|
|
14345
|
+
" $ unsubscribeTable(tableName=\"rightTable\", actionName=\"joinRight\")"
|
|
14346
|
+
]
|
|
14347
|
+
}
|
|
14348
|
+
]
|
|
14349
|
+
}
|
|
14350
|
+
]
|
|
14351
|
+
},
|
|
14119
14352
|
"createLookupJoinEngine": {
|
|
14120
14353
|
"title": "createLookupJoinEngine",
|
|
14121
14354
|
"type": "function",
|
|
@@ -14155,7 +14388,9 @@
|
|
|
14155
14388
|
"",
|
|
14156
14389
|
"lookup join 引擎输出表的第一列可以不是时间列，而 asof join 引擎输出表第一列必须是时间列。",
|
|
14157
14390
|
"",
|
|
14158
|
-
"lookup join 引擎当左表有新数据流入便会触发 jion 输出，因此无需考虑数据延迟，也无需缓存数据。而 asof join 引擎，当指定 timeColumn 时，需要考虑左右表的数据延时，因此需要缓存数据。"
|
|
14391
|
+
"lookup join 引擎当左表有新数据流入便会触发 jion 输出，因此无需考虑数据延迟，也无需缓存数据。而 asof join 引擎，当指定 timeColumn 时，需要考虑左右表的数据延时，因此需要缓存数据。",
|
|
14392
|
+
"",
|
|
14393
|
+
"更多流数据引擎的应用场景说明可以参考 :doc:`../../SeriesOfFunctions/streamingEngine`。"
|
|
14159
14394
|
]
|
|
14160
14395
|
}
|
|
14161
14396
|
]
|
|
@@ -14169,7 +14404,7 @@
|
|
|
14169
14404
|
"value": [
|
|
14170
14405
|
"`name` 必选参数，表示流数据 lookup join 引擎的名称，作为其在一个数据节点/计算节点上的唯一标识。可包含字母，数字和下划线，但必须以字母开头。",
|
|
14171
14406
|
"",
|
|
14172
|
-
"`leftTable`
|
|
14407
|
+
"`leftTable` 表对象。可以不包含数据，但结构必须与订阅的流数据表相同。",
|
|
14173
14408
|
"",
|
|
14174
14409
|
"`rightTable` 表对象，可以是内存表、流数据表或维度表。请注意，如果 *rightTable* 没有被订阅，必须设置 *checkTimes* 定时刷新数据。",
|
|
14175
14410
|
"",
|
|
@@ -14489,9 +14724,9 @@
|
|
|
14489
14724
|
"value": [
|
|
14490
14725
|
"",
|
|
14491
14726
|
" $ n=1000000;",
|
|
14492
|
-
" $ t=table(rand(`IBM`MS`APPL`AMZN,n) as symbol, rand(10.0, n) as value)",
|
|
14727
|
+
" $ t=table(2020.01.01T00:00:00 + 0..(n-1) as timestamp, rand(`IBM`MS`APPL`AMZN,n) as symbol, rand(10.0, n) as value)",
|
|
14493
14728
|
" $ db = database(\"dfs://rangedb_tradedata\", RANGE, `A`F`M`S`ZZZZ)",
|
|
14494
|
-
" $ Trades = db.createPartitionedTable(t,
|
|
14729
|
+
" $ Trades = db.createPartitionedTable(table=t, tableName=\"Trades\", partitionColumns=\"symbol\", compressMethods={timestamp:\"delta\"});",
|
|
14495
14730
|
""
|
|
14496
14731
|
]
|
|
14497
14732
|
},
|
|
@@ -14662,29 +14897,7 @@
|
|
|
14662
14897
|
"============= ===== ===== ======",
|
|
14663
14898
|
"09:30:00.001 AAPL 100 56.5",
|
|
14664
14899
|
"09:30:01.001 DELL 100 15.5",
|
|
14665
|
-
"============= ===== ===== ======"
|
|
14666
|
-
"",
|
|
14667
|
-
"例 3. 指定压缩算法",
|
|
14668
|
-
""
|
|
14669
|
-
]
|
|
14670
|
-
},
|
|
14671
|
-
{
|
|
14672
|
-
"type": "code",
|
|
14673
|
-
"language": "console",
|
|
14674
|
-
"value": [
|
|
14675
|
-
"",
|
|
14676
|
-
" $ db = database(\"dfs://demodb\", VALUE, 1..10)",
|
|
14677
|
-
" $ t=table(take(1, 86400) as id, 2020.01.01T00:00:00 + 0..86399 as timestamp, rand(1..100, 86400) as val)",
|
|
14678
|
-
" $ pt =db.createPartitionedTable(t, \"pt\", \"id\", {timestamp:\"delta\", val:\"delta\"})",
|
|
14679
|
-
" $ pt.append!(t)",
|
|
14680
|
-
""
|
|
14681
|
-
]
|
|
14682
|
-
},
|
|
14683
|
-
{
|
|
14684
|
-
"type": "text",
|
|
14685
|
-
"value": [
|
|
14686
|
-
".. meta::",
|
|
14687
|
-
" :keywords: 内存表"
|
|
14900
|
+
"============= ===== ===== ======"
|
|
14688
14901
|
]
|
|
14689
14902
|
}
|
|
14690
14903
|
]
|
|
@@ -16030,11 +16243,13 @@
|
|
|
16030
16243
|
"",
|
|
16031
16244
|
" 触发规则：",
|
|
16032
16245
|
"",
|
|
16033
|
-
" 当 useSystemTime=false 时，计算将由窗口结束后的第一条右表数据触发。",
|
|
16246
|
+
" * 当 useSystemTime=false 时，计算将由窗口结束后的第一条右表数据触发。",
|
|
16247
|
+
"",
|
|
16248
|
+
" * 当 useSystemTime=true 时，左表每注入一条数据，就触发右表未计算数据的计算。",
|
|
16034
16249
|
"",
|
|
16035
|
-
"
|
|
16250
|
+
" 注意：window=0:0 时，若 metrics 中指定了非聚合的指标，其输出列必须为对应类型的 array vector。",
|
|
16036
16251
|
"",
|
|
16037
|
-
"
|
|
16252
|
+
"更多流数据引擎的应用场景说明可以参考 :doc:`../../SeriesOfFunctions/streamingEngine`。"
|
|
16038
16253
|
]
|
|
16039
16254
|
}
|
|
16040
16255
|
]
|
|
@@ -16048,7 +16263,9 @@
|
|
|
16048
16263
|
"value": [
|
|
16049
16264
|
"`name` 必选参数，表示 window join 引擎的名称，作为其在一个数据节点/计算节点上的唯一标识。可包含字母，数字和下划线，但必须以字母开头。",
|
|
16050
16265
|
"",
|
|
16051
|
-
"`leftTable`
|
|
16266
|
+
"`leftTable` 表对象。可以不包含数据，但结构必须与订阅的流数据表相同。",
|
|
16267
|
+
"",
|
|
16268
|
+
"`rightTable` 表对象。可以不包含数据，但结构必须与订阅的流数据表相同。",
|
|
16052
16269
|
"",
|
|
16053
16270
|
"`outputTable` 必选参数，为计算结果的输出表。window join 引擎会将计算结果插入该表。",
|
|
16054
16271
|
"",
|
|
@@ -16069,7 +16286,7 @@
|
|
|
16069
16286
|
"",
|
|
16070
16287
|
"`metrics` 以元代码的格式表示计算指标，支持输入元组。有关元代码的更多信息可参考 :doc:`/Objects/Metaprogramming`。",
|
|
16071
16288
|
"",
|
|
16072
|
-
"*
|
|
16289
|
+
"* 计算指标可以是一个或多个表达式、系统内置或用户自定义函数。",
|
|
16073
16290
|
"* *metrics* 内支持调用具有多个返回值的函数，且必须指定列名，例如 <func(price) as \\`col1\\`col2>。",
|
|
16074
16291
|
"",
|
|
16075
16292
|
"若在 *metrics* 指定了 *leftTable* 和 *rightTable* 中具有相同名称的列，默认取左表的列，可以通过 \"tableName.colName\" 指定该列来自哪个表。",
|
|
@@ -34586,7 +34803,8 @@
|
|
|
34586
34803
|
"language": "console",
|
|
34587
34804
|
"value": [
|
|
34588
34805
|
" ",
|
|
34589
|
-
" $ getSessionMemoryStat();",
|
|
34806
|
+
" $ t = getSessionMemoryStat();",
|
|
34807
|
+
" $ t;",
|
|
34590
34808
|
""
|
|
34591
34809
|
]
|
|
34592
34810
|
},
|
|
@@ -35924,20 +36142,20 @@
|
|
|
35924
36142
|
{
|
|
35925
36143
|
"type": "text",
|
|
35926
36144
|
"value": [
|
|
35927
|
-
"====================================
|
|
35928
|
-
"chunkId path
|
|
35929
|
-
"====================================
|
|
35930
|
-
"dbfd1767-f9ca-689e-4d5e-643b8506e82d C
|
|
35931
|
-
"d221b457-fa7b-5990-4caa-13c99f56f716 C
|
|
35932
|
-
"92904d3b-0147-9bb8-4a28-f99525b250e7 C
|
|
35933
|
-
"7478c15a-0629-c8ab-47ee-a1d12c3c1cd6 C
|
|
35934
|
-
"8bc48c11-86ca-97ac-4ee4-8f829de92cc8 C
|
|
35935
|
-
"6b3a0a09-bc64-3bab-4535-344b7316d244 C
|
|
35936
|
-
"a7452c44-5d2b-6f82-4150-7bc48e941d64 C
|
|
35937
|
-
"a1a375cc-b6c0-29b2-485a-330af7447564 C
|
|
35938
|
-
"b04b4c04-6d43-0d8d-4000-6ae88e349eda C
|
|
35939
|
-
"b20df3a7-678b-1cbe-400d-d8e566706682 C
|
|
35940
|
-
"====================================
|
|
36145
|
+
"==================================== =================== ============= ========= ======= ====== ========== ================= ==========",
|
|
36146
|
+
"chunkId path dfsPath tableName version rowNum createCids latestPhysicalDir diskUsage",
|
|
36147
|
+
"==================================== =================== ============= ========= ======= ====== ========== ================= ==========",
|
|
36148
|
+
"dbfd1767-f9ca-689e-4d5e-643b8506e82d C:\\\\Users\\\\Downl... /testDB/10/8 pt1 2 100155 [2059] pt1_2_2059 696295",
|
|
36149
|
+
"d221b457-fa7b-5990-4caa-13c99f56f716 C:\\\\Users\\\\Downl... /testDB/9/8 pt1 2 99703 [2059] pt1_2_2059 693026",
|
|
36150
|
+
"92904d3b-0147-9bb8-4a28-f99525b250e7 C:\\\\Users\\\\Downl... /testDB/8/8 pt1 2 99791 [2059] pt1_2_2059 693848",
|
|
36151
|
+
"7478c15a-0629-c8ab-47ee-a1d12c3c1cd6 C:\\\\Users\\\\Downl... /testDB/1/8 pt1 2 100215 [2059] pt1_2_2059 696932",
|
|
36152
|
+
"8bc48c11-86ca-97ac-4ee4-8f829de92cc8 C:\\\\Users\\\\Downl... /testDB/5/8 pt1 2 100156 [2059] pt1_2_2059 696584",
|
|
36153
|
+
"6b3a0a09-bc64-3bab-4535-344b7316d244 C:\\\\Users\\\\Downl... /testDB/2/8 pt1 2 100121 [2059] pt1_2_2059 696303",
|
|
36154
|
+
"a7452c44-5d2b-6f82-4150-7bc48e941d64 C:\\\\Users\\\\Downl... /testDB/4/8 pt1 2 99858 [2059] pt1_2_2059 696572",
|
|
36155
|
+
"a1a375cc-b6c0-29b2-485a-330af7447564 C:\\\\Users\\\\Downl... /testDB/6/8 pt1 2 100280 [2059] pt1_2_2059 697596",
|
|
36156
|
+
"b04b4c04-6d43-0d8d-4000-6ae88e349eda C:\\\\Users\\\\Downl... /testDB/3/8 pt1 2 99858 [2059] pt1_2_2059 694400",
|
|
36157
|
+
"b20df3a7-678b-1cbe-400d-d8e566706682 C:\\\\Users\\\\Downl... /testDB/7/8 pt1 2 99865 [2059] pt1_2_2059 6942755",
|
|
36158
|
+
"==================================== =================== ============= ========= ======= ====== ========== ================= =========="
|
|
35941
36159
|
]
|
|
35942
36160
|
}
|
|
35943
36161
|
]
|
|
@@ -46456,7 +46674,7 @@
|
|
|
46456
46674
|
{
|
|
46457
46675
|
"type": "text",
|
|
46458
46676
|
"value": [
|
|
46459
|
-
"计算滑动线性回归，返回一个 tuple 类，包含两列，分别是 alpha 和 beta，对应 talib 中的 linearreg_slope
|
|
46677
|
+
"计算滑动线性回归，返回一个 tuple 类，包含两列，分别是 alpha 和 beta，对应 talib 中的 linearreg_intercept（线性回归截距）和 linearreg_slope（线性回归斜率指标）。"
|
|
46460
46678
|
]
|
|
46461
46679
|
}
|
|
46462
46680
|
]
|
|
@@ -56530,7 +56748,7 @@
|
|
|
56530
56748
|
{
|
|
56531
56749
|
"type": "text",
|
|
56532
56750
|
"value": [
|
|
56533
|
-
"moveReplicas(srcNode, destNode, chunkId
|
|
56751
|
+
"moveReplicas(srcNode, destNode, chunkId)"
|
|
56534
56752
|
]
|
|
56535
56753
|
}
|
|
56536
56754
|
]
|
|
@@ -57509,7 +57727,7 @@
|
|
|
57509
57727
|
{
|
|
57510
57728
|
"type": "text",
|
|
57511
57729
|
"value": [
|
|
57512
|
-
"mstd(X, window, [minPeriods]",
|
|
57730
|
+
"mstd(X, window, [minPeriods])",
|
|
57513
57731
|
"",
|
|
57514
57732
|
"参数说明和窗口计算规则请参考: :doc:`/FunctionsandCommands/SeriesOfFunctions/mFunctions`"
|
|
57515
57733
|
]
|
|
@@ -57782,7 +58000,7 @@
|
|
|
57782
58000
|
{
|
|
57783
58001
|
"type": "text",
|
|
57784
58002
|
"value": [
|
|
57785
|
-
"mstdp(X, window, [minPeriods]",
|
|
58003
|
+
"mstdp(X, window, [minPeriods])",
|
|
57786
58004
|
"",
|
|
57787
58005
|
"参数说明和窗口计算规则请参考: :doc:`/FunctionsandCommands/SeriesOfFunctions/mFunctions`"
|
|
57788
58006
|
]
|
|
@@ -62158,7 +62376,7 @@
|
|
|
62158
62376
|
{
|
|
62159
62377
|
"type": "text",
|
|
62160
62378
|
"value": [
|
|
62161
|
-
"pack(format, args
|
|
62379
|
+
"pack(format, args...)"
|
|
62162
62380
|
]
|
|
62163
62381
|
}
|
|
62164
62382
|
]
|
|
@@ -62797,7 +63015,7 @@
|
|
|
62797
63015
|
{
|
|
62798
63016
|
"type": "text",
|
|
62799
63017
|
"value": [
|
|
62800
|
-
"pca(
|
|
63018
|
+
"pca(ds, [colNames], [k], [normalize], [maxIter], [svdSolver], [randomState])"
|
|
62801
63019
|
]
|
|
62802
63020
|
}
|
|
62803
63021
|
]
|
|
@@ -64697,7 +64915,8 @@
|
|
|
64697
64915
|
"",
|
|
64698
64916
|
"`allowExists` 是一个布尔值。当 *allowExists* =true 时，若执行该函数前，订阅已经存在，不会抛出异常。默认值为 false。",
|
|
64699
64917
|
"",
|
|
64700
|
-
"",
|
|
64918
|
+
".. versionadded:: 1.30.17",
|
|
64919
|
+
" 参数 *resetOffset*",
|
|
64701
64920
|
"",
|
|
64702
64921
|
"`resetOffset` 是一个布尔值，表示是否重置 *offset* 为 - 1，默认值为 false。当 resetOffset =true 时，若流数据表中原 *offset* 指定的行没有数据，系统会重置 *offset*，并从即将进入流数据表的第一行开始订阅。"
|
|
64703
64922
|
]
|
|
@@ -69032,14 +69251,15 @@
|
|
|
69032
69251
|
"+------+------+------+------+------+",
|
|
69033
69252
|
"| col1 | col2 | col3 | col4 | col5 |",
|
|
69034
69253
|
"+======+======+======+======+======+",
|
|
69035
|
-
"|
|
|
69254
|
+
"| 11 | 6 | 6 | 10 | 4 |",
|
|
69036
69255
|
"+------+------+------+------+------+",
|
|
69037
|
-
"|
|
|
69256
|
+
"| 6 | 7 | 5 | 2 | 16 |",
|
|
69038
69257
|
"+------+------+------+------+------+",
|
|
69039
|
-
"|
|
|
69258
|
+
"| 2 | 16 | 14 | 19 | 9 |",
|
|
69040
69259
|
"+------+------+------+------+------+",
|
|
69041
|
-
"|
|
|
69260
|
+
"| 17 | 6 | 13 | 10 | 2 |",
|
|
69042
69261
|
"+------+------+------+------+------+",
|
|
69262
|
+
"",
|
|
69043
69263
|
""
|
|
69044
69264
|
]
|
|
69045
69265
|
},
|
|
@@ -69060,14 +69280,15 @@
|
|
|
69060
69280
|
"+-----+-----+",
|
|
69061
69281
|
"| A | B |",
|
|
69062
69282
|
"+=====+=====+",
|
|
69063
|
-
"|
|
|
69283
|
+
"| 11 | 6 |",
|
|
69064
69284
|
"+-----+-----+",
|
|
69065
|
-
"|
|
|
69285
|
+
"| 6 | 5 |",
|
|
69066
69286
|
"+-----+-----+",
|
|
69067
|
-
"|
|
|
69287
|
+
"| 2 | 14 |",
|
|
69068
69288
|
"+-----+-----+",
|
|
69069
|
-
"|
|
|
69289
|
+
"| 17 | 13 |",
|
|
69070
69290
|
"+-----+-----+",
|
|
69291
|
+
"",
|
|
69071
69292
|
""
|
|
69072
69293
|
]
|
|
69073
69294
|
},
|
|
@@ -69088,8 +69309,11 @@
|
|
|
69088
69309
|
"+-------+------+------+------+------+------+",
|
|
69089
69310
|
"| label | col1 | col2 | col3 | col4 | col5 |",
|
|
69090
69311
|
"+=======+======+======+======+======+======+",
|
|
69091
|
-
"| 1 |
|
|
69312
|
+
"| 1 | 11 | 6 | 6 | 10 | 4 |",
|
|
69313
|
+
"+-------+------+------+------+------+------+",
|
|
69314
|
+
"| 2 | 6 | 7 | 5 | 2 | 16 |",
|
|
69092
69315
|
"+-------+------+------+------+------+------+",
|
|
69316
|
+
"",
|
|
69093
69317
|
" ",
|
|
69094
69318
|
"例2：内置函数和用户自定函数的性能对比",
|
|
69095
69319
|
""
|
|
@@ -69111,6 +69335,27 @@
|
|
|
69111
69335
|
"",
|
|
69112
69336
|
""
|
|
69113
69337
|
]
|
|
69338
|
+
},
|
|
69339
|
+
{
|
|
69340
|
+
"type": "text",
|
|
69341
|
+
"value": [
|
|
69342
|
+
"例3：对面板数据进行分钟聚合",
|
|
69343
|
+
""
|
|
69344
|
+
]
|
|
69345
|
+
},
|
|
69346
|
+
{
|
|
69347
|
+
"type": "code",
|
|
69348
|
+
"language": "console",
|
|
69349
|
+
"value": [
|
|
69350
|
+
"",
|
|
69351
|
+
" $ n=1000",
|
|
69352
|
+
" $ timestamp = 09:00:00 + rand(10000, n).sort!()",
|
|
69353
|
+
" $ id = take(`st1`st2`st3, n)",
|
|
69354
|
+
" $ vol = 100 + rand(10.0, n)",
|
|
69355
|
+
" $ vt = table(timestamp, id, vol)",
|
|
69356
|
+
" $ m = exec vol from vt pivot by timestamp, id",
|
|
69357
|
+
" $ regroup(m, minute(m.rowNames()), avg)"
|
|
69358
|
+
]
|
|
69114
69359
|
}
|
|
69115
69360
|
]
|
|
69116
69361
|
}
|
|
@@ -77041,9 +77286,9 @@
|
|
|
77041
77286
|
"",
|
|
77042
77287
|
"`endDate` 是一个日期标量。",
|
|
77043
77288
|
"",
|
|
77044
|
-
"`frequency` 是一个字符。它可以是下列3
|
|
77289
|
+
"`frequency` 是一个字符。它可以是下列3个值之一：'D' 表示每日，'W' 表示每周，'M' 表示每月。",
|
|
77045
77290
|
"",
|
|
77046
|
-
"`days` 是一个整型标量/向量，表示执行定时任务的日期。如果frequency为W或M时，它是必需的。如果frequency为W，days可以取以下值：0（周日），1（周一），...，5（周五），6（周六）。",
|
|
77291
|
+
"`days` 是一个整型标量/向量，表示执行定时任务的日期。如果 frequency 为 'W' 或 'M' 时，它是必需的。如果frequency为W，days可以取以下值：0（周日），1（周一），...，5（周五），6（周六）。",
|
|
77047
77292
|
"",
|
|
77048
77293
|
"`onComplete` 是一个有4个参数的回调函数，细节请见以下最后一个例子。当定时作业执行完毕（包括有异常的情况）后，会执行该函数。可通过该函数向外部消息系统如邮件系统或微信与钉钉发送消息。"
|
|
77049
77294
|
]
|
|
@@ -77057,8 +77302,8 @@
|
|
|
77057
77302
|
{
|
|
77058
77303
|
"type": "text",
|
|
77059
77304
|
"value": [
|
|
77060
|
-
"返回定时任务的任务ID。如果jobId与已有的定时任务的ID不一致，系统返回jobId
|
|
77061
|
-
"我们可以使用
|
|
77305
|
+
"返回定时任务的任务 ID。如果 *jobId* 与已有的定时任务的 ID 不一致，系统返回 *jobId*。否则在 *jobId* 后面添加当前日期，\"000\", \"001\" 等作为后缀，直到产生唯一的任务 ID。 ",
|
|
77306
|
+
"我们可以使用 :doc:`../g/getRecentJobs` 来查看最近完成的定时任务。",
|
|
77062
77307
|
"",
|
|
77063
77308
|
"执行定时任务生成的信息保存在 jodId.msg 文件中；如果定时任务会返回值，它会保存在 jobId.object 文件中。",
|
|
77064
77309
|
"jobId.msg 和 jobId.object 保存在 ``batchIobs`` 文件夹中。我们可以分别使用 :doc:`../g/getJobMessage` 和 :doc:`../g/getJobReturn` 来查看这两个文件。"
|
|
@@ -77107,7 +77352,7 @@
|
|
|
77107
77352
|
"value": [
|
|
77108
77353
|
" $ scheduleJob(jobId=`monthly, jobDesc=\"Monthly Job 1\", jobFunc=run{\"monthlyJob.dos\"}, scheduleTime=17:23m, startDate=2018.01.01, endDate=2018.12.31, frequency='M', days=1);",
|
|
77109
77354
|
"",
|
|
77110
|
-
"这里使用部分应用run{<script>}，因为jobFunc必须是没有参数的函数。",
|
|
77355
|
+
"这里使用部分应用 run{<script>}，因为 *jobFunc* 必须是没有参数的函数。",
|
|
77111
77356
|
""
|
|
77112
77357
|
]
|
|
77113
77358
|
},
|
|
@@ -77162,7 +77407,7 @@
|
|
|
77162
77407
|
"value": [
|
|
77163
77408
|
" $ scheduleJob(jobId=`PnL, jobDesc=\"Calculate Profit & Loss\", jobFunc=run{\"PnL.dos\"}, scheduleTime=[12:00m, 02:00m, 14:50m], startDate=2018.01.01, endDate=2018.12.31, frequency='W', days=[1,2,3,4,5]);",
|
|
77164
77409
|
"",
|
|
77165
|
-
"定时任务执行结束后可发送邮件通知。以下脚本运行前需安装HttpClient插件。",
|
|
77410
|
+
"定时任务执行结束后可发送邮件通知。以下脚本运行前需安装 HttpClient 插件。",
|
|
77166
77411
|
""
|
|
77167
77412
|
]
|
|
77168
77413
|
},
|
|
@@ -83237,7 +83482,7 @@
|
|
|
83237
83482
|
"假设该函数计算结果对应输出表的列为 factor，且迭代仅基于前一个值，对于第 k 条记录(k = 0, 1, 2 …)，其计算逻辑为：",
|
|
83238
83483
|
"",
|
|
83239
83484
|
"* k < initialWindow：factor[k] = initial[k]",
|
|
83240
|
-
"* k >= initialWindow：factor[k] = combineCoeff[0] * X[k] + combineCoeff[1] * iterateFunc(factor[k-1]
|
|
83485
|
+
"* k >= initialWindow：factor[k] = combineCoeff[0] * X[k] + combineCoeff[1] * iterateFunc(factor)[k-1]。",
|
|
83241
83486
|
"",
|
|
83242
83487
|
"注意：若 ``iterateFunc`` 为窗口函数，则会基于前多个 factor 值进行计算。"
|
|
83243
83488
|
]
|
|
@@ -83253,27 +83498,94 @@
|
|
|
83253
83498
|
"language": "console",
|
|
83254
83499
|
"value": [
|
|
83255
83500
|
"",
|
|
83256
|
-
" $
|
|
83257
|
-
" $ trade
|
|
83501
|
+
" $ trade = table(take(\"A\", 6) join take(\"B\", 6) as sym, 1..12 as val0, take(10, 12) as val1)",
|
|
83502
|
+
" $ trade;",
|
|
83503
|
+
""
|
|
83504
|
+
]
|
|
83505
|
+
},
|
|
83506
|
+
{
|
|
83507
|
+
"type": "text",
|
|
83508
|
+
"value": [
|
|
83509
|
+
"+-----+------+------+",
|
|
83510
|
+
"| sym | val0 | val1 |",
|
|
83511
|
+
"+=====+======+======+",
|
|
83512
|
+
"| A | 1 | 10 |",
|
|
83513
|
+
"+-----+------+------+",
|
|
83514
|
+
"| A | 2 | 10 |",
|
|
83515
|
+
"+-----+------+------+",
|
|
83516
|
+
"| A | 3 | 10 |",
|
|
83517
|
+
"+-----+------+------+",
|
|
83518
|
+
"| A | 4 | 10 |",
|
|
83519
|
+
"+-----+------+------+",
|
|
83520
|
+
"| A | 5 | 10 |",
|
|
83521
|
+
"+-----+------+------+",
|
|
83522
|
+
"| A | 6 | 10 |",
|
|
83523
|
+
"+-----+------+------+",
|
|
83524
|
+
"| B | 7 | 10 |",
|
|
83525
|
+
"+-----+------+------+",
|
|
83526
|
+
"| B | 8 | 10 |",
|
|
83527
|
+
"+-----+------+------+",
|
|
83528
|
+
"| B | 9 | 10 |",
|
|
83529
|
+
"+-----+------+------+",
|
|
83530
|
+
"| B | 10 | 10 |",
|
|
83531
|
+
"+-----+------+------+",
|
|
83532
|
+
"| B | 11 | 10 |",
|
|
83533
|
+
"+-----+------+------+",
|
|
83534
|
+
"| B | 12 | 10 |",
|
|
83535
|
+
"+-----+------+------+",
|
|
83536
|
+
"",
|
|
83537
|
+
"定义一个响应式状态引擎，并按 sym 列分组进行计算。组内的计算逻辑如下：",
|
|
83538
|
+
"",
|
|
83539
|
+
"* 前 initalWindow 行记录，计算公式为 `factor[k]=initial[k]`，因此 factor[0], factor[1], factor[2] 均将 val1 列的值直接作为 factor 列的输出。",
|
|
83540
|
+
"* 之后的记录，对应计算公式为 `factor[k]=0.5*val0[k]+0.5*msum(factor, 3)[k-1]`。以计算 sym=`A，val0=4 这条记录为例，此时 factor 列仅有前 3 条数据的输出，即 factor=[10, 10, 10]，k=3，带入计算公式即 `0.5*4+0.5*msum([10, 10, 10], 3)[2]=17`。同理 sym=`A，val0=5 这条记录带入计算公式即 `0.5*5+0.5*msum([10, 10, 10, 17], 3)[3]=21`，以此类推。",
|
|
83541
|
+
""
|
|
83542
|
+
]
|
|
83543
|
+
},
|
|
83544
|
+
{
|
|
83545
|
+
"type": "code",
|
|
83546
|
+
"language": "console",
|
|
83547
|
+
"value": [
|
|
83258
83548
|
"",
|
|
83259
|
-
" $ inputTable = streamTable(1:0, `
|
|
83260
|
-
" $ outputTable = table(100:0, `sym`
|
|
83261
|
-
" $ engine = createReactiveStateEngine(name=\"rsTest\", metrics=<[
|
|
83549
|
+
" $ inputTable = streamTable(1:0, `sym`val0`val1, [SYMBOL, INT, INT]) ",
|
|
83550
|
+
" $ outputTable = table(100:0, `sym`factor, [STRING, DOUBLE])",
|
|
83551
|
+
" $ engine = createReactiveStateEngine(name=\"rsTest\", metrics=<[stateIterate(val0, val1, 3, msum{, 3}, [0.5, 0.5])]>, dummyTable=inputTable, outputTable=outputTable, keyColumn=[\"sym\"], keepOrder=true)",
|
|
83262
83552
|
"",
|
|
83263
83553
|
" $ engine.append!(trade)",
|
|
83264
|
-
" $ select
|
|
83265
|
-
" $ dropStreamEngine(\"rsTest\")",
|
|
83554
|
+
" $ select * from outputTable",
|
|
83266
83555
|
""
|
|
83267
83556
|
]
|
|
83268
83557
|
},
|
|
83269
83558
|
{
|
|
83270
83559
|
"type": "text",
|
|
83271
83560
|
"value": [
|
|
83272
|
-
"
|
|
83273
|
-
"",
|
|
83274
|
-
"
|
|
83561
|
+
"+-----+--------+",
|
|
83562
|
+
"| sym | factor |",
|
|
83563
|
+
"+=====+========+",
|
|
83564
|
+
"| A | 10 |",
|
|
83565
|
+
"+-----+--------+",
|
|
83566
|
+
"| A | 10 |",
|
|
83567
|
+
"+-----+--------+",
|
|
83568
|
+
"| A | 10 |",
|
|
83569
|
+
"+-----+--------+",
|
|
83570
|
+
"| A | 17 |",
|
|
83571
|
+
"+-----+--------+",
|
|
83572
|
+
"| A | 21 |",
|
|
83573
|
+
"+-----+--------+",
|
|
83574
|
+
"| A | 27 |",
|
|
83575
|
+
"+-----+--------+",
|
|
83576
|
+
"| B | 10 |",
|
|
83577
|
+
"+-----+--------+",
|
|
83578
|
+
"| B | 10 |",
|
|
83579
|
+
"+-----+--------+",
|
|
83580
|
+
"| B | 10 |",
|
|
83581
|
+
"+-----+--------+",
|
|
83582
|
+
"| B | 20 |",
|
|
83583
|
+
"+-----+--------+",
|
|
83584
|
+
"| B | 25.5 |",
|
|
83585
|
+
"+-----+--------+",
|
|
83586
|
+
"| B | 33.75 |",
|
|
83587
|
+
"+-----+--------+",
|
|
83275
83588
|
"",
|
|
83276
|
-
"对于上述蓝框部分的数据，均使用 origin 的结果进行填充，即 price1*qty；红框部分的数据皆触发 *iterateFunc* 逻辑，每条记录的 factor 是输出表中该记录前 10 条 factor 求平均后和 price0 加权（权重均为 0.5）得到的。",
|
|
83277
83589
|
"",
|
|
83278
83590
|
"相关函数：:doc:`../c/conditionalIterate`, :doc:`../s/stateMavg`"
|
|
83279
83591
|
]
|
|
@@ -83335,7 +83647,9 @@
|
|
|
83335
83647
|
{
|
|
83336
83648
|
"type": "text",
|
|
83337
83649
|
"value": [
|
|
83338
|
-
"定义一个响应式状态引擎，按照 sym
|
|
83650
|
+
"定义一个响应式状态引擎，按照 sym 分组。",
|
|
83651
|
+
"",
|
|
83652
|
+
"对于 A 组数据，窗口大小为 3，当 09:00:02 和 09:00:06 这两条数据到来时，窗口未满，因此直接输出 val 的值 2 和 6 到 total 列。下一条到来的 A 组数据的时间戳为 09:00:08，val=8，此时 A 组的第一个窗口触发计算，计算结果为 `(2+6+8)\\\\3=5.333333`；接下来一条 A 组数据的时间戳为 09:00:10，val=10，计算结果为 `(6+5.333333...+10)\\\\3=7.11111`，以此类推。",
|
|
83339
83653
|
""
|
|
83340
83654
|
]
|
|
83341
83655
|
},
|
|
@@ -83344,27 +83658,46 @@
|
|
|
83344
83658
|
"language": "console",
|
|
83345
83659
|
"value": [
|
|
83346
83660
|
"",
|
|
83347
|
-
" $ n=
|
|
83348
|
-
" $ trade = table(09:00:00 + 1..n as time, rand(`A`B, n) as sym,
|
|
83661
|
+
" $ n=10",
|
|
83662
|
+
" $ trade = table(09:00:00 + 1..n as time, rand(`A`B, n) as sym, 1..n as val)",
|
|
83349
83663
|
"",
|
|
83350
83664
|
" $ outputTable = table(100:0, `sym`time`total, [STRING, SECOND, DOUBLE])",
|
|
83351
83665
|
"",
|
|
83352
|
-
" $ engine = createReactiveStateEngine(name=\"test\", metrics=[<time>, <
|
|
83666
|
+
" $ engine = createReactiveStateEngine(name=\"test\", metrics=[<time>, <stateMavg(val, 3)>], dummyTable=trade, outputTable=outputTable, keyColumn=`sym, keepOrder=true)",
|
|
83353
83667
|
"",
|
|
83354
83668
|
" $ engine.append!(trade)",
|
|
83355
|
-
" $ select
|
|
83356
|
-
" $ dropStreamEngine(\"test\")",
|
|
83669
|
+
" $ select * from outputTable",
|
|
83357
83670
|
""
|
|
83358
83671
|
]
|
|
83359
83672
|
},
|
|
83360
83673
|
{
|
|
83361
83674
|
"type": "text",
|
|
83362
83675
|
"value": [
|
|
83363
|
-
"
|
|
83676
|
+
"+-----+----------+--------+",
|
|
83677
|
+
"| sym | time | total |",
|
|
83678
|
+
"+=====+==========+========+",
|
|
83679
|
+
"| B | 09:00:01 | 1 |",
|
|
83680
|
+
"+-----+----------+--------+",
|
|
83681
|
+
"| A | 09:00:02 | 2 |",
|
|
83682
|
+
"+-----+----------+--------+",
|
|
83683
|
+
"| B | 09:00:03 | 3 |",
|
|
83684
|
+
"+-----+----------+--------+",
|
|
83685
|
+
"| B | 09:00:04 | 2.6667 |",
|
|
83686
|
+
"+-----+----------+--------+",
|
|
83687
|
+
"| B | 09:00:05 | 3.5556 |",
|
|
83688
|
+
"+-----+----------+--------+",
|
|
83689
|
+
"| A | 09:00:06 | 6 |",
|
|
83690
|
+
"+-----+----------+--------+",
|
|
83691
|
+
"| B | 09:00:07 | 4.4074 |",
|
|
83692
|
+
"+-----+----------+--------+",
|
|
83693
|
+
"| A | 09:00:08 | 5.3333 |",
|
|
83694
|
+
"+-----+----------+--------+",
|
|
83695
|
+
"| B | 09:00:09 | 5.6543 |",
|
|
83696
|
+
"+-----+----------+--------+",
|
|
83697
|
+
"| A | 09:00:10 | 7.1111 |",
|
|
83698
|
+
"+-----+----------+--------+",
|
|
83364
83699
|
"",
|
|
83365
|
-
".. image:: /images/stateMavg_output.png",
|
|
83366
83700
|
"",
|
|
83367
|
-
"由于窗口长度是 3，对于各组前两条数据，total 等于 total0，即 price * qty（对应上述由红蓝框圈出的数据）。各组从第 3 条数据开始，total 等于它们前两条 total 和当前 price 的平均值。 ",
|
|
83368
83701
|
"",
|
|
83369
83702
|
"相关函数：:doc:`../c/conditionalIterate`, :doc:`../s/stateIterate`"
|
|
83370
83703
|
]
|